on-zero 0.6.11 → 0.6.13

package/dist/cjs/createZeroSQLiteServer.cjs

@@ -0,0 +1,319 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var createZeroSQLiteServer_exports = {};
+__export(createZeroSQLiteServer_exports, {
+  createZeroSQLiteServer: () => createZeroSQLiteServer,
+  createZeroSQLiteTransaction: () => createZeroSQLiteTransaction
+});
+module.exports = __toCommonJS(createZeroSQLiteServer_exports);
+var import_zero = require("@rocicorp/zero");
+var import_bindings = require("@rocicorp/zero/bindings");
+var import_createZeroServerCore = require("./createZeroServerCore.cjs");
+function createZeroSQLiteServer({
+  encodeValue = encodeSQLiteValue,
+  ledgerTables = defaultLedgerTables,
+  transactionProvider,
+  ...options
+}) {
+  const databaseOptions = {
+    encodeValue,
+    initializedLedgers: /* @__PURE__ */new Set(),
+    ledgerTables,
+    schema: options.schema,
+    transactionProvider
+  };
+  return (0, import_createZeroServerCore.createZeroServerCore)({
+    ...options,
+    createDatabase: () => createSQLiteDatabase(databaseOptions),
+    persistAlreadyProcessed: args => 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('"', '""')}"`;
+}