on-zero 0.7.2-1784530701923 → 0.7.2

package/dist/cjs/createZeroServer.cjs

@@ -0,0 +1,82 @@
+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 createZeroServer_exports = {};
+__export(createZeroServer_exports, {
+  createZeroServer: () => createZeroServer
+});
+module.exports = __toCommonJS(createZeroServer_exports);
+var import_pg = require("@rocicorp/zero/server/adapters/pg");
+var import_helpers = require("@take-out/helpers");
+var import_pg2 = require("pg");
+var import_createZeroServerCore = require("./createZeroServerCore.cjs");
+function createZeroServer({
+  database,
+  pool: externalPool,
+  ...options
+}) {
+  let pool;
+  if (externalPool) {
+    pool = externalPool;
+  } else {
+    const dbString = (0, import_helpers.assertString)(database, 'createZeroServer "database"');
+    const pgPool = new import_pg2.Pool({
+      connectionString: dbString,
+      ssl: dbString.includes("sslmode=require") ? {
+        rejectUnauthorized: false
+      } : void 0
+    });
+    pgPool.on("error", error => {
+      console.error("[on-zero] pool error", error.message);
+    });
+    pgPool.on("connect", client => {
+      client.on("error", error => {
+        console.error("[on-zero] client error", error.message);
+      });
+    });
+    pool = pgPool;
+  }
+  const databaseProvider = (0, import_pg.zeroNodePg)(options.schema, pool);
+  return (0, import_createZeroServerCore.createZeroServerCore)({
+    ...options,
+    createDatabase: () => databaseProvider,
+    persistAlreadyProcessed: args => persistAlreadyProcessedMutationResults(pool, args)
+  });
+}
+async function persistAlreadyProcessedMutationResults(pool, {
+  clientGroupID,
+  mutations,
+  upstreamSchema
+}) {
+  const table = `${quotePgIdentifier(upstreamSchema)}."mutations"`;
+  const values = mutations.map((_, index) => {
+    const offset = index * 4;
+    return `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}::json)`;
+  }).join(", ");
+  const params = mutations.flatMap(mutation => [clientGroupID, mutation.id.clientID, mutation.id.id, JSON.stringify(mutation.result)]);
+  await pool.query(`INSERT INTO ${table} ("clientGroupID", "clientID", "mutationID", "result")
+     VALUES ${values}
+     ON CONFLICT ("clientGroupID", "clientID", "mutationID") DO NOTHING`, params);
+}
+function quotePgIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}

package/dist/cjs/createZeroServer.native.js

@@ -0,0 +1,93 @@
+"use strict";
+
+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 createZeroServer_exports = {};
+__export(createZeroServer_exports, {
+  createZeroServer: () => createZeroServer
+});
+module.exports = __toCommonJS(createZeroServer_exports);
+var import_pg = require("@rocicorp/zero/server/adapters/pg");
+var import_helpers = require("@take-out/helpers");
+var import_pg2 = require("pg");
+var import_createZeroServerCore = require("./createZeroServerCore.native.js");
+function createZeroServer(param) {
+  var {
+    database,
+    pool: externalPool,
+    ...options
+  } = param;
+  var pool;
+  if (externalPool) {
+    pool = externalPool;
+  } else {
+    var dbString = (0, import_helpers.assertString)(database, 'createZeroServer "database"');
+    var pgPool = new import_pg2.Pool({
+      connectionString: dbString,
+      ssl: dbString.includes("sslmode=require") ? {
+        rejectUnauthorized: false
+      } : void 0
+    });
+    pgPool.on("error", function (error) {
+      console.error("[on-zero] pool error", error.message);
+    });
+    pgPool.on("connect", function (client) {
+      client.on("error", function (error) {
+        console.error("[on-zero] client error", error.message);
+      });
+    });
+    pool = pgPool;
+  }
+  var databaseProvider = (0, import_pg.zeroNodePg)(options.schema, pool);
+  return (0, import_createZeroServerCore.createZeroServerCore)({
+    ...options,
+    createDatabase: function () {
+      return databaseProvider;
+    },
+    persistAlreadyProcessed: function (args) {
+      return persistAlreadyProcessedMutationResults(pool, args);
+    }
+  });
+}
+async function persistAlreadyProcessedMutationResults(pool, param) {
+  var {
+    clientGroupID,
+    mutations,
+    upstreamSchema
+  } = param;
+  var table = `${quotePgIdentifier(upstreamSchema)}."mutations"`;
+  var values = mutations.map(function (_, index) {
+    var offset = index * 4;
+    return `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}::json)`;
+  }).join(", ");
+  var params = mutations.flatMap(function (mutation) {
+    return [clientGroupID, mutation.id.clientID, mutation.id.id, JSON.stringify(mutation.result)];
+  });
+  await pool.query(`INSERT INTO ${table} ("clientGroupID", "clientID", "mutationID", "result")
+     VALUES ${values}
+     ON CONFLICT ("clientGroupID", "clientID", "mutationID") DO NOTHING`, params);
+}
+function quotePgIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+//# sourceMappingURL=createZeroServer.native.js.map

