@sqldoc/templates 0.0.1

package/package.json

@@ -0,0 +1,161 @@
+{
+  "type": "module",
+  "name": "@sqldoc/templates",
+  "version": "0.0.1",
+  "description": "Code generation templates for sqldoc -- 18 templates across 6 languages plus tagged template syntax helpers",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./tags": {
+      "types": "./src/tags/index.ts",
+      "import": "./src/tags/index.ts",
+      "default": "./src/tags/index.ts"
+    },
+    "./typescript": {
+      "types": "./src/typescript/index.ts",
+      "import": "./src/typescript/index.ts",
+      "default": "./src/typescript/index.ts"
+    },
+    "./zod": {
+      "types": "./src/zod/index.ts",
+      "import": "./src/zod/index.ts",
+      "default": "./src/zod/index.ts"
+    },
+    "./drizzle": {
+      "types": "./src/drizzle/index.ts",
+      "import": "./src/drizzle/index.ts",
+      "default": "./src/drizzle/index.ts"
+    },
+    "./prisma": {
+      "types": "./src/prisma/index.ts",
+      "import": "./src/prisma/index.ts",
+      "default": "./src/prisma/index.ts"
+    },
+    "./kysely": {
+      "types": "./src/kysely/index.ts",
+      "import": "./src/kysely/index.ts",
+      "default": "./src/kysely/index.ts"
+    },
+    "./knex": {
+      "types": "./src/knex/index.ts",
+      "import": "./src/knex/index.ts",
+      "default": "./src/knex/index.ts"
+    },
+    "./go-structs": {
+      "types": "./src/go-structs/index.ts",
+      "import": "./src/go-structs/index.ts",
+      "default": "./src/go-structs/index.ts"
+    },
+    "./gorm": {
+      "types": "./src/gorm/index.ts",
+      "import": "./src/gorm/index.ts",
+      "default": "./src/gorm/index.ts"
+    },
+    "./sqlc": {
+      "types": "./src/sqlc/index.ts",
+      "import": "./src/sqlc/index.ts",
+      "default": "./src/sqlc/index.ts"
+    },
+    "./python-dataclasses": {
+      "types": "./src/python-dataclasses/index.ts",
+      "import": "./src/python-dataclasses/index.ts",
+      "default": "./src/python-dataclasses/index.ts"
+    },
+    "./sqlalchemy": {
+      "types": "./src/sqlalchemy/index.ts",
+      "import": "./src/sqlalchemy/index.ts",
+      "default": "./src/sqlalchemy/index.ts"
+    },
+    "./pydantic": {
+      "types": "./src/pydantic/index.ts",
+      "import": "./src/pydantic/index.ts",
+      "default": "./src/pydantic/index.ts"
+    },
+    "./java-records": {
+      "types": "./src/java-records/index.ts",
+      "import": "./src/java-records/index.ts",
+      "default": "./src/java-records/index.ts"
+    },
+    "./jpa": {
+      "types": "./src/jpa/index.ts",
+      "import": "./src/jpa/index.ts",
+      "default": "./src/jpa/index.ts"
+    },
+    "./kotlin-data": {
+      "types": "./src/kotlin-data/index.ts",
+      "import": "./src/kotlin-data/index.ts",
+      "default": "./src/kotlin-data/index.ts"
+    },
+    "./rust-structs": {
+      "types": "./src/rust-structs/index.ts",
+      "import": "./src/rust-structs/index.ts",
+      "default": "./src/rust-structs/index.ts"
+    },
+    "./diesel": {
+      "types": "./src/diesel/index.ts",
+      "import": "./src/diesel/index.ts",
+      "default": "./src/diesel/index.ts"
+    },
+    "./csharp-records": {
+      "types": "./src/csharp-records/index.ts",
+      "import": "./src/csharp-records/index.ts",
+      "default": "./src/csharp-records/index.ts"
+    },
+    "./efcore": {
+      "types": "./src/efcore/index.ts",
+      "import": "./src/efcore/index.ts",
+      "default": "./src/efcore/index.ts"
+    },
+    "./json-schema": {
+      "types": "./src/json-schema/index.ts",
+      "import": "./src/json-schema/index.ts",
+      "default": "./src/json-schema/index.ts"
+    },
+    "./xsd": {
+      "types": "./src/xsd/index.ts",
+      "import": "./src/xsd/index.ts",
+      "default": "./src/xsd/index.ts"
+    },
+    "./protobuf": {
+      "types": "./src/protobuf/index.ts",
+      "import": "./src/protobuf/index.ts",
+      "default": "./src/protobuf/index.ts"
+    },
+    "./cobol-copybook": {
+      "types": "./src/cobol-copybook/index.ts",
+      "import": "./src/cobol-copybook/index.ts",
+      "default": "./src/cobol-copybook/index.ts"
+    }
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "files": [
+    "src",
+    "package.json"
+  ],
+  "peerDependencies": {
+    "@sqldoc/atlas": "0.0.1",
+    "@sqldoc/core": "0.0.1",
+    "@sqldoc/ns-codegen": "0.0.1"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.4.1",
+    "@types/pg": "^8.11.0",
+    "@electric-sql/pglite-socket": "^0.1.1",
+    "pg": "^8.13.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0",
+    "@sqldoc/atlas": "0.0.1",
+    "@sqldoc/core": "0.0.1",
+    "@sqldoc/ns-codegen": "0.0.1",
+    "@sqldoc/ns-validate": "0.0.1"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:docker": "bun test src/__tests__/docker-templates.test.ts"
+  }
+}

