@sqldoc/templates 0.0.1

package/src/cobol-copybook/index.ts

@@ -0,0 +1,220 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, type EnrichedColumn, enrichRealm } from '../helpers/enrich.ts'
+
+/**
+ * Map PG types to COBOL PIC clauses.
+ * COBOL uses PIC (Picture) clauses to define data formats:
+ *   PIC X(n)    = alphanumeric, n characters
+ *   PIC 9(n)    = numeric, n digits
+ *   PIC S9(n)   = signed numeric
+ *   PIC 9(n)V9(m) = numeric with implied decimal
+ */
+function pgToCoboPic(col: EnrichedColumn): string {
+  const pgType = col.pgType
+    .toLowerCase()
+    .replace(/\(\d+(?:,\s*\d+)?\)/, '')
+    .trim()
+
+  switch (pgType) {
+    // Integers
+    case 'smallint':
+    case 'int2':
+      return 'PIC S9(4) COMP.'
+    case 'integer':
+    case 'int':
+    case 'int4':
+    case 'serial':
+    case 'serial4':
+      return 'PIC S9(9) COMP.'
+    case 'bigint':
+    case 'int8':
+    case 'bigserial':
+    case 'serial8':
+      return 'PIC S9(18) COMP.'
+    case 'smallserial':
+    case 'serial2':
+      return 'PIC S9(4) COMP.'
+
+    // Floats -- use COMP-2 (double precision float)
+    case 'real':
+    case 'float4':
+      return 'COMP-1.'
+    case 'double precision':
+    case 'float8':
+      return 'COMP-2.'
+
+    // Decimal -- use implied decimal point
+    case 'numeric':
+    case 'decimal':
+    case 'money': {
+      const m = col.pgType.match(/\((\d+)(?:,\s*(\d+))?\)/)
+      const prec = m ? parseInt(m[1], 10) : 10
+      const scale = m?.[2] ? parseInt(m[2], 10) : 2
+      return `PIC S9(${prec - scale})V9(${scale}) COMP-3.`
+    }
+
+    // Boolean -- single character Y/N
+    case 'boolean':
+    case 'bool':
+      return "PIC X VALUE 'N'."
+
+    // Date/time
+    case 'date':
+      return 'PIC 9(8).' // YYYYMMDD
+    case 'time':
+    case 'time without time zone':
+    case 'timetz':
+    case 'time with time zone':
+      return 'PIC 9(6).' // HHMMSS
+    case 'timestamp':
+    case 'timestamp without time zone':
+    case 'timestamptz':
+    case 'timestamp with time zone':
+      return 'PIC X(26).' // ISO 8601 string
+    case 'interval':
+      return 'PIC X(30).'
+
+    // Text -- estimate from varchar length or default to 255
+    case 'varchar':
+    case 'character varying': {
+      const lenMatch = col.pgType.match(/\((\d+)\)/)
+      const len = lenMatch ? parseInt(lenMatch[1], 10) : 255
+      return `PIC X(${len}).`
+    }
+    case 'char':
+    case 'character': {
+      const lenMatch = col.pgType.match(/\((\d+)\)/)
+      const len = lenMatch ? parseInt(lenMatch[1], 10) : 1
+      return `PIC X(${len}).`
+    }
+    case 'text':
+    case 'citext':
+    case 'name':
+      return 'PIC X(255).'
+
+    // UUID -- 36 char string (8-4-4-4-12)
+    case 'uuid':
+      return 'PIC X(36).'
+
+    // Binary/JSON/other -- treat as large string
+    case 'bytea':
+    case 'json':
+    case 'jsonb':
+    case 'xml':
+      return 'PIC X(4096).'
+
+    default:
+      return 'PIC X(255).'
+  }
+}
+
+// COBOL reserved words that can't be used as data names
+const COBOL_RESERVED = new Set([
+  'ADDRESS',
+  'ID',
+  'CONTENT',
+  'STATUS',
+  'NAME',
+  'TYPE',
+  'VALUE',
+  'SIZE',
+  'COUNT',
+  'DATE',
+  'TIME',
+  'DATA',
+  'FILE',
+  'KEY',
+  'RECORD',
+  'TABLE',
+  'INDEX',
+  'INPUT',
+  'OUTPUT',
+  'OPEN',
+  'CLOSE',
+  'READ',
+  'WRITE',
+  'DELETE',
+])
+
+function toCobolName(name: string): string {
+  // COBOL names are uppercase, hyphens instead of underscores, max 30 chars
+  let cobol = name.toUpperCase().replace(/_/g, '-').substring(0, 30)
+
+  // Prefix reserved words with WS- (Working Storage)
+  if (COBOL_RESERVED.has(cobol)) {
+    cobol = `WS-${cobol}`
+  }
+
+  return cobol
+}
+
+export default defineTemplate({
+  name: 'COBOL Copybook',
+  description: 'Generate COBOL copybook record definitions from SQL schema',
+  language: 'cobol',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const lines: string[] = ['      *> Generated by @sqldoc/templates/cobol-copybook', '      *> DO NOT EDIT', '']
+
+    // Enums as 88-level conditions
+    for (const e of schema.enums) {
+      const recordName = `${toCobolName(e.name)}-ENUM`
+      lines.push(`       01  ${recordName}  PIC X(50).`)
+      for (const v of e.values) {
+        const condName = `${toCobolName(e.name)}-${toCobolName(v)}`
+        lines.push(`           88  ${condName}  VALUE '${v}'.`)
+      }
+      lines.push('')
+    }
+
+    for (const table of activeTables(schema)) {
+      const recordName = `${toCobolName(table.name)}-RECORD`
+      lines.push(`       01  ${recordName}.`)
+
+      for (const col of table.columns) {
+        const fieldName = toCobolName(col.name)
+        if (col.category === 'enum' && col.enumValues?.length) {
+          // Enum column: use PIC X with 88-level conditions
+          const maxLen = Math.max(...col.enumValues.map((v) => v.length), 20)
+          lines.push(`           05  ${fieldName}  PIC X(${maxLen}).`)
+          for (const v of col.enumValues) {
+            const condName = `${fieldName}-${toCobolName(v)}`
+            lines.push(`               88  ${condName}  VALUE '${v}'.`)
+          }
+        } else {
+          const pic = pgToCoboPic(col)
+          lines.push(`           05  ${fieldName}  ${pic}`)
+        }
+      }
+
+      lines.push('')
+    }
+
+    // Views (read-only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const recordName = `${toCobolName(view.name)}-VIEW`
+      lines.push(`      *> Read-only (from view)`)
+      lines.push(`       01  ${recordName}.`)
+
+      for (const col of view.columns) {
+        const fieldName = toCobolName(col.name)
+        if (col.category === 'enum' && col.enumValues?.length) {
+          const maxLen = Math.max(...col.enumValues.map((v) => v.length), 20)
+          lines.push(`           05  ${fieldName}  PIC X(${maxLen}).`)
+          for (const v of col.enumValues) {
+            const condName = `${fieldName}-${toCobolName(v)}`
+            lines.push(`               88  ${condName}  VALUE '${v}'.`)
+          }
+        } else {
+          const pic = pgToCoboPic(col)
+          lines.push(`           05  ${fieldName}  ${pic}`)
+        }
+      }
+
+      lines.push('')
+    }
+
+    return { files: [{ path: 'schema.cpy', content: lines.join('\n') }] }
+  },
+})

