import { getValEndpointFromName } from "https://esm.town/v/postpostscript/meta"; import { getTableNames, replaceTableNames } from "https://esm.town/v/postpostscript/sqliteAST"; import { sqliteFromBlob } from "https://esm.town/v/postpostscript/sqliteBackup"; import { Statement, StatementInstance } from "https://esm.town/v/postpostscript/sqliteBuilder"; import { sqliteDump } from "https://esm.town/v/postpostscript/sqliteDump"; import { sqliteFromAPI } from "https://esm.town/v/postpostscript/sqliteFromAPI"; import type { SqliteInterface } from "https://esm.town/v/postpostscript/sqliteTypes"; import { createSqlite } from "https://esm.town/v/postpostscript/sqliteWasm"; import type { MaybePromise } from "https://esm.town/v/postpostscript/typeUtils"; import type { InStatement } from "https://esm.town/v/std/sqlite"; import type { ResultSet } from "npm:@libsql/client"; export const sqliteUniverse = { execute, batch, }; export function sqliteUniverseWithOptions(options: SqliteUniverseOptions) { return { execute(statement: InStatement) { return execute(statement, options); }, batch(statements: InStatement[]) { return batch(statements, options); }, }; } async function execute( statement: InStatement, options: SqliteUniverseOptions = {}, ): Promise> { const [res] = await batch([statement], options); return res; } async function batch( statements: InStatement[], options: SqliteUniverseOptions = {}, ): Promise[]> { const endpointTableMap: EndpointTableMap = {}; const fullTableNames = statements.map(getTableNames).reduce((res, { tables }) => { return new Set([...res, ...tables]); }, new Set()); fullTableNames.forEach(fullTable => { const parts = fullTable.split("/"); const endpoint = parts.slice(0, -1).join("/"); const table = parts.slice(-1)[0]; endpointTableMap[endpoint] ??= new Set(); endpointTableMap[endpoint].add(table); }); const sqlite = await createSqliteFromEndpointTables(endpointTableMap, options); const normalized = statements.map(statement => { let { sql, args } = typeof statement === "string" ? new StatementInstance(statement) : statement; let match; while (match = sql.match(/"([^"]+\/)sqlite_schema"/)) { const [full, start] = match; const index = sql.indexOf(full); const numPreviousArgs = sql.slice(0, index).split("?").length - 1; if (!args) { args = []; } args.splice(numPreviousArgs, 0, `${start}%`); sql = [ sql.slice(0, index), `(SELECT * FROM sqlite_schema WHERE tbl_name LIKE ?)`, sql.slice(index + full.length), ].join(""); } return new StatementInstance( sql, args, ); }); return sqlite.batch(normalized); } async function createSqliteFromEndpointTables( endpointTableMap: EndpointTableMap, { interfaces = defaultInterfaces }: SqliteUniverseOptions = {}, ) { const schemas = Object.entries(endpointTableMap).map(async ([endpoint, tables]) => { let sqlite = await interfaces.exact?.[endpoint]; if (sqlite instanceof Function) { sqlite = await sqlite({ endpoint, tables }); } for (let i = 0; !sqlite && i < interfaces.patterns?.length; i++) { const [test, method] = interfaces.patterns[i]; const match = endpoint.match(test); if (match) { sqlite = await method({ endpoint, match, tables, }); } } if (!sqlite && interfaces.fallback) { sqlite = await interfaces.fallback({ endpoint, tables }); } if (!sqlite) { throw new Error(`interface not valid for ${endpoint}`); } const tableNames = [...tables]; return sqliteDump({ tables: tableNames.filter(table => table !== "sqlite_schema"), sqlite, allSchemas: !!tableNames.find(table => table.toLowerCase().endsWith("sqlite_schema")), transformStatement(statement: StatementInstance, table: string) { if (!endpoint) return statement; return new StatementInstance( replaceTableNames(statement.sql, (name) => { return `${endpoint}/${name}`; }), statement.args, ); }, }); }); const sqlite = createSqlite(); sqlite.batch((await Promise.all(schemas)).flat()); return sqlite; } export const patterns = { https: [ /^https:\/\//, ({ endpoint }) => { return sqliteFromAPI(endpoint); }, ] as SqlitePatternTup, val: [ /^@/, ({ endpoint }) => { return sqliteFromAPI(endpoint); }, ] as SqlitePatternTup, blob: [ /^blob:\/\//, ({ endpoint }) => { return sqliteFromBlob({ name: endpoint.replace("blob://", ""), }); }, ] as SqlitePatternTup, }; export const defaultPatterns: SqlitePatternTup[] = [ patterns.https, patterns.val, ]; export const defaultInterfaces: EndpointSqliteInterfaces = { patterns: defaultPatterns, }; export type SqlitePatternTup = [ RegExp, ( info: { endpoint: string; tables: Set; match: RegExpMatchArray }, ) => MaybePromise, ]; export type EndpointTableMap = Record>; export type EndpointSqliteInterfaces = { fallback?: (info: { endpoint: string; tables: Set }) => MaybePromise; patterns?: SqlitePatternTup[]; exact?: Record< string, SqliteInterface | ((info: { endpoint: string; tables: Set }) => MaybePromise) >; }; export type SqliteUniverseOptions = { interfaces?: EndpointSqliteInterfaces; };

sqliteUniverse

Version 30