@sqldoc/templates 0.0.1

package/src/prisma/index.ts

@@ -0,0 +1,387 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, type EnrichedTable, enrichRealm } from '../helpers/enrich.ts'
+import { toPascalCase } from '../helpers/naming.ts'
+
+export const configSchema = {
+  provider: {
+    type: 'string',
+    description: 'Database provider (default: postgresql)',
+  },
+} as const
+
+/** Map a PostgreSQL type to a Prisma type */
+function pgToPrisma(pgType: string): string {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays
+  if (normalized.endsWith('[]')) {
+    return `${pgToPrisma(normalized.slice(0, -2))}[]`
+  }
+  if (normalized.startsWith('_')) {
+    return `${pgToPrisma(normalized.slice(1))}[]`
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  const map: Record<string, string> = {
+    // Numeric
+    smallint: 'Int',
+    int2: 'Int',
+    integer: 'Int',
+    int: 'Int',
+    int4: 'Int',
+    bigint: 'BigInt',
+    int8: 'BigInt',
+    serial: 'Int',
+    serial4: 'Int',
+    bigserial: 'BigInt',
+    serial8: 'BigInt',
+    smallserial: 'Int',
+    serial2: 'Int',
+    real: 'Float',
+    float4: 'Float',
+    'double precision': 'Float',
+    float8: 'Float',
+    numeric: 'Decimal',
+    decimal: 'Decimal',
+    money: 'String',
+
+    // String
+    text: 'String',
+    varchar: 'String',
+    'character varying': 'String',
+    char: 'String',
+    character: 'String',
+    name: 'String',
+    citext: 'String',
+
+    // Boolean
+    boolean: 'Boolean',
+    bool: 'Boolean',
+
+    // Date/Time
+    timestamp: 'DateTime',
+    'timestamp without time zone': 'DateTime',
+    timestamptz: 'DateTime',
+    'timestamp with time zone': 'DateTime',
+    date: 'DateTime',
+    time: 'String',
+    'time without time zone': 'String',
+    timetz: 'String',
+    'time with time zone': 'String',
+    interval: 'String',
+
+    // Binary
+    bytea: 'Bytes',
+
+    // JSON
+    json: 'Json',
+    jsonb: 'Json',
+
+    // UUID
+    uuid: 'String',
+
+    // Network
+    inet: 'String',
+    cidr: 'String',
+    macaddr: 'String',
+    macaddr8: 'String',
+
+    // Other
+    xml: 'String',
+    tsvector: 'String',
+    tsquery: 'String',
+    oid: 'Int',
+    point: 'String',
+    line: 'String',
+    box: 'String',
+    circle: 'String',
+    polygon: 'String',
+    path: 'String',
+  }
+
+  return map[baseType] ?? 'String'
+}
+
+/** Check if column has a unique index */
+function isUnique(table: EnrichedTable, colName: string): boolean {
+  return (
+    table.raw.indexes?.some(
+      (idx) => idx.unique === true && idx.parts?.length === 1 && idx.parts[0].column === colName,
+    ) ?? false
+  )
+}
+
+/** Format a Prisma default expression */
+function formatPrismaDefault(defaultValue: string | undefined, isSerial: boolean): string | undefined {
+  if (isSerial) return '@default(autoincrement())'
+  if (!defaultValue) return undefined
+
+  if (defaultValue === 'now()' || defaultValue === 'CURRENT_TIMESTAMP') return '@default(now())'
+  if (defaultValue === 'gen_random_uuid()') return '@default(uuid())'
+  if (defaultValue === 'true' || defaultValue === 'false') return `@default(${defaultValue})`
+  if (/^\d+$/.test(defaultValue)) return `@default(${defaultValue})`
+
+  // Check if it looks like an expression (has parens)
+  if (defaultValue.includes('(')) return `@default(dbgenerated("${defaultValue}"))`
+
+  return `@default("${defaultValue}")`
+}
+
+export default defineTemplate({
+  name: 'Prisma Schema',
+  description: 'Generate Prisma schema models from SQL schema',
+  language: 'sql',
+  configSchema,
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const tables = activeTables(schema)
+
+    // Build model name map for relations
+    const modelNameMap = new Map<string, string>()
+    for (const table of tables) {
+      modelNameMap.set(table.name, table.pascalName)
+    }
+
+    const provider = (ctx.config as any)?.provider ?? 'postgresql'
+
+    // Pre-compute: count how many FK relations target each model, to decide if we need named relations
+    // Also track reverse relations that need to be added to target models
+    const reverseRelations = new Map<string, Array<{ fromTable: string; relName: string; needsName: boolean }>>()
+    // Count per-model how many FKs point to the same target, keyed by "sourceTable -> targetTable"
+    const fkCountByTarget = new Map<string, Map<string, number>>()
+
+    for (const table of tables) {
+      if (table.belongsTo.length > 0) {
+        const targetCounts = new Map<string, number>()
+        for (const rel of table.belongsTo) {
+          targetCounts.set(rel.foreignTable, (targetCounts.get(rel.foreignTable) ?? 0) + 1)
+        }
+        fkCountByTarget.set(table.name, targetCounts)
+      }
+    }
+
+    // Determine which relations need explicit names
+    interface FkRelation {
+      column: string
+      refTable: string
+      refColumn: string
+      constraintName: string
+      relName: string
+      relationName: string | undefined
+    }
+
+    const tableRelations = new Map<string, FkRelation[]>()
+
+    for (const table of tables) {
+      if (table.belongsTo.length === 0) continue
+
+      const targetCounts = fkCountByTarget.get(table.name) ?? new Map()
+      const relations: FkRelation[] = []
+
+      for (const rel of table.belongsTo) {
+        const relName = rel.column.replace(/_id$/, '')
+        // Need explicit relation name for self-relations or multiple FKs to the same target
+        const isSelfRelation = rel.foreignTable === table.name
+        const needsRelationName = isSelfRelation || (targetCounts.get(rel.foreignTable) ?? 0) > 1
+        const relationName = needsRelationName ? rel.constraintName || `${table.name}_${rel.column}` : undefined
+
+        relations.push({
+          column: rel.column,
+          refTable: rel.foreignTable,
+          refColumn: rel.foreignColumn,
+          constraintName: rel.constraintName,
+          relName,
+          relationName,
+        })
+
+        // Track reverse relation
+        if (!reverseRelations.has(rel.foreignTable)) {
+          reverseRelations.set(rel.foreignTable, [])
+        }
+        reverseRelations.get(rel.foreignTable)!.push({
+          fromTable: table.name,
+          relName: needsRelationName ? relName : (modelNameMap.get(table.name) ?? toPascalCase(table.name)),
+          needsName: needsRelationName,
+        })
+      }
+
+      tableRelations.set(table.name, relations)
+    }
+
+    const blocks: string[] = [
+      '// Generated by @sqldoc/templates/prisma -- DO NOT EDIT',
+      '',
+      `datasource db {`,
+      `  provider = "${provider}"`,
+      `  url      = env("DATABASE_URL")`,
+      `}`,
+      '',
+      `generator client {`,
+      `  provider = "prisma-client-js"`,
+      `}`,
+      '',
+    ]
+
+    // Enums
+    for (const e of schema.enums) {
+      blocks.push(`enum ${e.pascalName} {`)
+      for (const val of e.values) {
+        blocks.push(`  ${val}`)
+      }
+      blocks.push('}')
+      blocks.push('')
+    }
+
+    for (const table of tables) {
+      const modelName = table.pascalName
+      const fieldLines: string[] = []
+
+      // Detect composite primary key (more than one PK column)
+      const pkCols = table.columns.filter((c: any) => c.isPrimaryKey)
+      const isCompositePk = pkCols.length > 1
+
+      for (const col of table.columns) {
+        let prismaType: string
+        if (col.typeOverride) {
+          prismaType = col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          prismaType = toPascalCase(col.pgType)
+        } else {
+          prismaType = pgToPrisma(col.pgType)
+        }
+
+        if (col.nullable && !prismaType.endsWith('[]')) {
+          prismaType += '?'
+        }
+
+        const attrs: string[] = []
+
+        // For composite PKs, use @@id at the model level instead of @id on each column
+        if (col.isPrimaryKey && !isCompositePk) {
+          attrs.push('@id')
+        }
+
+        const defaultAttr = formatPrismaDefault(col.defaultValue, col.isSerial)
+        if (defaultAttr) {
+          attrs.push(defaultAttr)
+        } else if (col.isSerial) {
+          attrs.push('@default(autoincrement())')
+        }
+
+        if (isUnique(table, col.name)) {
+          attrs.push('@unique')
+        }
+
+        // Map column name to Prisma field name + @map
+        const fieldName = col.name
+        const attrStr = attrs.length > 0 ? ` ${attrs.join(' ')}` : ''
+        fieldLines.push(`  ${fieldName} ${prismaType}${attrStr}`)
+      }
+
+      // Add relation fields for foreign keys on this table
+      const relations = tableRelations.get(table.name) ?? []
+      for (const rel of relations) {
+        const refModelName = modelNameMap.get(rel.refTable) ?? toPascalCase(rel.refTable)
+        const relNameAttr = rel.relationName ? `, name: "${rel.relationName}"` : ''
+        // If the FK column is nullable, the relation field must also be optional
+        const fkCol = table.columns.find((c: any) => c.name === rel.column)
+        const optionalMark = fkCol?.nullable ? '?' : ''
+        fieldLines.push(
+          `  ${rel.relName} ${refModelName}${optionalMark} @relation(fields: [${rel.column}], references: [${rel.refColumn}]${relNameAttr})`,
+        )
+      }
+
+      // Add reverse relation fields (other models that reference this one)
+      const reverseRels = reverseRelations.get(table.name) ?? []
+      // Group by source table to handle naming
+      const reverseBySource = new Map<string, typeof reverseRels>()
+      for (const rev of reverseRels) {
+        if (!reverseBySource.has(rev.fromTable)) {
+          reverseBySource.set(rev.fromTable, [])
+        }
+        reverseBySource.get(rev.fromTable)!.push(rev)
+      }
+
+      for (const [sourceTable, rels] of reverseBySource) {
+        const sourceModelName = modelNameMap.get(sourceTable) ?? toPascalCase(sourceTable)
+        if (rels.length === 1 && !rels[0].needsName) {
+          // Simple reverse: just add ModelName[]
+          const fieldName = sourceTable
+          fieldLines.push(`  ${fieldName} ${sourceModelName}[]`)
+        } else {
+          // Multiple relations from same source: need named relations
+          for (const rel of rels) {
+            const sourceRelations = tableRelations.get(sourceTable) ?? []
+            const matchingRel = sourceRelations.find((r) => r.relName === rel.relName)
+            const relationName = matchingRel?.relationName
+            const relNameAttr = relationName ? `(name: "${relationName}")` : ''
+            const fieldName = `${rel.relName}_${sourceTable}`
+            fieldLines.push(`  ${fieldName} ${sourceModelName}[] @relation${relNameAttr}`)
+          }
+        }
+      }
+
+      // Add @@id for composite primary keys
+      if (isCompositePk) {
+        fieldLines.push('')
+        fieldLines.push(`  @@id([${pkCols.map((c: any) => c.name).join(', ')}])`)
+      }
+
+      blocks.push(`model ${modelName} {`)
+      blocks.push(fieldLines.join('\n'))
+      blocks.push('}')
+      blocks.push('')
+    }
+
+    // Views (read-only — represented as Prisma models with @@map)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const fieldLines: string[] = []
+
+      // Views need a dummy @id — use the first column as a stand-in
+      const firstCol = view.columns[0]
+
+      for (const col of view.columns) {
+        let prismaType: string
+        if (col.typeOverride) {
+          prismaType = col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          prismaType = toPascalCase(col.pgType)
+        } else {
+          prismaType = pgToPrisma(col.pgType)
+        }
+
+        if (col.nullable && !prismaType.endsWith('[]')) {
+          prismaType += '?'
+        }
+
+        const attrs: string[] = []
+        if (firstCol && col.name === firstCol.name) {
+          attrs.push('@id')
+        }
+        const attrStr = attrs.length > 0 ? ` ${attrs.join(' ')}` : ''
+        fieldLines.push(`  ${col.name} ${prismaType}${attrStr}`)
+      }
+
+      fieldLines.push('')
+      fieldLines.push(`  @@map("${view.name}")`)
+
+      blocks.push(`/// Read-only (from view)`)
+      blocks.push(`model ${view.pascalName} {`)
+      blocks.push(fieldLines.join('\n'))
+      blocks.push('}')
+      blocks.push('')
+    }
+
+    return {
+      files: [
+        {
+          path: 'schema.prisma',
+          content: blocks.join('\n'),
+        },
+      ],
+    }
+  },
+})

