on-zero 0.7.10 → 0.8.0

package/src/generate.ts

@@ -1,9 +1,11 @@
 import { createHash } from 'node:crypto'
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
 import { basename, dirname, resolve } from 'node:path'
+
 import {
   formatObjectKey,
   generateGroupedQueriesFile,
+  generateInstancesFile,
   generateModelsFile,
   generateReadmeFile,
   generateSyncedMutationsFile,
@@ -14,10 +16,13 @@ import {
   parseTypeString,
   shouldSkipObjectKey,
 } from './generate-helpers'
+import { discoverDataLayout, namespaceImportPath } from './generate-layout'
+
 import type { ExtractedMutation, ModelMutations, SchemaColumn } from './generate-helpers'
+import type { DataLayout } from './generate-layout'
 
 const hash = (s: string) => createHash('sha256').update(s).digest('hex')
-const GENERATOR_CACHE_VERSION = '1'
+const GENERATOR_CACHE_VERSION = '5'
 
 const isGeneratorSourceFile = (name: string) =>
   name.endsWith('.ts') &&
@@ -31,24 +36,32 @@ const isGeneratorSourceFile = (name: string) =>
 // and building a TS program per query/model for type resolution — runs every
 // boot otherwise, even when the output is already current (the configureServer
 // watcher re-runs it on real edits, so the boot-time pass is pure redundancy).
-function hashInputTree(baseDir: string, generatedDir: string): string {
+function hashInputTree(sourceRoots: string[], generatedDir: string): string {
   const parts: string[] = []
+  const seen = new Set<string>()
   const walk = (dir: string) => {
     if (!existsSync(dir)) return
     const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) =>
-      a.name < b.name ? -1 : 1,
+      a.name < b.name ? -1 : 1
     )
     for (const entry of entries) {
       const full = resolve(dir, entry.name)
       if (entry.isDirectory()) {
-        if (entry.name === 'node_modules' || full === generatedDir) continue
+        if (
+          entry.name === 'node_modules' ||
+          entry.name === 'generated' ||
+          full === generatedDir
+        )
+          continue
         walk(full)
       } else if (entry.isFile() && isGeneratorSourceFile(entry.name)) {
+        if (seen.has(full)) continue
+        seen.add(full)
         parts.push(`${full}\0${readFileSync(full, 'utf-8')}`)
       }
     }
   }
-  walk(baseDir)
+  for (const root of sourceRoots) walk(root)
   return hash(parts.join('\0'))
 }
 
