@sqldoc/templates 0.0.1

package/src/java-records/test/Test.java

@@ -0,0 +1,93 @@
+import java.sql.*;
+import java.time.OffsetDateTime;
+
+/**
+ * Integration test for @sqldoc/templates/java-records
+ * Connects to real Postgres, verifies generated records work with actual data.
+ */
+public class Test {
+    static int failed = 0;
+
+    static void assertEq(Object actual, Object expected, String msg) {
+        if (!actual.equals(expected)) {
+            System.err.printf("FAIL: %s (got %s, expected %s)%n", msg, actual, expected);
+            failed++;
+        } else {
+            System.out.printf("  ok: %s%n", msg);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        String dbUrl = System.getenv("DATABASE_URL");
+        if (dbUrl == null || dbUrl.isEmpty()) {
+            System.err.println("DATABASE_URL not set");
+            System.exit(1);
+        }
+
+        // Convert postgres(ql):// to jdbc:postgresql://, extracting userinfo for JDBC
+        var uri = java.net.URI.create(dbUrl.replaceFirst("^postgres(ql)?://", "http://"));
+        var userInfo = uri.getUserInfo();
+        var jdbcUrl = "jdbc:postgresql://" + uri.getHost() + ":" + (uri.getPort() > 0 ? uri.getPort() : 5432) + uri.getPath();
+        var query = uri.getQuery();
+        if (userInfo != null) {
+            var parts = userInfo.split(":", 2);
+            var sep = query != null ? "&" : "?";
+            jdbcUrl += (query != null ? "?" + query : "") + sep + "user=" + parts[0] + "&password=" + (parts.length > 1 ? parts[1] : "");
+        } else if (query != null) {
+            jdbcUrl += "?" + query;
+        }
+        dbUrl = jdbcUrl;
+
+        System.out.println("--- java-records integration test ---");
+
+        try (Connection conn = DriverManager.getConnection(dbUrl)) {
+            // 1. Query user and construct generated record
+            try (PreparedStatement ps = conn.prepareStatement("SELECT * FROM users WHERE id = 1")) {
+                ResultSet rs = ps.executeQuery();
+                rs.next();
+                var user = new Users(
+                    rs.getLong("id"),
+                    rs.getString("email"),
+                    rs.getString("name"),
+                    rs.getObject("age") != null ? rs.getInt("age") : null,
+                    rs.getBoolean("is_active"),
+                    rs.getString("metadata"),
+                    null, // address (composite)
+                    rs.getObject("created_at", OffsetDateTime.class),
+                    null, // tags (array)
+                    rs.getBytes("avatar"),
+                    rs.getBigDecimal("balance"),
+                    rs.getObject("external_id") != null ? java.util.UUID.fromString(rs.getString("external_id")) : null
+                );
+                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 record
+            try (PreparedStatement ps = conn.prepareStatement("SELECT * FROM posts WHERE id = 1")) {
+                ResultSet rs = ps.executeQuery();
+                rs.next();
+                var post = new Posts(
+                    rs.getLong("id"),
+                    rs.getLong("user_id"),
+                    rs.getString("title"),
+                    rs.getString("body"),
+                    rs.getObject("published_at") != null ? rs.getObject("published_at", OffsetDateTime.class) : null,
+                    rs.getInt("view_count"),
+                    rs.getObject("rating") != null ? rs.getDouble("rating") : null
+                );
+                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.printf("%n%d assertion(s) failed%n", failed);
+            System.exit(1);
+        }
+        System.out.println("\nAll assertions passed!");
+    }
+}

package/src/jpa/index.ts

@@ -0,0 +1,279 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm, type TagEntry } from '../helpers/enrich.ts'
+import { toCamelCase, toPascalCase, toScreamingSnake } from '../helpers/naming.ts'
+import { pgToJava } from '../types/pg-to-java.ts'
+
+/**
+ * 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 validation annotations from @validate tags.
+ */
+function getValidationAnnotations(colTags: TagEntry[]): { annotations: string[]; imports: Set<string> } {
+  const annotations: string[] = []
+  const imports = new Set<string>()
+
+  for (const tag of colTags) {
+    if (tag.namespace !== 'validate') continue
+
+    if (tag.tag === 'notEmpty') {
+      annotations.push('@NotEmpty')
+      imports.add('jakarta.validation.constraints.NotEmpty')
+    } else if (tag.tag === 'length') {
+      const args = tag.args as Record<string, unknown>
+      const parts: string[] = []
+      if (args.min !== undefined) parts.push(`min = ${args.min}`)
+      if (args.max !== undefined) parts.push(`max = ${args.max}`)
+      annotations.push(`@Size(${parts.join(', ')})`)
+      imports.add('jakarta.validation.constraints.Size')
+    } else if (tag.tag === 'range') {
+      const args = tag.args as Record<string, unknown>
+      if (args.min !== undefined) {
+        annotations.push(`@Min(${args.min})`)
+        imports.add('jakarta.validation.constraints.Min')
+      }
+      if (args.max !== undefined) {
+        annotations.push(`@Max(${args.max})`)
+        imports.add('jakarta.validation.constraints.Max')
+      }
+    } else if (tag.tag === 'pattern') {
+      const pattern = Array.isArray(tag.args) ? tag.args[0] : undefined
+      if (pattern) {
+        // Escape backslashes for Java string literals
+        const escaped = pattern.replace(/\\/g, '\\\\')
+        annotations.push(`@Pattern(regexp = "${escaped}")`)
+        imports.add('jakarta.validation.constraints.Pattern')
+      }
+    }
+  }
+
+  return { annotations, imports }
+}
+
+export default defineTemplate({
+  name: 'JPA Entities',
+  description: 'Generate JPA @Entity classes with annotations from SQL schema',
+  language: 'java',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const files: Array<{ path: string; content: string }> = []
+
+    // Enums
+    for (const e of schema.enums) {
+      const className = toPascalCase(e.name)
+      const members = e.values.map((v) => {
+        const constName = toScreamingSnake(v)
+        return `    ${constName}("${v}")`
+      })
+
+      const parts: string[] = []
+      parts.push(`public enum ${className} {`)
+      parts.push(`${members.join(',\n')};`)
+      parts.push('')
+      parts.push(`    private final String value;`)
+      parts.push('')
+      parts.push(`    ${className}(String value) {`)
+      parts.push(`        this.value = value;`)
+      parts.push(`    }`)
+      parts.push('')
+      parts.push(`    public String getValue() {`)
+      parts.push(`        return value;`)
+      parts.push(`    }`)
+      parts.push('}')
+      parts.push('')
+
+      files.push({
+        path: `${className}.java`,
+        content: parts.join('\n'),
+      })
+    }
+
+    // Composite types as @Embeddable 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 allImports = new Set<string>()
+      allImports.add('jakarta.persistence.Embeddable')
+
+      const fieldLines: string[] = []
+      for (const f of fields) {
+        const mapped = pgToJava(f.type, false)
+        for (const imp of mapped.imports) allImports.add(imp)
+        fieldLines.push(`    private ${mapped.type} ${toCamelCase(f.name)};`)
+        fieldLines.push('')
+      }
+
+      const sortedImports = [...allImports].sort()
+      const importLines = sortedImports.map((imp) => `import ${imp};`)
+
+      const parts: string[] = []
+      parts.push(importLines.join('\n'))
+      parts.push('')
+      parts.push('@Embeddable')
+      parts.push(`public class ${className} {`)
+      parts.push('')
+      parts.push(fieldLines.join('\n'))
+      parts.push('}')
+      parts.push('')
+
+      files.push({
+        path: `${className}.java`,
+        content: parts.join('\n'),
+      })
+    }
+
+    for (const table of activeTables(schema)) {
+      const allImports = new Set<string>()
+      allImports.add('jakarta.persistence.*')
+
+      const fieldLines: string[] = []
+      for (const col of table.columns) {
+        let javaType: string
+        if (col.typeOverride) {
+          javaType = col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          javaType = toPascalCase(col.pgType)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          javaType = toPascalCase(col.pgType)
+        } else {
+          const mapped = pgToJava(col.pgType, col.nullable, col.category)
+          javaType = mapped.type
+          for (const imp of mapped.imports) allImports.add(imp)
+        }
+
+        const annotations: string[] = []
+
+        // PK annotations
+        if (col.isPrimaryKey) {
+          annotations.push('    @Id')
+          if (col.isSerial) {
+            annotations.push('    @GeneratedValue(strategy = GenerationType.IDENTITY)')
+          }
+        }
+
+        // Enum annotation
+        if (col.category === 'enum' && col.enumValues?.length) {
+          annotations.push('    @Enumerated(EnumType.STRING)')
+        }
+
+        // Composite annotation
+        if (col.category === 'composite' && col.compositeFields?.length) {
+          annotations.push('    @Embedded')
+        }
+
+        // FK annotations
+        if (col.foreignKey) {
+          annotations.push(`    @ManyToOne`)
+          annotations.push(`    @JoinColumn(name = "${col.name}")`)
+        }
+
+        // Column annotations
+        const colAnnotationParts: string[] = []
+        if (!col.nullable && !col.isPrimaryKey) {
+          colAnnotationParts.push('nullable = false')
+        }
+        const varcharLen = getVarcharLength(col.pgType)
+        if (varcharLen) {
+          colAnnotationParts.push(`length = ${varcharLen}`)
+        }
+        if (colAnnotationParts.length > 0) {
+          annotations.push(`    @Column(${colAnnotationParts.join(', ')})`)
+        }
+
+        // Validation annotations from @validate tags
+        const validation = getValidationAnnotations(col.tags)
+        for (const ann of validation.annotations) {
+          annotations.push(`    ${ann}`)
+        }
+        for (const imp of validation.imports) {
+          allImports.add(imp)
+        }
+
+        if (annotations.length > 0) {
+          fieldLines.push(annotations.join('\n'))
+        }
+        fieldLines.push(`    private ${javaType} ${col.camelName};`)
+        fieldLines.push('')
+      }
+
+      const sortedImports = [...allImports].sort()
+      const importLines = sortedImports.map((imp) => `import ${imp};`)
+
+      const parts: string[] = []
+      parts.push(importLines.join('\n'))
+      parts.push('')
+      parts.push('@Entity')
+      parts.push(`@Table(name = "${table.name}")`)
+      parts.push(`public class ${table.pascalName} {`)
+      parts.push('')
+      parts.push(fieldLines.join('\n'))
+      parts.push('}')
+      parts.push('')
+
+      files.push({
+        path: `${table.pascalName}.java`,
+        content: parts.join('\n'),
+      })
+    }
+
+    // Views (read-only — mapped as entities with a comment noting immutability)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const allImports = new Set<string>()
+      allImports.add('jakarta.persistence.*')
+
+      const fieldLines: string[] = []
+      for (const col of view.columns) {
+        let javaType: string
+        if (col.typeOverride) {
+          javaType = col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          javaType = toPascalCase(col.pgType)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          javaType = toPascalCase(col.pgType)
+        } else {
+          const mapped = pgToJava(col.pgType, col.nullable, col.category)
+          javaType = mapped.type
+          for (const imp of mapped.imports) allImports.add(imp)
+        }
+
+        fieldLines.push(`    private ${javaType} ${col.camelName};`)
+        fieldLines.push('')
+      }
+
+      const sortedImports = [...allImports].sort()
+      const importLines = sortedImports.map((imp) => `import ${imp};`)
+
+      const parts: string[] = []
+      parts.push(importLines.join('\n'))
+      parts.push('')
+      parts.push('/** Read-only (from view) */')
+      parts.push('@Entity')
+      parts.push(`@Table(name = "${view.name}")`)
+      parts.push(`public class ${view.pascalName} {`)
+      parts.push('')
+      parts.push(fieldLines.join('\n'))
+      parts.push('}')
+      parts.push('')
+
+      files.push({
+        path: `${view.pascalName}.java`,
+        content: parts.join('\n'),
+      })
+    }
+
+    return { files }
+  },
+})

