@sqldoc/templates 0.0.1

package/src/sqlc/index.ts

@@ -0,0 +1,148 @@
+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'
+
+/**
+ * sqlc-style nullable type mapping.
+ * Nullable primitives use database/sql Null types instead of pointers.
+ */
+const SQLC_NULL_MAP: Record<string, [string, string]> = {
+  string: ['sql.NullString', 'database/sql'],
+  int16: ['sql.NullInt16', 'database/sql'],
+  int32: ['sql.NullInt32', 'database/sql'],
+  int64: ['sql.NullInt64', 'database/sql'],
+  float32: ['sql.NullFloat64', 'database/sql'],
+  float64: ['sql.NullFloat64', 'database/sql'],
+  bool: ['sql.NullBool', 'database/sql'],
+  'time.Time': ['sql.NullTime', 'database/sql'],
+}
+
+export default defineTemplate({
+  name: 'sqlc Models',
+  description: 'Generate Go structs matching sqlc naming conventions with sql.Null types',
+  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)
+        return `\t${toPascalCase(f.name)} ${mapped.type}`
+      })
+      structBlocks.push(`type ${typeName} struct {\n${fieldLines.join('\n')}\n}`)
+    }
+
+    // Helper to resolve sqlc-style Go type for a column
+    function resolveGoType(col: any): string {
+      if (col.typeOverride) return col.typeOverride
+      if (col.category === 'enum' && col.enumValues?.length) {
+        const enumType = toPascalCase(col.pgType)
+        if (col.nullable) {
+          // Use sql.NullString for nullable enums (sqlc convention)
+          allImports.add('database/sql')
+          return 'sql.NullString'
+        }
+        return enumType
+      }
+      if (col.category === 'composite' && col.compositeFields?.length) {
+        return col.nullable ? `*${toPascalCase(col.pgType)}` : toPascalCase(col.pgType)
+      }
+      // First get the non-nullable base type
+      const mapped = pgToGo(col.pgType, false, col.category)
+      const baseType = mapped.type
+      for (const imp of mapped.imports) allImports.add(imp)
+
+      if (col.nullable) {
+        // Check if this is an array type -- arrays stay as-is (nil slice is Go's nullable)
+        if (baseType.startsWith('[]')) {
+          return baseType
+        }
+        // Use sql.NullXxx for known types
+        const nullMapping = SQLC_NULL_MAP[baseType]
+        if (nullMapping) {
+          allImports.add(nullMapping[1])
+          return nullMapping[0]
+        }
+        // Fallback to pointer for complex types
+        return `*${baseType}`
+      }
+      return baseType
+    }
+
+    for (const table of activeTables(schema)) {
+      const fields: string[] = []
+
+      for (const col of table.columns) {
+        fields.push(`\t${col.pascalName} ${resolveGoType(col)}`)
+      }
+
+      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) {
+        fields.push(`\t${col.pascalName} ${resolveGoType(col)}`)
+      }
+
+      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/sqlc -- DO NOT EDIT
+package models
+
+${importBlock}${structBlocks.join('\n\n')}\n`
+
+    return {
+      files: [{ path: 'models.go', content }],
+    }
+  },
+})

package/src/sqlc/test/.gitignore

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

package/src/sqlc/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"]

package/src/sqlc/test/test.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/jackc/pgx/v5"
+
+	// Import the generated models to verify they compile
+	_ "sqldoc-test/models"
+)
+
+var failed int
+
+func assert(condition bool, msg string) {
+	if !condition {
+		fmt.Fprintf(os.Stderr, "FAIL: %s\n", msg)
+		failed++
+	} else {
+		fmt.Printf("  ok: %s\n", msg)
+	}
+}
+
+func main() {
+	ctx := context.Background()
+	dbURL := os.Getenv("DATABASE_URL")
+	if dbURL == "" {
+		fmt.Fprintln(os.Stderr, "DATABASE_URL not set")
+		os.Exit(1)
+	}
+
+	conn, err := pgx.Connect(ctx, dbURL)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connect error: %v\n", err)
+		os.Exit(1)
+	}
+	defer conn.Close(ctx)
+
+	fmt.Println("--- sqlc integration test ---")
+
+	// 1. Query known seeded user
+	var email, name string
+	var age int32
+	var isActive bool
+	err = conn.QueryRow(ctx, "SELECT email, name, age, is_active FROM users WHERE id = 1").
+		Scan(&email, &name, &age, &isActive)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "query user error: %v\n", err)
+		os.Exit(1)
+	}
+	assert(email == "test@example.com", "user email matches")
+	assert(name == "Test User", "user name matches")
+	assert(age == 30, "user age matches")
+	assert(isActive, "user is_active matches")
+
+	// 2. Query known seeded post
+	var title string
+	err = conn.QueryRow(ctx, "SELECT title FROM posts WHERE id = 1").Scan(&title)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "query post error: %v\n", err)
+		os.Exit(1)
+	}
+	assert(title == "Hello World", "post title matches")
+
+	// 3. Insert a new post
+	_, err = conn.Exec(ctx,
+		"INSERT INTO posts (user_id, title, body, view_count) VALUES (1, 'Post from sqlc', 'test body', 0)")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "insert error: %v\n", err)
+		os.Exit(1)
+	}
+
+	// 4. Read it back
+	var newTitle string
+	var userID int64
+	err = conn.QueryRow(ctx, "SELECT title, user_id FROM posts WHERE title = 'Post from sqlc'").
+		Scan(&newTitle, &userID)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "read back error: %v\n", err)
+		os.Exit(1)
+	}
+	assert(newTitle == "Post from sqlc", "inserted post title matches")
+	assert(userID == 1, "inserted post user_id matches")
+
+	if failed > 0 {
+		fmt.Fprintf(os.Stderr, "\n%d assertion(s) failed\n", failed)
+		os.Exit(1)
+	}
+	fmt.Println("\nAll assertions passed!")
+}

package/src/tags/dedent.ts

@@ -0,0 +1,28 @@
+/** Strip common leading whitespace from a tagged template literal */
+export function dedent(strings: TemplateStringsArray, ...values: unknown[]): string {
+  // Interpolate
+  let result = ''
+  for (let i = 0; i < strings.length; i++) {
+    result += strings[i]
+    if (i < values.length) result += String(values[i])
+  }
+
+  // Split into lines
+  const lines = result.split('\n')
+
+  // Remove empty first/last lines
+  if (lines[0].trim() === '') lines.shift()
+  if (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop()
+
+  // Find minimum indent (ignoring empty lines)
+  const indent = lines
+    .filter((l) => l.trim().length > 0)
+    .reduce((min, l) => {
+      const match = l.match(/^(\s+)/)
+      return match ? Math.min(min, match[1].length) : 0
+    }, Infinity)
+
+  if (indent === Infinity || indent === 0) return lines.join('\n')
+
+  return lines.map((l) => l.slice(indent)).join('\n')
+}

package/src/tags/index.ts

@@ -0,0 +1,14 @@
+import { dedent } from './dedent.ts'
+
+// Re-export dedent for direct use
+export { dedent }
+
+// Each tag function is just dedent with a name (for grammar injection matching)
+export const ts = dedent
+export const go = dedent
+export const python = dedent
+export const sql = dedent
+export const java = dedent
+export const kotlin = dedent
+export const rust = dedent
+export const csharp = dedent

package/src/types/index.ts

@@ -0,0 +1,8 @@
+export { pgToCsharp } from './pg-to-csharp.ts'
+export { pgToGo } from './pg-to-go.ts'
+export { pgToJava } from './pg-to-java.ts'
+export { pgToKotlin } from './pg-to-kotlin.ts'
+export { pgToPython } from './pg-to-python.ts'
+export { pgToRust } from './pg-to-rust.ts'
+export type { TsTypeOptions } from './pg-to-ts.ts'
+export { pgToTs } from './pg-to-ts.ts'

package/src/types/pg-to-csharp.ts

@@ -0,0 +1,136 @@
+// C# value types that support nullable with ? suffix
+const _VALUE_TYPES = new Set([
+  'short',
+  'int',
+  'long',
+  'float',
+  'double',
+  'decimal',
+  'bool',
+  'DateTime',
+  'DateTimeOffset',
+  'DateOnly',
+  'TimeOnly',
+  'TimeSpan',
+  'Guid',
+])
+
+/** Category-based mapping — used when Atlas provides a type category */
+const CATEGORY_TO_CSHARP: Record<string, string> = {
+  string: 'string',
+  integer: 'long',
+  float: 'double',
+  decimal: 'decimal',
+  boolean: 'bool',
+  time: 'DateTime',
+  binary: 'byte[]',
+  json: 'string',
+  uuid: 'Guid',
+  spatial: 'string',
+  enum: 'string', // overridden per-column with actual enum type
+  unknown: 'string',
+}
+
+const PG_TO_CSHARP: Record<string, string> = {
+  // Numeric
+  smallint: 'short',
+  int2: 'short',
+  integer: 'int',
+  int: 'int',
+  int4: 'int',
+  bigint: 'long',
+  int8: 'long',
+  serial: 'int',
+  serial4: 'int',
+  bigserial: 'long',
+  serial8: 'long',
+  smallserial: 'short',
+  serial2: 'short',
+  real: 'float',
+  float4: 'float',
+  'double precision': 'double',
+  float8: 'double',
+  numeric: 'decimal',
+  decimal: 'decimal',
+  money: 'decimal',
+
+  // String
+  text: 'string',
+  varchar: 'string',
+  'character varying': 'string',
+  char: 'string',
+  character: 'string',
+  name: 'string',
+  citext: 'string',
+
+  // Boolean
+  boolean: 'bool',
+  bool: 'bool',
+
+  // Date/Time
+  timestamp: 'DateTime',
+  'timestamp without time zone': 'DateTime',
+  timestamptz: 'DateTimeOffset',
+  'timestamp with time zone': 'DateTimeOffset',
+  date: 'DateOnly',
+  time: 'TimeOnly',
+  'time without time zone': 'TimeOnly',
+  timetz: 'TimeOnly',
+  'time with time zone': 'TimeOnly',
+  interval: 'TimeSpan',
+
+  // Binary
+  bytea: 'byte[]',
+
+  // JSON
+  json: 'string',
+  jsonb: 'string',
+
+  // UUID
+  uuid: 'Guid',
+
+  // Network
+  inet: 'IPAddress',
+  cidr: 'string',
+  macaddr: 'string',
+}
+
+/**
+ * Map a PostgreSQL type to a C# type string.
+ * Nullable value types use ? suffix (int?), reference types use ? suffix (string?).
+ */
+export function pgToCsharp(pgType: string, nullable: boolean, category?: string): string {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays
+  if (normalized.endsWith('[]')) {
+    const base = pgToCsharp(normalized.slice(0, -2), false)
+    return wrapNullable(`${base}[]`, nullable)
+  }
+  if (normalized.startsWith('_')) {
+    const base = pgToCsharp(normalized.slice(1), false)
+    return wrapNullable(`${base}[]`, nullable)
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  // Try raw type lookup first for precise mapping
+  let csType = PG_TO_CSHARP[baseType]
+
+  // Fall back to category-based mapping for unknown raw types
+  if (csType === undefined && category) {
+    csType = CATEGORY_TO_CSHARP[category]
+  }
+
+  if (csType === undefined) {
+    csType = 'string'
+  }
+
+  return wrapNullable(csType, nullable)
+}
+
+function wrapNullable(type: string, nullable: boolean): string {
+  if (!nullable) return type
+  return `${type}?`
+}

package/src/types/pg-to-go.ts

@@ -0,0 +1,120 @@
+/** Category-based mapping — used when Atlas provides a type category */
+const CATEGORY_TO_GO: Record<string, [string, string | null]> = {
+  string: ['string', null],
+  integer: ['int64', null],
+  float: ['float64', null],
+  decimal: ['string', null],
+  boolean: ['bool', null],
+  time: ['time.Time', 'time'],
+  binary: ['[]byte', null],
+  json: ['json.RawMessage', 'encoding/json'],
+  uuid: ['uuid.UUID', 'github.com/google/uuid'],
+  spatial: ['string', null],
+  enum: ['string', null], // overridden per-column with actual enum type
+  unknown: ['interface{}', null],
+}
+
+const PG_TO_GO: Record<string, [string, string | null]> = {
+  // [goType, importPath]
+  // Numeric
+  smallint: ['int16', null],
+  int2: ['int16', null],
+  integer: ['int32', null],
+  int: ['int32', null],
+  int4: ['int32', null],
+  bigint: ['int64', null],
+  int8: ['int64', null],
+  serial: ['int32', null],
+  serial4: ['int32', null],
+  bigserial: ['int64', null],
+  serial8: ['int64', null],
+  smallserial: ['int16', null],
+  serial2: ['int16', null],
+  real: ['float32', null],
+  float4: ['float32', null],
+  'double precision': ['float64', null],
+  float8: ['float64', null],
+  numeric: ['string', null],
+  decimal: ['string', null],
+  money: ['string', null],
+
+  // String
+  text: ['string', null],
+  varchar: ['string', null],
+  'character varying': ['string', null],
+  char: ['string', null],
+  character: ['string', null],
+  name: ['string', null],
+  citext: ['string', null],
+
+  // Boolean
+  boolean: ['bool', null],
+  bool: ['bool', null],
+
+  // Date/Time
+  timestamp: ['time.Time', 'time'],
+  'timestamp without time zone': ['time.Time', 'time'],
+  timestamptz: ['time.Time', 'time'],
+  'timestamp with time zone': ['time.Time', 'time'],
+  date: ['time.Time', 'time'],
+  time: ['string', null],
+  'time without time zone': ['string', null],
+  timetz: ['string', null],
+  'time with time zone': ['string', null],
+  interval: ['string', null],
+
+  // Binary
+  bytea: ['[]byte', null],
+
+  // JSON
+  json: ['json.RawMessage', 'encoding/json'],
+  jsonb: ['json.RawMessage', 'encoding/json'],
+
+  // UUID
+  uuid: ['uuid.UUID', 'github.com/google/uuid'],
+
+  // Network
+  inet: ['string', null],
+  cidr: ['string', null],
+  macaddr: ['string', null],
+  macaddr8: ['string', null],
+}
+
+/**
+ * Map a PostgreSQL type to a Go type and required imports.
+ * Nullable Go types use pointers: *string, *int64, etc.
+ */
+export function pgToGo(pgType: string, nullable: boolean, category?: string): { type: string; imports: string[] } {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays: text[] or _text
+  if (normalized.endsWith('[]')) {
+    const base = pgToGo(normalized.slice(0, -2), false)
+    return { type: `[]${base.type}`, imports: base.imports }
+  }
+  if (normalized.startsWith('_')) {
+    const base = pgToGo(normalized.slice(1), false)
+    return { type: `[]${base.type}`, imports: base.imports }
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  // Try raw type lookup first for precise mapping
+  let mapping = PG_TO_GO[baseType]
+
+  // Fall back to category-based mapping for unknown raw types
+  if (!mapping && category) {
+    mapping = CATEGORY_TO_GO[category]
+  }
+
+  if (!mapping) return { type: 'interface{}', imports: [] }
+
+  const [goType, importPath] = mapping
+  const imports = importPath ? [importPath] : []
+
+  if (nullable) {
+    return { type: `*${goType}`, imports }
+  }
+  return { type: goType, imports }
+}