package/src/__tests__/dedent.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+import { dedent } from '../tags/dedent'
+
+describe('dedent', () => {
+  it('strips common leading whitespace', () => {
+    const result = dedent`
+      hello
+      world
+    `
+    expect(result).toBe('hello\nworld')
+  })
+
+  it('preserves relative indentation', () => {
+    const result = dedent`
+      if (true) {
+        return 1
+      }
+    `
+    expect(result).toBe('if (true) {\n  return 1\n}')
+  })
+
+  it('handles string interpolation', () => {
+    const name = 'World'
+    const result = dedent`
+      hello ${name}
+      goodbye
+    `
+    expect(result).toBe('hello World\ngoodbye')
+  })
+
+  it('handles zero-indent lines', () => {
+    const result = dedent`
+hello
+world
+    `
+    expect(result).toBe('hello\nworld')
+  })
+
+  it('removes empty first and last lines', () => {
+    const result = dedent`
+      content
+    `
+    expect(result).toBe('content')
+  })
+})

package/src/__tests__/docker-templates.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Docker-based template tests.
+ *
+ * Auto-discovers templates by finding src/<template>/test/Dockerfile.
+ * Starts a Postgres container on a shared Docker network, seeds it,
+ * runs codegen (output goes directly into each test dir), then for each template:
+ *   1. docker build  (typecheck / compile)
+ *   2. docker run    (integration test or no-op CMD)
+ *
+ * Run with: pnpm test:docker
+ */
+
+import { execSync } from 'node:child_process'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import pg from 'pg'
+import { afterAll, beforeAll, describe, test } from 'vitest'
+
+const thisDir = dirname(fileURLToPath(import.meta.url))
+const TEMPLATES_DIR = resolve(thisDir, '../..')
+const SRC_DIR = join(TEMPLATES_DIR, 'src')
+const TEST_DIR = join(TEMPLATES_DIR, 'test')
+const REPO_ROOT = resolve(TEMPLATES_DIR, '../..')
+
+const NETWORK = 'sqldoc-test-net'
+const PG_CONTAINER = 'sqldoc-test-pg'
+const PG_PORT = 54321
+const DB_URL = `postgresql://postgres:postgres@${PG_CONTAINER}:5432/postgres`
+
+function discoverTemplates(): string[] {
+  return readdirSync(SRC_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && existsSync(join(SRC_DIR, d.name, 'test', 'Dockerfile')))
+    .map((d) => d.name)
+    .sort()
+}
+
+const templates = discoverTemplates()
+
+function dockerExec(cmd: string, timeout = 30_000) {
+  return execSync(cmd, { stdio: 'pipe', timeout }).toString()
+}
+
+beforeAll(async () => {
+  // Clean up any leftovers from previous runs, then create fresh
+  try {
+    dockerExec(`docker rm -f ${PG_CONTAINER}`)
+  } catch {}
+  try {
+    dockerExec(`docker network rm ${NETWORK}`)
+  } catch {}
+  dockerExec(`docker network create ${NETWORK}`)
+  dockerExec(
+    `docker run -d --name ${PG_CONTAINER} --network ${NETWORK} -p ${PG_PORT}:5432 -e POSTGRES_PASSWORD=postgres postgres:17-alpine`,
+  )
+
+  // Wait for postgres to be ready
+  for (let i = 0; i < 30; i++) {
+    try {
+      dockerExec(`docker exec ${PG_CONTAINER} pg_isready -U postgres`)
+      break
+    } catch {
+      await new Promise((r) => setTimeout(r, 1000))
+    }
+  }
+
+  // Seed the database
+  const client = new pg.Client({
+    host: '127.0.0.1',
+    port: PG_PORT,
+    database: 'postgres',
+    user: 'postgres',
+    password: 'postgres',
+    connectionTimeoutMillis: 10_000,
+  })
+  await client.connect()
+  const schemaSql = readFileSync(join(TEST_DIR, 'fixture.sql'), 'utf-8')
+    .split('\n')
+    .filter((line) => !line.trim().startsWith('-- @import'))
+    .join('\n')
+  await client.query(schemaSql)
+  await client.query(readFileSync(join(TEST_DIR, 'fixture-seed.sql'), 'utf-8'))
+  await client.end()
+  console.log('Database seeded.')
+
+  // Run codegen — outputs directly into each src/<template>/test/ directory
+  console.log('Running codegen...')
+  execSync(
+    `node ${join(REPO_ROOT, 'packages/cli/src/index.ts')} codegen -c ${join(TEST_DIR, 'sqldoc.config.ts')} ${join(TEST_DIR, 'fixture.sql')}`,
+    {
+      cwd: TEMPLATES_DIR,
+      stdio: 'pipe',
+      timeout: 120_000,
+      env: { ...process.env, SQLDOC_RESOLVE_FROM_LOCAL_PACKAGE: 'true' },
+    },
+  )
+  console.log(`Codegen complete. Testing ${templates.length} templates.`)
+}, 180_000)
+
+afterAll(() => {
+  try {
+    dockerExec(`docker rm -f ${PG_CONTAINER}`)
+  } catch {}
+  try {
+    dockerExec(`docker network rm ${NETWORK}`)
+  } catch {}
+})
+
+describe('docker templates', () => {
+  for (const name of templates) {
+    test(name, () => {
+      const testDir = join(SRC_DIR, name, 'test')
+      const tag = `sqldoc-test-${name}`
+      try {
+        execSync(`docker build -t ${tag} ${testDir}`, {
+          stdio: 'pipe',
+          timeout: 120_000,
+        })
+        execSync(`docker run --rm --network ${NETWORK} -e DATABASE_URL="${DB_URL}" ${tag}`, {
+          stdio: 'pipe',
+          timeout: 30_000,
+        })
+      } catch (err: any) {
+        const stderr = err.stderr?.toString() ?? ''
+        const stdout = err.stdout?.toString() ?? ''
+        throw new Error(`Docker test failed for ${name}:\n${stderr}\n${stdout}`)
+      } finally {
+        try {
+          execSync(`docker rmi ${tag}`, { stdio: 'ignore' })
+        } catch {}
+      }
+    }, 180_000)
+  }
+})

