on-zero 0.7.2-1784530701923 → 0.7.2

package/dist/cjs/createZeroSQLiteServer.test.cjs

@@ -0,0 +1,595 @@
+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");
+var import_mutations = require("./mutations.cjs");
+var import_serverWhere = require("./serverWhere.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;
+  let statements;
+  (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;
+    statements = [];
+    const executor = {
+      async exec(sql, params = [], metadata) {
+        if (metadata) statements.push(metadata);
+        const result = db.prepare(sql).run(...params);
+        return {
+          changes: Number(result.changes)
+        };
+      },
+      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?.enqueueTask(async () => {
+                effectRuns++;
+              }, {
+                barrier: true
+              });
+            }
+          }
+        }
+      },
+      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);
+    (0, import_vitest.expect)(result.asyncTasks[0].barrier).toBe(true);
+    await result.asyncTasks[0].task();
+    (0, import_vitest.expect)(effectRuns).toBe(1);
+  });
+  (0, import_vitest.test)("keeps later writes after inserting an existing primary key", async () => {
+    db.prepare("INSERT INTO project (id, ownerId, name) VALUES (?, ?, ?)").run("p1", "u1", "original");
+    db.prepare("INSERT INTO project (id, ownerId, name) VALUES (?, ?, ?)").run("p2", "u1", "before");
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            converge: async ({
+              tx
+            }) => {
+              await tx.mutate.project.insert({
+                id: "p1",
+                ownerId: "u2",
+                name: "replacement"
+              });
+              await tx.mutate.project.update({
+                id: "p2",
+                name: "after"
+              });
+            }
+          }
+        }
+      },
+      createServerActions: () => ({}),
+      transactionProvider
+    });
+    const result = await server.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1, "project.converge", {})
+    });
+    (0, import_vitest.expect)(result.response.mutations[0].result).toEqual({});
+    (0, import_vitest.expect)(db.prepare("SELECT * FROM project ORDER BY id").all()).toEqual([{
+      id: "p1",
+      ownerId: "u1",
+      name: "original"
+    }, {
+      id: "p2",
+      ownerId: "u1",
+      name: "after"
+    }]);
+  });
+  (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)("allows a custom CRUD mutation to no-op without an automatic permission check", async () => {
+    const projectPermission = (0, import_serverWhere.serverWhere)("project", q => q.cmp("ownerId", "u1"));
+    const projectMutations = (0, import_mutations.mutations)("project", projectPermission, {
+      insert: async () => {}
+    });
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: projectMutations
+        }
+      },
+      createServerActions: () => ({}),
+      transactionProvider
+    });
+    const result = await server.handleMutationRequest({
+      authData: {
+        id: "u1",
+        role: "user"
+      },
+      request: pushRequest(1, "project.insert", {
+        id: "p1",
+        ownerId: "u1",
+        name: "skip"
+      })
+    });
+    (0, import_vitest.expect)(result.response.mutations[0].result).toEqual({});
+    (0, import_vitest.expect)(db.prepare("SELECT * FROM project").all()).toEqual([]);
+  });
+  (0, import_vitest.test)("rolls back when a custom CRUD mutation throws", async () => {
+    const projectPermission = (0, import_serverWhere.serverWhere)("project", q => q.cmp("ownerId", "u1"));
+    const projectMutations = (0, import_mutations.mutations)("project", projectPermission, {
+      insert: async ({
+        tx
+      }, value) => {
+        await tx.mutate.project.insert(value);
+        throw new Error("denied by custom validation");
+      }
+    });
+    const server = (0, import_createZeroSQLiteServer.createZeroSQLiteServer)({
+      schema: import_fixtureSchema.zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: projectMutations
+        }
+      },
+      createServerActions: () => ({}),
+      transactionProvider
+    });
+    const result = await server.handleMutationRequest({
+      authData: {
+        id: "u2",
+        role: "user"
+      },
+      request: pushRequest(1, "project.insert", {
+        id: "p2",
+        ownerId: "u2",
+        name: "unauthorized"
+      })
+    });
+    (0, import_vitest.expect)(result.response.mutations[0].result).toMatchObject({
+      error: "app",
+      message: "denied by custom validation"
+    });
+    (0, import_vitest.expect)(db.prepare("SELECT * FROM project").all()).toEqual([]);
+  });
+  (0, import_vitest.test)("permission-checks generated CRUD mutations", async () => {
+    let inserted;
+    let permissionChecks = 0;
+    const projectPermission = (0, import_serverWhere.serverWhere)("project", q => q.cmp("ownerId", "u1"));
+    const projectMutations = (0, import_mutations.mutations)("project", projectPermission);
+    const value = {
+      id: "p3",
+      ownerId: "u2",
+      name: "unauthorized"
+    };
+    await (0, import_vitest.expect)(projectMutations.insert({
+      tx: {
+        mutate: {
+          project: {
+            insert: async row => {
+              inserted = row;
+            }
+          }
+        }
+      },
+      can: async (_where, row) => {
+        permissionChecks++;
+        (0, import_vitest.expect)(row).toEqual(value);
+        throw new Error("denied");
+      }
+    }, value)).rejects.toThrow("denied");
+    (0, import_vitest.expect)(inserted).toEqual(value);
+    (0, import_vitest.expect)(permissionChecks).toBe(1);
+  });
+  (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.expect)(statements).toEqual([{
+      table: "note_records",
+      publicTable: "note",
+      kind: "insert"
+    }, {
+      table: "note_records",
+      publicTable: "note",
+      kind: "upsert"
+    }, {
+      table: "note_records",
+      publicTable: "note",
+      kind: "update"
+    }, {
+      table: "note_records",
+      publicTable: "note",
+      kind: "delete"
+    }]);
+  });
+  (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() {
+        return {
+          changes: 0
+        };
+      },
+      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");
+  });
+});