on-zero 0.7.10 → 0.8.0

package/src/generate-helpers.ts

@@ -254,7 +254,7 @@ export function parseTypeString(type: string): string | null {
     const hasNull = unionParts.includes('null')
     const hasUndefined = unionParts.includes('undefined') || unionParts.includes('void')
     const valueParts = unionParts.filter(
-      (part) => part !== 'null' && part !== 'undefined' && part !== 'void',
+      (part) => part !== 'null' && part !== 'undefined' && part !== 'void'
     )
     if (valueParts.length === 0) return hasNull ? 'v.null_()' : 'v.void_()'
 
@@ -310,21 +310,33 @@ export function parseTypeString(type: string): string | null {
 // these take already-parsed data and return the exact file contents the
 // generator should write. they are pure strings-in/strings-out.
 
-export function generateModelsFile(modelNames: string[], modelsDirName: string): string {
-  const sorted = [...modelNames].sort()
+export type GeneratedModule = { name: string; importPath: string }
+
+export type GeneratedInstance = {
+  name: string
+  scope: string | null
+  queryNames: string[]
+  modelNames: string[]
+  tables: string[]
+  syncTables: string[]
+  supportTables: string[]
+}
+
+export function generateModelsFile(modules: GeneratedModule[]): string {
+  const sorted = [...modules].sort((a, b) => a.name.localeCompare(b.name))
 
   const imports = sorted
     .map(
-      (name) =>
-        `import * as ${getModelImportName(name)} from '../${modelsDirName}/${name}'`,
+      ({ name, importPath }) =>
+        `import * as ${getModelImportName(name)} from '${importPath}'`
     )
     .join('\n')
 
   const sortedByImportName = [...sorted].sort((a, b) =>
-    getModelImportName(a).localeCompare(getModelImportName(b)),
+    getModelImportName(a.name).localeCompare(getModelImportName(b.name))
   )
   const modelsObj = `export const models = {\n${sortedByImportName
-    .map((name) => {
+    .map(({ name }) => {
       const importName = getModelImportName(name)
       return importName === name ? `  ${name},` : `  ${name}: ${importName},`
     })
@@ -347,13 +359,13 @@ export function generateTypesFile(modelNames: string[]): string {
   return `import type { TableInsertRow, TableUpdateRow } from 'on-zero'\nimport type * as schema from './tables'\n\n${typeExports}\n`
 }
 
-export function generateTablesFile(modelNames: string[], modelsDirName: string): string {
-  const sorted = [...modelNames].sort()
+export function generateTablesFile(modules: GeneratedModule[]): string {
+  const sorted = [...modules].sort((a, b) => a.name.localeCompare(b.name))
 
   const exports = sorted
     .map(
-      (name) =>
-        `export { schema as ${getModelImportName(name)} } from '../${modelsDirName}/${name}'`,
+      ({ name, importPath }) =>
+        `export { schema as ${getModelImportName(name)} } from '${importPath}'`
     )
     .join('\n')
 
@@ -367,12 +379,13 @@ this folder is auto-generated by on-zero. do not edit files here directly.
 
 ## what's generated
 
-- \`models.ts\` - exports all models from ../models
+- \`models.ts\` - exports every namespace's mutation module
 - \`types.ts\` - typescript types derived from table schemas
 - \`tables.ts\` - exports table schemas for type inference
 - \`groupedQueries.ts\` - namespaced query re-exports for client setup
 - \`syncedQueries.ts\` - namespaced syncedQuery wrappers for server setup
 - \`syncedMutations.ts\` - valibot validators for mutation args (server auto-validation)
+- \`instances.ts\` - generated client partitions, sync tables, and server-only support tables
 
 ## usage guidelines
 
@@ -380,25 +393,26 @@ this folder is auto-generated by on-zero. do not edit files here directly.
 
 ### queries
 
-write your queries as plain functions in \`../queries/\` and import them directly:
+write small namespaces in one file, or split a large namespace into
+\`queries.ts\` and \`mutations.ts\` inside a folder:
 
 \`\`\`ts
 // ✅ good - import from queries
-import { channelMessages } from '~/data/queries/message'
+import { channelMessages } from '~/data/message/queries'
 \`\`\`
 
 the generated query files are only used internally by zero client/server setup.
 
 ### types
 
-you can import types from this folder, but prefer re-exporting from \`../types.ts\`:
+you can import types from this folder, but prefer re-exporting from your app's public types barrel:
 
 \`\`\`ts
 // ❌ okay but not preferred
 import type { Message } from '~/data/generated/types'
 
-// ✅ better - re-export from types.ts
-import type { Message } from '~/data/types'
+// ✅ better - re-export from the app types barrel
+import type { Message } from '~/types'
 \`\`\`
 
 ## regeneration
@@ -422,13 +436,30 @@ see the [on-zero readme](./node_modules/on-zero/README.md) for full documentatio
 }
 
 export function generateGroupedQueriesFile(
-  queries: Array<{ name: string; sourceFile: string }>,
+  queries: Array<{ name: string; sourceFile: string; importPath: string }>
 ): string {
-  const sortedFiles = [...new Set(queries.map((q) => q.sourceFile))].sort()
+  const queryByFile = new Map<string, typeof queries>()
+  for (const query of queries) {
+    if (!queryByFile.has(query.sourceFile)) queryByFile.set(query.sourceFile, [])
+    queryByFile.get(query.sourceFile)!.push(query)
+  }
 
-  const exports = sortedFiles
-    .map((file) => `export * as ${file} from '../queries/${file}'`)
+  const sortedFiles = [...queryByFile.keys()].sort()
+  const imports = sortedFiles
+    .map(
+      (file) =>
+        `import * as ${file}Source from '${queryByFile.get(file)![0]!.importPath}'`
+    )
     .join('\n')
+  const exports = sortedFiles
+    .map((file) => {
+      const names = queryByFile
+        .get(file)!
+        .map((query) => query.name)
+        .sort()
+      return `export const ${file} = {\n${names.map((name) => `  ${name}: ${file}Source.${name},`).join('\n')}\n}`
+    })
+    .join('\n\n')
 
   return `/**
  * auto-generated by: on-zero generate
@@ -437,7 +468,53 @@ export function generateGroupedQueriesFile(
  * this file re-exports all query modules - while this breaks tree-shaking,
  * queries are typically small and few in number even in larger apps.
  */
-${exports}
+${imports}${imports ? '\n\n' : ''}${exports}
+`
+}
+
+export function generateInstancesFile(instances: GeneratedInstance[]): string {
+  const entries = [...instances]
+    .sort((a, b) =>
+      a.name === 'default' ? -1 : b.name === 'default' ? 1 : a.name.localeCompare(b.name)
+    )
+    .map((instance) => {
+      const queries = instance.queryNames
+        .sort()
+        .map((name) => `      ${formatObjectKey(name)}: groupedQueries.${name},`)
+        .join('\n')
+      const modelEntries = instance.modelNames
+        .sort()
+        .map((name) => `      ${formatObjectKey(name)}: models.${name},`)
+        .join('\n')
+      const scope = instance.scope ? JSON.stringify(instance.scope) : 'null'
+      const visibility = instance.scope
+        ? `(value: string) => ({ column: ${JSON.stringify(instance.scope)}, value })`
+        : 'null'
+      return `  ${formatObjectKey(instance.name)}: {
+    schema,
+    queries: {
+${queries}
+    },
+    models: {
+${modelEntries}
+    },
+    tables: ${JSON.stringify([...instance.tables].sort())},
+    syncTables: ${JSON.stringify([...instance.syncTables].sort())},
+    supportTables: ${JSON.stringify([...instance.supportTables].sort())},
+    scope: ${scope},
+    defaultVisibility: ${visibility},
+  },`
+    })
+    .join('\n')
+
+  return `// auto-generated by: on-zero generate
+import { schema } from './schema'
+import * as groupedQueries from './groupedQueries'
+import { models } from './models'
+
+export const instances = {
+${entries}
+} as const
 `
 }
 
@@ -447,7 +524,7 @@ export function generateSyncedQueriesFile(
     params: string
     valibotCode: string
     sourceFile: string
-  }>,
+  }>
 ): string {
   const queryByFile = new Map<string, typeof queries>()
   for (const q of queries) {
@@ -534,7 +611,7 @@ export function columnTypeToValibot(col: SchemaColumn): string {
 export function schemaColumnsToValibot(
   columns: Record<string, SchemaColumn>,
   primaryKeys: string[],
-  mode: 'insert' | 'update' | 'delete',
+  mode: 'insert' | 'update' | 'delete'
 ): string {
   const entries: string[] = []
 
@@ -544,7 +621,7 @@ export 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') {
@@ -553,11 +630,11 @@ export 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 })}`
         )
       }
     }
@@ -593,7 +670,7 @@ export function parseColumnType(initText: string): SchemaColumn {
 
 export function generateSyncedMutationsFile(modelMutations: ModelMutations[]): string {
   const sorted = [...modelMutations].sort((a, b) =>
-    a.modelName.localeCompare(b.modelName),
+    a.modelName.localeCompare(b.modelName)
   )
 
   const modelDefs = sorted
@@ -610,17 +687,17 @@ export function generateSyncedMutationsFile(modelMutations: ModelMutations[]): s
             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)},`
             )
           }
         }