on-zero 0.9.7 → 0.10.1

package/dist/cjs/generate.test.native.js

@@ -1,37 +1,11 @@
 "use strict";
 
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-// If the importer is in node compatibility mode or this is not an ESM
-// file that has been converted to a CommonJS file using a Babel-
-// compatible transform (i.e. "__esModule" has not been set), then set
-// "default" to the CommonJS "module.exports" for node compatibility.
-isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-  value: mod,
-  enumerable: true
-}) : target, mod));
 var import_fs = require("fs");
 var import_os = require("os");
 var import_path = require("path");
 var import_vm = require("vm");
-var zero = __toESM(require("@rocicorp/zero"), 1);
 var import_vitest = require("vitest");
 var import_generate = require("./generate.native.js");
-const import_meta = {};
 var testDir = (0, import_path.join)((0, import_os.tmpdir)(), "on-zero-test-" + Date.now());
 function writeFileSync(path, content) {
   (0, import_fs.mkdirSync)((0, import_path.dirname)(path), {
@@ -52,105 +26,6 @@ function writeFileSync(path, content) {
   });
 });
 (0, import_vitest.describe)("generate", function () {
-  (0, import_vitest.test)("generates models.ts, types.ts, tables.ts from model files", async function () {
-    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `
-import { table, string, boolean } from 'on-zero'
-
-export const schema = table('post', {
-  id: string(),
-  title: string(),
-  published: boolean(),
-})
-`);
-    writeFileSync((0, import_path.join)(testDir, "comment/mutations.ts"), `
-import { table, string } from 'on-zero'
-
-export const schema = table('comment', {
-  id: string(),
-  postId: string(),
-  body: string(),
-})
-`);
-    writeFileSync((0, import_path.join)(testDir, "post/post.test.ts"), `throw new Error('test files must not be generated as models')`);
-    writeFileSync((0, import_path.join)(testDir, "comment/comment.spec.ts"), `throw new Error('spec files must not be generated as queries')`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    (0, import_vitest.expect)(result.modelCount).toBe(2);
-    (0, import_vitest.expect)(result.schemaCount).toBe(2);
-    (0, import_vitest.expect)(result.filesChanged).toBeGreaterThan(0);
-    (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/models.ts"))).toBe(true);
-    (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/types.ts"))).toBe(true);
-    (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/tables.ts"))).toBe(true);
-    var modelsContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/models.ts"), "utf-8");
-    (0, import_vitest.expect)(modelsContent).toContain("import * as comment from '../comment/mutations'");
-    (0, import_vitest.expect)(modelsContent).toContain("import * as post from '../post/mutations'");
-    (0, import_vitest.expect)(modelsContent).not.toContain("post.test");
-    (0, import_vitest.expect)(modelsContent).toContain("export const models = {");
-    var typesContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/types.ts"), "utf-8");
-    (0, import_vitest.expect)(typesContent).toContain("export type Post = TableInsertRow<typeof schema.post>");
-    (0, import_vitest.expect)(typesContent).toContain("export type Comment = TableInsertRow<typeof schema.comment>");
-    var tablesContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/tables.ts"), "utf-8");
-    (0, import_vitest.expect)(tablesContent).toContain("export { schema as post } from '../post/mutations'");
-    (0, import_vitest.expect)(tablesContent).toContain("export { schema as comment } from '../comment/mutations'");
-  });
-  (0, import_vitest.test)("generates query validators from query files", async function () {
-    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
-    writeFileSync((0, import_path.join)(testDir, "post/queries.ts"), `
-import { zero } from '../zero'
-
-export const allPosts = () => zero.query.post
-
-export const postById = ({ id }: { id: string }) => zero.query.post.where('id', id)
-
-export const postsByAuthor = ({ authorId, limit }: { authorId: string; limit?: number }) =>
-  zero.query.post.where('authorId', authorId).limit(limit ?? 10)
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    (0, import_vitest.expect)(result.queryCount).toBe(3);
-    (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/groupedQueries.ts"))).toBe(true);
-    (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/syncedQueries.ts"))).toBe(true);
-    var groupedContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/groupedQueries.ts"), "utf-8");
-    (0, import_vitest.expect)(groupedContent).toContain("import * as postSource from '../post/queries'");
-    (0, import_vitest.expect)(groupedContent).toContain("postById: postSource.postById");
-    var syncedContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedQueries.ts"), "utf-8");
-    (0, import_vitest.expect)(syncedContent).toContain("allPosts: defineQuery");
-    (0, import_vitest.expect)(syncedContent).toContain("postById: defineQuery");
-    (0, import_vitest.expect)(syncedContent).toContain("postsByAuthor: defineQuery");
-    (0, import_vitest.expect)(syncedContent).toContain("v.object");
-  });
-  (0, import_vitest.test)("skips permission exports in queries", async function () {
-    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
-    writeFileSync((0, import_path.join)(testDir, "post/queries.ts"), `
-export const permission = () => ({ canRead: true })
-export const allPosts = () => zero.query.post
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    (0, import_vitest.expect)(result.queryCount).toBe(1);
-    var syncedContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedQueries.ts"), "utf-8");
-    (0, import_vitest.expect)(syncedContent).toContain("allPosts");
-    (0, import_vitest.expect)(syncedContent).not.toContain("permission:");
-  });
-  (0, import_vitest.test)("aliases user import without changing the model key", async function () {
-    writeFileSync((0, import_path.join)(testDir, "user/mutations.ts"), `export const schema = table('user', { id: string(), name: string() })`);
-    await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var modelsContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/models.ts"), "utf-8");
-    (0, import_vitest.expect)(modelsContent).toContain("import * as userPublic from '../user/mutations'");
-    (0, import_vitest.expect)(modelsContent).toContain("user: userPublic,");
-    (0, import_vitest.expect)(modelsContent).not.toContain("\n  userPublic,");
-    var typesContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/types.ts"), "utf-8");
-    (0, import_vitest.expect)(typesContent).toContain("typeof schema.userPublic");
-  });
   (0, import_vitest.test)("runs after command when files change", async function () {
     writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
     var markerFile = (0, import_path.join)(testDir, "after-ran");
@@ -196,51 +71,6 @@ export const allPosts = () => zero.query.post
   var dataDir = function dataDir2() {
     return (0, import_path.join)(testDir, "src/data");
   };
-  (0, import_vitest.test)("discovers file and folder namespaces and emits related sync closure", async function () {
-    writeFileSync((0, import_path.join)(dataDir(), "control/reaction.ts"), `export const allReactions = () => zql.reaction`);
-    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`);
-    writeFileSync((0, import_path.join)(dataDir(), "project/message/queries.ts"), `
-const unused = () => zql.message.related('notARealRelation')
-const withComments = () => zql.message.related('comments', (q) => q.related('author'))
-export const messages = () => withComments()
-`);
-    writeFileSync((0, import_path.join)(dataDir(), "project/message/mutations.ts"), `export const schema = table('message').columns({ id: string(), projectId: string() })`);
-    writeFileSync((0, import_path.join)(dataDir(), "project/message/helpers.ts"), `export const privateHelper = () => 'ignored'`);
-    writeFileSync((0, import_path.join)(testDir, "src/database/relations.ts"), `
-export const relations = defineRelations(schema, (r) => ({
-  message: { comments: r.many.comment({}) },
-  comment: { author: r.one.userPublic({}) },
-}))
-`);
-    writeFileSync((0, import_path.join)(testDir, "src/database/schema.ts"), `
-export const comment = sqliteTable('comment', { id: text(), projectId: text() })
-export const userPublic = sqliteTable('user_public', { id: text(), projectId: text() })
-`);
-    var membership = await (0, import_generate.deriveDataMembership)({
-      dir: dataDir()
-    });
-    (0, import_vitest.expect)(membership.allTables).toEqual(["comment", "message", "reaction", "userPublic"]);
-    (0, import_vitest.expect)(membership.instances.project).toEqual({
-      tables: ["message"],
-      syncTables: ["comment", "message", "userPublic"],
-      supportTables: [],
-      scope: "projectId"
-    });
-    await (0, import_generate.generate)({
-      dir: dataDir(),
-      silent: true
-    });
-    var grouped = (0, import_fs.readFileSync)((0, import_path.join)(dataDir(), "generated/groupedQueries.ts"), "utf8");
-    (0, import_vitest.expect)(grouped).toContain("from '../control/reaction'");
-    (0, import_vitest.expect)(grouped).toContain("from '../project/message/queries'");
-    (0, import_vitest.expect)(grouped).not.toContain("privateHelper");
-    var manifest = (0, import_fs.readFileSync)((0, import_path.join)(dataDir(), "generated/instances.ts"), "utf8");
-    (0, import_vitest.expect)(manifest).toContain("control: {");
-    (0, import_vitest.expect)(manifest).toContain("project: {");
-    (0, import_vitest.expect)(manifest).toContain('tables: ["message"]');
-    (0, import_vitest.expect)(manifest).toContain('syncTables: ["comment","message","userPublic"]');
-    (0, import_vitest.expect)(manifest).toContain(`defaultVisibility: (value: string) => ({ column: "projectId", value })`);
-  });
   (0, import_vitest.test)("derives query membership from the returned query root", async function () {
     writeFileSync((0, import_path.join)(dataDir(), "category/mutations.ts"), `export const schema = table('category').columns({ id: string() })`);
     writeFileSync((0, import_path.join)(dataDir(), "dashboard/queries.ts"), `export const monthSummary = () => zql.category.related('expenses')`);
@@ -459,42 +289,6 @@ export const messages = () => zql.message.related('author')
       silent: true
     })).rejects.toThrow(/namespace 'message'.*instances 'control' and 'project'/);
   });
-  (0, import_vitest.test)("resolves configured instance directories relative to the config file", async function () {
-    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { control: { dir: './planes/control-data', supportTables: ['audit'] }, project: { dir: '../project-data', scope: 'projectId' } } })`);
-    writeFileSync((0, import_path.join)(dataDir(), "planes/control-data/account.ts"), `export const accounts = () => zql.account`);
-    writeFileSync((0, import_path.join)(testDir, "src/project-data/message.ts"), `export const schema = table('message').columns({ id: string(), projectId: string() })`);
-    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
-      dir: dataDir(),
-      config: (0, import_path.join)(dataDir(), "on-zero.config.ts")
-    })).resolves.toEqual({
-      instances: {
-        control: {
-          tables: ["account"],
-          syncTables: ["account"],
-          supportTables: ["audit"],
-          scope: null
-        },
-        project: {
-          tables: ["message"],
-          syncTables: ["message"],
-          supportTables: [],
-          scope: "projectId"
-        }
-      },
-      allTables: ["account", "audit", "message"]
-    });
-    await (0, import_vitest.expect)((0, import_generate.generate)({
-      dir: dataDir(),
-      config: (0, import_path.join)(dataDir(), "on-zero.config.ts"),
-      silent: true
-    })).resolves.toMatchObject({
-      modelCount: 1,
-      schemaCount: 1
-    });
-    var models = (0, import_fs.readFileSync)((0, import_path.join)(dataDir(), "generated/models.ts"), "utf8");
-    (0, import_vitest.expect)(models).toContain("from '../../project-data/message'");
-    (0, import_vitest.expect)(models).not.toContain("account");
-  });
   (0, import_vitest.test)("rejects missing configured instance directories", async function () {
     writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { project: { dir: './missing' } } })`);
     await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
@@ -539,253 +333,6 @@ export const messages = () => zql.message.related('author')
   });
 });
 (0, import_vitest.describe)("mutations", function () {
-  (0, import_vitest.test)("generates validators for inline mutation param types", async function () {
-    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `
-import { table, string } from 'on-zero'
-import { mutations, serverWhere } from 'on-zero'
-
-export const schema = table('post').columns({
-  id: string(),
-  title: string(),
-}).primaryKey('id')
-
-const perm = serverWhere('post', () => true)
-
-export const mutate = mutations(schema, perm, {
-  archive: async ({ tx }, { id, reason }: { id: string; reason: string }) => {
-    await tx.mutate.post.update({ id, archived: true })
-  },
-})
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    (0, import_vitest.expect)(result.mutationCount).toBeGreaterThan(0);
-    (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"))).toBe(true);
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("archive");
-    (0, import_vitest.expect)(content).toContain("v.object");
-    (0, import_vitest.expect)(content).toContain("v.string()");
-  });
-  (0, import_vitest.test)("generates CRUD validators from schema columns", async function () {
-    writeFileSync((0, import_path.join)(testDir, "task/mutations.ts"), `
-import { table, string, number, boolean } from 'on-zero'
-import { mutations, serverWhere } from 'on-zero'
-
-export const schema = table('task').columns({
-  id: string(),
-  title: string(),
-  priority: number(),
-  done: boolean(),
-  note: string().optional(),
-}).primaryKey('id')
-
-const perm = serverWhere('task', () => true)
-
-export const mutate = mutations(schema, perm)
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("insert:");
-    (0, import_vitest.expect)(content).toMatch(/insert:.*v\.object/);
-    (0, import_vitest.expect)(content).toContain("update:");
-    (0, import_vitest.expect)(content).toContain("delete:");
-  });
-  (0, import_vitest.test)("treats models without export const mutate as empty mutations", async function () {
-    writeFileSync((0, import_path.join)(testDir, "readonly/mutations.ts"), `
-import { table, string } from 'on-zero'
-
-export const schema = table('readonly').columns({
-  id: string(),
-  name: string(),
-}).primaryKey('id')
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    (0, import_vitest.expect)(result.mutationCount).toBe(0);
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("readonly: {");
-  });
-  (0, import_vitest.test)("extracts custom mutations from bare mutations({})", async function () {
-    writeFileSync((0, import_path.join)(testDir, "admin/mutations.ts"), `
-import { mutations } from 'on-zero'
-
-export const mutate = mutations({
-  reset: async ({ tx }, { targetId }: { targetId: string }) => {
-    await tx.mutate.admin.delete({ id: targetId })
-  },
-})
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("reset");
-    (0, import_vitest.expect)(content).toContain("v.string()");
-  });
-  (0, import_vitest.test)("generates validators for string-model multiline mutation params", async function () {
-    writeFileSync((0, import_path.join)(testDir, "agentEvent/mutations.ts"), `
-import { mutations, serverWhere } from 'on-zero'
-
-const perm = serverWhere('agentEvent', () => true)
-
-export const mutate = mutations('agentEvent', perm, {
-  claimReviewLease: async (
-    { tx },
-    props: {
-      id: string
-      projectId: string
-      agentId: string
-      userId: string
-      taskId: string
-      reviewKey: string
-      runnerId: string
-      createdAt: number
-    },
-  ) => {
-    await tx.mutate.agentEvent.insert(props)
-  },
-})
-`);
-    await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("claimReviewLease");
-    (0, import_vitest.expect)(content).toContain("projectId: v.string()");
-    (0, import_vitest.expect)(content).toContain("createdAt: v.number()");
-    (0, import_vitest.expect)(content).not.toContain("claimReviewLease: v.object({})");
-  });
-  (0, import_vitest.test)("generates validators for object intersections", async function () {
-    writeFileSync((0, import_path.join)(testDir, "agent/mutations.ts"), `
-import { mutations, serverWhere } from 'on-zero'
-
-const perm = serverWhere('agent', () => true)
-
-export const mutate = mutations('agent', perm, {
-  update: async (
-    { tx },
-    props: {
-      id: string
-    } & {
-      status?: string
-      currentTaskId?: string
-      [key: string]: unknown
-    },
-  ) => {
-    await tx.mutate.agent.update(props)
-  },
-})
-`);
-    await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("update");
-    (0, import_vitest.expect)(content).toContain("id: v.string()");
-    (0, import_vitest.expect)(content).toContain("status: v.optional(v.string())");
-    (0, import_vitest.expect)(content).toContain("currentTaskId: v.optional(v.string())");
-    (0, import_vitest.expect)(content).not.toContain("update: v.object({})");
-    (0, import_vitest.expect)(content).not.toContain("[key");
-  });
-  (0, import_vitest.test)("uses v.unknown for untyped mutation payloads", async function () {
-    writeFileSync((0, import_path.join)(testDir, "project/mutations.ts"), `
-import { mutations, serverWhere } from 'on-zero'
-
-const perm = serverWhere('project', () => true)
-
-export const mutate = mutations('project', perm, {
-  insert: async ({ tx }, project) => {
-    await tx.mutate.project.insert(project)
-  },
-})
-`);
-    await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("insert: v.unknown()");
-    (0, import_vitest.expect)(content).not.toContain("insert: v.void_()");
-  });
-  (0, import_vitest.test)("handles mutations with only context param (void)", async function () {
-    writeFileSync((0, import_path.join)(testDir, "user/mutations.ts"), `
-import { table, string } from 'on-zero'
-import { mutations, serverWhere } from 'on-zero'
-
-export const schema = table('user').columns({
-  id: string(),
-  name: string(),
-}).primaryKey('id')
-
-const perm = serverWhere('user', () => true)
-
-export const mutate = mutations(schema, perm, {
-  finishOnboarding: async ({ tx }) => {
-    // no second param
-  },
-})
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("finishOnboarding");
-  });
-  (0, import_vitest.test)("handles primitive param type", async function () {
-    writeFileSync((0, import_path.join)(testDir, "user/mutations.ts"), `
-import { table, string } from 'on-zero'
-import { mutations, serverWhere } from 'on-zero'
-
-export const schema = table('user').columns({
-  id: string(),
-  name: string(),
-}).primaryKey('id')
-
-const perm = serverWhere('user', () => true)
-
-export const mutate = mutations(schema, perm, {
-  completeSignup: async ({ tx }, userId: string) => {
-    await tx.mutate.user.update({ id: userId })
-  },
-})
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("completeSignup");
-    (0, import_vitest.expect)(content).toContain("v.string()");
-  });
-  (0, import_vitest.test)("handles array param type", async function () {
-    writeFileSync((0, import_path.join)(testDir, "batch/mutations.ts"), `
-import { mutations } from 'on-zero'
-
-export const mutate = mutations({
-  bulkDelete: async ({ tx }, ids: Array<{ id: string }>) => {
-    for (const { id } of ids) await tx.mutate.batch.delete({ id })
-  },
-})
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("bulkDelete");
-    (0, import_vitest.expect)(content).toContain("v.array");
-  });
   (0, import_vitest.test)("populates mutationCount and caching works", async function () {
     writeFileSync((0, import_path.join)(testDir, "item/mutations.ts"), `
 import { table, string } from 'on-zero'
@@ -817,242 +364,4 @@ export const mutate = mutations(schema, perm, {
     (0, import_vitest.expect)(second.mutationCount).toBe(first.mutationCount);
   });
 });
-(0, import_vitest.describe)("type resolution", function () {
-  (0, import_vitest.test)("resolves imported type references for mutations", async function () {
-    writeFileSync((0, import_path.join)(testDir, "post/types.ts"), `
-export type ArchiveParams = {
-  id: string
-  reason: string
-  archived: boolean
-}
-`);
-    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `
-import { table, string, boolean } from 'on-zero'
-import { mutations } from 'on-zero'
-import type { ArchiveParams } from './types'
-
-export const mutate = mutations({
-  archive: async ({ tx }, params: ArchiveParams) => {
-    await tx.mutate.post.update(params)
-  },
-})
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("v.string()");
-    (0, import_vitest.expect)(content).toContain("v.boolean()");
-    (0, import_vitest.expect)(content).toContain("reason");
-    (0, import_vitest.expect)(content).toContain("archived");
-  });
-  (0, import_vitest.test)("resolves utility types like Pick", async function () {
-    writeFileSync((0, import_path.join)(testDir, "item/types.ts"), `
-export type Item = {
-  id: string
-  name: string
-  description: string
-  count: number
-}
-`);
-    writeFileSync((0, import_path.join)(testDir, "item/mutations.ts"), `
-import { table, string, number } from 'on-zero'
-import { mutations, serverWhere } from 'on-zero'
-import type { Item } from './types'
-
-export const schema = table('item').columns({
-  id: string(),
-  name: string(),
-  description: string(),
-  count: number(),
-}).primaryKey('id')
-
-const perm = serverWhere('item', () => true)
-
-export const mutate = mutations(schema, perm, {
-  rename: async ({ tx }, updates: Pick<Item, 'id' | 'name'>) => {
-    await tx.mutate.item.update(updates)
-  },
-})
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("id");
-    (0, import_vitest.expect)(content).toContain("name");
-    (0, import_vitest.expect)(content).not.toMatch(/rename:[\s\S]*description/);
-    (0, import_vitest.expect)(content).not.toMatch(/rename:[\s\S]*count/);
-  });
-  (0, import_vitest.test)("resolves instantiated Zero row fields through Partial and Omit", async function () {
-    (0, import_fs.symlinkSync)((0, import_path.join)(import_meta.dirname, "../node_modules"), (0, import_path.join)(testDir, "node_modules"), "dir");
-    writeFileSync((0, import_path.join)(testDir, "item/types.ts"), `
-import type { Row } from '@rocicorp/zero'
-import { drizzleZeroConfig } from 'drizzle-zero-sqlite'
-import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
-
-const item = sqliteTable('item', {
-  id: text().primaryKey(),
-  name: text().notNull(),
-  description: text().notNull(),
-})
-const schema = drizzleZeroConfig({ item })
-
-export type Item = Row<(typeof schema)['tables']['item']>
-`);
-    writeFileSync((0, import_path.join)(testDir, "item/mutations.ts"), `
-import { mutations } from 'on-zero'
-import type { Item } from './types'
-
-type ItemUpdate = { id: string } & Partial<Omit<Item, 'id'>>
-
-export const mutate = mutations('item', {
-  update: async ({ tx }, props: ItemUpdate) => {
-    await tx.mutate.item.update(props)
-  },
-})
-`);
-    await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("name: v.optional(v.string())");
-    (0, import_vitest.expect)(content).toContain("description: v.optional(v.string())");
-    (0, import_vitest.expect)(content).not.toContain("name: v.optional(v.unknown())");
-    (0, import_vitest.expect)(content).not.toContain("description: v.optional(v.unknown())");
-  });
-  (0, import_vitest.test)("skips symbol-keyed properties when resolving imported mutation param types", async function () {
-    writeFileSync((0, import_path.join)(testDir, "item/types.ts"), `
-export type WeirdParams = {
-  id: string
-  [Symbol.iterator]?: () => Iterator<string>
-}
-`);
-    writeFileSync((0, import_path.join)(testDir, "item/mutations.ts"), `
-import { mutations } from 'on-zero'
-import type { WeirdParams } from './types'
-
-export const mutate = mutations({
-  run: async ({ tx }, params: WeirdParams) => {
-    await tx.mutate.item.delete({ id: params.id })
-  },
-})
-`);
-    await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedMutations.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("run");
-    (0, import_vitest.expect)(content).toContain("id: v.string()");
-    (0, import_vitest.expect)(content).not.toContain("__@iterator");
-  });
-  (0, import_vitest.test)("resolves imported types in query params", async function () {
-    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
-    writeFileSync((0, import_path.join)(testDir, "post/types.ts"), `
-export type PostFilter = {
-  authorId: string
-  published: boolean
-}
-`);
-    writeFileSync((0, import_path.join)(testDir, "post/queries.ts"), `
-import type { PostFilter } from './types'
-
-export const filteredPosts = (filter: PostFilter) => zero.query.post
-`);
-    var result = await (0, import_generate.generate)({
-      dir: testDir,
-      silent: true
-    });
-    var content = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedQueries.ts"), "utf-8");
-    (0, import_vitest.expect)(content).toContain("filteredPosts");
-    (0, import_vitest.expect)(content).toContain("v.object");
-    (0, import_vitest.expect)(content).toContain("authorId");
-    (0, import_vitest.expect)(content).toContain("v.boolean()");
-  });
-});
-(0, import_vitest.describe)("generateDrizzleSchemaFile", function () {
-  (0, import_vitest.test)("preserves table server names and executable two-hop relationships", function () {
-    var schema = {
-      tables: {
-        users: {
-          name: "users",
-          serverName: "user_records",
-          primaryKey: ["id"],
-          columns: {
-            id: {
-              type: "string",
-              optional: false,
-              customType: null
-            }
-          }
-        },
-        groups: {
-          name: "groups",
-          primaryKey: ["id"],
-          columns: {
-            id: {
-              type: "string",
-              optional: false,
-              customType: null
-            }
-          }
-        },
-        memberships: {
-          name: "memberships",
-          primaryKey: ["userId", "groupId"],
-          columns: {
-            userId: {
-              type: "string",
-              optional: false,
-              customType: null
-            },
-            groupId: {
-              type: "string",
-              optional: false,
-              customType: null
-            }
-          }
-        }
-      },
-      relationships: {
-        users: {
-          groups: [{
-            sourceField: ["id"],
-            destField: ["userId"],
-            destSchema: "memberships",
-            cardinality: "many"
-          }, {
-            sourceField: ["groupId"],
-            destField: ["id"],
-            destSchema: "groups",
-            cardinality: "many"
-          }]
-        }
-      }
-    };
-    var source = (0, import_generate.generateDrizzleSchemaFile)(schema);
-    var executableSource = source.replace("import { boolean, createSchema, json, number, relationships, string, table } from '@rocicorp/zero'", "").replace("export const schema =", "globalThis.generatedSchema =");
-    var context = {
-      ...zero
-    };
-    (0, import_vm.runInNewContext)(executableSource, context);
-    (0, import_vitest.expect)(source).toContain('const usersTable = table("users").from("user_records")');
-    (0, import_vitest.expect)(context.generatedSchema).toMatchObject({
-      tables: {
-        users: {
-          serverName: "user_records"
-        }
-      },
-      relationships: {
-        users: {
-          groups: schema.relationships.users.groups
-        }
-      }
-    });
-  });
-});
 //# sourceMappingURL=generate.test.native.js.map