@sqldoc/templates 0.0.1

package/src/kotlin-data/index.ts

@@ -0,0 +1,147 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm } from '../helpers/enrich.ts'
+import { toCamelCase, toPascalCase, toScreamingSnake } from '../helpers/naming.ts'
+import { pgToKotlin } from '../types/pg-to-kotlin.ts'
+
+export default defineTemplate({
+  name: 'Kotlin Data Classes',
+  description: 'Generate Kotlin data classes from SQL schema',
+  language: 'kotlin',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const classes: string[] = []
+
+    // Enums
+    for (const e of schema.enums) {
+      const className = toPascalCase(e.name)
+      const members = e.values.map((v) => `    ${toScreamingSnake(v)}`).join(',\n')
+      classes.push(`enum class ${className} {\n${members}\n}`)
+    }
+
+    // Composite types as data 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 ktFields = fields.map((f) => {
+        const ktType = pgToKotlin(f.type, false)
+        return `    val ${toCamelCase(f.name)}: ${ktType}`
+      })
+      classes.push(`data class ${className}(`)
+      classes.push(ktFields.join(',\n'))
+      classes.push(')')
+    }
+
+    for (const table of activeTables(schema)) {
+      const fields: string[] = []
+      for (const col of table.columns) {
+        let ktType: string
+        if (col.typeOverride) {
+          ktType = col.nullable ? `${col.typeOverride}?` : col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          ktType = col.nullable ? `${toPascalCase(col.pgType)}?` : toPascalCase(col.pgType)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          const compositeType = toPascalCase(col.pgType)
+          ktType = col.nullable ? `${compositeType}?` : compositeType
+        } else {
+          ktType = pgToKotlin(col.pgType, col.nullable, col.category)
+        }
+
+        const defaultVal = col.nullable ? ' = null' : ''
+        fields.push(`    val ${col.camelName}: ${ktType}${defaultVal}`)
+      }
+
+      classes.push(`data class ${table.pascalName}(`)
+      classes.push(fields.join(',\n'))
+      classes.push(')')
+    }
+
+    // Views (read-only — val only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const fields: string[] = []
+      for (const col of view.columns) {
+        let ktType: string
+        if (col.typeOverride) {
+          ktType = col.nullable ? `${col.typeOverride}?` : col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          ktType = col.nullable ? `${toPascalCase(col.pgType)}?` : toPascalCase(col.pgType)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          const compositeType = toPascalCase(col.pgType)
+          ktType = col.nullable ? `${compositeType}?` : compositeType
+        } else {
+          ktType = pgToKotlin(col.pgType, col.nullable, col.category)
+        }
+
+        const defaultVal = col.nullable ? ' = null' : ''
+        fields.push(`    val ${col.camelName}: ${ktType}${defaultVal}`)
+      }
+
+      classes.push(`/** Read-only (from view) */`)
+      classes.push(`data class ${view.pascalName}(`)
+      classes.push(fields.join(',\n'))
+      classes.push(')')
+    }
+
+    // Functions (skip trigger functions)
+    for (const fn of schema.functions) {
+      const retRaw = fn.returnType?.type?.toLowerCase() ?? ''
+      if (retRaw === 'trigger') continue
+
+      const params = fn.args
+        .filter((a) => !a.name?.startsWith('_') && (a as any).mode !== 'OUT')
+        .map((a) => {
+          const argType = pgToKotlin(a.type, false, a.category)
+          return `${toCamelCase(a.name || 'arg')}: ${argType}`
+        })
+        .join(', ')
+
+      let retType: string
+      if (retRaw.startsWith('setof ')) {
+        const tableName = retRaw.replace('setof ', '')
+        const table = schema.tables.find((t) => t.name === tableName)
+        retType = table ? `List<${table.pascalName}>` : `List<${pgToKotlin(tableName, false)}>`
+      } else if (fn.returnType) {
+        retType = pgToKotlin(fn.returnType.type, false, fn.returnType.category)
+      } else {
+        retType = 'Unit'
+      }
+
+      classes.push(`typealias ${fn.pascalName} = (${params}) -> ${retType}`)
+    }
+
+    if (classes.length === 0) {
+      return { files: [] }
+    }
+
+    const imports = new Set<string>()
+    // Check if any imported types are used in generated content
+    const content = classes.join('\n')
+    if (content.includes('BigDecimal')) imports.add('import java.math.BigDecimal')
+    if (content.includes('OffsetDateTime')) imports.add('import java.time.OffsetDateTime')
+    if (content.includes('LocalDateTime')) imports.add('import java.time.LocalDateTime')
+    if (content.includes('LocalDate') && !content.includes('LocalDateTime')) imports.add('import java.time.LocalDate')
+    if (content.includes('LocalTime')) imports.add('import java.time.LocalTime')
+    if (content.includes('Duration')) imports.add('import java.time.Duration')
+    if (content.includes('UUID')) imports.add('import java.util.UUID')
+
+    const parts: string[] = []
+    const sortedImports = [...imports].sort()
+    if (sortedImports.length > 0) {
+      parts.push(sortedImports.join('\n'))
+      parts.push('')
+    }
+    parts.push(classes.join('\n\n'))
+    parts.push('')
+
+    return {
+      files: [{ path: 'Models.kt', content: parts.join('\n') }],
+    }
+  },
+})

