@sqldoc/templates 0.0.1

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

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/jackc/pgx/v5"
+
+	"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("--- go-structs integration test ---")
+
+	// 1. Query user into generated struct
+	var user models.Users
+	err = conn.QueryRow(ctx, "SELECT id, email, name, age, is_active FROM users WHERE id = 1").
+		Scan(&user.Id, &user.Email, &user.Name, &user.Age, &user.IsActive)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "query user error: %v\n", err)
+		os.Exit(1)
+	}
+	assert(user.Email == "test@example.com", "user.Email matches")
+	assert(user.Name != nil && *user.Name == "Test User", "user.Name matches")
+	assert(user.Age != nil && *user.Age == 30, "user.Age matches")
+	assert(user.IsActive == true, "user.IsActive matches")
+
+	// 2. Query post into generated struct
+	var post models.Posts
+	err = conn.QueryRow(ctx, "SELECT id, user_id, title, body, view_count FROM posts WHERE id = 1").
+		Scan(&post.Id, &post.UserId, &post.Title, &post.Body, &post.ViewCount)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "query post error: %v\n", err)
+		os.Exit(1)
+	}
+	assert(post.Title == "Hello World", "post.Title matches")
+	assert(post.UserId == 1, "post.UserId matches")
+	assert(post.ViewCount == 42, "post.ViewCount 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/gorm/index.ts

@@ -0,0 +1,134 @@
+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: 'GORM Models',
+  description: 'Generate Go structs with GORM 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)
+
+        // Build GORM tag parts
+        const gormParts: string[] = []
+        if (col.isPrimaryKey) gormParts.push('primaryKey')
+        gormParts.push(`type:${col.pgType}`)
+        if (!col.nullable) gormParts.push('not null')
+        if (col.isSerial) gormParts.push('autoIncrement')
+        if (col.defaultValue) gormParts.push(`default:${col.defaultValue}`)
+        if (col.foreignKey) {
+          gormParts.push(`foreignKey:${col.foreignKey.column}`)
+        }
+
+        const gormTag = `gorm:"${gormParts.join(';')}"`
+        const jsonTag = `json:"${col.name},omitempty"`
+        const tag = `\`${gormTag} ${jsonTag}\``
+
+        fields.push(`\t${col.pascalName} ${goType} ${tag}`)
+      }
+
+      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 gormTag = `gorm:"type:${col.pgType}"`
+        const jsonTag = `json:"${col.name},omitempty"`
+        const tag = `\`${gormTag} ${jsonTag}\``
+
+        fields.push(`\t${col.pascalName} ${goType} ${tag}`)
+      }
+
+      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/gorm -- DO NOT EDIT
+package models
+
+${importBlock}${structBlocks.join('\n\n')}\n`
+
+    return {
+      files: [{ path: 'models.go', content }],
+    }
+  },
+})

package/src/gorm/test/.gitignore

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

package/src/gorm/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 gorm.io/gorm gorm.io/driver/postgres && 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/gorm/test/test.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"sqldoc-test/models"
+
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+)
+
+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() {
+	dbURL := os.Getenv("DATABASE_URL")
+	if dbURL == "" {
+		fmt.Fprintln(os.Stderr, "DATABASE_URL not set")
+		os.Exit(1)
+	}
+
+	db, err := gorm.Open(postgres.Open(dbURL), &gorm.Config{})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connect error: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Println("--- gorm integration test ---")
+
+	// 1. Query user via GORM using generated model
+	var user models.Users
+	if err := db.First(&user, 1).Error; err != nil {
+		fmt.Fprintf(os.Stderr, "query user error: %v\n", err)
+		os.Exit(1)
+	}
+	assert(user.Email == "test@example.com", "user.Email matches")
+	assert(user.Name != nil && *user.Name == "Test User", "user.Name matches")
+	assert(user.Age != nil && *user.Age == 30, "user.Age matches")
+	assert(user.IsActive == true, "user.IsActive matches")
+
+	// 2. Query post via GORM using generated model
+	var post models.Posts
+	if err := db.First(&post, 1).Error; err != nil {
+		fmt.Fprintf(os.Stderr, "query post error: %v\n", err)
+		os.Exit(1)
+	}
+	assert(post.Title == "Hello World", "post.Title matches")
+	assert(post.UserId == 1, "post.UserId matches")
+	assert(post.ViewCount == 42, "post.ViewCount 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/helpers/atlas.ts

@@ -0,0 +1,43 @@
+import type { AtlasColumn, AtlasRealm, AtlasTable, AtlasView } from '@sqldoc/atlas'
+
+/** Extract all tables from all schemas in a realm */
+export function getTablesFromRealm(realm: AtlasRealm): AtlasTable[] {
+  return realm.schemas.flatMap((s) => s.tables ?? [])
+}
+
+/** Extract all views from all schemas in a realm */
+export function getViewsFromRealm(realm: AtlasRealm): AtlasView[] {
+  return realm.schemas.flatMap((s) => s.views ?? [])
+}
+
+/** Check if a column is nullable */
+export function isNullable(column: AtlasColumn): boolean {
+  return column.type?.null === true
+}
+
+/** Get the column type string, falling back to 'unknown' */
+export function getColumnType(column: AtlasColumn): string {
+  return column.type?.T ?? column.type?.raw ?? 'unknown'
+}
+
+/** Find all codegen tags for a given SQL object from allFileTags */
+export function findTagsForObject(
+  allFileTags: Array<{
+    sourceFile: string
+    objects: Array<{
+      objectName: string
+      target: string
+      tags: Array<{ namespace: string; tag: string | null; args: Record<string, unknown> | unknown[] }>
+    }>
+  }>,
+  objectName: string,
+): Array<{ namespace: string; tag: string | null; args: Record<string, unknown> | unknown[] }> {
+  for (const file of allFileTags) {
+    for (const obj of file.objects) {
+      if (obj.objectName === objectName) {
+        return obj.tags
+      }
+    }
+  }
+  return []
+}