@sqldoc/templates 0.0.1

package/src/drizzle/index.ts

@@ -0,0 +1,255 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm } from '../helpers/enrich.ts'
+import { toCamelCase } from '../helpers/naming.ts'
+
+export const configSchema = {
+  schemaName: {
+    type: 'string',
+    description: 'PostgreSQL schema name override',
+  },
+} as const
+
+/** Track which drizzle-orm/pg-core imports are used */
+interface ImportTracker {
+  used: Set<string>
+}
+
+/** Map a PostgreSQL type to a Drizzle column builder call */
+function pgToDrizzle(pgType: string, colName: string, tracker: ImportTracker): string {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Strip length specifiers for lookup
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  const map: Record<string, [string, string]> = {
+    // [drizzle-function-name, import-name]
+    smallint: ['smallint', 'smallint'],
+    int2: ['smallint', 'smallint'],
+    integer: ['integer', 'integer'],
+    int: ['integer', 'integer'],
+    int4: ['integer', 'integer'],
+    bigint: ['bigint', 'bigint'],
+    int8: ['bigint', 'bigint'],
+    serial: ['serial', 'serial'],
+    serial4: ['serial', 'serial'],
+    bigserial: ['bigserial', 'bigserial'],
+    serial8: ['bigserial', 'bigserial'],
+    smallserial: ['smallserial', 'smallserial'],
+    serial2: ['smallserial', 'smallserial'],
+    real: ['real', 'real'],
+    float4: ['real', 'real'],
+    'double precision': ['doublePrecision', 'doublePrecision'],
+    float8: ['doublePrecision', 'doublePrecision'],
+    numeric: ['numeric', 'numeric'],
+    decimal: ['numeric', 'numeric'],
+    money: ['text', 'text'],
+
+    text: ['text', 'text'],
+    varchar: ['varchar', 'varchar'],
+    'character varying': ['varchar', 'varchar'],
+    char: ['char', 'char'],
+    character: ['char', 'char'],
+    name: ['text', 'text'],
+    citext: ['text', 'text'],
+
+    boolean: ['boolean', 'boolean'],
+    bool: ['boolean', 'boolean'],
+
+    timestamp: ['timestamp', 'timestamp'],
+    'timestamp without time zone': ['timestamp', 'timestamp'],
+    timestamptz: ['timestamp', 'timestamp'],
+    'timestamp with time zone': ['timestamp', 'timestamp'],
+    date: ['date', 'date'],
+    time: ['time', 'time'],
+    'time without time zone': ['time', 'time'],
+    timetz: ['time', 'time'],
+    'time with time zone': ['time', 'time'],
+    interval: ['interval', 'interval'],
+
+    bytea: ['text', 'text'],
+
+    json: ['json', 'json'],
+    jsonb: ['jsonb', 'jsonb'],
+
+    uuid: ['uuid', 'uuid'],
+
+    inet: ['inet', 'inet'],
+    cidr: ['text', 'text'],
+    macaddr: ['macaddr', 'macaddr'],
+    macaddr8: ['macaddr8', 'macaddr8'],
+
+    xml: ['text', 'text'],
+    tsvector: ['text', 'text'],
+    tsquery: ['text', 'text'],
+    oid: ['integer', 'integer'],
+    point: ['text', 'text'],
+    line: ['text', 'text'],
+    box: ['text', 'text'],
+    circle: ['text', 'text'],
+    polygon: ['text', 'text'],
+    path: ['text', 'text'],
+  }
+
+  const entry = map[baseType]
+  if (entry) {
+    tracker.used.add(entry[1])
+    // bigint and bigserial require a mode option in drizzle-orm 0.38+
+    if (entry[0] === 'bigint' || entry[0] === 'bigserial') {
+      return `${entry[0]}('${colName}', { mode: 'number' })`
+    }
+    return `${entry[0]}('${colName}')`
+  }
+
+  // Fallback: arrays and unknowns
+  if (normalized.endsWith('[]') || normalized.startsWith('_')) {
+    tracker.used.add('text')
+    return `text('${colName}')`
+  }
+
+  tracker.used.add('text')
+  return `text('${colName}')`
+}
+
+/** Format a default expression for Drizzle */
+function formatDefault(defaultValue: string | undefined): string | undefined {
+  if (!defaultValue) return undefined
+  // Heuristic: expressions with parens or uppercase keywords are likely SQL expressions
+  if (defaultValue.includes('(') || /^[A-Z_]+$/.test(defaultValue)) {
+    return `sql\`${defaultValue}\``
+  }
+  if (defaultValue === 'true' || defaultValue === 'false') return defaultValue
+  if (/^\d+$/.test(defaultValue)) return defaultValue
+  return `'${defaultValue}'`
+}
+
+export default defineTemplate({
+  name: 'Drizzle Schema',
+  description: 'Generate Drizzle ORM pgTable schema definitions from SQL schema',
+  language: 'typescript',
+  configSchema,
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const tables = activeTables(schema)
+    const tracker: ImportTracker = { used: new Set(['pgTable']) }
+    const tableBlocks: string[] = []
+
+    // We'll need a map from table name to camelCase variable name for FK references
+    const tableVarMap = new Map<string, string>()
+    for (const table of tables) {
+      tableVarMap.set(table.name, toCamelCase(table.pascalName))
+    }
+
+    // Enums
+    const enumBlocks: string[] = []
+    if (schema.enums.length > 0) {
+      tracker.used.add('pgEnum')
+      for (const e of schema.enums) {
+        const values = e.values.map((v) => `'${v}'`).join(', ')
+        enumBlocks.push(`export const ${toCamelCase(e.name)}Enum = pgEnum('${e.name}', [${values}])`)
+      }
+    }
+
+    for (const table of tables) {
+      const varName = toCamelCase(table.pascalName)
+
+      const colLines: string[] = []
+
+      for (const col of table.columns) {
+        let builder: string
+        if (col.typeOverride) {
+          tracker.used.add('text')
+          builder = `text('${col.name}')`
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          builder = `${toCamelCase(col.pgType)}Enum('${col.name}')`
+        } else {
+          builder = pgToDrizzle(col.pgType, col.name, tracker)
+        }
+
+        // Add modifiers
+        if (col.isPrimaryKey) {
+          builder += '.primaryKey()'
+        }
+        if (!col.nullable && !col.isSerial) {
+          builder += '.notNull()'
+        }
+
+        const defaultExpr = formatDefault(col.defaultValue)
+        if (defaultExpr) {
+          if (defaultExpr.startsWith('sql`')) {
+            tracker.used.add('sql')
+            builder += `.default(${defaultExpr})`
+          } else {
+            builder += `.default(${defaultExpr})`
+          }
+        }
+
+        // Foreign key references (skip self-references to avoid circular implicit-any in TS)
+        if (col.foreignKey && col.foreignKey.table !== table.name) {
+          const refVar = tableVarMap.get(col.foreignKey.table) ?? toCamelCase(col.foreignKey.table)
+          const refCol = col.foreignKey.column
+          builder += `.references(() => ${refVar}.${toCamelCase(refCol)})`
+        }
+
+        colLines.push(`  ${toCamelCase(col.name)}: ${builder},`)
+      }
+
+      tableBlocks.push(`export const ${varName} = pgTable('${table.name}', {\n${colLines.join('\n')}\n})`)
+    }
+
+    // Views (read-only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const varName = toCamelCase(view.pascalName)
+      tracker.used.add('pgView')
+
+      const colLines: string[] = []
+      for (const col of view.columns) {
+        let builder: string
+        if (col.typeOverride) {
+          tracker.used.add('text')
+          builder = `text('${col.name}')`
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          builder = `${toCamelCase(col.pgType)}Enum('${col.name}')`
+        } else {
+          builder = pgToDrizzle(col.pgType, col.name, tracker)
+        }
+
+        colLines.push(`  ${toCamelCase(col.name)}: ${builder},`)
+      }
+
+      tableBlocks.push(
+        `/** Read-only (from view) */\nexport const ${varName} = pgView('${view.name}', {\n${colLines.join('\n')}\n})`,
+      )
+    }
+
+    // Build imports
+    const importNames = Array.from(tracker.used).sort()
+    const sqlImport = importNames.includes('sql')
+    const pgCoreImports = importNames.filter((n) => n !== 'sql')
+
+    const lines: string[] = [
+      '// Generated by @sqldoc/templates/drizzle -- DO NOT EDIT',
+      '',
+      `import { ${pgCoreImports.join(', ')} } from 'drizzle-orm/pg-core'`,
+    ]
+    if (sqlImport) {
+      lines.push("import { sql } from 'drizzle-orm'")
+    }
+    lines.push('')
+    if (enumBlocks.length > 0) {
+      lines.push(enumBlocks.join('\n'))
+      lines.push('')
+    }
+    lines.push(tableBlocks.join('\n\n'))
+    lines.push('')
+
+    return {
+      files: [
+        {
+          path: 'schema.ts',
+          content: lines.join('\n'),
+        },
+      ],
+    }
+  },
+})