package/src/kotlin-data/test/.gitignore

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

package/src/kotlin-data/test/Dockerfile

@@ -0,0 +1,14 @@
+FROM eclipse-temurin:21-jdk-alpine
+RUN apk add --no-cache curl unzip zip bash
+# Install Kotlin via SDKMAN
+RUN curl -s https://get.sdkman.io | bash && \
+    bash -c "source /root/.sdkman/bin/sdkman-init.sh && sdk install kotlin"
+# Download PostgreSQL JDBC driver
+RUN mkdir -p /deps && \
+    curl -sL -o /deps/postgresql-42.7.4.jar https://repo1.maven.org/maven2/org/postgresql/postgresql/42.7.4/postgresql-42.7.4.jar
+WORKDIR /app
+COPY . .
+# Step 1: compile the generated data classes + test
+RUN bash -c "source /root/.sdkman/bin/sdkman-init.sh && kotlinc -cp /deps/* *.kt Test.kt -include-runtime -d out.jar"
+# Step 2: run integration test against real DB
+CMD ["java", "-cp", "out.jar:/deps/*", "TestKt"]

package/src/kotlin-data/test/Test.kt

@@ -0,0 +1,82 @@
+import java.sql.DriverManager
+
+/**
+ * Integration test for @sqldoc/templates/kotlin-data
+ * Connects to real Postgres via JDBC, verifies generated data classes work with actual data.
+ */
+var failed = 0
+
+fun assertEq(actual: Any?, expected: Any?, msg: String) {
+    if (actual != expected) {
+        System.err.println("FAIL: $msg (got $actual, expected $expected)")
+        failed++
+    } else {
+        println("  ok: $msg")
+    }
+}
+
+fun main() {
+    var dbUrl = System.getenv("DATABASE_URL")
+    if (dbUrl.isNullOrEmpty()) {
+        System.err.println("DATABASE_URL not set")
+        System.exit(1)
+    }
+
+    // Convert postgres(ql):// to jdbc:postgresql://, extracting userinfo for JDBC
+    val uri = java.net.URI(dbUrl.replaceFirst(Regex("^postgres(ql)?://"), "http://"))
+    val userInfo = uri.userInfo
+    var jdbcUrl = "jdbc:postgresql://${uri.host}:${if (uri.port > 0) uri.port else 5432}${uri.path}"
+    val query = uri.query
+    if (userInfo != null) {
+        val parts = userInfo.split(":", limit = 2)
+        val sep = if (query != null) "&" else "?"
+        jdbcUrl += (if (query != null) "?$query" else "") + "${sep}user=${parts[0]}&password=${parts.getOrElse(1) { "" }}"
+    } else if (query != null) {
+        jdbcUrl += "?$query"
+    }
+    dbUrl = jdbcUrl
+
+    println("--- kotlin-data integration test ---")
+
+    DriverManager.getConnection(dbUrl).use { conn ->
+        // 1. Query user and construct generated data class
+        conn.prepareStatement("SELECT id, email, name, age, is_active, created_at FROM users WHERE id = 1").use { ps ->
+            val rs = ps.executeQuery()
+            rs.next()
+            val user = Users(
+                id = rs.getLong("id"),
+                email = rs.getString("email"),
+                name = rs.getString("name"),
+                age = rs.getInt("age"),
+                isActive = rs.getBoolean("is_active"),
+                createdAt = rs.getObject("created_at", java.time.OffsetDateTime::class.java)
+            )
+            assertEq(user.email, "test@example.com", "user.email matches")
+            assertEq(user.name, "Test User", "user.name matches")
+            assertEq(user.age, 30, "user.age matches")
+            assertEq(user.isActive, true, "user.isActive matches")
+        }
+
+        // 2. Query post and construct generated data class
+        conn.prepareStatement("SELECT id, user_id, title, body, view_count FROM posts WHERE id = 1").use { ps ->
+            val rs = ps.executeQuery()
+            rs.next()
+            val post = Posts(
+                id = rs.getLong("id"),
+                userId = rs.getLong("user_id"),
+                title = rs.getString("title"),
+                body = rs.getString("body"),
+                viewCount = rs.getInt("view_count")
+            )
+            assertEq(post.title, "Hello World", "post.title matches")
+            assertEq(post.userId, 1L, "post.userId matches")
+            assertEq(post.viewCount, 42, "post.viewCount matches")
+        }
+    }
+
+    if (failed > 0) {
+        System.err.println("\n$failed assertion(s) failed")
+        System.exit(1)
+    }
+    println("\nAll assertions passed!")
+}

