over-zero 0.0.10 → 0.0.11

package/src/cli.ts

@@ -0,0 +1,511 @@
+#!/usr/bin/env node
+import { ModelToValibot } from '@sinclair/typebox-codegen/model'
+import { TypeScriptToModel } from '@sinclair/typebox-codegen/typescript'
+import { defineCommand, runMain } from 'citty'
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { basename, resolve } from 'node:path'
+import * as ts from 'typescript'
+
+const generateQueries = defineCommand({
+  meta: {
+    name: 'generate-queries',
+    description: 'Generate server-side query validators from TypeScript query functions',
+  },
+  args: {
+    dir: {
+      type: 'positional',
+      description: 'Directory containing query files',
+      required: false,
+      default: '.',
+    },
+  },
+  async run({ args }) {
+    const dir = resolve(args.dir)
+
+    const { readdirSync, writeFileSync } = await import('node:fs')
+
+    const files = readdirSync(dir).filter((f) => f.endsWith('.ts'))
+
+    const allQueries: Array<{ name: string; params: string; valibotCode: string }> = []
+
+    // process files in parallel
+    const results = await Promise.all(
+      files.map(async (file) => {
+        const filePath = resolve(dir, file)
+        const queries: typeof allQueries = []
+
+        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
+
+              const declaration = node.declarationList.declarations[0]
+              if (!declaration || !ts.isVariableDeclaration(declaration)) return
+
+              const name = declaration.name.getText(sourceFile)
+
+              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'
+                }
+
+                try {
+                  const typeString = `type QueryParams = ${paramType}`
+                  const model = TypeScriptToModel.Generate(typeString)
+                  const valibotCode = ModelToValibot.Generate(model)
+
+                  queries.push({ name, params: paramType, valibotCode })
+                } catch (err) {
+                  console.error(`✗ ${name}: ${err}`)
+                }
+              }
+            }
+          })
+        } catch (err) {
+          console.error(`Error processing ${file}:`, err)
+        }
+
+        return queries
+      })
+    )
+
+    allQueries.push(...results.flat())
+    console.info(`✓ ${allQueries.length} query validators`)
+  },
+})
+
+function generateServerQueriesFile(
+  queries: Array<{ name: string; params: string; valibotCode: string }>
+) {
+  const imports = `import * as v from 'valibot'\nimport * as queries from './queries'\n`
+
+  const validators = queries
+    .map((q) => {
+      // extract just the schema definition (without import and type export)
+      const lines = q.valibotCode.split('\n').filter((l) => l.trim())
+      // find line starting with "export const QueryParams"
+      const schemaLineIndex = lines.findIndex((l) =>
+        l.startsWith('export const QueryParams')
+      )
+      if (schemaLineIndex === -1) {
+        return `export const ${q.name}Schema = v.void()`
+      }
+
+      // get the full schema (might be multiline)
+      const schemaLines: string[] = []
+      let openBraces = 0
+      let started = false
+
+      for (let i = schemaLineIndex; i < lines.length; i++) {
+        const line = lines[i]!
+        const cleaned = started ? line : line.replace('export const QueryParams = ', '')
+        schemaLines.push(cleaned)
+        started = true
+
+        // count braces to know when we're done
+        openBraces += (cleaned.match(/\{/g) || []).length
+        openBraces -= (cleaned.match(/\}/g) || []).length
+        openBraces += (cleaned.match(/\(/g) || []).length
+        openBraces -= (cleaned.match(/\)/g) || []).length
+
+        // done when braces are balanced and we have at least one line
+        if (openBraces === 0 && schemaLines.length > 0) {
+          break
+        }
+      }
+
+      const schemaDef = schemaLines.join('\n')
+      return `export const ${q.name}Schema = ${schemaDef}`
+    })
+    .join('\n\n')
+
+  const queryMap = `\nexport const queryValidators = {\n${queries.map((q) => `  ${q.name}: ${q.name}Schema,`).join('\n')}\n} as const\n`
+
+  return imports + '\n' + validators + '\n' + queryMap
+}
+
+const generate = defineCommand({
+  meta: {
+    name: 'generate',
+    description: 'Generate models, types, tables, and query validators',
+  },
+  args: {
+    dir: {
+      type: 'positional',
+      description: 'Base directory (defaults to src/data)',
+      required: false,
+      default: 'src/data',
+    },
+    watch: {
+      type: 'boolean',
+      description: 'Watch for changes and regenerate',
+      required: false,
+      default: false,
+    },
+    after: {
+      type: 'string',
+      description: 'Command to run after generation completes',
+      required: false,
+    },
+  },
+  async run({ args }) {
+    const baseDir = resolve(args.dir)
+    const modelsDir = resolve(baseDir, 'models')
+    const generatedDir = resolve(baseDir, 'generated')
+    const queriesDir = resolve(baseDir, 'queries')
+
+    const runGenerate = async () => {
+      // ensure generated dir exists
+      if (!existsSync(generatedDir)) {
+        mkdirSync(generatedDir, { recursive: true })
+      }
+
+      // read all model files and check for schemas in parallel
+      const allModelFiles = readdirSync(modelsDir)
+        .filter((f) => f.endsWith('.ts'))
+        .sort()
+
+      const schemaChecks = await Promise.all(
+        allModelFiles.map(async (f) => ({
+          file: f,
+          hasSchema: readFileSync(resolve(modelsDir, f), 'utf-8').includes(
+            'export const schema = table('
+          ),
+        }))
+      )
+
+      const filesWithSchema = schemaChecks.filter((c) => c.hasSchema).map((c) => c.file)
+
+      // generate all files in parallel
+      const [modelsOutput, typesOutput, tablesOutput] = await Promise.all([
+        Promise.resolve(generateModelsFile(allModelFiles)),
+        Promise.resolve(generateTypesFile(filesWithSchema)),
+        Promise.resolve(generateTablesFile(filesWithSchema)),
+      ])
+
+      // write all generated files in parallel
+      await Promise.all([
+        Promise.resolve(
+          writeFileSync(resolve(generatedDir, 'models.ts'), modelsOutput, 'utf-8')
+        ),
+        Promise.resolve(
+          writeFileSync(resolve(generatedDir, 'types.ts'), typesOutput, 'utf-8')
+        ),
+        Promise.resolve(
+          writeFileSync(resolve(generatedDir, 'tables.ts'), tablesOutput, 'utf-8')
+        ),
+      ])
+
+      // generate synced queries
+      if (existsSync(queriesDir)) {
+        const queryFiles = readdirSync(queriesDir).filter((f) => f.endsWith('.ts'))
+
+        // process query files in parallel
+        const queryResults = await Promise.all(
+          queryFiles.map(async (file) => {
+            const filePath = resolve(queriesDir, file)
+            const fileBaseName = basename(file, '.ts')
+            const queries: Array<{
+              name: string
+              params: string
+              valibotCode: string
+              sourceFile: string
+            }> = []
+
+            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
+
+                  const declaration = node.declarationList.declarations[0]
+                  if (!declaration || !ts.isVariableDeclaration(declaration)) return
+
+                  const name = declaration.name.getText(sourceFile)
+
+                  // skip 'permission' exports
+                  if (name === 'permission') return
+
+                  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'
+                    }
+
+                    try {
+                      const typeString = `type QueryParams = ${paramType}`
+                      const model = TypeScriptToModel.Generate(typeString)
+                      const valibotCode = ModelToValibot.Generate(model)
+
+                      queries.push({
+                        name,
+                        params: paramType,
+                        valibotCode,
+                        sourceFile: fileBaseName,
+                      })
+                    } catch (err) {
+                      console.error(`✗ ${name}: ${err}`)
+                    }
+                  }
+                }
+              })
+            } catch (err) {
+              console.error(`Error processing ${file}:`, err)
+            }
+
+            return queries
+          })
+        )
+
+        const allQueries = queryResults.flat()
+        const queriesOutput = generateQueriesFile(allQueries)
+        writeFileSync(resolve(generatedDir, 'queries.ts'), queriesOutput, 'utf-8')
+
+        console.info(
+          `✓ ${allModelFiles.length} models (${filesWithSchema.length} schemas), ${allQueries.length} queries`
+        )
+      } else {
+        console.info(
+          `✓ ${allModelFiles.length} models (${filesWithSchema.length} schemas)`
+        )
+      }
+
+      // run after command if provided
+      if (args.after) {
+        try {
+          const { execSync } = await import('node:child_process')
+          execSync(args.after, { stdio: 'inherit' })
+        } catch (err) {
+          console.error(`Error running after command: ${err}`)
+        }
+      }
+    }
+
+    // run once
+    await runGenerate()
+
+    // watch mode
+    if (args.watch) {
+      console.info('\n👀 watching...\n')
+      const chokidar = await import('chokidar')
+
+      let debounceTimer: ReturnType<typeof setTimeout> | null = null
+
+      const debouncedRegenerate = (path: string, event: string) => {
+        if (debounceTimer) {
+          clearTimeout(debounceTimer)
+        }
+
+        console.info(`\n${event} ${path}`)
+
+        debounceTimer = setTimeout(() => {
+          runGenerate()
+        }, 1000)
+      }
+
+      const watcher = chokidar.watch([modelsDir, queriesDir], {
+        persistent: true,
+        ignoreInitial: true,
+      })
+
+      watcher.on('change', (path) => debouncedRegenerate(path, '📝'))
+      watcher.on('add', (path) => debouncedRegenerate(path, '➕'))
+      watcher.on('unlink', (path) => debouncedRegenerate(path, '🗑️ '))
+
+      // keep process alive
+      await new Promise(() => {})
+    }
+  },
+})
+
+function generateModelsFile(modelFiles: string[]) {
+  const modelNames = modelFiles.map((f) => basename(f, '.ts')).sort()
+
+  // special case: user.ts should be imported as userPublic
+  const getImportName = (name: string) => (name === 'user' ? 'userPublic' : name)
+
+  // generate imports (sorted)
+  const imports = modelNames
+    .map((name) => {
+      const importName = getImportName(name)
+      return `import * as ${importName} from '~/data/models/${name}'`
+    })
+    .join('\n')
+
+  // generate models object (sorted by import name)
+  const sortedByImportName = [...modelNames].sort((a, b) =>
+    getImportName(a).localeCompare(getImportName(b))
+  )
+  const modelsObj = `export const models = {\n${sortedByImportName.map((name) => `  ${getImportName(name)},`).join('\n')}\n}`
+
+  return `// auto-generated by: over-zero generate\n${imports}\n\n${modelsObj}\n`
+}
+
+function generateTypesFile(modelFiles: string[]) {
+  const modelNames = modelFiles.map((f) => basename(f, '.ts')).sort()
+
+  // special case: user.ts should reference userPublic in schema
+  const getSchemaName = (name: string) => (name === 'user' ? 'userPublic' : name)
+
+  // generate type exports using TableInsertRow and TableUpdateRow (sorted)
+  const typeExports = modelNames
+    .map((name) => {
+      const pascalName = name.charAt(0).toUpperCase() + name.slice(1)
+      const schemaName = getSchemaName(name)
+      return `export type ${pascalName} = TableInsertRow<typeof schema.${schemaName}>\nexport type ${pascalName}Update = TableUpdateRow<typeof schema.${schemaName}>`
+    })
+    .join('\n\n')
+
+  return `import type { TableInsertRow, TableUpdateRow } from 'over-zero'\nimport type * as schema from '../tables'\n\n${typeExports}\n`
+}
+
+function generateTablesFile(modelFiles: string[]) {
+  const modelNames = modelFiles.map((f) => basename(f, '.ts')).sort()
+
+  // special case: user.ts should be exported as userPublic
+  const getExportName = (name: string) => (name === 'user' ? 'userPublic' : name)
+
+  // generate schema exports (sorted)
+  const exports = modelNames
+    .map(
+      (name) => `export { schema as ${getExportName(name)} } from '~/data/models/${name}'`
+    )
+    .join('\n')
+
+  return `// auto-generated by: over-zero generate\n// this is separate from models as otherwise you end up with circular types :/\n\n${exports}\n`
+}
+
+function generateQueriesFile(
+  queries: Array<{
+    name: string
+    params: string
+    valibotCode: string
+    sourceFile: string
+  }>
+) {
+  // sort queries alphabetically
+  const sortedQueries = [...queries].sort((a, b) => a.name.localeCompare(b.name))
+
+  // Group queries by source file
+  const queryByFile = new Map<string, typeof queries>()
+  for (const q of sortedQueries) {
+    if (!queryByFile.has(q.sourceFile)) {
+      queryByFile.set(q.sourceFile, [])
+    }
+    queryByFile.get(q.sourceFile)!.push(q)
+  }
+
+  // Generate imports for each query file (sorted)
+  const queryImports = Array.from(queryByFile.keys())
+    .sort()
+    .map((file) => `import * as ${file}Queries from '../queries/${file}'`)
+    .join('\n')
+
+  const imports = `import * as v from 'valibot'
+import { syncedQuery } from '@rocicorp/zero'
+${queryImports}
+`
+
+  const syncedQueries = sortedQueries
+    .map((q) => {
+      // extract validator schema
+      const lines = q.valibotCode.split('\n').filter((l) => l.trim())
+      const schemaLineIndex = lines.findIndex((l) =>
+        l.startsWith('export const QueryParams')
+      )
+
+      let validatorDef = 'v.void()'
+      if (schemaLineIndex !== -1) {
+        const schemaLines: string[] = []
+        let openBraces = 0
+        let started = false
+
+        for (let i = schemaLineIndex; i < lines.length; i++) {
+          const line = lines[i]!
+          const cleaned = started ? line : line.replace('export const QueryParams = ', '')
+          schemaLines.push(cleaned)
+          started = true
+
+          openBraces += (cleaned.match(/\{/g) || []).length
+          openBraces -= (cleaned.match(/\}/g) || []).length
+          openBraces += (cleaned.match(/\(/g) || []).length
+          openBraces -= (cleaned.match(/\)/g) || []).length
+
+          if (openBraces === 0 && schemaLines.length > 0) {
+            break
+          }
+        }
+        validatorDef = schemaLines.join('\n')
+      }
+
+      // wrap validator in v.parser(v.tuple([...]))
+      const wrappedValidator =
+        validatorDef === 'v.void()'
+          ? 'v.parser(v.tuple([]))'
+          : `v.parser(v.tuple([${validatorDef}]))`
+
+      // for void queries, no arg parameter
+      const queryFn =
+        validatorDef === 'v.void()'
+          ? `() => {
+  return ${q.sourceFile}Queries.${q.name}()
+}`
+          : `(arg) => {
+  return ${q.sourceFile}Queries.${q.name}(arg)
+}`
+
+      return `export const ${q.name} = syncedQuery('${q.name}', ${wrappedValidator}, ${queryFn})`
+    })
+    .join('\n\n')
+
+  return imports + '\n' + syncedQueries + '\n'
+}
+
+const main = defineCommand({
+  meta: {
+    name: 'over-zero',
+    description: 'Over-zero CLI tools',
+  },
+  subCommands: {
+    generate: generate,
+    'generate-queries': generateQueries,
+  },
+})
+
+runMain(main)