package/dist/cjs/createZeroServer.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","createZeroServer_exports","__export","createZeroServer","module","exports","import_pg","require","import_helpers","import_pg2","import_createZeroServerCore","param","database","pool","externalPool","options","dbString","assertString","pgPool","Pool","connectionString","ssl","includes","rejectUnauthorized","on","error","console","message","client","databaseProvider","zeroNodePg","schema","createZeroServerCore","createDatabase","persistAlreadyProcessed","args","persistAlreadyProcessedMutationResults","clientGroupID","mutations","upstreamSchema","table","quotePgIdentifier","values","map","_","index","offset","join","params","flatMap","mutation","id","clientID","JSON","stringify","result","query"],"sources":["../../src/createZeroServer.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,wBAAA;AAAAC,QAAA,CAAAD,wBAAA;EAAAE,gBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAA2BT,YAAA,CAAAK,wBAAA;AAC3B,IAAAK,SAAA,GAAAC,OAA6B;AAC7B,IAAAC,cAAqB,GAAAD,OAAA;AAErB,IAAAE,UAAA,GAAAF,OAAA;AAqBO,IAAAG,2BAIL,GAAAH,OAAA;AAAA,SACAJ,iBAAAQ,KAAA;EACA;IAAMC,QAAA;IAAAC,IAAA,EAAAC,YAAA;IAAA,GAAAC;EAAA,IAAAJ,KAAA;EACN,IAAGE,IAAA;EACL,IAW8CC,YAAA;IAC5CD,IAAI,GAAAC,YAAA;EACJ,OAAI;IACF,IAAAE,QAAO,OAAAR,cAAA,CAAAS,YAAA,EAAAL,QAAA;IACT,IAAAM,MAAO,OAAAT,UAAA,CAAAU,IAAA;MACLC,gBAAM,EAAAJ,QAAW;MACjBK,GAAA,EAAML,QAAS,CAAAM,QAAI,kBAAK;QACtBC,kBAAkB;MAClB,SAAK;IAGP,CAAC;IACDL,MAAA,CAAOM,EAAA,CAAG,SAAS,UAACC,KAAU;MAC5BC,OAAA,CAAQD,KAAA,CAAM,wBAAwBA,KAAA,CAAME,OAAO;IACrD,CAAC;IACDT,MAAA,CAAOM,EAAA,CAAG,WAAW,UAACI,MAAW;MAC/BA,MAAA,CAAOJ,EAAA,CAAG,SAAS,UAACC,KAAU;QAC5BC,OAAA,CAAQD,KAAA,CAAM,0BAA0BA,KAAA,CAAME,OAAO;MACvD,CAAC;IACH,CAAC;IACDd,IAAA,GAAOK,MAAA;EACT;EAEA,IAAAW,gBAAM,OAAAvB,SAAmB,CAAAwB,UAAA,EAAAf,OAAW,CAAAgB,MAAQ,EAAAlB,IAAQ;EAEpD,WAAOH,2BAAA,CAAAsB,oBAAA,EAAqB;IAC1B,GAAGjB,OAAA;IACHkB,cAAA,EAAgB,SAAAA,CAAA,EAAM;MACtB,OAAAJ,gBAAyB;IAC1B;IACHK,uBAAA,WAAAA,CAAAC,IAAA;MAEA,OAAAC,sCAAe,CAAAvB,IACb,EAAAsB,IACE;IAEF;EACA;AAEI;AACA,eAAOC,sCAAqCA,CAAAvB,IAAU,EAAAF,KAAM;EAC9D,IACC;IAAA0B,aAAS;IAAAC,SAAA;IAAAC;EAAA,IAAA5B,KAAA;EACZ,IAAA6B,KAAM,MAASC,iBAAU,CAAQF,cAAc;EAAA,IAC7CG,MAAA,GAAAJ,SAAA,CAAAK,GAAA,WAAAC,CAAA,EAAAC,KAAA;IACA,IAAAC,MAAS,GAAGD,KAAA;IACZ,YAAYC,MAAA,UAAAA,MAAA,UAAAA,MAAA,UAAAA,MAAA;EAAA,EACZ,CAAAC,IAAK;EACP,IAACC,MAAA,GAAAV,SAAA,CAAAW,OAAA,WAAAC,QAAA;IAED,OAAM,CACJb,aAAe,EAAKa,QACV,CAAAC,EAAA,CAAAC,QAAM,EAAAF,QAAA,CAAAC,EAAA,CAAAA,EAAA,EAEhBE,IAAA,CAAAC,SAAA,CAAAJ,QAAA,CAAAK,MAAA,EACF;EACF;EAEA,MAAA1C,IAAS,CAAA2C,KAAA,gBAAiChB,KAAA;AACxC,cAAWE,MAAM;AACnB,0EAAAM,MAAA","ignoreList":[]}