package/src/drizzle/test/.gitignore

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

package/src/drizzle/test/Dockerfile

@@ -0,0 +1,8 @@
+FROM node:23-slim
+WORKDIR /app
+COPY . .
+RUN npm init -y && npm pkg set type=module && npm install typescript@5 drizzle-orm@0.38 pg @types/pg @types/node --save-dev
+# Step 1: typecheck the generated schema
+RUN npx tsc --noEmit --strict --esModuleInterop --module nodenext --moduleResolution nodenext --allowImportingTsExtensions --skipLibCheck *.ts
+# Step 2: run integration test against real DB
+CMD ["node", "--experimental-strip-types", "test.ts"]

package/src/drizzle/test/test.ts

@@ -0,0 +1,71 @@
+/**
+ * Integration test for @sqldoc/templates/drizzle
+ * Connects to real Postgres via drizzle-orm, verifies generated schema works.
+ */
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { eq } from 'drizzle-orm'
+import pg from 'pg'
+import * as schema from './schema.ts'
+
+const DATABASE_URL = process.env.DATABASE_URL
+if (!DATABASE_URL) {
+  console.error('DATABASE_URL not set')
+  process.exit(1)
+}
+
+const pool = new pg.Pool({ connectionString: DATABASE_URL })
+const db = drizzle(pool, { schema })
+
+let failed = 0
+function assert(condition: boolean, msg: string) {
+  if (!condition) {
+    console.error(`FAIL: ${msg}`)
+    failed++
+  } else {
+    console.log(`  ok: ${msg}`)
+  }
+}
+
+async function run() {
+  try {
+    console.log('--- drizzle integration test ---')
+
+    // 1. Query known seeded user
+    const users = await db.select().from(schema.users).where(eq(schema.users.id, 1))
+    assert(users.length === 1, 'seeded user found')
+    assert(users[0].email === 'test@example.com', 'user email matches')
+    assert(users[0].name === 'Test User', 'user name matches')
+
+    // 2. Query known seeded post
+    const posts = await db.select().from(schema.posts).where(eq(schema.posts.id, 1))
+    assert(posts.length === 1, 'seeded post found')
+    assert(posts[0].title === 'Hello World', 'post title matches')
+
+    // 3. Insert a new post
+    await db.insert(schema.posts).values({
+      userId: 1,
+      title: 'Post from drizzle',
+      body: 'test body',
+      viewCount: 0,
+    })
+
+    // 4. Read it back
+    const newPosts = await db.select().from(schema.posts).where(eq(schema.posts.title, 'Post from drizzle'))
+    assert(newPosts.length === 1, 'inserted post found')
+    assert(newPosts[0].title === 'Post from drizzle', 'inserted post title matches')
+    assert(Number(newPosts[0].userId) === 1, 'inserted post user_id matches')
+
+    if (failed > 0) {
+      console.error(`\n${failed} assertion(s) failed`)
+      process.exit(1)
+    }
+    console.log('\nAll assertions passed!')
+  } finally {
+    await pool.end()
+  }
+}
+
+run().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/src/efcore/index.ts

