on-zero 0.6.11 → 0.6.13

package/dist/cjs/createZeroSQLiteServer.test.cjs

@@ -0,0 +1,429 @@
+var import_node_sqlite = require("node:sqlite");
+var import_zero = require("@rocicorp/zero");
+var import_bindings = require("@rocicorp/zero/bindings");
+var import_vitest = require("vitest");
+var import_createZeroSQLiteServer = require("./createZeroSQLiteServer.cjs");
+var import_fixtureSchema = require("./httpPull/fixtureSchema.cjs");
+const note = (0, import_zero.table)("note").from("note_records").columns({
+  id: (0, import_zero.string)().from("note_id"),
+  done: (0, import_zero.boolean)(),
+  data: (0, import_zero.json)().optional()
+}).primaryKey("id");
+const sqliteTypesSchema = (0, import_zero.createSchema)({
+  tables: [note],
+  relationships: [],
+  enableLegacyQueries: true
+});
+const person = (0, import_zero.table)("person").columns({
+  id: (0, import_zero.string)()
+}).primaryKey("id");
+const membership = (0, import_zero.table)("membership").columns({
+  personId: (0, import_zero.string)(),
+  teamId: (0, import_zero.string)()
+}).primaryKey("personId", "teamId");
+const team = (0, import_zero.table)("team").from("team_records").columns({
+  id: (0, import_zero.string)().from("team_id"),
+  active: (0, import_zero.boolean)().from("is_active"),
+  metadata: (0, import_zero.json)().from("metadata_json")
+}).primaryKey("id");
+const twoHopSchema = (0, import_zero.createSchema)({
+  tables: [person, membership, team],
+  relationships: [(0, import_zero.relationships)(person, ({
+    many
+  }) => ({
+    teams: many({
+      sourceField: ["id"],
+      destSchema: membership,
+      destField: ["personId"]
+    }, {
+      sourceField: ["teamId"],
+      destSchema: team,
+      destField: ["id"]
+    })
+  }))]
+});
+function pushRequest(id, name, args) {
+  return new Request("http://localhost/push?schema=zero_0&appID=zero", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      clientGroupID: "cg1",
+      mutations: [{
+        type: "custom",
+        id,
+        clientID: "client-a",
+        name,
+        args: [args],
+        timestamp: 1
+      }],
+      pushVersion: 1,
+      timestamp: 1,
+      requestID: "req-" + id
+    })
+  });
+}
+function cleanupRequest() {
+  return new Request("http://localhost/push?schema=zero_0&appID=zero", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      clientGroupID: "cg1",
+      mutations: [{
+        type: "custom",
+        id: 2,
+        clientID: "client-a",
+        name: "_zero_cleanupResults",
+        args: [{
+          clientGroupID: "cg1",
+          clientID: "client-a",
+          upToMutationID: 1
+        }],
+        timestamp: 1
+      }],
+      pushVersion: 1,
+      timestamp: 1,
+      requestID: "cleanup"
+    })
+  });
+}
+(0, import_vitest.describe)("createZeroSQLiteServer", () => {
+  let db;
+  let retryNextTransaction;
+  let transactionProvider;
+  (0, import_vitest.beforeEach)(() => {
+    db = new import_node_sqlite.DatabaseSync(":memory:");
+    db.exec(["CREATE TABLE project (id TEXT PRIMARY KEY, ownerId TEXT NOT NULL, name TEXT NOT NULL);", "CREATE TABLE note_records (note_id TEXT PRIMARY KEY, done INTEGER NOT NULL, data TEXT);"].join("\n"));
+    retryNextTransaction = false;
+    const executor = {
+      async exec(sql, params = []) {
+        db.prepare(sql).run(...params);
+      },
+      async query(sql, params = []) {
+        return db.prepare(sql).all(...params);
+      },
+      async queryAst(ast, format) {
+        let rows;
+        if (ast.table === "project") {
+          rows = db.prepare("SELECT * FROM project ORDER BY id").all();
+        } else if (ast.table === "note") {
+          rows = db.prepare("SELECT note_id, done, data FROM note_records ORDER BY note_id").all().map(row => ({
+            id: row.note_id,
+            done: row.done !== 0,
+            data: typeof row.data === "string" ? JSON.parse(row.data) : row.data
+          }));
+        } else if (ast.table === "person") {
+          rows = [{
+            id: "p1",
+            teams: [{
+              id: "t1",
+              active: true,
+              metadata: {
+                label: "core"
+              }
+            }]
+          }];
+        } else {
+          throw new Error("unexpected table " + ast.table);
+        }
+        return format.singular ? rows[0] : rows;
+      }
+    };
+    const run = async callback => {
+      db.exec("BEGIN");
+      try {
+        const value = await callback(executor);
+        db.exec("COMMIT");
+        return value;
+      } catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+      }
+    };
+    transactionProvider = async callback => {
+      if (retryNextTransaction) {
+        retryNextTransaction = false;
+        db.exec("BEGIN");
+        await callback(executor);
+        db.exec("ROLLBACK");
+      }
+      return run(callback);
+    };
+  });
+  (0, import_vitest.afterEach)(() => {
+    db.close();
+  });
+  (0, import_vitest.test)("commits CRUD, the mutation ledger, and one retry-safe async task", async () => {
+    let effectRuns = 0;
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            create: async ({
+              tx,
+              server: server2
+            }, value) => {
+              await tx.mutate.project.insert(value);
+              server2?.asyncTasks.push(async () => {});
+              (0, import_vitest.expect)(server2?.asyncTasks).toHaveLength(1);
+              server2?.asyncTasks.splice(0, 1, async () => {});
+              server2.asyncTasks[0] = async () => {
+                effectRuns++;
+              };
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      transactionProvider
+    });
+    retryNextTransaction = true;
+    const result = await server.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1, "project.create", {
+        id: "p1",
+        ownerId: "u1",
+        name: "first"
+      }),
+      skipAsyncTasks: true
+    });
+    (0, import_vitest.expect)(result.response.mutations[0].result).toEqual({});
+    (0, import_vitest.expect)(db.prepare("SELECT * FROM project").all()).toEqual([{
+      id: "p1",
+      ownerId: "u1",
+      name: "first"
+    }]);
+    (0, import_vitest.expect)(db.prepare("SELECT * FROM zero_0_clients").all()).toEqual([{
+      clientGroupID: "cg1",
+      clientID: "client-a",
+      lastMutationID: 1
+    }]);
+    (0, import_vitest.expect)(result.asyncTasks).toHaveLength(1);
+    await result.asyncTasks[0]();
+    (0, import_vitest.expect)(effectRuns).toBe(1);
+  });
+  (0, import_vitest.test)("rolls back row writes and persists an application error with its LMID", async () => {
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            fail: async ({
+              tx
+            }, value) => {
+              await tx.mutate.project.insert(value);
+              throw new Error("rejected");
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      transactionProvider
+    });
+    const result = await server.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1, "project.fail", {
+        id: "p1",
+        ownerId: "u1",
+        name: "first"
+      })
+    });
+    (0, import_vitest.expect)(result.response.mutations[0].result).toMatchObject({
+      error: "app",
+      message: "rejected"
+    });
+    (0, import_vitest.expect)(db.prepare("SELECT * FROM project").all()).toEqual([]);
+    (0, import_vitest.expect)(db.prepare("SELECT lastMutationID FROM zero_0_clients").get()).toEqual({
+      lastMutationID: 1
+    });
+    const stored = db.prepare("SELECT result FROM zero_0_mutations").get();
+    (0, import_vitest.expect)(JSON.parse(stored.result)).toMatchObject({
+      error: "app",
+      message: "rejected"
+    });
+  });
+  (0, import_vitest.test)("recovers duplicate results and deletes them through the cleanup mutation", async () => {
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            create: async ({
+              tx
+            }, value2) => {
+              await tx.mutate.project.insert(value2);
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      transactionProvider
+    });
+    const value = {
+      id: "p1",
+      ownerId: "u1",
+      name: "first"
+    };
+    await server.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1, "project.create", value)
+    });
+    const duplicate = await server.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1, "project.create", value)
+    });
+    (0, import_vitest.expect)(duplicate.response.mutations[0].result).toMatchObject({
+      error: "alreadyProcessed"
+    });
+    (0, import_vitest.expect)(db.prepare("SELECT lastMutationID FROM zero_0_clients").get()).toEqual({
+      lastMutationID: 1
+    });
+    (0, import_vitest.expect)(db.prepare("SELECT COUNT(*) AS count FROM zero_0_mutations").get()).toEqual({
+      count: 1
+    });
+    await server.handleMutationRequest({
+      authData: null,
+      request: cleanupRequest()
+    });
+    (0, import_vitest.expect)(db.prepare("SELECT COUNT(*) AS count FROM zero_0_mutations").get()).toEqual({
+      count: 0
+    });
+  });
+  (0, import_vitest.test)("supports direct CRUD, server names, value codecs, and query AST execution", async () => {
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: sqliteTypesSchema,
+      models: {
+        note: {
+          mutate: {
+            insert: async ({
+              tx
+            }, value) => {
+              await tx.mutate.note.insert(value);
+            },
+            upsert: async ({
+              tx
+            }, value) => {
+              await tx.mutate.note.upsert(value);
+            },
+            update: async ({
+              tx
+            }, value) => {
+              await tx.mutate.note.update(value);
+            },
+            delete: async ({
+              tx
+            }, value) => {
+              await tx.mutate.note.delete(value);
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      transactionProvider
+    });
+    await server.mutate.note.insert({
+      id: "n1",
+      done: false,
+      data: {
+        label: "first"
+      }
+    });
+    await server.mutate.note.upsert({
+      id: "n1",
+      done: true,
+      data: {
+        label: "second"
+      }
+    });
+    await server.mutate.note.update({
+      id: "n1",
+      done: false
+    });
+    (0, import_vitest.expect)(db.prepare("SELECT * FROM note_records").get()).toEqual({
+      note_id: "n1",
+      done: 0,
+      data: JSON.stringify({
+        label: "second"
+      })
+    });
+    await (0, import_vitest.expect)(server.query(q => q.note)).resolves.toEqual([{
+      id: "n1",
+      done: false,
+      data: {
+        label: "second"
+      }
+    }]);
+    await server.transaction(async tx => {
+      if (tx.location !== "server") throw new Error("expected server transaction");
+      await (0, import_vitest.expect)(tx.query.note.one().run()).resolves.toEqual({
+        id: "n1",
+        done: false,
+        data: {
+          label: "second"
+        }
+      });
+      await (0, import_vitest.expect)(tx.dbTransaction.query("SELECT * FROM note_records", [])).resolves.toEqual([{
+        note_id: "n1",
+        done: 0,
+        data: JSON.stringify({
+          label: "second"
+        })
+      }]);
+    });
+    await server.mutate.note.delete({
+      id: "n1"
+    });
+    (0, import_vitest.expect)(db.prepare("SELECT * FROM note_records").all()).toEqual([]);
+  });
+  (0, import_vitest.test)("decodes destination rows through a hidden two-hop junction", async () => {
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: twoHopSchema,
+      models: {},
+      createServerActions: () => ({}),
+      transactionProvider
+    });
+    await (0, import_vitest.expect)(server.query(q => q.person.related("teams"))).resolves.toEqual([{
+      id: "p1",
+      teams: [{
+        id: "t1",
+        active: true,
+        metadata: {
+          label: "core"
+        }
+      }]
+    }]);
+  });
+  (0, import_vitest.test)("accepts a hydrated singular query result from the transaction executor", async () => {
+    const hydrated = {
+      id: "n1",
+      done: false,
+      data: {
+        label: "already decoded"
+      }
+    };
+    let receivedQueryName;
+    const hydratedExecutor = {
+      async exec() {},
+      async query() {
+        return [];
+      },
+      async queryAst(_ast, _format, queryName) {
+        receivedQueryName = queryName;
+        return hydrated;
+      }
+    };
+    const hydratedProvider = async callback => callback(hydratedExecutor);
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: sqliteTypesSchema,
+      models: {},
+      createServerActions: () => ({}),
+      transactionProvider: hydratedProvider
+    });
+    await (0, import_vitest.expect)(server.query(q => (0, import_bindings.asQueryInternals)(q.note.one()).nameAndArgs("noteByID", ["n1"]))).resolves.toEqual(hydrated);
+    (0, import_vitest.expect)(receivedQueryName).toBe("noteByID");
+  });
+});