package/src/prisma/test/.gitignore

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

package/src/prisma/test/Dockerfile

@@ -0,0 +1,7 @@
+FROM node:23-slim
+WORKDIR /app
+COPY . .
+RUN npm init -y && npm install prisma@6 --save-dev
+ENV DATABASE_URL="postgresql://user:pass@localhost:5432/db"
+RUN npx prisma validate --schema=schema.prisma
+CMD ["echo", "ok"]

package/src/protobuf/index.ts

@@ -0,0 +1,219 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm } from '../helpers/enrich.ts'
+import { toPascalCase, toScreamingSnake } from '../helpers/naming.ts'
+
+const PG_TO_PROTO: Record<string, string> = {
+  smallint: 'int32',
+  int2: 'int32',
+  integer: 'int32',
+  int: 'int32',
+  int4: 'int32',
+  bigint: 'int64',
+  int8: 'int64',
+  serial: 'int32',
+  serial4: 'int32',
+  bigserial: 'int64',
+  serial8: 'int64',
+  smallserial: 'int32',
+  serial2: 'int32',
+  real: 'float',
+  float4: 'float',
+  'double precision': 'double',
+  float8: 'double',
+  numeric: 'string',
+  decimal: 'string',
+  money: 'string',
+  text: 'string',
+  varchar: 'string',
+  'character varying': 'string',
+  char: 'string',
+  character: 'string',
+  name: 'string',
+  citext: 'string',
+  boolean: 'bool',
+  bool: 'bool',
+  timestamp: 'google.protobuf.Timestamp',
+  'timestamp without time zone': 'google.protobuf.Timestamp',
+  timestamptz: 'google.protobuf.Timestamp',
+  'timestamp with time zone': 'google.protobuf.Timestamp',
+  date: 'string',
+  time: 'string',
+  'time without time zone': 'string',
+  timetz: 'string',
+  interval: 'string',
+  bytea: 'bytes',
+  json: 'string',
+  jsonb: 'string',
+  uuid: 'string',
+  inet: 'string',
+  xml: 'string',
+}
+
+function pgToProto(pgType: string): { type: string; repeated: boolean } {
+  const normalized = pgType.toLowerCase().trim()
+
+  if (normalized.endsWith('[]')) {
+    return { type: pgToProto(normalized.slice(0, -2)).type, repeated: true }
+  }
+  if (normalized.startsWith('_')) {
+    return { type: pgToProto(normalized.slice(1)).type, repeated: true }
+  }
+
+  const base = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+  return { type: PG_TO_PROTO[base] ?? 'string', repeated: false }
+}
+
+export default defineTemplate({
+  name: 'Protocol Buffers',
+  description: 'Generate Protocol Buffers message definitions from SQL schema',
+  language: 'protobuf',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const allColumns = [...schema.tables.flatMap((t) => t.columns), ...schema.views.flatMap((v) => v.columns)]
+    const needsTimestamp = allColumns.some((c) => {
+      const base = c.pgType
+        .toLowerCase()
+        .replace(/\(\d+(?:,\s*\d+)?\)/, '')
+        .trim()
+      return base.startsWith('timestamp')
+    })
+
+    const lines: string[] = [
+      '// Generated by @sqldoc/templates/protobuf -- DO NOT EDIT',
+      'syntax = "proto3";',
+      '',
+      'package schema;',
+      '',
+    ]
+
+    if (needsTimestamp) {
+      lines.push('import "google/protobuf/timestamp.proto";')
+      lines.push('')
+    }
+
+    // Enums
+    for (const e of schema.enums) {
+      const enumName = toPascalCase(e.name)
+      lines.push(`enum ${enumName} {`)
+      lines.push(`  ${toScreamingSnake(e.name)}_UNSPECIFIED = 0;`)
+      e.values.forEach((v, i) => {
+        lines.push(`  ${toScreamingSnake(e.name)}_${toScreamingSnake(v)} = ${i + 1};`)
+      })
+      lines.push('}')
+      lines.push('')
+    }
+
+    // Composite types as messages
+    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 msgName = toPascalCase(name)
+      lines.push(`message ${msgName} {`)
+      let fieldNum = 1
+      for (const f of fields) {
+        const { type, repeated } = pgToProto(f.type)
+        const prefix = repeated ? 'repeated ' : ''
+        lines.push(`  ${prefix}${type} ${f.name} = ${fieldNum};`)
+        fieldNum++
+      }
+      lines.push('}')
+      lines.push('')
+    }
+
+    for (const table of activeTables(schema)) {
+      lines.push(`message ${table.pascalName} {`)
+
+      let fieldNum = 1
+      for (const col of table.columns) {
+        if (col.category === 'enum' && col.enumValues?.length) {
+          const enumType = toPascalCase(col.pgType)
+          const prefix = col.nullable ? 'optional ' : ''
+          lines.push(`  ${prefix}${enumType} ${col.name} = ${fieldNum};`)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          const compositeType = toPascalCase(col.pgType)
+          const prefix = col.nullable ? 'optional ' : ''
+          lines.push(`  ${prefix}${compositeType} ${col.name} = ${fieldNum};`)
+        } else {
+          const { type, repeated } = pgToProto(col.pgType)
+          const prefix = repeated ? 'repeated ' : col.nullable ? 'optional ' : ''
+          lines.push(`  ${prefix}${type} ${col.name} = ${fieldNum};`)
+        }
+        fieldNum++
+      }
+
+      lines.push('}')
+      lines.push('')
+    }
+
+    // Views (read-only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      lines.push(`// Read-only (from view)`)
+      lines.push(`message ${view.pascalName} {`)
+
+      let fieldNum = 1
+      for (const col of view.columns) {
+        if (col.category === 'enum' && col.enumValues?.length) {
+          const enumType = toPascalCase(col.pgType)
+          const prefix = col.nullable ? 'optional ' : ''
+          lines.push(`  ${prefix}${enumType} ${col.name} = ${fieldNum};`)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          const compositeType = toPascalCase(col.pgType)
+          const prefix = col.nullable ? 'optional ' : ''
+          lines.push(`  ${prefix}${compositeType} ${col.name} = ${fieldNum};`)
+        } else {
+          const { type, repeated } = pgToProto(col.pgType)
+          const prefix = repeated ? 'repeated ' : col.nullable ? 'optional ' : ''
+          lines.push(`  ${prefix}${type} ${col.name} = ${fieldNum};`)
+        }
+        fieldNum++
+      }
+
+      lines.push('}')
+      lines.push('')
+    }
+
+    // Functions (skip trigger functions)
+    for (const fn of schema.functions) {
+      const retRaw = fn.returnType?.type?.toLowerCase() ?? ''
+      if (retRaw === 'trigger') continue
+
+      // Request message
+      const reqName = `${fn.pascalName}Request`
+      lines.push(`message ${reqName} {`)
+      let fieldNum = 1
+      for (const a of fn.args.filter((a) => !a.name?.startsWith('_') && (a as any).mode !== 'OUT')) {
+        const { type, repeated } = pgToProto(a.type)
+        const prefix = repeated ? 'repeated ' : ''
+        lines.push(`  ${prefix}${type} ${a.name || 'arg'} = ${fieldNum};`)
+        fieldNum++
+      }
+      lines.push('}')
+      lines.push('')
+
+      // Response message
+      const respName = `${fn.pascalName}Response`
+      lines.push(`message ${respName} {`)
+      if (retRaw.startsWith('setof ')) {
+        const tableName = retRaw.replace('setof ', '')
+        const table = schema.tables.find((t) => t.name === tableName)
+        const retType = table ? table.pascalName : toPascalCase(tableName)
+        lines.push(`  repeated ${retType} results = 1;`)
+      } else if (fn.returnType) {
+        const { type, repeated } = pgToProto(fn.returnType.type)
+        const prefix = repeated ? 'repeated ' : ''
+        lines.push(`  ${prefix}${type} result = 1;`)
+      }
+      lines.push('}')
+      lines.push('')
+    }
+
+    return { files: [{ path: 'schema.proto', content: lines.join('\n') }] }
+  },
+})

package/src/protobuf/test/.gitignore

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

package/src/protobuf/test/Dockerfile

@@ -0,0 +1,6 @@
+FROM alpine:3.20
+RUN apk add --no-cache protobuf protobuf-dev
+WORKDIR /app
+COPY . .
+RUN protoc --proto_path=/usr/include --proto_path=. --descriptor_set_out=/dev/null schema.proto
+CMD ["echo", "ok"]