@sqldoc/templates 0.0.1

package/src/zod/index.ts

@@ -0,0 +1,289 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm, type TagEntry } from '../helpers/enrich.ts'
+import { toCamelCase, toPascalCase } from '../helpers/naming.ts'
+
+export const configSchema = {
+  dateType: {
+    type: 'enum',
+    values: ['Date', 'dayjs', 'luxon', 'string'],
+    description: 'How to represent date/time types',
+  },
+  nullableStyle: {
+    type: 'enum',
+    values: ['optional', 'null-union'],
+    description: 'Use .optional() or .nullable() for nullable columns',
+  },
+  bigintType: {
+    type: 'enum',
+    values: ['number', 'bigint', 'string'],
+    description: 'How to represent bigint/bigserial columns',
+  },
+  strict: {
+    type: 'boolean',
+    description: 'Enable strict mode for Zod schemas',
+  },
+} as const
+
+/** Map a PostgreSQL type to a Zod schema call */
+function pgToZod(pgType: string): string {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays
+  if (normalized.endsWith('[]')) {
+    return `z.array(${pgToZod(normalized.slice(0, -2))})`
+  }
+  if (normalized.startsWith('_')) {
+    return `z.array(${pgToZod(normalized.slice(1))})`
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  const map: Record<string, string> = {
+    // Numeric
+    smallint: 'z.number()',
+    int2: 'z.number()',
+    integer: 'z.number()',
+    int: 'z.number()',
+    int4: 'z.number()',
+    bigint: 'z.number()',
+    int8: 'z.number()',
+    serial: 'z.number()',
+    serial4: 'z.number()',
+    bigserial: 'z.number()',
+    serial8: 'z.number()',
+    smallserial: 'z.number()',
+    serial2: 'z.number()',
+    real: 'z.number()',
+    float4: 'z.number()',
+    'double precision': 'z.number()',
+    float8: 'z.number()',
+    numeric: 'z.string()',
+    decimal: 'z.string()',
+    money: 'z.string()',
+
+    // String
+    text: 'z.string()',
+    varchar: 'z.string()',
+    'character varying': 'z.string()',
+    char: 'z.string()',
+    character: 'z.string()',
+    name: 'z.string()',
+    citext: 'z.string()',
+
+    // Boolean
+    boolean: 'z.boolean()',
+    bool: 'z.boolean()',
+
+    // Date/Time
+    timestamp: 'z.date()',
+    'timestamp without time zone': 'z.date()',
+    timestamptz: 'z.date()',
+    'timestamp with time zone': 'z.date()',
+    date: 'z.string()',
+    time: 'z.string()',
+    'time without time zone': 'z.string()',
+    timetz: 'z.string()',
+    'time with time zone': 'z.string()',
+    interval: 'z.string()',
+
+    // Binary
+    bytea: 'z.instanceof(Buffer)',
+
+    // JSON
+    json: 'z.unknown()',
+    jsonb: 'z.unknown()',
+
+    // UUID
+    uuid: 'z.string().uuid()',
+
+    // Network
+    inet: 'z.string()',
+    cidr: 'z.string()',
+    macaddr: 'z.string()',
+    macaddr8: 'z.string()',
+
+    // Other
+    xml: 'z.string()',
+    tsvector: 'z.string()',
+    tsquery: 'z.string()',
+    oid: 'z.number()',
+    point: 'z.string()',
+    line: 'z.string()',
+    box: 'z.string()',
+    circle: 'z.string()',
+    polygon: 'z.string()',
+    path: 'z.string()',
+  }
+
+  return map[baseType] ?? 'z.unknown()'
+}
+
+/** Extract @validate modifiers and append Zod chain calls */
+function applyValidation(baseSchema: string, tags: TagEntry[]): string {
+  let schema = baseSchema
+
+  for (const t of tags) {
+    if (t.namespace !== 'validate') continue
+
+    if (t.tag === 'notEmpty') {
+      schema += '.min(1)'
+    } else if (t.tag === 'length') {
+      const args = t.args as Record<string, unknown>
+      if (args.min !== undefined) schema += `.min(${args.min})`
+      if (args.max !== undefined) schema += `.max(${args.max})`
+    } else if (t.tag === 'range') {
+      const args = t.args as Record<string, unknown>
+      if (args.min !== undefined) schema += `.min(${args.min})`
+      if (args.max !== undefined) schema += `.max(${args.max})`
+    } else if (t.tag === 'pattern') {
+      const pattern = Array.isArray(t.args) ? t.args[0] : undefined
+      if (pattern) schema += `.regex(/${pattern}/)`
+    }
+  }
+
+  return schema
+}
+
+export default defineTemplate({
+  name: 'Zod Schemas',
+  description: 'Generate Zod validation schemas from SQL schema',
+  language: 'typescript',
+  configSchema,
+
+  generate(ctx) {
+    const config = ctx.config ?? {}
+    const schema = enrichRealm(ctx)
+
+    const lines: string[] = ['// Generated by @sqldoc/templates/zod -- DO NOT EDIT', '', "import { z } from 'zod'", '']
+
+    // Enums
+    for (const e of schema.enums) {
+      const values = e.values.map((v) => `'${v}'`).join(', ')
+      lines.push(`export const ${toCamelCase(e.name)}Schema = z.enum([${values}])`)
+      lines.push(`export type ${e.pascalName} = z.infer<typeof ${toCamelCase(e.name)}Schema>`)
+      lines.push('')
+    }
+
+    // Composite types (collected from columns)
+    const composites = new Map<string, Array<{ name: string; type: string }>>()
+    for (const table of schema.tables) {
+      for (const col of table.columns) {
+        if (col.category === 'composite' && col.compositeFields?.length && !composites.has(col.pgType)) {
+          composites.set(col.pgType, col.compositeFields)
+        }
+      }
+    }
+    for (const [name, fields] of composites) {
+      const camelName = toCamelCase(name)
+      const typeName = toPascalCase(name)
+      lines.push(`export const ${camelName}Schema = z.object({`)
+      for (const f of fields) {
+        lines.push(`  ${toCamelCase(f.name)}: ${pgToZod(f.type)},`)
+      }
+      lines.push('})')
+      lines.push(`export type ${typeName} = z.infer<typeof ${camelName}Schema>`)
+      lines.push('')
+    }
+
+    for (const table of activeTables(schema)) {
+      const camelName = toCamelCase(table.pascalName)
+
+      lines.push(`export const ${camelName}Schema = z.object({`)
+
+      for (const col of table.columns) {
+        const propName = toCamelCase(col.name)
+        const zodSchema = resolveZodType(col, config)
+        lines.push(`  ${propName}: ${zodSchema},`)
+      }
+
+      lines.push('})')
+      lines.push('')
+      lines.push(`export type ${table.pascalName} = z.infer<typeof ${camelName}Schema>`)
+      lines.push('')
+    }
+
+    // Views (read-only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const camelName = toCamelCase(view.pascalName)
+
+      lines.push(`/** Read-only schema (from view) */`)
+      lines.push(`export const ${camelName}Schema = z.object({`)
+
+      for (const col of view.columns) {
+        const propName = toCamelCase(col.name)
+        const zodSchema = resolveZodType(col, config)
+        lines.push(`  ${propName}: ${zodSchema},`)
+      }
+
+      lines.push('})')
+      lines.push('')
+      lines.push(`export type ${view.pascalName} = z.infer<typeof ${camelName}Schema>`)
+      lines.push('')
+    }
+
+    // Functions (skip trigger functions)
+    for (const fn of schema.functions) {
+      const retRaw = fn.returnType?.type?.toLowerCase() ?? ''
+      if (retRaw === 'trigger') continue
+
+      const camelName = toCamelCase(fn.pascalName)
+
+      // Build input schema
+      const inputArgs = fn.args.filter((a) => !a.name?.startsWith('_') && (a as any).mode !== 'OUT')
+      lines.push(`export const ${camelName}InputSchema = z.object({`)
+      for (const a of inputArgs) {
+        lines.push(`  ${toCamelCase(a.name || 'arg')}: ${pgToZod(a.type)},`)
+      }
+      lines.push('})')
+      lines.push('')
+
+      // Build output schema
+      let outputSchema: string
+      if (retRaw.startsWith('setof ')) {
+        const tableName = retRaw.replace('setof ', '')
+        const table = schema.tables.find((t) => t.name === tableName)
+        if (table) {
+          outputSchema = `z.array(${toCamelCase(table.pascalName)}Schema)`
+        } else {
+          outputSchema = `z.array(${pgToZod(tableName)})`
+        }
+      } else if (fn.returnType) {
+        outputSchema = pgToZod(fn.returnType.type)
+      } else {
+        outputSchema = 'z.void()'
+      }
+      lines.push(`export const ${camelName}OutputSchema = ${outputSchema}`)
+      lines.push('')
+    }
+
+    return {
+      files: [
+        {
+          path: 'schemas.ts',
+          content: lines.join('\n'),
+        },
+      ],
+    }
+
+    function resolveZodType(col: any, config: any): string {
+      let zodSchema: string
+      if (col.typeOverride) {
+        zodSchema = col.typeOverride
+      } else if (col.category === 'enum' && col.enumValues?.length) {
+        zodSchema = `${toCamelCase(col.pgType)}Schema`
+      } else if (col.category === 'composite' && col.compositeFields?.length) {
+        zodSchema = `${toCamelCase(col.pgType)}Schema`
+      } else {
+        zodSchema = pgToZod(col.pgType)
+        zodSchema = applyValidation(zodSchema, col.tags)
+      }
+
+      if (col.nullable) {
+        zodSchema += config.nullableStyle === 'null-union' ? '.nullable()' : '.optional()'
+      }
+
+      return zodSchema
+    }
+  },
+})

package/src/zod/test/.gitignore

@@ -0,0 +1,6 @@
+# Generated by codegen — only Dockerfile and test scripts are tracked
+*
+!.gitignore
+!Dockerfile
+!test.*
+!Test.*

package/src/zod/test/Dockerfile

@@ -0,0 +1,6 @@
+FROM node:23-slim
+WORKDIR /app
+COPY . .
+RUN npm init -y && npm install typescript@5 zod@3 @types/node --save-dev
+RUN npx tsc --noEmit --strict --esModuleInterop --module nodenext --moduleResolution nodenext *.ts
+CMD ["echo", "ok"]