package/src/kysely/index.ts

@@ -0,0 +1,165 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm } from '../helpers/enrich.ts'
+import { toCamelCase, toPascalCase } from '../helpers/naming.ts'
+import { pgToTs, type TsTypeOptions } from '../types/pg-to-ts.ts'
+
+export const configSchema = {
+  dateType: {
+    type: 'enum',
+    values: ['Date', 'dayjs', 'luxon', 'string'],
+    description: 'How to represent date/time types',
+  },
+  bigintType: {
+    type: 'enum',
+    values: ['number', 'bigint', 'string'],
+    description: 'How to represent bigint/bigserial columns',
+  },
+} as const
+
+export default defineTemplate({
+  name: 'Kysely Database',
+  description: 'Generate Kysely Database interface and table types from SQL schema',
+  language: 'typescript',
+  configSchema,
+
+  generate(ctx) {
+    const config = ctx.config ?? {}
+    const options: TsTypeOptions = {
+      dateType: config.dateType,
+      bigintType: config.bigintType,
+      nullableStyle: 'null-union',
+    }
+
+    const schema = enrichRealm(ctx)
+    const lines: string[] = [
+      '// Generated by @sqldoc/templates/kysely -- DO NOT EDIT',
+      '',
+      "import type { Generated } from 'kysely'",
+      '',
+    ]
+
+    // Enums
+    for (const e of schema.enums) {
+      const values = e.values.map((v) => `'${v}'`).join(' | ')
+      lines.push(`export type ${e.pascalName} = ${values}`)
+      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 typeName = toPascalCase(name)
+      lines.push(`export interface ${typeName} {`)
+      for (const f of fields) {
+        lines.push(`  ${toCamelCase(f.name)}: ${pgToTs(f.type, false, options)}`)
+      }
+      lines.push('}')
+      lines.push('')
+    }
+
+    // Generate per-table interfaces
+    const tableEntries: string[] = []
+
+    for (const table of activeTables(schema)) {
+      const interfaceName = `${table.pascalName}Table`
+
+      lines.push(`export interface ${interfaceName} {`)
+
+      for (const col of table.columns) {
+        let tsType = resolveType(col, options)
+
+        // Wrap auto-generated columns in Generated<T>
+        if (col.isSerial || col.raw.default !== undefined) {
+          tsType = `Generated<${tsType}>`
+        }
+
+        lines.push(`  ${col.name}: ${tsType}`)
+      }
+
+      lines.push('}')
+      lines.push('')
+
+      tableEntries.push(`  ${table.name}: ${interfaceName}`)
+    }
+
+    // Views (read-only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const interfaceName = `${view.pascalName}View`
+
+      lines.push(`/** Read-only (from view) */`)
+      lines.push(`export interface ${interfaceName} {`)
+
+      for (const col of view.columns) {
+        const tsType = resolveType(col, options)
+        lines.push(`  ${col.name}: ${tsType}`)
+      }
+
+      lines.push('}')
+      lines.push('')
+
+      tableEntries.push(`  ${view.name}: ${interfaceName}`)
+    }
+
+    // Generate the Database interface
+    lines.push('export interface Database {')
+    lines.push(tableEntries.join('\n'))
+    lines.push('}')
+    lines.push('')
+
+    // Functions (skip trigger functions)
+    for (const fn of schema.functions) {
+      const retRaw = fn.returnType?.type?.toLowerCase() ?? ''
+      if (retRaw === 'trigger') continue
+
+      const params = fn.args
+        .filter((a) => !a.name?.startsWith('_') && (a as any).mode !== 'OUT')
+        .map((a) => {
+          const argType = pgToTs(a.type, false, options, a.category as any)
+          return `${toCamelCase(a.name || 'arg')}: ${argType}`
+        })
+        .join(', ')
+
+      let retType: string
+      if (retRaw.startsWith('setof ')) {
+        const tableName = retRaw.replace('setof ', '')
+        const table = schema.tables.find((t) => t.name === tableName)
+        retType = table ? `${table.pascalName}Table[]` : `${pgToTs(tableName, false, options)}[]`
+      } else if (fn.returnType) {
+        retType = pgToTs(fn.returnType.type, false, options, fn.returnType.category as any)
+      } else {
+        retType = 'void'
+      }
+
+      lines.push(`export type ${fn.pascalName} = (${params}) => ${retType}`)
+      lines.push('')
+    }
+
+    return {
+      files: [
+        {
+          path: 'database.ts',
+          content: lines.join('\n'),
+        },
+      ],
+    }
+
+    function resolveType(col: any, options: TsTypeOptions): string {
+      if (col.typeOverride) return col.typeOverride
+      if (col.category === 'enum' && col.enumValues?.length) {
+        return col.nullable ? `${toPascalCase(col.pgType)} | null` : toPascalCase(col.pgType)
+      }
+      if (col.category === 'composite' && col.compositeFields?.length) {
+        const compositeType = toPascalCase(col.pgType)
+        return col.nullable ? `${compositeType} | null` : compositeType
+      }
+      return pgToTs(col.pgType, col.nullable, options, col.category)
+    }
+  },
+})