package/src/jpa/test/.gitignore

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

package/src/jpa/test/Dockerfile

@@ -0,0 +1,14 @@
+FROM eclipse-temurin:21-jdk-alpine
+WORKDIR /app
+RUN apk add --no-cache curl
+# Download Jakarta Persistence API JARs and PostgreSQL JDBC driver
+RUN mkdir -p /deps && \
+    curl -sL -o /deps/jakarta.persistence-api-3.2.0.jar https://repo1.maven.org/maven2/jakarta/persistence/jakarta.persistence-api/3.2.0/jakarta.persistence-api-3.2.0.jar && \
+    curl -sL -o /deps/jakarta.validation-api-3.1.0.jar https://repo1.maven.org/maven2/jakarta/validation/jakarta.validation-api/3.1.0/jakarta.validation-api-3.1.0.jar && \
+    curl -sL -o /deps/jakarta.annotation-api-3.0.0.jar https://repo1.maven.org/maven2/jakarta/annotation/jakarta.annotation-api/3.0.0/jakarta.annotation-api-3.0.0.jar && \
+    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
+COPY . .
+# Step 1: compile the generated JPA entities + test
+RUN javac -cp "/deps/*:." *.java Test.java
+# Step 2: run integration test against real DB
+CMD ["java", "-cp", "/deps/*:.", "Test"]