package/dist/cjs/createZeroServer.test.cjs

@@ -0,0 +1,378 @@
+var import_vitest = require("vitest");
+var import_createZeroServer = require("./createZeroServer.cjs");
+var import_fixtureSchema = require("./httpPull/fixtureSchema.cjs");
+class FakePgClient {
+  lastMutationID = 0;
+  pendingLastMutationID;
+  mutationResultInserts = [];
+  async query(sql, params = []) {
+    if (sql === "BEGIN") {
+      this.pendingLastMutationID = void 0;
+      return {
+        rows: []
+      };
+    }
+    if (sql === "COMMIT") {
+      if (this.pendingLastMutationID !== void 0) {
+        this.lastMutationID = this.pendingLastMutationID;
+      }
+      this.pendingLastMutationID = void 0;
+      return {
+        rows: []
+      };
+    }
+    if (sql === "ROLLBACK") {
+      this.pendingLastMutationID = void 0;
+      return {
+        rows: []
+      };
+    }
+    if (sql.includes(".clients") && sql.includes('RETURNING "lastMutationID"')) {
+      const nextMutationID = this.lastMutationID + 1;
+      this.pendingLastMutationID = nextMutationID;
+      return {
+        rows: [{
+          lastMutationID: nextMutationID
+        }]
+      };
+    }
+    if (sql.includes("information_schema.columns")) {
+      return {
+        rows: [...schemaRows("user", ["id", "name"]), ...schemaRows("project", ["id", "ownerId", "name"]), ...schemaRows("member", ["id", "projectId", "userId"])]
+      };
+    }
+    if (sql.includes('INSERT INTO "zero_0"."mutations"') || sql.includes('INSERT INTO "zero_0".mutations')) {
+      this.mutationResultInserts.push(params);
+      return {
+        rows: []
+      };
+    }
+    throw new Error(`unexpected fake pg query: ${sql}`);
+  }
+}
+function schemaRows(table, columns) {
+  return columns.map(column => ({
+    schema: "public",
+    table,
+    column,
+    dataType: "text",
+    length: null,
+    precision: null,
+    scale: null,
+    typtype: "b",
+    typename: "text",
+    elemTyptype: null,
+    elemTypname: null
+  }));
+}
+function pushRequest(mutationIDs) {
+  const ids = Array.isArray(mutationIDs) ? mutationIDs : [mutationIDs];
+  return new Request("http://localhost/push?schema=zero_0&appID=zero", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      clientGroupID: "cg1",
+      mutations: ids.map(mutationID => ({
+        type: "custom",
+        id: mutationID,
+        clientID: "client-a",
+        name: "project.touch",
+        args: [{}],
+        timestamp: 1
+      })),
+      pushVersion: 1,
+      timestamp: 1,
+      requestID: `req-${ids.join("-")}`
+    })
+  });
+}
+(0, import_vitest.describe)("createZeroServer mutation recovery", () => {
+  (0, import_vitest.test)("discards async tasks from a rolled-back PostgreSQL mutation", async () => {
+    const pg = new FakePgClient();
+    let effectRuns = 0;
+    const consoleWarn = import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+    const zeroServer = (0, import_createZeroServer.createZeroServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({
+              server
+            }) => {
+              server?.enqueueTask(async () => {
+                effectRuns++;
+              });
+              throw new Error("rejected");
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      pool: pg
+    });
+    const result = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1),
+      skipAsyncTasks: true
+    });
+    (0, import_vitest.expect)(result.response.mutations[0].result).toMatchObject({
+      error: "app",
+      message: "rejected"
+    });
+    (0, import_vitest.expect)(result.asyncTasks).toEqual([]);
+    (0, import_vitest.expect)(effectRuns).toBe(0);
+    (0, import_vitest.expect)(consoleWarn).toHaveBeenCalledWith("PushProcessor", import_vitest.expect.stringContaining("Error processing mutation"), import_vitest.expect.stringContaining("rejected"));
+    consoleWarn.mockRestore();
+  });
+  (0, import_vitest.test)("awaits barrier tasks before resolving the push response", async () => {
+    const pg = new FakePgClient();
+    let releaseBarrier;
+    let markBarrierStarted;
+    const barrierStarted = new Promise(resolve => {
+      markBarrierStarted = resolve;
+    });
+    const barrier = new Promise(resolve => {
+      releaseBarrier = resolve;
+    });
+    const zeroServer = (0, import_createZeroServer.createZeroServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({
+              server
+            }) => {
+              server?.enqueueTask(async () => {
+                markBarrierStarted();
+                await barrier;
+              }, {
+                barrier: true
+              });
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      pool: pg
+    });
+    let responseResolved = false;
+    const resultPromise = zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1)
+    }).then(result2 => {
+      responseResolved = true;
+      return result2;
+    });
+    await barrierStarted;
+    await Promise.resolve();
+    (0, import_vitest.expect)(responseResolved).toBe(false);
+    releaseBarrier();
+    const result = await resultPromise;
+    (0, import_vitest.expect)(result.response.mutations[0].result).toEqual({});
+  });
+  (0, import_vitest.test)("does not fail the push when a background task rejects", async () => {
+    const pg = new FakePgClient();
+    const error = new Error("background failed");
+    const consoleError = import_vitest.vi.spyOn(console, "error").mockImplementation(() => {});
+    const zeroServer = (0, import_createZeroServer.createZeroServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({
+              server
+            }) => {
+              server?.enqueueTask(async () => {
+                throw error;
+              });
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      pool: pg
+    });
+    const result = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1)
+    });
+    (0, import_vitest.expect)(result.response.mutations[0].result).toEqual({});
+    await import_vitest.vi.waitFor(() => {
+      (0, import_vitest.expect)(consoleError).toHaveBeenCalledWith("[on-zero] async task failed", error);
+    });
+    consoleError.mockRestore();
+  });
+  (0, import_vitest.test)("registers a promise that settles every background task with the request scheduler", async () => {
+    const pg = new FakePgClient();
+    const error = new Error("background failed");
+    const consoleError = import_vitest.vi.spyOn(console, "error").mockImplementation(() => {});
+    let releaseSibling;
+    const siblingGate = new Promise(resolve => {
+      releaseSibling = resolve;
+    });
+    let siblingFinished = false;
+    let scheduled;
+    const zeroServer = (0, import_createZeroServer.createZeroServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({
+              server
+            }) => {
+              server?.enqueueTask(async () => {
+                throw error;
+              });
+              server?.enqueueTask(async () => {
+                await siblingGate;
+                siblingFinished = true;
+              });
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      pool: pg
+    });
+    const result = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1),
+      scheduleBackgroundTask: promise => {
+        scheduled = promise;
+      }
+    });
+    (0, import_vitest.expect)(result.response.mutations[0].result).toEqual({});
+    (0, import_vitest.expect)(scheduled).toBeInstanceOf(Promise);
+    (0, import_vitest.expect)(siblingFinished).toBe(false);
+    let scheduledSettled = false;
+    void scheduled.then(() => {
+      scheduledSettled = true;
+    });
+    await Promise.resolve();
+    (0, import_vitest.expect)(scheduledSettled).toBe(false);
+    releaseSibling();
+    await scheduled;
+    (0, import_vitest.expect)(siblingFinished).toBe(true);
+    (0, import_vitest.expect)(consoleError).toHaveBeenCalledWith("[on-zero] async task failed", error);
+    consoleError.mockRestore();
+  });
+  (0, import_vitest.test)("awaits background tasks when the request has no scheduler", async () => {
+    const pg = new FakePgClient();
+    let markTaskStarted;
+    const taskStarted = new Promise(resolve => {
+      markTaskStarted = resolve;
+    });
+    let releaseTask;
+    const taskGate = new Promise(resolve => {
+      releaseTask = resolve;
+    });
+    const zeroServer = (0, import_createZeroServer.createZeroServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({
+              server
+            }) => {
+              server?.enqueueTask(async () => {
+                markTaskStarted();
+                await taskGate;
+              });
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      pool: pg
+    });
+    let responseResolved = false;
+    const resultPromise = zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1)
+    }).then(result2 => {
+      responseResolved = true;
+      return result2;
+    });
+    await taskStarted;
+    await Promise.resolve();
+    (0, import_vitest.expect)(responseResolved).toBe(false);
+    releaseTask();
+    const result = await resultPromise;
+    (0, import_vitest.expect)(result.response.mutations[0].result).toEqual({});
+  });
+  (0, import_vitest.test)("persists alreadyProcessed duplicate results for zero-cache recovery rows", async () => {
+    const pg = new FakePgClient();
+    const consoleWarn = import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+    const zeroServer = (0, import_createZeroServer.createZeroServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async () => {}
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      pool: pg
+    });
+    const first = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1)
+    });
+    (0, import_vitest.expect)(first.response.mutations[0].result).toEqual({});
+    (0, import_vitest.expect)(pg.lastMutationID).toBe(1);
+    (0, import_vitest.expect)(pg.mutationResultInserts).toEqual([]);
+    const duplicate = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1)
+    });
+    const duplicateResult = duplicate.response.mutations[0].result;
+    (0, import_vitest.expect)(duplicateResult.error).toBe("alreadyProcessed");
+    (0, import_vitest.expect)(pg.lastMutationID).toBe(1);
+    (0, import_vitest.expect)(pg.mutationResultInserts).toEqual([["cg1", "client-a", 1, JSON.stringify({
+      error: "alreadyProcessed",
+      details: duplicateResult.details
+    })]]);
+    (0, import_vitest.expect)(consoleWarn).not.toHaveBeenCalled();
+    consoleWarn.mockRestore();
+  });
+  (0, import_vitest.test)("persists only alreadyProcessed results in a mixed recovery push", async () => {
+    const pg = new FakePgClient();
+    const zeroServer = (0, import_createZeroServer.createZeroServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async () => {}
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      pool: pg
+    });
+    await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1)
+    });
+    const mixed = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest([1, 2])
+    });
+    const results = mixed.response.mutations.map(mutation => ({
+      id: mutation.id.id,
+      result: mutation.result
+    }));
+    (0, import_vitest.expect)(results[0].result.error).toBe("alreadyProcessed");
+    (0, import_vitest.expect)(results[1]).toEqual({
+      id: 2,
+      result: {}
+    });
+    (0, import_vitest.expect)(pg.lastMutationID).toBe(2);
+    (0, import_vitest.expect)(pg.mutationResultInserts).toEqual([["cg1", "client-a", 1, JSON.stringify({
+      error: "alreadyProcessed",
+      details: results[0].result.details
+    })]]);
+  });
+});