@@ -0,0 +1,190 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm, type TagEntry } from '../helpers/enrich.ts'
+import { toPascalCase } from '../helpers/naming.ts'
+import { pgToCsharp } from '../types/pg-to-csharp.ts'
+
+// C# reference types that get [Required] when non-nullable
+const REFERENCE_TYPES = new Set(['string', 'byte[]', 'IPAddress'])
+
+/**
+ * Extract varchar length from pgType, e.g. varchar(255) -> 255
+ */
+function getVarcharLength(pgType: string): number | undefined {
+  const match = pgType.match(/(?:varchar|character varying)\((\d+)\)/i)
+  return match ? parseInt(match[1], 10) : undefined
+}
+
+/**
+ * Generate EF Core data annotations from @validate tags.
+ */
+function getValidationAnnotations(colTags: TagEntry[]): string[] {
+  const annotations: string[] = []
+
+  for (const tag of colTags) {
+    if (tag.namespace !== 'validate') continue
+
+    if (tag.tag === 'length') {
+      const args = tag.args as Record<string, unknown>
+      if (args.max !== undefined) {
+        annotations.push(`    [MaxLength(${args.max})]`)
+      }
+    } else if (tag.tag === 'range') {
+      const args = tag.args as Record<string, unknown>
+      const min = args.min ?? 0
+      const max = args.max ?? 0
+      annotations.push(`    [Range(${min}, ${max})]`)
+    } else if (tag.tag === 'pattern') {
+      const pattern = Array.isArray(tag.args) ? tag.args[0] : undefined
+      if (pattern) {
+        annotations.push(`    [RegularExpression(@"${pattern}")]`)
+      }
+    }
+  }
+
+  return annotations
+}
+
+export default defineTemplate({
+  name: 'EF Core Entities',
+  description: 'Generate Entity Framework Core entity classes with data annotations from SQL schema',
+  language: 'csharp',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const classes: string[] = []
+
+    // Enums
+    for (const e of schema.enums) {
+      const enumName = toPascalCase(e.name)
+      const members = e.values.map((v) => `    ${toPascalCase(v)}`).join(',\n')
+      classes.push(`public enum ${enumName}\n{\n${members}\n}`)
+    }
+
+    // Composite types as [Owned] classes
+    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 propertyLines: string[] = []
+      for (const f of fields) {
+        const csType = pgToCsharp(f.type, false)
+        propertyLines.push(`    public ${csType} ${toPascalCase(f.name)} { get; set; }`)
+        propertyLines.push('')
+      }
+
+      classes.push(`[Owned]`)
+      classes.push(`public class ${className}`)
+      classes.push('{')
+      classes.push(propertyLines.join('\n'))
+      classes.push('}')
+    }
+
+    for (const table of activeTables(schema)) {
+      const propertyLines: 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)
+        }
+
+        const annotations: string[] = []
+
+        // PK annotation
+        if (col.isPrimaryKey) {
+          annotations.push('    [Key]')
+        }
+
+        // FK annotation
+        if (col.foreignKey) {
+          annotations.push(`    [ForeignKey("${col.pascalName}")]`)
+        }
+
+        // Required for non-nullable reference types
+        const baseType = csType.replace('?', '')
+        if (!col.nullable && REFERENCE_TYPES.has(baseType) && !col.isPrimaryKey) {
+          annotations.push('    [Required]')
+        }
+
+        // MaxLength for varchar
+        const varcharLen = getVarcharLength(col.pgType)
+        if (varcharLen) {
+          annotations.push(`    [MaxLength(${varcharLen})]`)
+        }
+
+        // Validation annotations from @validate tags
+        const validationAnnotations = getValidationAnnotations(col.tags)
+        annotations.push(...validationAnnotations)
+
+        if (annotations.length > 0) {
+          propertyLines.push(annotations.join('\n'))
+        }
+        propertyLines.push(`    public ${csType} ${col.pascalName} { get; set; }`)
+        propertyLines.push('')
+      }
+
+      classes.push(`public class ${table.pascalName}`)
+      classes.push('{')
+      classes.push(propertyLines.join('\n'))
+      classes.push('}')
+    }
+
+    // Views (read-only — [Keyless] entities)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const propertyLines: 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)
+        }
+
+        propertyLines.push(`    public ${csType} ${col.pascalName} { get; }`)
+        propertyLines.push('')
+      }
+
+      classes.push(`/// <summary>Read-only (from view)</summary>`)
+      classes.push(`[Keyless]`)
+      classes.push(`public class ${view.pascalName}`)
+      classes.push('{')
+      classes.push(propertyLines.join('\n'))
+      classes.push('}')
+    }
+
+    if (classes.length === 0) {
+      return { files: [] }
+    }
+
+    const parts: string[] = []
+    parts.push('using System.ComponentModel.DataAnnotations;')
+    parts.push('using System.ComponentModel.DataAnnotations.Schema;')
+    parts.push('using Microsoft.EntityFrameworkCore;')
+    parts.push('')
+    parts.push('namespace Generated;')
+    parts.push('')
+    parts.push(classes.join('\n\n'))
+    parts.push('')
+
+    return {
+      files: [{ path: 'Models.cs', content: parts.join('\n') }],
+    }
+  },
+})