package/src/kysely/test/.gitignore

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

package/src/kysely/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 kysely@0.27 pg @types/pg @types/node --save-dev
+# Step 1: typecheck the generated types
+RUN npx tsc --noEmit --strict --esModuleInterop --module nodenext --moduleResolution nodenext database.ts
+# Step 2: run integration test against real DB
+CMD ["node", "--experimental-strip-types", "test.ts"]

package/src/kysely/test/test.ts

@@ -0,0 +1,82 @@
+/**
+ * Integration test for @sqldoc/templates/kysely
+ * Connects to real Postgres via Kysely, verifies generated Database interface works.
+ */
+import { Kysely, PostgresDialect } from 'kysely'
+import pg from 'pg'
+import type { Database } from './database.ts'
+
+const DATABASE_URL = process.env.DATABASE_URL
+if (!DATABASE_URL) {
+  console.error('DATABASE_URL not set')
+  process.exit(1)
+}
+
+const db = new Kysely<Database>({
+  dialect: new PostgresDialect({
+    pool: new pg.Pool({ connectionString: DATABASE_URL }),
+  }),
+})
+
+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('--- kysely integration test ---')
+
+    // 1. Query known seeded user using Kysely's type-safe query builder
+    const user = await db.selectFrom('users').selectAll().where('id', '=', 1).executeTakeFirstOrThrow()
+
+    assert(user.email === 'test@example.com', 'user email matches')
+    assert(user.name === 'Test User', 'user name matches')
+    assert(user.is_active === true, 'user is_active matches')
+
+    // 2. Query known seeded post
+    const post = await db.selectFrom('posts').selectAll().where('id', '=', 1).executeTakeFirstOrThrow()
+
+    assert(post.title === 'Hello World', 'post title matches')
+
+    // 3. Insert a new post via type-safe insert
+    await db
+      .insertInto('posts')
+      .values({
+        user_id: 1,
+        title: 'Post from kysely',
+        body: 'test body',
+        view_count: 0,
+      })
+      .execute()
+
+    // 4. Read it back
+    const newPost = await db
+      .selectFrom('posts')
+      .selectAll()
+      .where('title', '=', 'Post from kysely')
+      .executeTakeFirstOrThrow()
+
+    assert(newPost.title === 'Post from kysely', 'inserted post title matches')
+    // pg returns bigint columns as strings; use loose equality for numeric comparison
+    assert(Number(newPost.user_id) === 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 db.destroy()
+  }
+}
+
+run().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})