@@ -108,7 +121,7 @@ function writeFileIfChanged(filePath: string, content: string): boolean {
 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')
@@ -128,7 +141,7 @@ function createTypeResolver(
       const parsed = ts.parseJsonConfigFileContent(
         configFile.config,
         ts.sys,
-        dirname(configPath),
+        dirname(configPath)
       )
       compilerOptions = { ...compilerOptions, ...parsed.options }
     }
@@ -155,7 +168,7 @@ function createTypeResolver(
   const program = ts.createProgram(
     files.map((f) => f.path),
     compilerOptions,
-    host,
+    host
   )
   const checker = program.getTypeChecker()
 
@@ -183,7 +196,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
 
@@ -212,7 +225,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>()
 
@@ -276,7 +289,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
 
@@ -406,7 +419,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) {
@@ -446,7 +459,7 @@ function extractSchemaColumns(
 function getInstantiatedPropertyType(
   checker: import('typescript').TypeChecker,
   parent: import('typescript').Type,
-  name: string,
+  name: string
 ) {
   const resolveProperty: unknown = Reflect.get(checker, 'getTypeOfPropertyOfType')
   if (typeof resolveProperty !== 'function') return undefined
@@ -461,7 +474,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
@@ -510,14 +523,11 @@ 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 &&
@@ -544,7 +554,7 @@ function tsTypeToValibot(
   // resolve symbol property type with fallbacks
   const resolveSymbolType = (
     parent: import('typescript').Type,
-    prop: import('typescript').Symbol,
+    prop: import('typescript').Symbol
   ) => {
     // mapped and conditional types can expose transient symbols with no
     // declaration, so resolve each property against its concrete parent.
@@ -659,7 +669,7 @@ function serializeColumn(col: SchemaColumn): string {
   parts.push(`type: '${col.type}'`)
   parts.push(`optional: ${col.optional}`)
   parts.push(
-    `customType: null as unknown as ${col.type === 'json' ? 'ReadonlyJSONValue' : col.type}`,
+    `customType: null as unknown as ${col.type === 'json' ? 'ReadonlyJSONValue' : col.type}`
   )
   if (col.serverName) {
     parts.push(`serverName: '${col.serverName}'`)
@@ -740,7 +750,7 @@ export function generateDrizzleSchemaFile(schema: DrizzleZeroSchema): string {
         // many-to-many (2 hops)
         if (hops.length !== 2) {
           throw new Error(
-            `Relationship ${tableName}.${relName} must have one or two hops`,
+            `Relationship ${tableName}.${relName} must have one or two hops`
           )
         }
         const cardinality = hops[0]!.cardinality
@@ -760,7 +770,7 @@ export function generateDrizzleSchemaFile(schema: DrizzleZeroSchema): string {
       .join(',\n')
 
     lines.push(
-      `const ${tableName}Relationships = relationships(${tableName}Table, ({ one, many }) => ({`,
+      `const ${tableName}Relationships = relationships(${tableName}Table, ({ one, many }) => ({`
     )
     lines.push(relBody)
     lines.push(`}))`)
@@ -790,6 +800,8 @@ export function generateDrizzleSchemaFile(schema: DrizzleZeroSchema): string {
 export interface GenerateOptions {
   /** base data directory */
   dir: string
+  /** explicit on-zero.config.ts path; auto-discovered in `dir` when omitted */
+  config?: string
   /** run after generation */
   after?: string
   /** suppress output */
@@ -811,16 +823,152 @@ export interface GenerateResult {
   mutationCount: number
 }
 
+export type DataMembership = {
+  instances: Record<
+    string,
+    {
+      tables: string[]
+      syncTables: string[]
+      supportTables: string[]
+      scope: string | null
+    }
+  >
+  allTables: string[]
+}
+
+function dataMembershipFromLayout(layout: DataLayout): DataMembership {
+  return {
+    instances: Object.fromEntries(
+      layout.instances.map((instance) => [
+        instance.name,
+        {
+          tables: instance.namespaces.map((namespace) => namespace.name).sort(),
+          syncTables: [...instance.syncTables],
+          supportTables: [...instance.supportTables],
+          scope: instance.scope,
+        },
+      ])
+    ),
+    allTables: [
+      ...new Set(
+        layout.instances.flatMap((instance) => [
+          ...instance.syncTables,
+          ...instance.supportTables,
+        ])
+      ),
+    ].sort(),
+  }
+}
+
+export async function deriveDataMembership(options: {
+  dir: string
+  config?: string
+}): Promise<DataMembership> {
+  const ts = await import('typescript')
+  const layout = discoverDataLayout(
+    ts,
+    resolve(options.dir),
+    options.config ? resolve(options.config) : undefined
+  )
+  return dataMembershipFromLayout(layout)
+}
+
+export async function generateDrizzleSchemaInputFile(options: {
+  dir: string
+  schemaImportPath: string
+  config?: string
+}): Promise<string> {
+  const ts = await import('typescript')
+  const baseDir = resolve(options.dir)
+  const layout = discoverDataLayout(
+    ts,
+    baseDir,
+    options.config ? resolve(options.config) : undefined
+  )
+  const tableNames = dataMembershipFromLayout(layout).allTables
+  const relationsPath =
+    layout.metadataPaths.find(
+      (path) =>
+        basename(path) === 'relations.ts' &&
+        dirname(path) === resolve(dirname(baseDir), 'database')
+    ) ?? layout.metadataPaths.find((path) => basename(path) === 'relations.ts')
+  const relationEntries: string[] = []
+
+  if (relationsPath) {
+    const source = ts.createSourceFile(
+      relationsPath,
+      readFileSync(relationsPath, 'utf8'),
+      ts.ScriptTarget.Latest,
+      true
+    )
+    const included = new Set(tableNames)
+    const visit = (node: import('typescript').Node) => {
+      if (
+        !ts.isCallExpression(node) ||
+        node.expression.getText(source) !== 'defineRelations'
+      ) {
+        ts.forEachChild(node, visit)
+        return
+      }
+      const factory = node.arguments[1]
+      if (
+        !factory ||
+        (!ts.isArrowFunction(factory) && !ts.isFunctionExpression(factory))
+      ) {
+        return
+      }
+      const body = ts.isParenthesizedExpression(factory.body)
+        ? factory.body.expression
+        : factory.body
+      if (!ts.isObjectLiteralExpression(body)) return
+
+      for (const tableProperty of body.properties) {
+        if (
+          !ts.isPropertyAssignment(tableProperty) ||
+          !ts.isObjectLiteralExpression(tableProperty.initializer)
+        ) {
+          continue
+        }
+        const table = tableProperty.name.getText(source).replace(/^['"]|['"]$/g, '')
+        if (!included.has(table)) continue
+        const relations: string[] = []
+        for (const relationProperty of tableProperty.initializer.properties) {
+          if (
+            !ts.isPropertyAssignment(relationProperty) ||
+            !ts.isCallExpression(relationProperty.initializer) ||
+            !ts.isPropertyAccessExpression(relationProperty.initializer.expression)
+          ) {
+            continue
+          }
+          const target = relationProperty.initializer.expression.name.text
+          if (included.has(target)) relations.push(relationProperty.getText(source))
+        }
+        relationEntries.push(
+          `  ${tableProperty.name.getText(source)}: {${relations.length ? `\n${relations.map((relation) => `    ${relation},`).join('\n')}\n  ` : ''}},`
+        )
+      }
+    }
+    visit(source)
+  }
+
+  const schemaImportPath = JSON.stringify(options.schemaImportPath)
+  return [
+    '// auto-generated from the on-zero data layout',
+    `import { defineRelations } from 'drizzle-orm'`,
+    `import * as schema from ${schemaImportPath}`,
+    '',
+    `export { ${tableNames.join(', ')} } from ${schemaImportPath}`,
+    `export const relations = defineRelations(schema, (r) => ({`,
+    ...relationEntries,
+    `}))`,
+    '',
+  ].join('\n')
+}
+
 export async function generate(options: GenerateOptions): Promise<GenerateResult> {
-  const { dir, after, silent, force } = options
+  const { dir, after, silent, force, config } = options
   const baseDir = resolve(dir)
-  // 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')
 
   if (!existsSync(generatedDir)) {
     mkdirSync(generatedDir, { recursive: true })
@@ -828,12 +976,24 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
 
   loadCache()
 
+  // the layout pass is intentionally first: config, filenames, and related()
+  // calls determine schema membership before any type program exists.
+  const ts = await import('typescript')
+  const layout = discoverDataLayout(ts, baseDir, config ? resolve(config) : undefined)
+  const metadataHash = hash(
+    layout.metadataPaths
+      .map((path) => `${path}\0${readFileSync(path, 'utf8')}`)
+      .join('\0')
+  )
+
   // input-freshness gate: if nothing under baseDir changed since the last
   // COMPLETED generate (the input hash is only stored at the end, after
   // saveCache), the outputs are already current — skip the typescript-program
   // build entirely and return the cached counts. the configureServer watcher
   // still re-runs generate on real model/query edits.
-  const inputHash = hashInputTree(baseDir, generatedDir)
+  const inputHash = hash(
+    `${hashInputTree(layout.sourceRoots, generatedDir)}\0${metadataHash}`
+  )
   if (
     !force &&
     generateCache.__generatorVersion === GENERATOR_CACHE_VERSION &&
@@ -853,19 +1013,26 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
     }
   }
 
-  const allModelFiles = readdirSync(modelsDir).filter(isGeneratorSourceFile).sort()
-
-  const filesWithSchema = allModelFiles.filter((f) =>
-    readFileSync(resolve(modelsDir, f), 'utf-8').includes('export const schema = table('),
+  const modelNamespaces = layout.namespaces.filter(
+    (namespace): namespace is typeof namespace & { modelPath: string } =>
+      namespace.modelPath !== null
   )
-
-  const allModelNames = allModelFiles.map((f) => basename(f, '.ts'))
-  const schemaModelNames = filesWithSchema.map((f) => basename(f, '.ts'))
+  const filesWithSchema = modelNamespaces.filter((namespace) =>
+    readFileSync(namespace.modelPath, 'utf-8').includes('export const schema = table(')
+  )
+  const modelModules = modelNamespaces.map((namespace) => ({
+    name: namespace.name,
+    importPath: namespaceImportPath(baseDir, namespace.modelPath),
+  }))
+  const schemaModules = filesWithSchema.map((namespace) => ({
+    name: namespace.name,
+    importPath: namespaceImportPath(baseDir, namespace.modelPath),
+  }))
 
   const writeResults = [
     writeFileIfChanged(
       resolve(generatedDir, 'models.ts'),
-      generateModelsFile(allModelNames, modelsDirName),
+      generateModelsFile(modelModules)
     ),
     // only generate types.ts and tables.ts when model files define schemas.
     // when using drizzle-zero CLI for schema generation, these files are
@@ -874,11 +1041,11 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
       ? [
           writeFileIfChanged(
             resolve(generatedDir, 'types.ts'),
-            generateTypesFile(schemaModelNames),
+            generateTypesFile(schemaModules.map((module) => module.name))
           ),
           writeFileIfChanged(
             resolve(generatedDir, 'tables.ts'),
-            generateTablesFile(schemaModelNames, modelsDirName),
+            generateTablesFile(schemaModules)
           ),
         ]
       : []),
@@ -889,9 +1056,6 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
   let queryCount = 0
   let mutationCount = 0
 
-  // lazy-load typescript
-  const ts = await import('typescript')
-
   // lightweight string-based parser for inline type annotations from source text
   // handles simple cases: primitives, inline objects, arrays
   // returns null for type references that need the checker to resolve
@@ -903,119 +1067,134 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
     }
   }
 
-  // generate query files if queries directory exists
-  if (existsSync(queriesDir)) {
-    const queryFiles = readdirSync(queriesDir).filter(isGeneratorSourceFile)
-
-    const allQueries: Array<{
-      name: string
-      params: string
-      valibotCode: string
-      sourceFile: string
-    }> = []
-
-    // build resolver for query files (lazy - only created if needed)
-    let queryResolver: ReturnType<typeof createTypeResolver> | null = null
-    const getQueryResolver = () => {
-      if (!queryResolver) {
-        const allFiles = readdirSync(queriesDir)
-          .filter(isGeneratorSourceFile)
-          .map((f) => ({
-            path: resolve(queriesDir, f),
-            content: readFileSync(resolve(queriesDir, f), 'utf-8'),
-          }))
-        queryResolver = createTypeResolver(ts, allFiles, queriesDir)
-      }
-      return queryResolver
+  const allQueries: Array<{
+    name: string
+    params: string
+    valibotCode: string
+    sourceFile: string
+    importPath: string
+  }> = []
+
+  let queryResolver: ReturnType<typeof createTypeResolver> | null = null
+  const getQueryResolver = () => {
+    if (!queryResolver) {
+      const allFiles = [
+        ...new Set(layout.namespaces.flatMap((namespace) => namespace.sourcePaths)),
+      ].map((path) => ({ path, content: readFileSync(path, 'utf-8') }))
+      queryResolver = createTypeResolver(ts, allFiles, baseDir)
     }
+    return queryResolver
+  }
 
-    for (const file of queryFiles) {
-      const filePath = resolve(queriesDir, file)
-      const fileBaseName = basename(file, '.ts')
+  for (const namespace of layout.namespaces.filter(
+    (namespace): namespace is typeof namespace & { queryPath: string } =>
+      namespace.queryPath !== null
+  )) {
+    const filePath = namespace.queryPath
 
-      try {
-        const content = readFileSync(filePath, 'utf-8')
-        const sourceFile = ts.createSourceFile(
-          filePath,
-          content,
-          ts.ScriptTarget.Latest,
-          true,
-        )
+    try {
+      const content = readFileSync(filePath, 'utf-8')
+      const sourceFile = ts.createSourceFile(
+        filePath,
+        content,
+        ts.ScriptTarget.Latest,
+        true
+      )
 
-        ts.forEachChild(sourceFile, (node) => {
-          if (ts.isVariableStatement(node)) {
-            const exportModifier = node.modifiers?.find(
-              (m) => m.kind === ts.SyntaxKind.ExportKeyword,
-            )
-            if (!exportModifier) return
+      ts.forEachChild(sourceFile, (node) => {
+        if (ts.isVariableStatement(node)) {
+          const exportModifier = node.modifiers?.find(
+            (m) => m.kind === ts.SyntaxKind.ExportKeyword
+          )
+          if (!exportModifier) return
 
-            const declaration = node.declarationList.declarations[0]
-            if (!declaration || !ts.isVariableDeclaration(declaration)) return
+          const declaration = node.declarationList.declarations[0]
+          if (!declaration || !ts.isVariableDeclaration(declaration)) return
 
-            const name = declaration.name.getText(sourceFile)
-            if (name === 'permission') return
+          const name = declaration.name.getText(sourceFile)
+          if (['mutate', 'permission', 'schema', 'where'].includes(name)) return
 
-            if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
-              const params = declaration.initializer.parameters
-              let paramType = 'void'
+          if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
+            const params = declaration.initializer.parameters
+            let paramType = 'void'
 
-              if (params.length > 0) {
-                const param = params[0]!
-                paramType = param.type?.getText(sourceFile) || 'unknown'
-              }
+            if (params.length > 0) {
+              const param = params[0]!
+              paramType = param.type?.getText(sourceFile) || 'unknown'
+            }
 
-              let valibotCode = typeToValibot(paramType)
-
-              // if direct parse failed (unresolved reference), use TypeChecker
-              if (!valibotCode && params.length > 0 && params[0]!.type) {
-                const resolver = getQueryResolver()
-                const resolverSourceFile = resolver.program.getSourceFile(filePath)
-                if (resolverSourceFile) {
-                  const resolvedType = resolveParamType(
-                    ts,
-                    resolver,
-                    resolverSourceFile,
-                    name,
-                    0,
-                  )
-                  if (resolvedType) {
-                    valibotCode = resolver.typeToValibot(resolvedType)
-                  }
+            let valibotCode = typeToValibot(paramType)
+
+            // if direct parse failed (unresolved reference), use TypeChecker
+            if (!valibotCode && params.length > 0 && params[0]!.type) {
+              const resolver = getQueryResolver()
+              const resolverSourceFile = resolver.program.getSourceFile(filePath)
+              if (resolverSourceFile) {
+                const resolvedType = resolveParamType(
+                  ts,
+                  resolver,
+                  resolverSourceFile,
+                  name,
+                  0
+                )
+                if (resolvedType) {
+                  valibotCode = resolver.typeToValibot(resolvedType)
                 }
               }
+            }
 
-              if (valibotCode) {
-                allQueries.push({
-                  name,
-                  params: paramType,
-                  valibotCode,
-                  sourceFile: fileBaseName,
-                })
-              } else if (!silent && paramType !== 'void') {
-                console.error(`✗ ${name}: could not resolve type "${paramType}"`)
-              }
+            if (valibotCode) {
+              allQueries.push({
+                name,
+                params: paramType,
+                valibotCode,
+                sourceFile: namespace.name,
+                importPath: namespaceImportPath(baseDir, filePath),
+              })
+            } else if (!silent && paramType !== 'void') {
+              console.error(`✗ ${name}: could not resolve type "${paramType}"`)
             }
           }
-        })
-      } catch (err) {
-        if (!silent) console.error(`Error processing ${file}:`, err)
-      }
+        }
+      })
+    } catch (err) {
+      if (!silent) console.error(`Error processing ${filePath}:`, err)
     }
+  }
 
-    queryCount = allQueries.length
+  queryCount = allQueries.length
 
-    const groupedChanged = writeFileIfChanged(
-      resolve(generatedDir, 'groupedQueries.ts'),
-      generateGroupedQueriesFile(allQueries),
-    )
-    const syncedChanged = writeFileIfChanged(
-      resolve(generatedDir, 'syncedQueries.ts'),
-      generateSyncedQueriesFile(allQueries),
-    )
+  const groupedChanged = writeFileIfChanged(
+    resolve(generatedDir, 'groupedQueries.ts'),
+    generateGroupedQueriesFile(allQueries)
+  )
+  const syncedChanged = writeFileIfChanged(
+    resolve(generatedDir, 'syncedQueries.ts'),
+    generateSyncedQueriesFile(allQueries)
+  )
 
-    if (groupedChanged) filesChanged++
-    if (syncedChanged) filesChanged++
-  }
+  if (groupedChanged) filesChanged++
+  if (syncedChanged) filesChanged++
+
+  const instancesChanged = writeFileIfChanged(
+    resolve(generatedDir, 'instances.ts'),
+    generateInstancesFile(
+      layout.instances.map((instance) => ({
+        name: instance.name,
+        scope: instance.scope,
+        queryNames: instance.namespaces
+          .map((namespace) => namespace.name)
+          .filter((name) => allQueries.some((query) => query.sourceFile === name)),
+        modelNames: instance.namespaces
+          .filter((namespace) => namespace.modelPath)
+          .map((namespace) => namespace.name),
+        tables: instance.namespaces.map((namespace) => namespace.name),
+        syncTables: instance.syncTables,
+        supportTables: instance.supportTables,
+      }))
+    )
+  )
+  if (instancesChanged) filesChanged++
 
   // generate mutation validators from model files
   const allModelMutations: ModelMutations[] = []
@@ -1024,9 +1203,9 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
   const mutationFiles: Array<{ path: string; content: string; baseName: string }> = []
   const unresolvedModels: Array<{ baseName: string; filePath: string }> = []
 
-  for (const file of allModelFiles) {
-    const filePath = resolve(modelsDir, file)
-    const fileBaseName = basename(file, '.ts')
+  for (const namespace of modelNamespaces) {
+    const filePath = namespace.modelPath
+    const fileBaseName = namespace.name
 
     try {
       const content = readFileSync(filePath, 'utf-8')
@@ -1037,7 +1216,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
         filePath,
         content,
         ts.ScriptTarget.Latest,
-        true,
+        true
       )
       const result = extractMutationsFromModel(
         ts,
@@ -1045,7 +1224,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
         content,
         filePath,
         !!silent,
-        typeToValibot,
+        typeToValibot
       )
 
       if (result) {
@@ -1054,14 +1233,14 @@ 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 })
         }
       }
     } catch (err) {
-      if (!silent) console.error(`Error extracting mutations from ${file}:`, err)
+      if (!silent) console.error(`Error extracting mutations from ${filePath}:`, err)
     }
   }
 
@@ -1081,7 +1260,13 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
       }
       return results
     }
-    const allFiles = collectTsFiles(baseDir)
+    const allFiles = [
+      ...new Map(
+        layout.sourceRoots
+          .flatMap(collectTsFiles)
+          .map((file) => [file.path, file] as const)
+      ).values(),
+    ]
     const modelResolver = createTypeResolver(ts, allFiles, baseDir)
 
     for (const { baseName, filePath } of unresolvedModels) {
@@ -1091,7 +1276,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
       const resolvedTypes = resolveMutationParamTypes(
         ts,
         modelResolver,
-        resolverSourceFile,
+        resolverSourceFile
       )
       if (resolvedTypes.size === 0) continue
 
@@ -1101,7 +1286,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
         filePath,
         content,
         ts.ScriptTarget.Latest,
-        true,
+        true
       )
       const result = extractMutationsFromModel(
         ts,
@@ -1111,7 +1296,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
         !!silent,
         typeToValibot,
         resolvedTypes,
-        modelResolver.typeToValibot,
+        modelResolver.typeToValibot
       )
 
       if (result) {
@@ -1127,21 +1312,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` : ''}`,
+      `✓ ${modelNamespaces.length} models (${filesWithSchema.length} schemas)${queryCount ? `, ${queryCount} queries` : ''}${mutationCount ? `, ${mutationCount} mutations` : ''}`
     )
   }
 
@@ -1162,7 +1347,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
   generateCache.__generatorVersion = GENERATOR_CACHE_VERSION
   generateCache.__inputHash = inputHash
   generateCache.__counts = JSON.stringify({
-    modelCount: allModelFiles.length,
+    modelCount: modelNamespaces.length,
     schemaCount: filesWithSchema.length,
     queryCount,
     mutationCount,
@@ -1171,7 +1356,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
 
   return {
     filesChanged,
-    modelCount: allModelFiles.length,
+    modelCount: modelNamespaces.length,
     schemaCount: filesWithSchema.length,
     queryCount,
     mutationCount,
@@ -1181,9 +1366,6 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
 export async function watch(options: WatchOptions) {
   const { dir, debounce = 1000 } = options
   const baseDir = resolve(dir)
-  const mutationsDir = resolve(baseDir, 'mutations')
-  const modelsDir = existsSync(mutationsDir) ? mutationsDir : resolve(baseDir, 'models')
-  const queriesDir = resolve(baseDir, 'queries')
   const generatedDir = resolve(baseDir, 'generated')
 
   // initial run (silent)
@@ -1202,11 +1384,26 @@ export async function watch(options: WatchOptions) {
     }, debounce)
   }
 
-  const watcher = chokidar.watch([modelsDir, queriesDir], {
-    persistent: true,
-    ignoreInitial: true,
-    ignored: [generatedDir],
-  })
+  const databaseDir = resolve(dirname(baseDir), 'database')
+  const ts = await import('typescript')
+  const layout = discoverDataLayout(
+    ts,
+    baseDir,
+    options.config ? resolve(options.config) : undefined
+  )
+  const watcher = chokidar.watch(
+    [
+      ...new Set([
+        ...layout.sourceRoots,
+        ...(existsSync(databaseDir) ? [databaseDir] : []),
+      ]),
+    ],
+    {
+      persistent: true,
+      ignoreInitial: true,
+      ignored: [generatedDir, /node_modules/],
+    }
+  )
 
   watcher.on('change', (path) => debouncedRegenerate(path, '📝'))
   watcher.on('add', (path) => debouncedRegenerate(path, '➕'))