on-zero 0.2.10 → 0.3.0

package/src/generate.ts

@@ -53,16 +53,18 @@ function writeFileIfChanged(filePath: string, content: string): boolean {
   return true
 }
 
-function generateModelsFile(modelFiles: string[]) {
+function generateModelsFile(modelFiles: string[], modelsDirName: string) {
   const modelNames = modelFiles.map((f) => basename(f, '.ts')).sort()
   const getImportName = (name: string) => (name === 'user' ? 'userPublic' : name)
 
   const imports = modelNames
-    .map((name) => `import * as ${getImportName(name)} from '../models/${name}'`)
+    .map(
+      (name) => `import * as ${getImportName(name)} from '../${modelsDirName}/${name}'`,
+    )
     .join('\n')
 
   const sortedByImportName = [...modelNames].sort((a, b) =>
-    getImportName(a).localeCompare(getImportName(b))
+    getImportName(a).localeCompare(getImportName(b)),
   )
   const modelsObj = `export const models = {\n${sortedByImportName.map((name) => `  ${getImportName(name)},`).join('\n')}\n}`
 
@@ -84,15 +86,18 @@ function generateTypesFile(modelFiles: string[]) {
   return `import type { TableInsertRow, TableUpdateRow } from 'on-zero'\nimport type * as schema from './tables'\n\n${typeExports}\n`
 }
 
-function generateTablesFile(modelFiles: string[]) {
+function generateTablesFile(modelFiles: string[], modelsDirName: string) {
   const modelNames = modelFiles.map((f) => basename(f, '.ts')).sort()
   const getExportName = (name: string) => (name === 'user' ? 'userPublic' : name)
 
   const exports = modelNames
-    .map((name) => `export { schema as ${getExportName(name)} } from '../models/${name}'`)
+    .map(
+      (name) =>
+        `export { schema as ${getExportName(name)} } from '../${modelsDirName}/${name}'`,
+    )
     .join('\n')
 
-  return `// auto-generated by: on-zero generate\n// this is separate from models as otherwise you end up with circular types :/\n\n${exports}\n`
+  return `// auto-generated by: on-zero generate\n\n${exports}\n`
 }
 
 function generateReadmeFile() {
@@ -157,7 +162,7 @@ see the [on-zero readme](./node_modules/on-zero/README.md) for full documentatio
 }
 
 function generateGroupedQueriesFile(
-  queries: Array<{ name: string; sourceFile: string }>
+  queries: Array<{ name: string; sourceFile: string }>,
 ) {
   const sortedFiles = [...new Set(queries.map((q) => q.sourceFile))].sort()
 
@@ -182,7 +187,7 @@ function generateSyncedQueriesFile(
     params: string
     valibotCode: string
     sourceFile: string
-  }>
+  }>,
 ) {
   const queryByFile = new Map<string, typeof queries>()
   for (const q of queries) {
@@ -242,11 +247,7 @@ ${queriesObject}
 `
 }
 
-// column type in schema → valibot validator
-type SchemaColumn = {
-  type: 'string' | 'number' | 'boolean' | 'json' | 'enum'
-  optional: boolean
-}
+// used by valibot mutation validator codegen (subset of SchemaColumn below)
 
 type ExtractedMutation = {
   name: string
@@ -258,7 +259,7 @@ type ExtractedMutation = {
 function createTypeResolver(
   ts: typeof import('typescript'),
   files: Array<{ path: string; content: string }>,
-  dir: string
+  dir: string,
 ) {
   // find tsconfig if it exists for path alias resolution
   const configPath = ts.findConfigFile(dir, ts.sys.fileExists, 'tsconfig.json')
@@ -278,7 +279,7 @@ function createTypeResolver(
       const parsed = ts.parseJsonConfigFileContent(
         configFile.config,
         ts.sys,
-        dirname(configPath)
+        dirname(configPath),
       )
       compilerOptions = { ...compilerOptions, ...parsed.options }
     }
@@ -305,7 +306,7 @@ function createTypeResolver(
   const program = ts.createProgram(
     files.map((f) => f.path),
     compilerOptions,
-    host
+    host,
   )
   const checker = program.getTypeChecker()
 
@@ -333,7 +334,7 @@ function resolveParamType(
   resolver: ReturnType<typeof createTypeResolver>,
   sourceFile: import('typescript').SourceFile,
   exportName: string,
-  paramIndex: number
+  paramIndex: number,
 ): import('typescript').Type | null {
   let result: import('typescript').Type | null = null
 
@@ -362,7 +363,7 @@ function resolveParamType(
 function resolveMutationParamTypes(
   ts: typeof import('typescript'),
   resolver: ReturnType<typeof createTypeResolver>,
-  sourceFile: import('typescript').SourceFile
+  sourceFile: import('typescript').SourceFile,
 ): Map<string, import('typescript').Type> {
   const resolved = new Map<string, import('typescript').Type>()
 
@@ -434,7 +435,7 @@ function extractMutationsFromModel(
   silent: boolean,
   typeToValibot: (typeString: string) => string | null,
   resolvedTypes?: Map<string, import('typescript').Type>,
-  resolvedTypeToValibot?: (type: import('typescript').Type) => string
+  resolvedTypeToValibot?: (type: import('typescript').Type) => string,
 ): ModelMutations | null {
   let mutateNode: import('typescript').CallExpression | null = null
 
@@ -556,7 +557,7 @@ function extractSchemaColumns(
   ts: typeof import('typescript'),
   sourceFile: ReturnType<typeof ts.createSourceFile>,
   columns: Record<string, SchemaColumn>,
-  primaryKeys: string[]
+  primaryKeys: string[],
 ) {
   // walk AST to find table(...).columns({...}).primaryKey(...)
   function visit(node: import('typescript').Node) {
@@ -602,11 +603,11 @@ function parseColumnType(initText: string): SchemaColumn {
   else if (initText.startsWith('json(') || initText.startsWith('json<')) type = 'json'
   else if (initText.startsWith('enumeration(')) type = 'enum'
 
-  return { type, optional }
+  return { type, optional, customType: undefined }
 }
 
 function columnTypeToValibot(col: SchemaColumn): string {
-  let base: string
+  let base = 'v.string()'
   switch (col.type) {
     case 'string':
       base = 'v.string()'
@@ -623,8 +624,6 @@ function columnTypeToValibot(col: SchemaColumn): string {
     case 'enum':
       base = 'v.string()'
       break
-    default:
-      base = 'v.unknown()'
   }
   return col.optional ? `v.optional(v.nullable(${base}))` : base
 }
@@ -642,7 +641,7 @@ function formatObjectKey(name: string): string {
 function schemaColumnsToValibot(
   columns: Record<string, SchemaColumn>,
   primaryKeys: string[],
-  mode: 'insert' | 'update' | 'delete'
+  mode: 'insert' | 'update' | 'delete',
 ): string {
   const entries: string[] = []
 
@@ -652,7 +651,7 @@ function schemaColumnsToValibot(
       const col = columns[pk]
       if (col)
         entries.push(
-          `${formatObjectKey(pk)}: ${columnTypeToValibot({ ...col, optional: false })}`
+          `${formatObjectKey(pk)}: ${columnTypeToValibot({ ...col, optional: false })}`,
         )
     }
   } else if (mode === 'update') {
@@ -661,11 +660,11 @@ function schemaColumnsToValibot(
       const isPK = primaryKeys.includes(name)
       if (isPK) {
         entries.push(
-          `${formatObjectKey(name)}: ${columnTypeToValibot({ ...col, optional: false })}`
+          `${formatObjectKey(name)}: ${columnTypeToValibot({ ...col, optional: false })}`,
         )
       } else {
         entries.push(
-          `${formatObjectKey(name)}: ${columnTypeToValibot({ ...col, optional: true })}`
+          `${formatObjectKey(name)}: ${columnTypeToValibot({ ...col, optional: true })}`,
         )
       }
     }
@@ -681,7 +680,7 @@ function schemaColumnsToValibot(
 
 function generateSyncedMutationsFile(modelMutations: ModelMutations[]) {
   const sorted = [...modelMutations].sort((a, b) =>
-    a.modelName.localeCompare(b.modelName)
+    a.modelName.localeCompare(b.modelName),
   )
 
   const modelDefs = sorted
@@ -698,17 +697,17 @@ function generateSyncedMutationsFile(modelMutations: ModelMutations[]) {
             const customMut = model.custom.find((m) => m.name === mode)!
             if (customMut.valibotCode) {
               entries.push(
-                `    ${mode}: ${extractValibotExpression(customMut.valibotCode)},`
+                `    ${mode}: ${extractValibotExpression(customMut.valibotCode)},`,
               )
             } else {
               // fall back to schema-derived
               entries.push(
-                `    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`
+                `    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`,
               )
             }
           } else {
             entries.push(
-              `    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`
+              `    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`,
             )
           }
         }
@@ -796,7 +795,7 @@ function tsTypeToValibot(
   ts: typeof import('typescript'),
   checker: import('typescript').TypeChecker,
   type: import('typescript').Type,
-  seen?: Set<import('typescript').Type>
+  seen?: Set<import('typescript').Type>,
 ): string {
   // prevent infinite recursion on circular types
   // only track structured types (objects, intersections) — not primitives/unions
@@ -835,11 +834,14 @@ function tsTypeToValibot(
     const members = type.types
     const hasNull = members.some((t) => t.getFlags() & ts.TypeFlags.Null)
     const hasUndefined = members.some(
-      (t) => t.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)
+      (t) => t.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Void),
     )
     const rest = members.filter(
       (t) =>
-        !(t.getFlags() & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void))
+        !(
+          t.getFlags() &
+          (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void)
+        ),
     )
     if (
       rest.length === 2 &&
@@ -950,6 +952,152 @@ function tsTypeToValibot(
   return 'v.unknown()'
 }
 
+type SchemaColumn = {
+  type: string
+  optional: boolean
+  customType: unknown
+  serverName?: string
+}
+
+type SchemaTable = {
+  name: string
+  columns: Record<string, SchemaColumn>
+  primaryKey: string[]
+}
+
+type SchemaRelationHop = {
+  sourceField: string[]
+  destField: string[]
+  destSchema: string
+  cardinality: 'one' | 'many'
+}
+
+type DrizzleZeroSchema = {
+  tables: Record<string, SchemaTable>
+  relationships: Record<string, Record<string, SchemaRelationHop[]>>
+}
+
+function serializeColumn(col: SchemaColumn): string {
+  const parts: string[] = []
+  parts.push(`type: '${col.type}'`)
+  parts.push(`optional: ${col.optional}`)
+  parts.push(
+    `customType: null as unknown as ${col.type === 'json' ? 'ReadonlyJSONValue' : col.type}`,
+  )
+  if (col.serverName) {
+    parts.push(`serverName: '${col.serverName}'`)
+  }
+  return `{ ${parts.join(', ')} }`
+}
+
+function serializeColumnBuilder(col: SchemaColumn): string {
+  const zeroType =
+    col.type === 'string'
+      ? 'string'
+      : col.type === 'number'
+        ? 'number'
+        : col.type === 'boolean'
+          ? 'boolean'
+          : 'json'
+  let expr = `${zeroType}()`
+  if (col.serverName) {
+    expr += `.from('${col.serverName}')`
+  }
+  if (col.optional) {
+    expr += '.optional()'
+  }
+  return expr
+}
+
+/**
+ * generate a typed schema.ts from drizzle-zero output.
+ * produces a file using table()/createSchema()/relationships() from @rocicorp/zero
+ * so the full type system works (no `relationships: any`).
+ *
+ */
+export function generateDrizzleSchemaFile(schema: DrizzleZeroSchema): string {
+  const lines: string[] = [
+    `// auto-generated by: on-zero generate (from drizzle schema)`,
+    `import { boolean, createSchema, json, number, relationships, string, table } from '@rocicorp/zero'`,
+    ``,
+  ]
+
+  const tableNames = Object.keys(schema.tables).sort()
+
+  // emit table consts using Zero's builder API
+  for (const tableName of tableNames) {
+    const t = schema.tables[tableName]!
+    const colEntries = Object.entries(t.columns)
+      .map(([colName, col]) => `    ${colName}: ${serializeColumnBuilder(col)},`)
+      .join('\n')
+    const pkArgs = t.primaryKey.map((k) => `'${k}'`).join(', ')
+
+    lines.push(`const ${tableName}Table = table('${t.name}')`)
+    lines.push(`  .columns({`)
+    lines.push(colEntries)
+    lines.push(`  })`)
+    lines.push(`  .primaryKey(${pkArgs})`)
+    lines.push(``)
+  }
+
+  // emit relationship consts
+  const relTableNames = Object.keys(schema.relationships).sort()
+  for (const tableName of relTableNames) {
+    const rels = schema.relationships[tableName]!
+    const relEntries = Object.entries(rels)
+    if (relEntries.length === 0) continue
+
+    const relBody = relEntries
+      .map(([relName, hops]) => {
+        // each relationship is an array of hops (usually 1, 2 for many-to-many)
+        if (hops.length === 1) {
+          const hop = hops[0]!
+          const fn = hop.cardinality === 'one' ? 'one' : 'many'
+          const sf = hop.sourceField.map((f) => `'${f}'`).join(', ')
+          const df = hop.destField.map((f) => `'${f}'`).join(', ')
+          return `    ${relName}: ${fn}({\n      sourceField: [${sf}],\n      destSchema: ${hop.destSchema}Table,\n      destField: [${df}],\n    })`
+        }
+        // many-to-many (2 hops)
+        const hopCode = hops
+          .map((hop) => {
+            const fn = hop.cardinality === 'one' ? 'one' : 'many'
+            const sf = hop.sourceField.map((f) => `'${f}'`).join(', ')
+            const df = hop.destField.map((f) => `'${f}'`).join(', ')
+            return `${fn}({ sourceField: [${sf}], destSchema: ${hop.destSchema}Table, destField: [${df}] })`
+          })
+          .join(', ')
+        return `    ${relName}: [${hopCode}]`
+      })
+      .join(',\n')
+
+    lines.push(
+      `const ${tableName}Relationships = relationships(${tableName}Table, ({ one, many }) => ({`,
+    )
+    lines.push(relBody)
+    lines.push(`}))`)
+    lines.push(``)
+  }
+
+  // emit createSchema
+  const tableList = tableNames.map((n) => `  ${n}Table,`).join('\n')
+  const relList = relTableNames
+    .filter((n) => Object.keys(schema.relationships[n]!).length > 0)
+    .map((n) => `  ${n}Relationships,`)
+    .join('\n')
+
+  lines.push(`export const schema = createSchema({`)
+  lines.push(`  tables: [`)
+  lines.push(tableList)
+  lines.push(`  ],`)
+  lines.push(`  relationships: [`)
+  lines.push(relList)
+  lines.push(`  ],`)
+  lines.push(`})`)
+  lines.push(``)
+
+  return lines.join('\n')
+}
+
 export interface GenerateOptions {
   /** base data directory */
   dir: string
@@ -975,7 +1123,11 @@ export interface GenerateResult {
 export async function generate(options: GenerateOptions): Promise<GenerateResult> {
   const { dir, after, silent } = options
   const baseDir = resolve(dir)
-  const modelsDir = resolve(baseDir, 'models')
+  // support both mutations/ (new) and models/ (legacy) directories
+  const mutationsDir = resolve(baseDir, 'mutations')
+  const usesMutationsDir = existsSync(mutationsDir)
+  const modelsDir = usesMutationsDir ? mutationsDir : resolve(baseDir, 'models')
+  const modelsDirName = usesMutationsDir ? 'mutations' : 'models'
   const generatedDir = resolve(baseDir, 'generated')
   const queriesDir = resolve(baseDir, 'queries')
 
@@ -990,21 +1142,21 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
     .sort()
 
   const filesWithSchema = allModelFiles.filter((f) =>
-    readFileSync(resolve(modelsDir, f), 'utf-8').includes('export const schema = table(')
+    readFileSync(resolve(modelsDir, f), 'utf-8').includes('export const schema = table('),
   )
 
   const writeResults = [
     writeFileIfChanged(
       resolve(generatedDir, 'models.ts'),
-      generateModelsFile(allModelFiles)
+      generateModelsFile(allModelFiles, modelsDirName),
     ),
     writeFileIfChanged(
       resolve(generatedDir, 'types.ts'),
-      generateTypesFile(filesWithSchema)
+      generateTypesFile(filesWithSchema),
     ),
     writeFileIfChanged(
       resolve(generatedDir, 'tables.ts'),
-      generateTablesFile(filesWithSchema)
+      generateTablesFile(filesWithSchema, modelsDirName),
     ),
     writeFileIfChanged(resolve(generatedDir, 'README.md'), generateReadmeFile()),
   ]
@@ -1063,13 +1215,13 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
           filePath,
           content,
           ts.ScriptTarget.Latest,
-          true
+          true,
         )
 
         ts.forEachChild(sourceFile, (node) => {
           if (ts.isVariableStatement(node)) {
             const exportModifier = node.modifiers?.find(
-              (m) => m.kind === ts.SyntaxKind.ExportKeyword
+              (m) => m.kind === ts.SyntaxKind.ExportKeyword,
             )
             if (!exportModifier) return
 
@@ -1100,7 +1252,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
                     resolver,
                     resolverSourceFile,
                     name,
-                    0
+                    0,
                   )
                   if (resolvedType) {
                     valibotCode = resolver.typeToValibot(resolvedType)
@@ -1130,11 +1282,11 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
 
     const groupedChanged = writeFileIfChanged(
       resolve(generatedDir, 'groupedQueries.ts'),
-      generateGroupedQueriesFile(allQueries)
+      generateGroupedQueriesFile(allQueries),
     )
     const syncedChanged = writeFileIfChanged(
       resolve(generatedDir, 'syncedQueries.ts'),
-      generateSyncedQueriesFile(allQueries)
+      generateSyncedQueriesFile(allQueries),
     )
 
     if (groupedChanged) filesChanged++
@@ -1161,7 +1313,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
         filePath,
         content,
         ts.ScriptTarget.Latest,
-        true
+        true,
       )
       const result = extractMutationsFromModel(
         ts,
@@ -1169,7 +1321,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
         content,
         filePath,
         !!silent,
-        typeToValibot
+        typeToValibot,
       )
 
       if (result) {
@@ -1178,7 +1330,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
 
         // check if any custom mutations have unresolved types
         const hasUnresolved = result.custom.some(
-          (m) => m.paramType !== 'void' && m.paramType !== 'unknown' && !m.valibotCode
+          (m) => m.paramType !== 'void' && m.paramType !== 'unknown' && !m.valibotCode,
         )
         if (hasUnresolved) {
           unresolvedModels.push({ baseName: fileBaseName, filePath })
@@ -1219,7 +1371,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
       const resolvedTypes = resolveMutationParamTypes(
         ts,
         modelResolver,
-        resolverSourceFile
+        resolverSourceFile,
       )
       if (resolvedTypes.size === 0) continue
 
@@ -1229,7 +1381,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
         filePath,
         content,
         ts.ScriptTarget.Latest,
-        true
+        true,
       )
       const result = extractMutationsFromModel(
         ts,
@@ -1239,7 +1391,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
         !!silent,
         typeToValibot,
         resolvedTypes,
-        modelResolver.typeToValibot
+        modelResolver.typeToValibot,
       )
 
       if (result) {
@@ -1255,21 +1407,21 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
   for (const model of allModelMutations) {
     if (model.hasCRUD) mutationCount += 3 // insert, update, delete
     mutationCount += model.custom.filter(
-      (m) => !model.hasCRUD || !['insert', 'update', 'delete', 'upsert'].includes(m.name)
+      (m) => !model.hasCRUD || !['insert', 'update', 'delete', 'upsert'].includes(m.name),
     ).length
   }
 
   if (allModelMutations.length > 0) {
     const mutationsChanged = writeFileIfChanged(
       resolve(generatedDir, 'syncedMutations.ts'),
-      generateSyncedMutationsFile(allModelMutations)
+      generateSyncedMutationsFile(allModelMutations),
     )
     if (mutationsChanged) filesChanged++
   }
 
   if (filesChanged > 0 && !silent) {
     console.info(
-      `✓ ${allModelFiles.length} models (${filesWithSchema.length} schemas)${queryCount ? `, ${queryCount} queries` : ''}${mutationCount ? `, ${mutationCount} mutations` : ''}`
+      `✓ ${allModelFiles.length} models (${filesWithSchema.length} schemas)${queryCount ? `, ${queryCount} queries` : ''}${mutationCount ? `, ${mutationCount} mutations` : ''}`,
     )
   }
 
@@ -1300,7 +1452,8 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
 export async function watch(options: WatchOptions) {
   const { dir, debounce = 1000 } = options
   const baseDir = resolve(dir)
-  const modelsDir = resolve(baseDir, 'models')
+  const mutationsDir = resolve(baseDir, 'mutations')
+  const modelsDir = existsSync(mutationsDir) ? mutationsDir : resolve(baseDir, 'models')
   const queriesDir = resolve(baseDir, 'queries')
   const generatedDir = resolve(baseDir, 'generated')
 

package/src/helpers/batchQuery.ts

@@ -18,7 +18,7 @@ export function createBatchQuery(server: ServerWithQuery) {
       chunk: number
       pause?: number
       stopAfter?: number
-    } = { chunk: 20 }
+    } = { chunk: 20 },
   ) {
     let hasMore = true
     let last: Item | null = null

package/src/helpers/createMutators.ts

@@ -66,6 +66,7 @@ export function createMutators<Models extends GenericModels>({
             : undefined,
       }
 
+      // eslint-disable-next-line typescript-eslint/return-await
       return await runWithContext(mutationContext, () => {
         // @ts-expect-error type shenanigan
         // map to our mutations() helper
@@ -76,7 +77,7 @@ export function createMutators<Models extends GenericModels>({
 
   function withDevelopmentLogging<Args extends any[]>(
     name: string,
-    fn: (...args: Args) => Promise<void>
+    fn: (...args: Args) => Promise<void>,
   ) {
     if (process.env.NODE_ENV !== 'development' && !process.env.IS_TESTING) {
       return fn
@@ -127,7 +128,7 @@ export function createMutators<Models extends GenericModels>({
     fn: (...args: Args) => Promise<void>,
     // don't want this too high - zero runs mutations in order and waits for the last to finish it seems
     // so if one mutation gets stuck it will just sit there
-    timeoutMs: number = time.ms.minutes(1)
+    timeoutMs: number = time.ms.minutes(1),
   ) {
     return async (...args: Args): Promise<void> => {
       const timeoutPromise = new Promise<never>((_, reject) => {
@@ -143,7 +144,7 @@ export function createMutators<Models extends GenericModels>({
   function withValidation<Args extends any[]>(
     tableName: string,
     mutatorName: string,
-    fn: (...args: Args) => Promise<void>
+    fn: (...args: Args) => Promise<void>,
   ) {
     const validator = mutationValidators?.[tableName]?.[mutatorName]
 
@@ -190,9 +191,9 @@ export function createMutators<Models extends GenericModels>({
             withValidation(
               moduleName,
               name,
-              withContext((...args: any[]) => getDynamicFn()(...args))
-            )
-          )
+              withContext((...args: any[]) => getDynamicFn()(...args)),
+            ),
+          ),
         )
       }
     }

package/src/helpers/didRunPermissionCheck.ts

@@ -4,7 +4,7 @@ import type { MutatorContext } from '../types'
 
 const PermissionCheckRan = globalValue(
   `on-zero:permissions-check`,
-  () => new WeakMap<MutatorContext, boolean>()
+  () => new WeakMap<MutatorContext, boolean>(),
 )
 
 export const getDidRunPermissionCheck = (ctx: MutatorContext) => {

package/src/helpers/mutatorContext.ts

@@ -22,7 +22,7 @@ export function isInZeroMutation() {
 
 export function runWithContext<T>(
   context: MutatorContext,
-  fn: () => T | Promise<T>
+  fn: () => T | Promise<T>,
 ): Promise<T> {
   return asyncContext.run(context, fn)
 }
@@ -37,7 +37,7 @@ export function getScopedAuthData(): AuthData | null | undefined {
 
 export function runWithAuthScope<T>(
   authData: AuthData | null,
-  fn: () => T | Promise<T>
+  fn: () => T | Promise<T>,
 ): Promise<T> {
   return authScopeContext.run(authData, fn)
 }

package/src/helpers/prettyFormatZeroQuery.ts

@@ -4,7 +4,7 @@ import type { Query } from '@rocicorp/zero'
 
 export const prettyFormatZeroQuery = (
   query: Query<any, any, any>,
-  mode: 'full' | 'minimal' = 'full'
+  mode: 'full' | 'minimal' = 'full',
 ): string => {
   const astObject = query['_completeAst']?.()
 

package/src/helpers/queryContext.ts

@@ -14,7 +14,7 @@ export function isInQueryContext() {
 
 export function runWithQueryContext<T>(
   context: { authData: AuthData | null },
-  fn: () => T | Promise<T>
+  fn: () => T | Promise<T>,
 ): Promise<T> {
   return asyncContext.run(context, fn)
 }

package/src/helpers/useZeroDebug.ts

@@ -42,7 +42,7 @@ export const useZeroDebug = (query: Query<any, any, any>, options: any, results:
     if (shouldLog) {
       if (COLLAPSED) {
         console.groupCollapsed(
-          `${isPermissionQuery ? `👮‍♂️` : `✨`}${prettyFormatZeroQuery(query, 'minimal')}`
+          `${isPermissionQuery ? `👮‍♂️` : `✨`}${prettyFormatZeroQuery(query, 'minimal')}`,
         )
         console.info(id, prettyFormatZeroQuery(query, 'full'))
         console.info('cached result', results)
@@ -80,7 +80,7 @@ export const useZeroDebug = (query: Query<any, any, any>, options: any, results:
             table,
             changeCount: history.changeCount,
             recentAsts: history.asts,
-          }
+          },
         )
       }
     }