@casekit/orm2-cli 0.0.0-20250331202540 → 1.0.0

package/build/commands/db-pull/util/renderModel.defaultValues.test.js

@@ -0,0 +1,518 @@
+import { describe, expect, it } from "vitest";
+import { unindent } from "@casekit/unindent";
+import { renderModel } from "./renderModel.js";
+describe("renderModel - default values", () => {
+    it("handles numeric defaults", async () => {
+        const table = {
+            schema: "public",
+            name: "products",
+            columns: [
+                {
+                    schema: "public",
+                    table: "products",
+                    column: "id",
+                    ordinalPosition: 1,
+                    type: "integer",
+                    default: null,
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "int4",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "products",
+                    column: "price",
+                    ordinalPosition: 2,
+                    type: "numeric",
+                    default: "0",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "numeric",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "products",
+                    column: "discount",
+                    ordinalPosition: 3,
+                    type: "numeric",
+                    default: "0.15",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "numeric",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+            ],
+            foreignKeys: [],
+            primaryKey: null,
+            uniqueConstraints: [],
+        };
+        const result = await renderModel(table, []);
+        expect(result.trim()).toBe(unindent `
+            import { type ModelDefinition } from "@casekit/orm2";
+
+            export const products = {
+                fields: {
+                    id: { type: "integer" },
+                    price: { type: "numeric", default: 0 },
+                    discount: { type: "numeric", default: 0.15 },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+    });
+    it("handles boolean defaults", async () => {
+        const table = {
+            schema: "public",
+            name: "settings",
+            columns: [
+                {
+                    schema: "public",
+                    table: "settings",
+                    column: "id",
+                    ordinalPosition: 1,
+                    type: "integer",
+                    default: null,
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "int4",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "settings",
+                    column: "is_active",
+                    ordinalPosition: 2,
+                    type: "boolean",
+                    default: "true",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "bool",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "settings",
+                    column: "is_deleted",
+                    ordinalPosition: 3,
+                    type: "boolean",
+                    default: "false",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "bool",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+            ],
+            foreignKeys: [],
+            primaryKey: null,
+            uniqueConstraints: [],
+        };
+        const result = await renderModel(table, []);
+        expect(result.trim()).toBe(unindent `
+            import { type ModelDefinition } from "@casekit/orm2";
+
+            export const settings = {
+                fields: {
+                    id: { type: "integer" },
+                    isActive: { column: "is_active", type: "boolean", default: true },
+                    isDeleted: { column: "is_deleted", type: "boolean", default: false },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+    });
+    it("handles string literal defaults", async () => {
+        const table = {
+            schema: "public",
+            name: "users",
+            columns: [
+                {
+                    schema: "public",
+                    table: "users",
+                    column: "id",
+                    ordinalPosition: 1,
+                    type: "integer",
+                    default: null,
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "int4",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "users",
+                    column: "status",
+                    ordinalPosition: 2,
+                    type: "text",
+                    default: "'active'::text",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "text",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "users",
+                    column: "role",
+                    ordinalPosition: 3,
+                    type: "text",
+                    default: "'user'::text",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "text",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+            ],
+            foreignKeys: [],
+            primaryKey: null,
+            uniqueConstraints: [],
+        };
+        const result = await renderModel(table, []);
+        expect(result.trim()).toBe(unindent `
+            import { type ModelDefinition } from "@casekit/orm2";
+
+            export const users = {
+                fields: {
+                    id: { type: "integer" },
+                    status: { type: "text", default: "active" },
+                    role: { type: "text", default: "user" },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+    });
+    it("handles SQL function defaults", async () => {
+        const table = {
+            schema: "public",
+            name: "events",
+            columns: [
+                {
+                    schema: "public",
+                    table: "events",
+                    column: "id",
+                    ordinalPosition: 1,
+                    type: "uuid",
+                    default: "gen_random_uuid()",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "uuid",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "events",
+                    column: "created_at",
+                    ordinalPosition: 2,
+                    type: "timestamp",
+                    default: "now()",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "timestamp",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "events",
+                    column: "event_date",
+                    ordinalPosition: 3,
+                    type: "date",
+                    default: "CURRENT_DATE",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "date",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+            ],
+            foreignKeys: [],
+            primaryKey: null,
+            uniqueConstraints: [],
+        };
+        const result = await renderModel(table, []);
+        expect(result.trim()).toBe(unindent `
+            import { type ModelDefinition, sql } from "@casekit/orm2";
+
+            export const events = {
+                fields: {
+                    id: { type: "uuid", default: sql\`gen_random_uuid()\` },
+                    createdAt: {
+                        column: "created_at",
+                        type: "timestamp",
+                        default: sql\`now()\`,
+                    },
+                    eventDate: {
+                        column: "event_date",
+                        type: "date",
+                        default: sql\`CURRENT_DATE\`,
+                    },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+    });
+    it("handles serial columns with nextval defaults", async () => {
+        const table = {
+            schema: "public",
+            name: "posts",
+            columns: [
+                {
+                    schema: "public",
+                    table: "posts",
+                    column: "id",
+                    ordinalPosition: 1,
+                    type: "integer",
+                    default: "nextval('posts_id_seq'::regclass)",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "int4",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "posts",
+                    column: "sequence_num",
+                    ordinalPosition: 2,
+                    type: "bigint",
+                    default: "nextval('posts_sequence_num_seq'::regclass)",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "int8",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+            ],
+            foreignKeys: [],
+            primaryKey: null,
+            uniqueConstraints: [],
+        };
+        const result = await renderModel(table, []);
+        expect(result.trim()).toBe(unindent `
+            import { type ModelDefinition, sql } from "@casekit/orm2";
+
+            export const posts = {
+                fields: {
+                    id: {
+                        type: "integer",
+                        default: sql\`nextval('posts_id_seq'::regclass)\`,
+                    },
+                    sequenceNum: {
+                        column: "sequence_num",
+                        type: "bigint",
+                        default: sql\`nextval('posts_sequence_num_seq'::regclass)\`,
+                    },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+    });
+    it("handles array and JSON defaults", async () => {
+        const table = {
+            schema: "public",
+            name: "configs",
+            columns: [
+                {
+                    schema: "public",
+                    table: "configs",
+                    column: "id",
+                    ordinalPosition: 1,
+                    type: "integer",
+                    default: null,
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "int4",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "configs",
+                    column: "tags",
+                    ordinalPosition: 2,
+                    type: "ARRAY",
+                    default: "'[]'::text[]",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "_text",
+                    elementType: "text",
+                    elementTypeSchema: "pg_catalog",
+                    cardinality: 1,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "configs",
+                    column: "metadata",
+                    ordinalPosition: 3,
+                    type: "jsonb",
+                    default: "'{}'::jsonb",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "jsonb",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "configs",
+                    column: "settings",
+                    ordinalPosition: 4,
+                    type: "json",
+                    default: "'null'::json",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "json",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+            ],
+            foreignKeys: [],
+            primaryKey: null,
+            uniqueConstraints: [],
+        };
+        const result = await renderModel(table, []);
+        expect(result.trim()).toBe(unindent `
+            import { type ModelDefinition, sql } from "@casekit/orm2";
+
+            export const configs = {
+                fields: {
+                    id: { type: "integer" },
+                    tags: { type: "text[]", default: sql\`'[]'::text[]\` },
+                    metadata: { type: "jsonb", default: sql\`'{}'::jsonb\` },
+                    settings: { type: "json", default: sql\`'null'::json\` },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+    });
+    it("imports sql only when needed for defaults", async () => {
+        const table = {
+            schema: "public",
+            name: "simple",
+            columns: [
+                {
+                    schema: "public",
+                    table: "simple",
+                    column: "id",
+                    ordinalPosition: 1,
+                    type: "integer",
+                    default: "42",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "int4",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "simple",
+                    column: "active",
+                    ordinalPosition: 2,
+                    type: "boolean",
+                    default: "true",
+                    nullable: false,
+                    udtSchema: "pg_catalog",
+                    udt: "bool",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+                {
+                    schema: "public",
+                    table: "simple",
+                    column: "name",
+                    ordinalPosition: 3,
+                    type: "text",
+                    default: null,
+                    nullable: true,
+                    udtSchema: "pg_catalog",
+                    udt: "text",
+                    elementType: null,
+                    elementTypeSchema: null,
+                    cardinality: 0,
+                    size: null,
+                    isSerial: false,
+                },
+            ],
+            foreignKeys: [],
+            primaryKey: null,
+            uniqueConstraints: [],
+        };
+        const result = await renderModel(table, []);
+        // Note: no sql import since all defaults are simple values
+        expect(result.trim()).toBe(unindent `
+            import { type ModelDefinition } from "@casekit/orm2";
+
+            export const simple = {
+                fields: {
+                    id: { type: "integer", default: 42 },
+                    active: { type: "boolean", default: true },
+                    name: { type: "text", nullable: true },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+    });
+});

package/build/commands/db-pull/util/renderModel.js

@@ -0,0 +1,88 @@
+import { camelCase } from "es-toolkit/string";
+import { prettify } from "#util/prettify.js";
+import { renderFieldDefinition } from "./renderFieldDefinition.js";
+import { renderRelations } from "./renderRelations.js";
+export const renderModel = async (table, allTables) => {
+    // Render fields
+    const fields = table.columns
+        .map((column) => {
+        const fieldName = camelCase(column.column);
+        const definition = renderFieldDefinition(column, table);
+        return `        ${fieldName}: ${definition}`;
+    })
+        .join(",\n");
+    // Render multi-column primary key
+    let primaryKeyDef = "";
+    if (table.primaryKey && table.primaryKey.columns.length > 1) {
+        const pkColumns = table.primaryKey.columns.map((col) => `"${camelCase(col)}"`);
+        primaryKeyDef = `\n    primaryKey: [${pkColumns.join(", ")}],`;
+    }
+    // Render multi-column unique constraints
+    let uniqueConstraintsDef = "";
+    const multiColumnUniqueConstraints = table.uniqueConstraints.filter((uc) => {
+        // Parse columns from definition - this is a bit hacky but matches legacy
+        const match = /\(([^)]+)\)/.exec(uc.definition);
+        if (!match?.[1])
+            return false;
+        const columns = match[1].split(",").map((c) => c.trim());
+        return columns.length > 1;
+    });
+    if (multiColumnUniqueConstraints.length > 0) {
+        const constraints = multiColumnUniqueConstraints.map((uc) => {
+            const match = /\(([^)]+)\)/.exec(uc.definition);
+            const columns = match?.[1]
+                ? match[1].split(",").map((c) => c.trim())
+                : [];
+            const fields = columns
+                .map((c) => `"${camelCase(c)}"`)
+                .join(", ");
+            const hasNullsNotDistinct = uc.definition.includes("NULLS NOT DISTINCT");
+            if (hasNullsNotDistinct) {
+                return `{ fields: [${fields}], nullsNotDistinct: true }`;
+            }
+            return `{ fields: [${fields}] }`;
+        });
+        uniqueConstraintsDef = `\n    uniqueConstraints: [\n        ${constraints.join(",\n        ")}\n    ],`;
+    }
+    // Render multi-column foreign keys
+    let foreignKeysDef = "";
+    const multiColumnForeignKeys = table.foreignKeys.filter((fk) => fk.columnsFrom.length > 1);
+    if (multiColumnForeignKeys.length > 0) {
+        const constraints = multiColumnForeignKeys.map((fk) => {
+            const fields = fk.columnsFrom
+                .map((f) => `"${camelCase(f)}"`)
+                .join(", ");
+            const toFields = fk.columnsTo
+                .map((f) => `"${camelCase(f)}"`)
+                .join(", ");
+            return `{\n            fields: [${fields}],\n            references: {\n                model: "${camelCase(fk.tableTo)}",\n                fields: [${toFields}]\n            }\n        }`;
+        });
+        foreignKeysDef = `\n    foreignKeys: [\n        ${constraints.join(",\n        ")}\n    ],`;
+    }
+    // Render relations
+    const allForeignKeys = allTables.flatMap((t) => t.foreignKeys);
+    const relations = renderRelations(table, allForeignKeys);
+    const relationsDef = relations
+        ? `\n    relations: {\n        ${relations}\n    },`
+        : "";
+    // Build the final model
+    const modelName = camelCase(table.name);
+    const tableDef = modelName !== table.name ? `\n    table: "${table.name}",` : "";
+    const schemaDef = table.schema !== "public" ? `\n    schema: "${table.schema}",` : "";
+    const hasAdditionalSections = primaryKeyDef || uniqueConstraintsDef || foreignKeysDef || relationsDef;
+    const codeWithoutImports = `
+export const ${modelName} = {${schemaDef}${tableDef}
+    fields: {
+${fields},
+    }${hasAdditionalSections ? "," : ""}${primaryKeyDef}${uniqueConstraintsDef}${foreignKeysDef}${relationsDef}
+} as const satisfies ModelDefinition;
+`;
+    const needsSql = codeWithoutImports.includes("sql`");
+    const imports = ["type ModelDefinition"];
+    if (needsSql) {
+        imports.push("sql");
+    }
+    const code = `import { ${imports.join(", ")} } from "@casekit/orm2";\n` +
+        codeWithoutImports;
+    return await prettify(process.cwd(), code);
+};

package/build/commands/db-pull/util/renderModel.relations.test.d.ts

@@ -0,0 +1 @@
+export {};