package/src/cobol-copybook/test/.gitignore

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

package/src/cobol-copybook/test/Dockerfile

@@ -0,0 +1,7 @@
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y --no-install-recommends gnucobol4 && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+COPY . .
+RUN printf '       IDENTIFICATION DIVISION.\n       PROGRAM-ID. TEST-CPY.\n       DATA DIVISION.\n       WORKING-STORAGE SECTION.\n       COPY "schema.cpy".\n       PROCEDURE DIVISION.\n           STOP RUN.\n' > test.cob
+RUN cobc -fsyntax-only test.cob
+CMD ["echo", "ok"]

package/src/csharp-records/index.ts

@@ -0,0 +1,131 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm } from '../helpers/enrich.ts'
+import { toPascalCase } from '../helpers/naming.ts'
+import { pgToCsharp } from '../types/pg-to-csharp.ts'
+
+export default defineTemplate({
+  name: 'C# Records',
+  description: 'Generate C# record types from SQL schema',
+  language: 'csharp',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const records: string[] = []
+
+    // Enums
+    for (const e of schema.enums) {
+      const enumName = toPascalCase(e.name)
+      const members = e.values.map((v) => `    ${toPascalCase(v)}`).join(',\n')
+      records.push(`public enum ${enumName}\n{\n${members}\n}`)
+    }
+
+    // Composite types as records
+    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 className = toPascalCase(name)
+      const csFields = fields.map((f) => {
+        const csType = pgToCsharp(f.type, false)
+        return `    ${csType} ${toPascalCase(f.name)}`
+      })
+      records.push(`public record ${className}(`)
+      records.push(csFields.join(',\n'))
+      records.push(');')
+    }
+
+    for (const table of activeTables(schema)) {
+      const params: string[] = []
+      for (const col of table.columns) {
+        let csType: string
+        if (col.typeOverride) {
+          csType = col.nullable ? `${col.typeOverride}?` : col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          csType = col.nullable ? `${toPascalCase(col.pgType)}?` : toPascalCase(col.pgType)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          const compositeType = toPascalCase(col.pgType)
+          csType = col.nullable ? `${compositeType}?` : compositeType
+        } else {
+          csType = pgToCsharp(col.pgType, col.nullable, col.category)
+        }
+
+        params.push(`    ${csType} ${col.pascalName}`)
+      }
+
+      records.push(`public record ${table.pascalName}(`)
+      records.push(params.join(',\n'))
+      records.push(');')
+    }
+
+    // Views (read-only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const params: string[] = []
+      for (const col of view.columns) {
+        let csType: string
+        if (col.typeOverride) {
+          csType = col.nullable ? `${col.typeOverride}?` : col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          csType = col.nullable ? `${toPascalCase(col.pgType)}?` : toPascalCase(col.pgType)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          const compositeType = toPascalCase(col.pgType)
+          csType = col.nullable ? `${compositeType}?` : compositeType
+        } else {
+          csType = pgToCsharp(col.pgType, col.nullable, col.category)
+        }
+
+        params.push(`    ${csType} ${col.pascalName}`)
+      }
+
+      records.push(`/// <summary>Read-only (from view)</summary>`)
+      records.push(`public record ${view.pascalName}(`)
+      records.push(params.join(',\n'))
+      records.push(');')
+    }
+
+    // Functions (skip trigger functions)
+    for (const fn of schema.functions) {
+      const retRaw = fn.returnType?.type?.toLowerCase() ?? ''
+      if (retRaw === 'trigger') continue
+
+      let retType: string
+      if (retRaw.startsWith('setof ')) {
+        const tableName = retRaw.replace('setof ', '')
+        const table = schema.tables.find((t) => t.name === tableName)
+        retType = table ? `IEnumerable<${table.pascalName}>` : `IEnumerable<${toPascalCase(tableName)}>`
+      } else if (fn.returnType) {
+        retType = pgToCsharp(fn.returnType.type, false, fn.returnType.category)
+      } else {
+        retType = 'void'
+      }
+
+      const argParts = fn.args
+        .filter((a) => !a.name?.startsWith('_') && (a as any).mode !== 'OUT')
+        .map((a) => {
+          const csType = pgToCsharp(a.type, false, a.category)
+          const paramName = toPascalCase(a.name || 'arg').replace(/^./, (c) => c.toLowerCase()) // lowerCamelCase
+          return `${csType} ${paramName}`
+        })
+
+      records.push(`public delegate ${retType} ${fn.pascalName}(${argParts.join(', ')});`)
+    }
+
+    if (records.length === 0) {
+      return { files: [] }
+    }
+
+    const parts: string[] = []
+    parts.push('namespace Generated;')
+    parts.push('')
+    parts.push(records.join('\n\n'))
+    parts.push('')
+
+    return {
+      files: [{ path: 'Models.cs', content: parts.join('\n') }],
+    }
+  },
+})