package/src/jpa/test/Test.java

@@ -0,0 +1,111 @@
+import java.sql.*;
+import java.lang.reflect.Field;
+
+/**
+ * Integration test for @sqldoc/templates/jpa
+ * Verifies generated JPA entities compile, have expected fields, and DB has expected data.
+ */
+public class Test {
+    static int failed = 0;
+
+    static void assertEq(Object actual, Object expected, String msg) {
+        if (!actual.equals(expected)) {
+            System.err.printf("FAIL: %s (got %s, expected %s)%n", msg, actual, expected);
+            failed++;
+        } else {
+            System.out.printf("  ok: %s%n", msg);
+        }
+    }
+
+    static void assertHasField(Class<?> cls, String fieldName, String msg) {
+        try {
+            cls.getDeclaredField(fieldName);
+            System.out.printf("  ok: %s%n", msg);
+        } catch (NoSuchFieldException e) {
+            System.err.printf("FAIL: %s (field '%s' not found)%n", msg, fieldName);
+            failed++;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        String dbUrl = System.getenv("DATABASE_URL");
+        if (dbUrl == null || dbUrl.isEmpty()) {
+            System.err.println("DATABASE_URL not set");
+            System.exit(1);
+        }
+
+        // Convert postgres(ql):// to jdbc:postgresql://, extracting userinfo for JDBC
+        var uri = java.net.URI.create(dbUrl.replaceFirst("^postgres(ql)?://", "http://"));
+        var userInfo = uri.getUserInfo();
+        var jdbcUrl = "jdbc:postgresql://" + uri.getHost() + ":" + (uri.getPort() > 0 ? uri.getPort() : 5432) + uri.getPath();
+        var query = uri.getQuery();
+        if (userInfo != null) {
+            var parts = userInfo.split(":", 2);
+            var sep = query != null ? "&" : "?";
+            jdbcUrl += (query != null ? "?" + query : "") + sep + "user=" + parts[0] + "&password=" + (parts.length > 1 ? parts[1] : "");
+        } else if (query != null) {
+            jdbcUrl += "?" + query;
+        }
+        dbUrl = jdbcUrl;
+
+        System.out.println("--- jpa integration test ---");
+
+        // 1. Verify generated entity classes have expected fields
+        assertHasField(Users.class, "id", "Users has 'id' field");
+        assertHasField(Users.class, "email", "Users has 'email' field");
+        assertHasField(Users.class, "name", "Users has 'name' field");
+        assertHasField(Users.class, "isActive", "Users has 'isActive' field");
+        assertHasField(Posts.class, "title", "Posts has 'title' field");
+        assertHasField(Posts.class, "viewCount", "Posts has 'viewCount' field");
+
+        // 2. Instantiate entity and populate via reflection (JPA entities have private fields)
+        try (Connection conn = DriverManager.getConnection(dbUrl)) {
+            try (PreparedStatement ps = conn.prepareStatement(
+                    "SELECT id, email, name, age, is_active FROM users WHERE id = 1")) {
+                ResultSet rs = ps.executeQuery();
+                rs.next();
+                var user = new Users();
+                setField(user, "id", rs.getLong("id"));
+                setField(user, "email", rs.getString("email"));
+                setField(user, "name", rs.getString("name"));
+                setField(user, "age", rs.getObject("age") != null ? rs.getInt("age") : null);
+                setField(user, "isActive", rs.getBoolean("is_active"));
+
+                assertEq(getField(user, "email"), "test@example.com", "user.email matches");
+                assertEq(getField(user, "name"), "Test User", "user.name matches");
+                assertEq(getField(user, "isActive"), true, "user.isActive matches");
+            }
+
+            try (PreparedStatement ps = conn.prepareStatement(
+                    "SELECT id, title, view_count FROM posts WHERE id = 1")) {
+                ResultSet rs = ps.executeQuery();
+                rs.next();
+                var post = new Posts();
+                setField(post, "id", rs.getLong("id"));
+                setField(post, "title", rs.getString("title"));
+                setField(post, "viewCount", rs.getInt("view_count"));
+
+                assertEq(getField(post, "title"), "Hello World", "post.title matches");
+                assertEq(getField(post, "viewCount"), 42, "post.viewCount matches");
+            }
+        }
+
+        if (failed > 0) {
+            System.err.printf("%n%d assertion(s) failed%n", failed);
+            System.exit(1);
+        }
+        System.out.println("\nAll assertions passed!");
+    }
+
+    static void setField(Object obj, String name, Object value) throws Exception {
+        Field f = obj.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        f.set(obj, value);
+    }
+
+    static Object getField(Object obj, String name) throws Exception {
+        Field f = obj.getClass().getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(obj);
+    }
+}