on-zero 0.16.16 → 0.16.17

package/dist/esm/mutations.test.native.js

@@ -1,7 +1,67 @@
-import { describe, expect, test } from "vitest";
+import { AsyncLocalStorage } from "async_hooks";
+import { DatabaseSync } from "node:sqlite";
+import { createSchema, string, table } from "@rocicorp/zero";
+import { createSQLiteApplicationDatabase, createSyncExecutor } from "orez-lite";
+import { createQueryCompiler } from "orez-lite/cloudflare/query-compiler";
+import { executeTransactionQueryPlan } from "orez-lite/cloudflare/transaction-query";
+import { afterAll, describe, expect, test, vi } from "vitest";
+import { createZeroServerBindings, setupAsyncLocalStorage } from "./server.native.js";
+import { getMutationsPermissions } from "./modelRegistry.native.js";
 import { mutations } from "./mutations.native.js";
 import { serverWhere } from "./serverWhere.native.js";
+var previousEnvironment = vi.hoisted(function () {
+  var previous = process.env.VITE_ENVIRONMENT;
+  process.env.VITE_ENVIRONMENT = "client";
+  return previous;
+});
+afterAll(function () {
+  if (previousEnvironment === void 0) delete process.env.VITE_ENVIRONMENT;else process.env.VITE_ENVIRONMENT = previousEnvironment;
+});
 describe("mutations registry", function () {
+  test("explicit opt-out removes generated CRUD from existing proxies and retains permissions", async function () {
+    var record = table("closedRecord").columns({
+      id: string()
+    }).primaryKey("id");
+    var permission = serverWhere("closedRecord", function () {
+      return true;
+    });
+    var first = mutations(record, permission);
+    expect(Object.keys(first).sort()).toEqual(["delete", "insert", "update", "upsert"]);
+    var custom = vi.fn(async function () {});
+    var closed = mutations(record, permission, {
+      custom
+    }, {
+      crud: false
+    });
+    expect(closed).toBe(first);
+    expect(Object.keys(closed)).toEqual(["custom"]);
+    expect("insert" in closed).toBe(false);
+    expect(Reflect.get(closed, "upsert")).toBeUndefined();
+    expect(getMutationsPermissions("closedRecord")).toBe(permission);
+    await closed.custom();
+    expect(custom).toHaveBeenCalledOnce();
+    var reopened = mutations(record, permission, {}, {
+      crud: true
+    });
+    expect(Object.keys(reopened).sort()).toEqual(["custom", "delete", "insert", "update", "upsert"]);
+  });
+  test("opt-out preserves explicitly declared CRUD handlers", async function () {
+    var record = table("customRecord").columns({
+      id: string()
+    }).primaryKey("id");
+    var permission = serverWhere("customRecord", function () {
+      return true;
+    });
+    var insert = vi.fn(async function () {});
+    var custom = mutations(record, permission, {
+      insert
+    }, {
+      crud: false
+    });
+    expect(Object.keys(custom)).toEqual(["insert"]);
+    await custom.insert();
+    expect(insert).toHaveBeenCalledOnce();
+  });
   test("re-registering a handler replaces it per key (HMR)", function () {
     var permissions = serverWhere("post", function () {
       return true;
@@ -17,4 +77,203 @@ describe("mutations registry", function () {
     expect(proxy.custom).toBe(v2);
   });
 });
+describe("generated CRUD authorization", function () {
+  test("authorizes both sides of composite-key writes through the server executor", async function () {
+    setupAsyncLocalStorage(AsyncLocalStorage);
+    var document = table("document").columns({
+      workspace: string(),
+      id: string(),
+      ownerId: string(),
+      title: string()
+    }).primaryKey("workspace", "id");
+    var schema = createSchema({
+      tables: [document],
+      relationships: [],
+      enableLegacyQueries: true
+    });
+    var sqlite = new DatabaseSync(":memory:");
+    sqlite.exec("CREATE TABLE document (workspace TEXT, id TEXT, ownerId TEXT, title TEXT, PRIMARY KEY (workspace, id))");
+    var compile = createQueryCompiler(schema);
+    var query = async function query2(sql) {
+      var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+      return sqlite.prepare(sql).all(...params.map(function (value) {
+        return value;
+      }));
+    };
+    var tx = {
+      query,
+      exec: async function exec(sql) {
+        var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+        return {
+          changes: Number(sqlite.prepare(sql).run(...params.map(function (value) {
+            return value;
+          })).changes)
+        };
+      },
+      queryAst: async function queryAst(ast, format, queryName) {
+        return executeTransactionQueryPlan(compile(ast, format), function (sql, params) {
+          return sqlite.prepare(sql).all(...params.map(function (value) {
+            return value;
+          }));
+        }, {
+          queryName
+        });
+      }
+    };
+    var database = createSQLiteApplicationDatabase({
+      query,
+      transaction: async function transaction(work) {
+        sqlite.exec("BEGIN");
+        try {
+          var result = await work(tx);
+          sqlite.exec("COMMIT");
+          return result;
+        } catch (error) {
+          sqlite.exec("ROLLBACK");
+          throw error;
+        }
+      }
+    });
+    var permission = serverWhere("document", function (eb, auth2) {
+      return eb.cmp("ownerId", auth2 && "id" in auth2 && typeof auth2.id === "string" ? auth2.id : "");
+    });
+    var bindings = createZeroServerBindings({
+      schema,
+      models: {
+        document: {
+          mutate: mutations(document, permission)
+        }
+      },
+      createServerActions: function createServerActions() {
+        return {};
+      }
+    });
+    var executor = createSyncExecutor({
+      database,
+      schema,
+      mutators: bindings.mutators,
+      effects: {
+        runBackground: function runBackground(promise) {
+          return promise;
+        },
+        report: function report(error) {
+          throw error;
+        }
+      }
+    });
+    var server = bindings.server(executor);
+    var auth = {
+      authData: {
+        id: "alice"
+      }
+    };
+    var own = {
+      workspace: "a",
+      id: "same",
+      ownerId: "alice",
+      title: "own"
+    };
+    var foreign = {
+      workspace: "b",
+      id: "same",
+      ownerId: "bob",
+      title: "foreign"
+    };
+    try {
+      await server.mutate.document.insert(own, auth);
+      await server.mutate.document.insert(foreign, {
+        authData: {
+          id: "bob"
+        }
+      });
+      await expect(server.mutate.document.insert({
+        ...foreign,
+        id: "forbidden"
+      }, auth)).rejects.toThrow();
+      await expect(server.mutate.document.upsert({
+        ...foreign,
+        ownerId: "alice"
+      }, auth)).rejects.toThrow();
+      await expect(server.mutate.document.update({
+        ...own,
+        ownerId: "bob"
+      }, auth)).rejects.toThrow();
+      await expect(server.mutate.document.upsert({
+        ...own,
+        ownerId: "bob"
+      }, auth)).rejects.toThrow();
+      await expect(server.mutate.document.upsert({
+        ...foreign,
+        id: "missing"
+      }, auth)).rejects.toThrow();
+      await server.mutate.document.upsert({
+        ...own,
+        title: "updated"
+      }, auth);
+      await server.mutate.document.upsert({
+        ...own,
+        title: "updated"
+      }, auth);
+      await server.mutate.document.upsert({
+        ...own,
+        id: "new"
+      }, auth);
+      expect(sqlite.prepare("SELECT * FROM document ORDER BY workspace, id").all()).toEqual([{
+        ...own,
+        id: "new"
+      }, {
+        ...own,
+        title: "updated"
+      }, foreign]);
+      var closedBindings = createZeroServerBindings({
+        schema,
+        models: {
+          document: {
+            mutate: mutations(document, permission, {
+              rename: async function rename(ctx, input) {
+                await ctx.can(permission, input);
+                await ctx.tx.mutate.document.update(input);
+              }
+            }, {
+              crud: false
+            })
+          }
+        },
+        createServerActions: function createServerActions() {
+          return {};
+        }
+      });
+      expect(Object.keys(closedBindings.mutators)).toEqual(["document|rename"]);
+      var closedExecutor = createSyncExecutor({
+        database,
+        schema,
+        mutators: closedBindings.mutators,
+        effects: {
+          runBackground: function runBackground(promise) {
+            return promise;
+          },
+          report: function report(error) {
+            throw error;
+          }
+        }
+      });
+      for (var _i = 0, _iter = ["insert", "update", "delete", "upsert"]; _i < _iter.length; _i++) {
+        var action = _iter[_i];
+        await expect(closedExecutor.execute(`document|${action}`, own, {
+          userID: "alice"
+        })).rejects.toThrow(`unknown mutator: document|${action}`);
+      }
+      await closedBindings.server(closedExecutor).mutate.document.rename({
+        workspace: "a",
+        id: "same",
+        title: "renamed"
+      }, auth);
+      expect(sqlite.prepare("SELECT title FROM document WHERE workspace = ? AND id = ?").get("a", "same")).toEqual({
+        title: "renamed"
+      });
+    } finally {
+      sqlite.close();
+    }
+  });
+});
 //# sourceMappingURL=mutations.test.native.js.map

package/dist/esm/mutations.test.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["describe","expect","test","mutations","serverWhere","permissions","v1","v12","v2","v22","custom"],"sources":["../../src/mutations.test.ts"],"sourcesContent":[null],"mappings":"AAAA,SAASA,QAAA,EAAUC,MAAA,EAAQC,IAAA,QAAY;AAEvC,SAASC,SAAA,QAAiB;AAC1B,SAASC,WAAA,QAAmB;AAE5BJ,QAAA,CAAS,sBAAsB,YAAM;EACnCE,IAAA,CAAK,sDAAsD,YAAM;IAC/D,IAAAG,WAAM,GAAAD,WAAc,OAAY,cAAc;MAC9C,OAAM,IAAK;IAAa;IACxB,IAAAE,EAAM,kBAAiBC,IAAA,GAAC;IACxB,IAAAC,EAAA,kBAAkBC,IAAA,GAClB;IAGAN,SAAO,OAAM,EAAAE,WAAe;MAC7BK,MAAA,EAAAJ;IACF","ignoreList":[]}
+{"version":3,"names":["AsyncLocalStorage","DatabaseSync","createSchema","string","table","createSQLiteApplicationDatabase","createSyncExecutor","createQueryCompiler","executeTransactionQueryPlan","afterAll","describe","expect","test","vi","createZeroServerBindings","setupAsyncLocalStorage","getMutationsPermissions","mutations","serverWhere","previousEnvironment","hoisted","previous","process","env","VITE_ENVIRONMENT","record","columns","id","primaryKey","permission","first","Object","keys","sort","toEqual","custom","fn","closed","crud","toBe","Reflect","get","toBeUndefined","toHaveBeenCalledOnce","reopened","insert","permissions","v1","v12","v2","v22","proxy","document","workspace","ownerId","title","schema","tables","relationships","enableLegacyQueries","sqlite","exec","compile","query","query2","sql","params","arguments","length","prepare","all","map","value","tx","changes","Number","run","queryAst","ast","format","queryName","database","transaction","work","result","error","eb","auth2","cmp","bindings","models","mutate","createServerActions","executor","mutators","effects","runBackground","promise","report","server","auth","authData","own","foreign"],"sources":["../../src/mutations.test.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "on-zero",
-  "version": "0.16.16",
+  "version": "0.16.17",
   "description": "A typed layer over @rocicorp/zero with queries, mutations, and permissions",
   "sideEffects": false,
   "files": [
@@ -105,7 +105,7 @@
     "chokidar": "^4.0.3",
     "citty": "^0.1.6",
     "dequal": "^2.0.3",
-    "orez-lite": "0.16.16",
+    "orez-lite": "0.16.17",
     "valibot": "^1.1.0"
   },
   "peerDependencies": {

package/src/createZeroClient.httpAuth.test.ts

@@ -92,12 +92,11 @@ test('warm headless client refreshes an expired bearer and reconnects', async ()
   })
 
   try {
-    await eventually(() =>
+    await eventually(() => {
+      expect(refreshAuth).toHaveBeenCalledTimes(1)
+      expect(authorizations).toEqual(['Bearer expired-token', 'Bearer fresh-token'])
       expect(connection.zero.connection.state.current.name).toBe('connected')
-    )
-
-    expect(refreshAuth).toHaveBeenCalledTimes(1)
-    expect(authorizations).toEqual(['Bearer expired-token', 'Bearer fresh-token'])
+    })
   } finally {
     await connection.close()
   }

package/src/generate-helpers.test.ts

@@ -1,3 +1,6 @@
+import { runInNewContext } from 'node:vm'
+
+import * as v from 'valibot'
 import { describe, expect, test } from 'vitest'
 
 import {
@@ -73,4 +76,125 @@ describe('generated mutation validators', () => {
       id: v.string(),
     }),`)
   })
+
+  test('emits an upsert validator alongside the other generated crud slots', () => {
+    const source = generateSyncedMutationsFile([
+      {
+        modelName: 'post',
+        hasCRUD: true,
+        columns: {
+          id: { type: 'string', optional: false, customType: undefined },
+          title: { type: 'string', optional: true, customType: undefined },
+        },
+        primaryKeys: ['id'],
+        custom: [],
+      },
+    ])
+
+    // upsert takes the insert payload shape: every column, optionality as declared
+    expect(source).toContain(`    upsert: v.object({
+    id: v.string(),
+    title: v.optional(v.nullable(v.string())),
+  }),`)
+    expect(source).toContain('    insert: v.object({')
+    expect(source).toContain('    update: v.object({')
+    expect(source).toContain('    delete: v.object({')
+  })
+
+  test('keeps a custom upsert override instead of dropping it', () => {
+    const source = generateSyncedMutationsFile([
+      {
+        modelName: 'post',
+        hasCRUD: true,
+        columns: {
+          id: { type: 'string', optional: false, customType: undefined },
+        },
+        primaryKeys: ['id'],
+        custom: [
+          {
+            name: 'upsert',
+            paramType: '{ id: string; draft: boolean }',
+            valibotCode: 'v.object({\n    id: v.string(),\n    draft: v.boolean(),\n  })',
+          },
+        ],
+      },
+    ])
+
+    expect(source).toContain(`    upsert: v.object({
+      id: v.string(),
+      draft: v.boolean(),
+    }),`)
+    // the override replaces the generated slot rather than appearing twice
+    expect(source.match(/upsert:/g)).toHaveLength(1)
+  })
+
+  test('honors a custom unknown payload even when table columns are available', () => {
+    const source = generateSyncedMutationsFile([
+      {
+        modelName: 'post',
+        hasCRUD: true,
+        columns: { id: { type: 'string', optional: false, customType: undefined } },
+        primaryKeys: ['id'],
+        custom: [{ name: 'upsert', paramType: 'unknown', valibotCode: '' }],
+      },
+    ])
+    const validators = runInNewContext(
+      source
+        .replace("import * as v from 'valibot'", '')
+        .replace('export const mutationValidators', 'const mutationValidators') +
+        '\nmutationValidators',
+      { v }
+    )
+    expect(v.parse(validators.post.upsert, { customInput: true })).toEqual({
+      customInput: true,
+    })
+    expect(() => v.parse(validators.post.insert, { customInput: true })).toThrow()
+  })
+
+  test('emits only authored handlers when the model opted out of crud', () => {
+    const source = generateSyncedMutationsFile([
+      {
+        modelName: 'appNotification',
+        hasCRUD: false,
+        columns: {
+          id: { type: 'string', optional: false, customType: undefined },
+        },
+        primaryKeys: ['id'],
+        custom: [
+          {
+            name: 'markRead',
+            paramType: '{ id: string }',
+            valibotCode: 'v.object({\n    id: v.string(),\n  })',
+          },
+        ],
+      },
+    ])
+
+    expect(source).toContain('    markRead: v.object({')
+    for (const slot of ['insert', 'update', 'delete', 'upsert']) {
+      expect(source).not.toContain(`    ${slot}:`)
+    }
+  })
+
+  test('keeps an authored crud-named handler when there are no schema columns', () => {
+    const source = generateSyncedMutationsFile([
+      {
+        modelName: 'post',
+        hasCRUD: true,
+        columns: {},
+        primaryKeys: [],
+        custom: [
+          {
+            name: 'insert',
+            paramType: '{ id: string }',
+            valibotCode: 'v.object({\n    id: v.string(),\n  })',
+          },
+        ],
+      },
+    ])
+
+    expect(source).toContain(`    insert: v.object({
+      id: v.string(),
+    }),`)
+  })
 })

package/src/generate-helpers.ts

@@ -23,6 +23,8 @@ export type ExtractedMutation = {
 
 export type ModelMutations = {
   modelName: string
+  // true when the mutate call registers a table (any 2+ arg form) and did not
+  // opt out with `mutations(table, permissions, handlers, { crud: false })`
   hasCRUD: boolean
   // populated when hasCRUD
   columns: Record<string, SchemaColumn>
@@ -671,10 +673,16 @@ export function columnTypeToValibot(col: SchemaColumn): string {
   return col.optional ? `v.optional(v.nullable(${base}))` : base
 }
 
+// the four generated crud slots, in the order they are emitted. `upsert`
+// takes the same payload shape as `insert` (see CRUDMutations in mutations.ts).
+export const CRUD_MUTATION_NAMES = ['insert', 'update', 'delete', 'upsert'] as const
+
+export type CRUDMutationName = (typeof CRUD_MUTATION_NAMES)[number]
+
 export function schemaColumnsToValibot(
   columns: Record<string, SchemaColumn>,
   primaryKeys: string[],
-  mode: 'insert' | 'update' | 'delete'
+  mode: CRUDMutationName
 ): string {
   const entries: string[] = []
 
@@ -702,12 +710,16 @@ export function schemaColumnsToValibot(
       }
     }
   } else {
-    // insert: all columns as-is
+    // insert and upsert: all columns as-is
     for (const [name, col] of Object.entries(columns)) {
       entries.push(`${formatObjectKey(name)}: ${columnTypeToValibot(col)}`)
     }
   }
 
+  // a schema with no declared primary key yields no `delete` entries; emitting
+  // the entry list unguarded produced `v.object({ , })`, which does not parse
+  if (entries.length === 0) return 'v.object({})'
+
   return `v.object({\n    ${entries.join(',\n    ')},\n  })`
 }
 
@@ -748,36 +760,40 @@ export function generateSyncedMutationsFile(modelMutations: ModelMutations[]): s
     .map((model) => {
       const entries: string[] = []
 
-      // crud validators from schema
-      if (model.hasCRUD && Object.keys(model.columns).length > 0) {
-        for (const mode of ['insert', 'update', 'delete'] as const) {
-          // skip if custom mutation overrides this crud op
-          const hasCustomOverride = model.custom.some((m) => m.name === mode)
-          if (hasCustomOverride) {
-            // use the custom version's validator instead
-            const customMut = model.custom.find((m) => m.name === mode)!
-            if (customMut.valibotCode) {
-              entries.push(
-                `    ${mode}: ${indentContinuationLines(extractValibotExpression(customMut.valibotCode), 2)},`
-              )
-            } else {
-              // fall back to schema-derived
-              entries.push(
-                `    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`
-              )
-            }
-          } else {
-            entries.push(
-              `    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`
-            )
-          }
+      // crud validators from schema. a model that opted out with
+      // `{ crud: false }`, or that has no inline schema columns, emits nothing
+      // here and leaves any authored insert/update/delete/upsert to the custom
+      // loop below.
+      const emitted = new Set<string>()
+      const canDeriveCRUD = model.hasCRUD && Object.keys(model.columns).length > 0
+
+      for (const mode of CRUD_MUTATION_NAMES) {
+        // a custom handler with the same name replaces the generated op, so its
+        // own payload type wins over the schema-derived shape
+        const customMut = model.custom.find((m) => m.name === mode)
+        if (customMut?.valibotCode) {
+          entries.push(
+            `    ${mode}: ${indentContinuationLines(extractValibotExpression(customMut.valibotCode), 2)},`
+          )
+          emitted.add(mode)
+          continue
+        }
+        if (customMut?.paramType === 'void') {
+          entries.push(`    ${mode}: v.void_(),`)
+          emitted.add(mode)
+          continue
+        }
+        if (canDeriveCRUD && !customMut) {
+          entries.push(
+            `    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`
+          )
+          emitted.add(mode)
         }
       }
 
       // custom mutations (excluding crud overrides already handled)
       for (const mut of model.custom) {
-        if (model.hasCRUD && ['insert', 'update', 'delete', 'upsert'].includes(mut.name))
-          continue
+        if (emitted.has(mut.name)) continue
         if (mut.paramType === 'void') {
           entries.push(`    ${mut.name}: v.void_(),`)
           continue

package/src/generate-lite.test.ts

@@ -457,4 +457,57 @@ describe('generateLite', () => {
       })
     ).toThrow(/uses removed instance\.ts configuration/)
   })
+  test('generates crud validators for a schema model and drops them on crud false', () => {
+    const empty = { mutations: [], queries: [] }
+    const schema = {
+      tableName: 'appNotification',
+      primaryKeys: ['id'],
+      columns: [
+        { name: 'id', builderText: 'string()' },
+        { name: 'readAt', builderText: 'number().optional()' },
+      ],
+    }
+    const handlers = [{ name: 'markRead', paramTypeText: '{ id: string }' }]
+
+    const run = (crud?: boolean) =>
+      generateLite({
+        files: { [`${DIR}/appNotification.ts`]: '// namespace' },
+        dir: DIR,
+        parse: makeParse({
+          [`${DIR}/appNotification.ts`]: {
+            ...empty,
+            mutations: [
+              {
+                modelName: 'appNotification',
+                handlers,
+                schema,
+                ...(crud === undefined ? {} : { crud }),
+              },
+            ],
+          },
+        }),
+      })
+
+    const withCRUD = run()
+    const validators = withCRUD.files['syncedMutations.ts']!
+    for (const slot of ['insert', 'update', 'delete', 'upsert']) {
+      expect(validators).toContain(`    ${slot}: v.object({`)
+    }
+    expect(validators).toContain('    markRead: v.object({')
+    // one count per generated slot plus the authored handler
+    expect(withCRUD.mutationCount).toBe(5)
+
+    const optedOut = run(false)
+    const optedOutValidators = optedOut.files['syncedMutations.ts']!
+    for (const slot of ['insert', 'update', 'delete', 'upsert']) {
+      expect(optedOutValidators).not.toContain(`    ${slot}:`)
+    }
+    expect(optedOutValidators).toContain('    markRead: v.object({')
+    expect(optedOut.mutationCount).toBe(1)
+    // the schema itself is still registered, so permissions/tables are unaffected
+    expect(optedOut.schemaCount).toBe(1)
+
+    // an explicit `{ crud: true }` is the same as omitting the options object
+    expect(run(true).files['syncedMutations.ts']).toBe(validators)
+  })
 })