on-zero 0.6.13 → 0.6.15

package/dist/cjs/createZeroSQLiteServer.cjs

@@ -17,21 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
   value: true
 }), mod);
 var createZeroSQLiteServer_exports = {};
 __export(createZeroSQLiteServer_exports, {
-  createZeroSQLiteServer: () => createZeroSQLiteServer,
-  createZeroSQLiteTransaction: () => createZeroSQLiteTransaction
+  createZeroSQLiteServer: () => createZeroSQLiteServer
 });
 module.exports = __toCommonJS(createZeroSQLiteServer_exports);
-var import_zero = require("@rocicorp/zero");
-var import_bindings = require("@rocicorp/zero/bindings");
 var import_createZeroServerCore = require("./createZeroServerCore.cjs");
+var import_sqliteRuntime = require("./sqliteRuntime.cjs");
+__reExport(createZeroSQLiteServer_exports, require("./sqliteRuntime.cjs"), module.exports);
 function createZeroSQLiteServer({
-  encodeValue = encodeSQLiteValue,
-  ledgerTables = defaultLedgerTables,
+  encodeValue = import_sqliteRuntime.encodeSQLiteValue,
+  ledgerTables = import_sqliteRuntime.defaultLedgerTables,
   transactionProvider,
   ...options
 }) {
@@ -44,276 +44,7 @@ function createZeroSQLiteServer({
   };
   return (0, import_createZeroServerCore.createZeroServerCore)({
     ...options,
-    createDatabase: () => createSQLiteDatabase(databaseOptions),
-    persistAlreadyProcessed: args => persistAlreadyProcessedMutationResults(databaseOptions, args)
+    createDatabase: () => (0, import_sqliteRuntime.createSQLiteDatabase)(databaseOptions),
+    persistAlreadyProcessed: args => (0, import_sqliteRuntime.persistAlreadyProcessedMutationResults)(databaseOptions, args)
   });
-}
-function createSQLiteDatabase(options) {
-  return {
-    async transaction(callback, input) {
-      let committedLedgers = /* @__PURE__ */new Set();
-      const value = await options.transactionProvider(async executor => {
-        const attemptLedgers = /* @__PURE__ */new Set();
-        const ensureLedger = async upstreamSchema => {
-          const tables = options.ledgerTables(upstreamSchema);
-          const key = ledgerKey(tables);
-          if (options.initializedLedgers.has(key) || attemptLedgers.has(key)) {
-            return;
-          }
-          await createLedgerTables(executor, tables);
-          attemptLedgers.add(key);
-        };
-        const transaction = createZeroSQLiteTransaction(options, executor, input);
-        const result = await callback(transaction, createLedgerHooks(options, executor, ensureLedger, input));
-        committedLedgers = attemptLedgers;
-        return result;
-      });
-      for (const key of committedLedgers) options.initializedLedgers.add(key);
-      return value;
-    }
-  };
-}
-function createZeroSQLiteTransaction(options, executor, input) {
-  const transactionOptions = {
-    encodeValue: options.encodeValue ?? encodeSQLiteValue,
-    schema: options.schema
-  };
-  const clientID = input?.clientID ?? "";
-  const mutationID = input?.mutationID ?? 0;
-  const mutate = new Proxy({}, {
-    get(_target, tableKey) {
-      const tableName = String(tableKey);
-      if (!options.schema.tables[tableName]) {
-        throw new Error(`unknown SQLite mutation table ${tableName}`);
-      }
-      return new Proxy({}, {
-        get(_innerTarget, kindKey) {
-          const kind = String(kindKey);
-          if (!isCrudKind(kind)) return;
-          return value => executeCrud(transactionOptions, executor, tableName, kind, value);
-        }
-      });
-    }
-  });
-  const runQuery = (ast, format, queryName) => Promise.resolve(executor.queryAst(ast, format, queryName));
-  const dbTransaction = {
-    wrappedTransaction: executor,
-    query: (sql, args) => executor.query(sql, args),
-    runQuery
-  };
-  return {
-    clientID,
-    dbTransaction,
-    location: "server",
-    mutate,
-    mutationID,
-    query: transactionOptions.schema.enableLegacyQueries ? createLegacyQueryBuilder(transactionOptions.schema, query => {
-      const internals = (0, import_bindings.asQueryInternals)(query);
-      return runQuery(internals.ast, internals.format, internals.customQueryID?.name);
-    }) : void 0,
-    reason: "authoritative",
-    async run(query) {
-      const internals = (0, import_bindings.asQueryInternals)(query);
-      return runQuery(internals.ast, internals.format, internals.customQueryID?.name);
-    }
-  };
-}
-function isCrudKind(value) {
-  return value === "delete" || value === "insert" || value === "update" || value === "upsert";
-}
-async function executeCrud(options, executor, tableName, kind, raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`${tableName}.${kind} expects an object`);
-  }
-  const table = options.schema.tables[tableName];
-  const values = Object.fromEntries(Object.entries(raw).filter(([, value]) => value !== void 0));
-  for (const columnName of Object.keys(values)) {
-    if (!table.columns[columnName]) {
-      throw new Error(`unknown SQLite column ${tableName}.${columnName}`);
-    }
-  }
-  const primaryValues = table.primaryKey.map(columnName => {
-    if (!(columnName in values)) {
-      throw new Error(`${tableName}.${kind} is missing primary key ${columnName}`);
-    }
-    return encodeColumn(options, tableName, columnName, values[columnName]);
-  });
-  const primaryWhere = table.primaryKey.map(columnName => `${quoteSQLiteIdentifier(serverColumn(table, columnName))} = ?`).join(" AND ");
-  const serverTableName = quoteSQLiteIdentifier(table.serverName ?? table.name);
-  if (kind === "delete") {
-    await executor.exec(`DELETE FROM ${serverTableName} WHERE ${primaryWhere}`, primaryValues);
-    return;
-  }
-  const columnNames = Object.keys(values);
-  if (columnNames.length === 0) {
-    throw new Error(`${tableName}.${kind} has no values`);
-  }
-  const serverColumns = columnNames.map(columnName => quoteSQLiteIdentifier(serverColumn(table, columnName)));
-  const params = columnNames.map(columnName => encodeColumn(options, tableName, columnName, values[columnName]));
-  const insert = `INSERT INTO ${serverTableName} (${serverColumns.join(", ")}) VALUES (${columnNames.map(() => "?").join(", ")})`;
-  if (kind === "insert") {
-    await executor.exec(insert, params);
-    return;
-  }
-  if (kind === "upsert") {
-    const mutableColumns2 = columnNames.filter(columnName => !table.primaryKey.includes(columnName));
-    const conflictColumns = table.primaryKey.map(columnName => quoteSQLiteIdentifier(serverColumn(table, columnName))).join(", ");
-    const conflictAction = mutableColumns2.length === 0 ? "DO NOTHING" : `DO UPDATE SET ${mutableColumns2.map(columnName => {
-      const column = quoteSQLiteIdentifier(serverColumn(table, columnName));
-      return `${column} = excluded.${column}`;
-    }).join(", ")}`;
-    await executor.exec(`${insert} ON CONFLICT (${conflictColumns}) ${conflictAction}`, params);
-    return;
-  }
-  const mutableColumns = columnNames.filter(columnName => !table.primaryKey.includes(columnName));
-  if (mutableColumns.length === 0) return;
-  await executor.exec(`UPDATE ${serverTableName} SET ${mutableColumns.map(columnName => `${quoteSQLiteIdentifier(serverColumn(table, columnName))} = ?`).join(", ")} WHERE ${primaryWhere}`, [...mutableColumns.map(columnName => encodeColumn(options, tableName, columnName, values[columnName])), ...primaryValues]);
-}
-function serverColumn(table, columnName) {
-  const column = table.columns[columnName];
-  if (!column) throw new Error(`unknown SQLite column ${table.name}.${columnName}`);
-  return column.serverName ?? columnName;
-}
-function encodeColumn(options, tableName, columnName, value) {
-  return options.encodeValue(value, {
-    column: options.schema.tables[tableName].columns[columnName],
-    columnName,
-    tableName
-  });
-}
-function createLegacyQueryBuilder(schema, run) {
-  const builder = (0, import_zero.createBuilder)(schema);
-  return new Proxy(builder, {
-    get(target, property) {
-      return makeRunnableQuery(Reflect.get(target, property, target), run);
-    }
-  });
-}
-function makeRunnableQuery(query, run) {
-  if (!isQueryBuilder(query)) return query;
-  return new Proxy(query, {
-    get(target, property) {
-      if (property === "run") return () => run(target);
-      if (property === "materialize" || property === "preload") {
-        return () => {
-          throw new Error(`${String(property)}() is not supported in server transactions`);
-        };
-      }
-      const value = Reflect.get(target, property, target);
-      if (typeof value !== "function") return value;
-      return (...args) => makeRunnableQuery(Reflect.apply(value, target, args), run);
-    }
-  });
-}
-function isQueryBuilder(value) {
-  if (!value || typeof value !== "object") return false;
-  try {
-    (0, import_bindings.asQueryInternals)(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function createLedgerHooks(options, executor, ensureLedger, input) {
-  const upstreamSchema = input?.upstreamSchema ?? "";
-  const clientGroupID = input?.clientGroupID ?? "";
-  const clientID = input?.clientID ?? "";
-  const tables = options.ledgerTables(upstreamSchema);
-  const clientsTable = quoteSQLiteIdentifier(tables.clients);
-  const mutationsTable = quoteSQLiteIdentifier(tables.mutations);
-  return {
-    async updateClientMutationID() {
-      await ensureLedger(upstreamSchema);
-      const rows = await executor.query(`INSERT INTO ${clientsTable}
-           (clientGroupID, clientID, lastMutationID)
-         VALUES (?, ?, 1)
-         ON CONFLICT (clientGroupID, clientID)
-         DO UPDATE SET lastMutationID = lastMutationID + 1
-         RETURNING lastMutationID`, [clientGroupID, clientID]);
-      const lastMutationID = rows[0]?.lastMutationID;
-      if (typeof lastMutationID !== "number" && typeof lastMutationID !== "bigint") {
-        throw new Error("SQLite mutation ledger returned no lastMutationID");
-      }
-      return {
-        lastMutationID
-      };
-    },
-    async writeMutationResult(result) {
-      await ensureLedger(upstreamSchema);
-      await executor.exec(`INSERT INTO ${mutationsTable}
-           (clientGroupID, clientID, mutationID, result)
-         VALUES (?, ?, ?, ?)`, [clientGroupID, result.id.clientID, result.id.id, JSON.stringify(result.result)]);
-    },
-    async deleteMutationResults(args) {
-      await ensureLedger(upstreamSchema);
-      if ("type" in args && args.type === "bulk") {
-        if (args.clientIDs.length === 0) return;
-        await executor.exec(`DELETE FROM ${mutationsTable}
-           WHERE clientGroupID = ?
-             AND clientID IN (${args.clientIDs.map(() => "?").join(", ")})`, [args.clientGroupID, ...args.clientIDs]);
-        return;
-      }
-      await executor.exec(`DELETE FROM ${mutationsTable}
-         WHERE clientGroupID = ?
-           AND clientID = ?
-           AND mutationID <= ?`, [args.clientGroupID, args.clientID, args.upToMutationID]);
-    }
-  };
-}
-async function persistAlreadyProcessedMutationResults(options, {
-  clientGroupID,
-  mutations,
-  upstreamSchema
-}) {
-  const tables = options.ledgerTables(upstreamSchema);
-  const table = quoteSQLiteIdentifier(tables.mutations);
-  const key = ledgerKey(tables);
-  await options.transactionProvider(async executor => {
-    if (!options.initializedLedgers.has(key)) {
-      await createLedgerTables(executor, tables);
-    }
-    for (const mutation of mutations) {
-      await executor.exec(`INSERT INTO ${table}
-           (clientGroupID, clientID, mutationID, result)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT (clientGroupID, clientID, mutationID) DO NOTHING`, [clientGroupID, mutation.id.clientID, mutation.id.id, JSON.stringify(mutation.result)]);
-    }
-  });
-  options.initializedLedgers.add(key);
-}
-async function createLedgerTables(executor, tables) {
-  await executor.exec(`CREATE TABLE IF NOT EXISTS ${quoteSQLiteIdentifier(tables.clients)} (
-       clientGroupID TEXT NOT NULL,
-       clientID TEXT NOT NULL,
-       lastMutationID INTEGER NOT NULL,
-       PRIMARY KEY (clientGroupID, clientID)
-     )`);
-  await executor.exec(`CREATE TABLE IF NOT EXISTS ${quoteSQLiteIdentifier(tables.mutations)} (
-       clientGroupID TEXT NOT NULL,
-       clientID TEXT NOT NULL,
-       mutationID INTEGER NOT NULL,
-       result TEXT NOT NULL,
-       PRIMARY KEY (clientGroupID, clientID, mutationID)
-     )`);
-}
-function ledgerKey(tables) {
-  return `${tables.clients}\0${tables.mutations}`;
-}
-function defaultLedgerTables(upstreamSchema) {
-  const prefix = upstreamSchema ? `${upstreamSchema}_` : "";
-  return {
-    clients: `${prefix}clients`,
-    mutations: `${prefix}mutations`
-  };
-}
-function encodeSQLiteValue(value, {
-  column
-}) {
-  if (value === null) return null;
-  if (column.type === "boolean") return value ? 1 : 0;
-  if (column.type === "json") return JSON.stringify(value);
-  return value;
-}
-function quoteSQLiteIdentifier(value) {
-  return `"${value.replaceAll('"', '""')}"`;
 }