package/src/__tests__/go-structs.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it } from 'vitest'
+import goStructs from '../go-structs/index.ts'
+
+const generate = goStructs.generate
+
+import type { AtlasRealm } from '@sqldoc/atlas'
+import type { TemplateContext } from '@sqldoc/ns-codegen'
+
+const testRealm: AtlasRealm = {
+  schemas: [
+    {
+      name: 'public',
+      tables: [
+        {
+          name: 'users',
+          columns: [
+            { name: 'id', type: { T: 'bigserial', null: false, category: 'integer' } },
+            { name: 'email', type: { T: 'character varying', raw: 'varchar(255)', null: false, category: 'string' } },
+            { name: 'name', type: { T: 'text', null: true, category: 'string' } },
+            { name: 'age', type: { T: 'integer', null: true, category: 'integer' } },
+            { name: 'is_active', type: { T: 'boolean', null: false, category: 'boolean' } },
+            { name: 'metadata', type: { T: 'jsonb', null: true, category: 'json' } },
+            { name: 'created_at', type: { T: 'timestamp with time zone', null: false, category: 'time' } },
+            { name: 'tags', type: { T: 'text[]', null: true, category: 'array' } },
+            { name: 'avatar', type: { T: 'bytea', null: true, category: 'binary' } },
+            { name: 'balance', type: { T: 'numeric(10,2)', null: true, category: 'decimal' } },
+            { name: 'external_id', type: { T: 'uuid', null: true, category: 'uuid' } },
+          ],
+          primary_key: { parts: [{ column: 'id' }] },
+        },
+        {
+          name: 'posts',
+          columns: [
+            { name: 'id', type: { T: 'bigserial', null: false, category: 'integer' } },
+            { name: 'user_id', type: { T: 'bigint', null: false, category: 'integer' } },
+            { name: 'title', type: { T: 'text', null: false, category: 'string' } },
+            { name: 'body', type: { T: 'text', null: false, category: 'string' } },
+            { name: 'published_at', type: { T: 'timestamp with time zone', null: true, category: 'time' } },
+            { name: 'view_count', type: { T: 'integer', null: false, category: 'integer' } },
+            { name: 'rating', type: { T: 'double precision', null: true, category: 'float' } },
+          ],
+          primary_key: { parts: [{ column: 'id' }] },
+          foreign_keys: [
+            { symbol: 'posts_user_id_fkey', columns: ['user_id'], ref_table: 'users', ref_columns: ['id'] },
+          ],
+        },
+        {
+          name: 'comments',
+          columns: [
+            { name: 'id', type: { T: 'bigserial', null: false, category: 'integer' } },
+            { name: 'post_id', type: { T: 'bigint', null: false, category: 'integer' } },
+            { name: 'user_id', type: { T: 'bigint', null: false, category: 'integer' } },
+            { name: 'content', type: { T: 'text', null: false, category: 'string' } },
+            { name: 'created_at', type: { T: 'timestamp with time zone', null: false, category: 'time' } },
+          ],
+          primary_key: { parts: [{ column: 'id' }] },
+          foreign_keys: [
+            { symbol: 'comments_post_id_fkey', columns: ['post_id'], ref_table: 'posts', ref_columns: ['id'] },
+            { symbol: 'comments_user_id_fkey', columns: ['user_id'], ref_table: 'users', ref_columns: ['id'] },
+          ],
+        },
+      ],
+    },
+  ],
+}
+
+function makeCtx(overrides?: Partial<TemplateContext>): TemplateContext {
+  return {
+    realm: testRealm,
+    allFileTags: [],
+    docsMeta: [],
+    config: {},
+    output: './out',
+    templateName: 'go-structs',
+    ...overrides,
+  }
+}
+
+describe('go-structs template', () => {
+  it('generates Go structs with json tags', () => {
+    const result = generate(makeCtx())
+    expect(result.files).toHaveLength(1)
+    expect(result.files[0].path).toBe('models.go')
+
+    const content = result.files[0].content
+    expect(content).toContain('type Users struct {')
+    expect(content).toContain('type Posts struct {')
+    expect(content).toContain('type Comments struct {')
+  })
+
+  it('maps bigserial to int64', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('Id int64')
+  })
+
+  it('maps nullable text to *string', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('Name *string')
+  })
+
+  it('maps text[] to []string', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('Tags []string')
+  })
+
+  it('includes time import for timestamptz', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('import (')
+    expect(content).toContain('"time"')
+  })
+
+  it('uses omitempty for nullable json tags', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('`json:"name,omitempty"`')
+    expect(content).toContain('`json:"email"`')
+  })
+
+  it('respects @codegen.skip tag', () => {
+    const ctx = makeCtx({
+      allFileTags: [
+        {
+          sourceFile: 'test.sql',
+          objects: [
+            {
+              objectName: 'comments',
+              target: 'table',
+              tags: [{ namespace: 'codegen', tag: 'skip', args: [] }],
+            },
+          ],
+        },
+      ],
+    })
+    const result = generate(ctx)
+    const content = result.files[0].content
+    expect(content).not.toContain('type Comments struct')
+    expect(content).toContain('type Users struct')
+  })
+
+  it('respects @codegen.rename tag', () => {
+    const ctx = makeCtx({
+      allFileTags: [
+        {
+          sourceFile: 'test.sql',
+          objects: [
+            {
+              objectName: 'users',
+              target: 'table',
+              tags: [{ namespace: 'codegen', tag: 'rename', args: ['Account'] }],
+            },
+          ],
+        },
+      ],
+    })
+    const result = generate(ctx)
+    const content = result.files[0].content
+    expect(content).toContain('type Account struct')
+    expect(content).not.toContain('type Users struct')
+  })
+
+  it('respects @codegen.type override on column', () => {
+    const ctx = makeCtx({
+      allFileTags: [
+        {
+          sourceFile: 'test.sql',
+          objects: [
+            {
+              objectName: 'users.metadata',
+              target: 'column',
+              tags: [{ namespace: 'codegen', tag: 'type', args: ['map[string]interface{}'] }],
+            },
+          ],
+        },
+      ],
+    })
+    const result = generate(ctx)
+    const content = result.files[0].content
+    expect(content).toContain('Metadata map[string]interface{}')
+  })
+})