package/src/csharp-records/test/.gitignore

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

package/src/csharp-records/test/Dockerfile

@@ -0,0 +1,6 @@
+FROM mcr.microsoft.com/dotnet/sdk:9.0-alpine
+WORKDIR /app
+RUN dotnet new classlib -n TypeCheck --force && rm TypeCheck/Class1.cs
+COPY *.cs TypeCheck/
+RUN dotnet build TypeCheck/
+CMD ["echo", "ok"]

package/src/diesel/index.ts

@@ -0,0 +1,247 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm } from '../helpers/enrich.ts'
+import { toPascalCase } from '../helpers/naming.ts'
+import { pgToRust } from '../types/pg-to-rust.ts'
+
+/**
+ * Mapping from PostgreSQL types to Diesel SQL types.
+ */
+const PG_TO_DIESEL: Record<string, string> = {
+  smallint: 'SmallInt',
+  int2: 'SmallInt',
+  integer: 'Integer',
+  int: 'Integer',
+  int4: 'Integer',
+  bigint: 'BigInt',
+  int8: 'BigInt',
+  serial: 'Integer',
+  serial4: 'Integer',
+  bigserial: 'BigInt',
+  serial8: 'BigInt',
+  smallserial: 'SmallInt',
+  serial2: 'SmallInt',
+  real: 'Float',
+  float4: 'Float',
+  'double precision': 'Double',
+  float8: 'Double',
+  numeric: 'Numeric',
+  decimal: 'Numeric',
+  text: 'Text',
+  varchar: 'Text',
+  'character varying': 'Text',
+  char: 'Text',
+  character: 'Text',
+  name: 'Text',
+  citext: 'Text',
+  boolean: 'Bool',
+  bool: 'Bool',
+  timestamp: 'Timestamp',
+  'timestamp without time zone': 'Timestamp',
+  timestamptz: 'Timestamptz',
+  'timestamp with time zone': 'Timestamptz',
+  date: 'Date',
+  time: 'Time',
+  'time without time zone': 'Time',
+  bytea: 'Bytea',
+  json: 'Jsonb',
+  jsonb: 'Jsonb',
+  uuid: 'Uuid',
+  inet: 'Inet',
+  money: 'Money',
+}
+
+/**
+ * Map a PostgreSQL column type to Diesel's SQL type name.
+ */
+function pgToDieselType(pgType: string, nullable: boolean): string {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays
+  if (normalized.endsWith('[]') || normalized.startsWith('_')) {
+    const baseType = normalized.endsWith('[]') ? normalized.slice(0, -2) : normalized.slice(1)
+    const inner = pgToDieselType(baseType, false)
+    const arrayType = `Array<${inner}>`
+    return nullable ? `Nullable<${arrayType}>` : arrayType
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+  const dieselType = PG_TO_DIESEL[baseType] ?? 'Text'
+
+  return nullable ? `Nullable<${dieselType}>` : dieselType
+}
+
+export default defineTemplate({
+  name: 'Diesel Schema',
+  description: 'Generate Diesel table! macros and Queryable structs from SQL schema',
+  language: 'rust',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const tableMacros: string[] = []
+    const modelStructs: string[] = []
+    const allImports = new Set<string>()
+    allImports.add('serde::{Serialize, Deserialize}')
+
+    // Enums
+    const enumBlocks: string[] = []
+    for (const e of schema.enums) {
+      const enumName = toPascalCase(e.name)
+      const variants = e.values.map((v) => {
+        const variantName = toPascalCase(v)
+        return `    #[serde(rename = "${v}")]\n    ${variantName},`
+      })
+      enumBlocks.push(
+        `#[derive(Debug, Clone, Serialize, Deserialize, diesel_derive_enum::DbEnum)]\npub enum ${enumName} {\n${variants.join('\n')}\n}`,
+      )
+    }
+
+    // Composite types as structs
+    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)
+        }
+      }
+    }
+    const compositeBlocks: string[] = []
+    for (const [name, fields] of composites) {
+      const structName = toPascalCase(name)
+      const rustFields = fields.map((f) => {
+        const mapped = pgToRust(f.type, false)
+        for (const imp of mapped.imports) allImports.add(imp)
+        return `    pub ${f.name}: ${mapped.type},`
+      })
+      compositeBlocks.push(
+        `#[derive(Debug, Clone, Serialize, Deserialize)]\npub struct ${structName} {\n${rustFields.join('\n')}\n}`,
+      )
+    }
+
+    for (const table of activeTables(schema)) {
+      // Determine PK column
+      const pkColumn = table.primaryKey[0] ?? 'id'
+
+      // Generate table! macro
+      const macroColumns: string[] = []
+      for (const col of table.columns) {
+        const dieselType =
+          col.category === 'enum'
+            ? 'Text'
+            : col.category === 'composite'
+              ? 'Text'
+              : pgToDieselType(col.pgType, col.nullable)
+        macroColumns.push(`        ${col.name} -> ${dieselType},`)
+      }
+
+      tableMacros.push(`diesel::table! {`)
+      tableMacros.push(`    ${table.name} (${pkColumn}) {`)
+      tableMacros.push(macroColumns.join('\n'))
+      tableMacros.push(`    }`)
+      tableMacros.push(`}`)
+
+      // Generate Queryable struct
+      const fields: string[] = []
+      for (const col of table.columns) {
+        let rustType: string
+        if (col.typeOverride) {
+          rustType = col.nullable ? `Option<${col.typeOverride}>` : col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          const enumType = toPascalCase(col.pgType)
+          rustType = col.nullable ? `Option<${enumType}>` : enumType
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          const compositeType = toPascalCase(col.pgType)
+          rustType = col.nullable ? `Option<${compositeType}>` : compositeType
+        } else {
+          const mapped = pgToRust(col.pgType, col.nullable, col.category)
+          rustType = mapped.type
+          for (const imp of mapped.imports) allImports.add(imp)
+        }
+
+        fields.push(`    pub ${col.name}: ${rustType},`)
+      }
+
+      modelStructs.push('#[derive(Debug, Clone, Queryable, Selectable, Serialize, Deserialize)]')
+      modelStructs.push(`#[diesel(table_name = ${table.name})]`)
+      modelStructs.push(`pub struct ${table.pascalName} {`)
+      modelStructs.push(fields.join('\n'))
+      modelStructs.push('}')
+    }
+
+    // Views (read-only) — generate both view schema and Queryable struct
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      // Generate table! macro for the view (Diesel uses table! for views too)
+      const macroColumns: string[] = []
+      const firstCol = view.columns[0]?.name ?? 'id'
+      for (const col of view.columns) {
+        const dieselType =
+          col.category === 'enum'
+            ? 'Text'
+            : col.category === 'composite'
+              ? 'Text'
+              : pgToDieselType(col.pgType, col.nullable)
+        macroColumns.push(`        ${col.name} -> ${dieselType},`)
+      }
+
+      tableMacros.push(`diesel::table! {`)
+      tableMacros.push(`    ${view.name} (${firstCol}) {`)
+      tableMacros.push(macroColumns.join('\n'))
+      tableMacros.push(`    }`)
+      tableMacros.push(`}`)
+
+      const fields: string[] = []
+      for (const col of view.columns) {
+        let rustType: string
+        if (col.typeOverride) {
+          rustType = col.nullable ? `Option<${col.typeOverride}>` : col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          const enumType = toPascalCase(col.pgType)
+          rustType = col.nullable ? `Option<${enumType}>` : enumType
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          const compositeType = toPascalCase(col.pgType)
+          rustType = col.nullable ? `Option<${compositeType}>` : compositeType
+        } else {
+          const mapped = pgToRust(col.pgType, col.nullable, col.category)
+          rustType = mapped.type
+          for (const imp of mapped.imports) allImports.add(imp)
+        }
+
+        fields.push(`    pub ${col.name}: ${rustType},`)
+      }
+
+      modelStructs.push(`/// Read-only (from view)`)
+      modelStructs.push('#[derive(Debug, Clone, Queryable, Serialize, Deserialize)]')
+      modelStructs.push(`pub struct ${view.pascalName} {`)
+      modelStructs.push(fields.join('\n'))
+      modelStructs.push('}')
+    }
+
+    if (tableMacros.length === 0 && enumBlocks.length === 0 && compositeBlocks.length === 0) {
+      return { files: [] }
+    }
+
+    // schema.rs
+    const schemaContent = `${tableMacros.join('\n\n')}\n`
+
+    // models.rs
+    const sortedImports = [...allImports].sort()
+    const useLines = sortedImports.map((imp) => `use ${imp};`)
+    const modelsContent = [
+      'use diesel::prelude::*;',
+      'use crate::schema::*;',
+      ...useLines,
+      '',
+      ...(enumBlocks.length > 0 ? [...enumBlocks, ''] : []),
+      ...(compositeBlocks.length > 0 ? [...compositeBlocks, ''] : []),
+      modelStructs.join('\n\n'),
+      '',
+    ].join('\n')
+
+    return {
+      files: [
+        { path: 'schema.rs', content: schemaContent },
+        { path: 'models.rs', content: modelsContent },
+      ],
+    }
+  },
+})

package/src/diesel/test/.gitignore

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

package/src/diesel/test/Dockerfile

@@ -0,0 +1,16 @@
+FROM rust:1.85-slim
+WORKDIR /app
+RUN cargo init --name typecheck .
+RUN cat >> Cargo.toml <<'TOML'
+diesel = { version = "2", features = ["postgres"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+chrono = { version = "0.4", features = ["serde"] }
+uuid = { version = "1", features = ["serde"] }
+bigdecimal = { version = "0.4", features = ["serde"] }
+TOML
+RUN rm src/main.rs
+COPY . src/
+RUN echo 'mod schema;' > src/lib.rs && echo 'mod models;' >> src/lib.rs
+RUN cargo check
+CMD ["echo", "ok"]