package/src/efcore/test/.gitignore

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

package/src/efcore/test/Dockerfile

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

package/src/go-structs/index.ts

@@ -0,0 +1,119 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm } from '../helpers/enrich.ts'
+import { toPascalCase } from '../helpers/naming.ts'
+import { pgToGo } from '../types/pg-to-go.ts'
+
+export default defineTemplate({
+  name: 'Go Structs',
+  description: 'Generate plain Go structs with json struct tags from SQL schema',
+  language: 'go',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const allImports = new Set<string>()
+    const structBlocks: string[] = []
+
+    // Enums
+    for (const e of schema.enums) {
+      const typeName = toPascalCase(e.name)
+      structBlocks.push(`type ${typeName} string`)
+      structBlocks.push('')
+      const constLines = e.values.map((v) => {
+        const constName = `${typeName}${toPascalCase(v)}`
+        return `\t${constName} ${typeName} = "${v}"`
+      })
+      structBlocks.push(`const (\n${constLines.join('\n')}\n)`)
+    }
+
+    // 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 view of schema.views) {
+      for (const col of view.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 typeName = toPascalCase(name)
+      const fieldLines = fields.map((f) => {
+        const mapped = pgToGo(f.type, false)
+        for (const imp of mapped.imports) allImports.add(imp)
+        const jsonTag = `\`json:"${f.name}"\``
+        return `\t${toPascalCase(f.name)} ${mapped.type} ${jsonTag}`
+      })
+      structBlocks.push(`type ${typeName} struct {\n${fieldLines.join('\n')}\n}`)
+    }
+
+    // Helper to resolve Go type for a column
+    function resolveGoType(col: any): string {
+      if (col.typeOverride) return col.typeOverride
+      if (col.category === 'enum' && col.enumValues?.length) {
+        return col.nullable ? `*${toPascalCase(col.pgType)}` : toPascalCase(col.pgType)
+      }
+      if (col.category === 'composite' && col.compositeFields?.length) {
+        return col.nullable ? `*${toPascalCase(col.pgType)}` : toPascalCase(col.pgType)
+      }
+      const mapped = pgToGo(col.pgType, col.nullable, col.category)
+      for (const imp of mapped.imports) allImports.add(imp)
+      return mapped.type
+    }
+
+    for (const table of activeTables(schema)) {
+      const fields: string[] = []
+
+      for (const col of table.columns) {
+        const goType = resolveGoType(col)
+
+        const jsonTag = col.nullable ? `\`json:"${col.name},omitempty"\`` : `\`json:"${col.name}"\``
+
+        fields.push(`\t${col.pascalName} ${goType} ${jsonTag}`)
+      }
+
+      structBlocks.push(`type ${table.pascalName} struct {\n${fields.join('\n')}\n}`)
+    }
+
+    // Views (read-only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const fields: string[] = []
+
+      for (const col of view.columns) {
+        const goType = resolveGoType(col)
+
+        const jsonTag = col.nullable ? `\`json:"${col.name},omitempty"\`` : `\`json:"${col.name}"\``
+
+        fields.push(`\t${col.pascalName} ${goType} ${jsonTag}`)
+      }
+
+      structBlocks.push(
+        `// ${view.pascalName} is read-only (from view)\ntype ${view.pascalName} struct {\n${fields.join('\n')}\n}`,
+      )
+    }
+
+    let importBlock = ''
+    if (allImports.size > 0) {
+      const sorted = [...allImports].sort()
+      if (sorted.length === 1) {
+        importBlock = `import "${sorted[0]}"\n\n`
+      } else {
+        importBlock = `import (\n${sorted.map((i) => `\t"${i}"`).join('\n')}\n)\n\n`
+      }
+    }
+
+    const content = `// Generated by @sqldoc/templates/go-structs -- DO NOT EDIT
+package models
+
+${importBlock}${structBlocks.join('\n\n')}\n`
+
+    return {
+      files: [{ path: 'models.go', content }],
+    }
+  },
+})

package/src/go-structs/test/.gitignore

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

package/src/go-structs/test/Dockerfile

@@ -0,0 +1,13 @@
+FROM golang:1.24-alpine
+WORKDIR /app
+# Set up Go module with models as a sub-package
+RUN go mod init sqldoc-test
+RUN mkdir -p models cmd/test
+COPY models.go models/
+COPY test.go cmd/test/main.go
+ENV GOTOOLCHAIN=auto
+RUN go get github.com/jackc/pgx/v5 && go mod tidy
+# Step 1: typecheck/compile all packages
+RUN go build -o /usr/local/bin/test-runner ./cmd/test
+# Step 2: run integration test against real DB
+CMD ["test-runner"]