package/src/__tests__/naming.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest'
+import { toCamelCase, toPascalCase, toScreamingSnake } from '../helpers/naming'
+
+describe('toPascalCase', () => {
+  it('converts snake_case to PascalCase', () => {
+    expect(toPascalCase('user_accounts')).toBe('UserAccounts')
+  })
+
+  it('handles single word', () => {
+    expect(toPascalCase('id')).toBe('Id')
+  })
+
+  it('handles leading underscore', () => {
+    expect(toPascalCase('_private_field')).toBe('PrivateField')
+  })
+
+  it('handles multiple underscores', () => {
+    expect(toPascalCase('user__name')).toBe('UserName')
+  })
+
+  it('handles already capitalized segments', () => {
+    expect(toPascalCase('USER_STATUS')).toBe('UserStatus')
+  })
+})
+
+describe('toCamelCase', () => {
+  it('converts snake_case to camelCase', () => {
+    expect(toCamelCase('user_accounts')).toBe('userAccounts')
+  })
+
+  it('handles single word', () => {
+    expect(toCamelCase('name')).toBe('name')
+  })
+
+  it('produces lowercase first char', () => {
+    expect(toCamelCase('ID')).toBe('id')
+  })
+})
+
+describe('toScreamingSnake', () => {
+  it('converts to SCREAMING_SNAKE', () => {
+    expect(toScreamingSnake('user_status')).toBe('USER_STATUS')
+  })
+
+  it('handles already lowercase', () => {
+    expect(toScreamingSnake('created_at')).toBe('CREATED_AT')
+  })
+})