@casekit/orm2-cli 0.0.0-20250331202540 → 0.0.0

package/build/commands/db-pull/util/renderRelations.d.ts

@@ -0,0 +1,2 @@
+import type { ForeignKey, Table } from "@casekit/orm2-migrate";
+export declare const renderRelations: (table: Table, allForeignKeys: ForeignKey[]) => string;

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

@@ -0,0 +1,55 @@
+import { camelCase } from "es-toolkit/string";
+import { guessManyToOneRelationName, guessOneToManyRelationName, } from "./relationNames.js";
+export const renderRelations = (table, allForeignKeys) => {
+    const relations = [];
+    // N:1 relations (this table references others)
+    table.foreignKeys.forEach((fk) => {
+        const relationName = guessManyToOneRelationName(fk);
+        const parts = [`type: "N:1"`, `model: "${camelCase(fk.tableTo)}"`];
+        if (fk.columnsFrom.length === 1 &&
+            fk.columnsTo.length === 1 &&
+            fk.columnsFrom[0] &&
+            fk.columnsTo[0]) {
+            const fromField = camelCase(fk.columnsFrom[0]);
+            const toField = camelCase(fk.columnsTo[0]);
+            parts.push(`fromField: "${fromField}"`);
+            parts.push(`toField: "${toField}"`);
+        }
+        else {
+            parts.push(`fromField: [${fk.columnsFrom.map((f) => `"${camelCase(f)}"`).join(", ")}]`);
+            parts.push(`toField: [${fk.columnsTo.map((f) => `"${camelCase(f)}"`).join(", ")}]`);
+        }
+        // Check if the foreign key column is nullable
+        const isNullable = fk.columnsFrom.length === 1 &&
+            table.columns.find((c) => c.column === fk.columnsFrom[0])?.nullable;
+        if (isNullable) {
+            parts.push("optional: true");
+        }
+        relations.push(`${relationName}: { ${parts.join(", ")} }`);
+    });
+    // 1:N relations (other tables reference this one)
+    allForeignKeys
+        .filter((fk) => fk.tableTo === table.name && fk.schema === table.schema)
+        .forEach((fk) => {
+        const relationName = guessOneToManyRelationName(fk);
+        const parts = [
+            `type: "1:N"`,
+            `model: "${camelCase(fk.tableFrom)}"`,
+        ];
+        if (fk.columnsFrom.length === 1 &&
+            fk.columnsTo.length === 1 &&
+            fk.columnsFrom[0] &&
+            fk.columnsTo[0]) {
+            const fromField = camelCase(fk.columnsTo[0]);
+            const toField = camelCase(fk.columnsFrom[0]);
+            parts.push(`fromField: "${fromField}"`);
+            parts.push(`toField: "${toField}"`);
+        }
+        else {
+            parts.push(`fromField: [${fk.columnsTo.map((f) => `"${camelCase(f)}"`).join(", ")}]`);
+            parts.push(`toField: [${fk.columnsFrom.map((f) => `"${camelCase(f)}"`).join(", ")}]`);
+        }
+        relations.push(`${relationName}: { ${parts.join(", ")} }`);
+    });
+    return relations.length > 0 ? relations.join(",\n        ") : "";
+};

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

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

package/build/commands/db-pull/util/renderRelations.test.js

@@ -0,0 +1,165 @@
+import { describe, expect, it } from "vitest";
+import { renderRelations } from "./renderRelations.js";
+describe("renderRelations", () => {
+    const createColumn = (column, nullable = false) => ({
+        schema: "public",
+        table: "test",
+        column,
+        ordinalPosition: 1,
+        type: "integer",
+        default: null,
+        nullable,
+        udtSchema: "pg_catalog",
+        udt: "int4",
+        elementType: null,
+        elementTypeSchema: null,
+        cardinality: 0,
+        size: null,
+        isSerial: false,
+    });
+    const createForeignKey = (overrides) => ({
+        constraintName: "test_fk",
+        schema: "public",
+        tableFrom: "posts",
+        tableTo: "users",
+        columnsFrom: ["user_id"],
+        columnsTo: ["id"],
+        ...overrides,
+    });
+    const createTable = (overrides = {}) => ({
+        schema: "public",
+        name: "posts",
+        columns: [createColumn("id"), createColumn("user_id")],
+        primaryKey: null,
+        uniqueConstraints: [],
+        foreignKeys: [],
+        ...overrides,
+    });
+    it("renders empty string when no relations exist", () => {
+        const table = createTable();
+        const allForeignKeys = [];
+        expect(renderRelations(table, allForeignKeys)).toBe("");
+    });
+    it("renders N:1 relation for single column foreign key", () => {
+        const fk = createForeignKey({});
+        const table = createTable({ foreignKeys: [fk] });
+        expect(renderRelations(table, [])).toBe('user: { type: "N:1", model: "users", fromField: "userId", toField: "id" }');
+    });
+    it("renders N:1 relation with non-id target field", () => {
+        const fk = createForeignKey({
+            columnsFrom: ["email"],
+            columnsTo: ["email"],
+        });
+        const table = createTable({
+            columns: [createColumn("id"), createColumn("email")],
+            foreignKeys: [fk],
+        });
+        expect(renderRelations(table, [])).toBe('email: { type: "N:1", model: "users", fromField: "email", toField: "email" }');
+    });
+    it("renders N:1 relation with optional flag for nullable columns", () => {
+        const fk = createForeignKey({});
+        const table = createTable({
+            columns: [createColumn("id"), createColumn("user_id", true)],
+            foreignKeys: [fk],
+        });
+        expect(renderRelations(table, [])).toBe('user: { type: "N:1", model: "users", fromField: "userId", toField: "id", optional: true }');
+    });
+    it("renders N:1 relation for multi-column foreign key", () => {
+        const fk = createForeignKey({
+            columnsFrom: ["tenant_id", "user_id"],
+            columnsTo: ["tenant_id", "id"],
+        });
+        const table = createTable({
+            columns: [
+                createColumn("id"),
+                createColumn("tenant_id"),
+                createColumn("user_id"),
+            ],
+            foreignKeys: [fk],
+        });
+        expect(renderRelations(table, [])).toBe('tenantUser: { type: "N:1", model: "users", fromField: ["tenantId", "userId"], toField: ["tenantId", "id"] }');
+    });
+    it("renders 1:N relation for incoming foreign key", () => {
+        const table = createTable({ name: "users", foreignKeys: [] });
+        const allForeignKeys = [createForeignKey({})];
+        expect(renderRelations(table, allForeignKeys)).toBe('posts: { type: "1:N", model: "posts", fromField: "id", toField: "userId" }');
+    });
+    it("renders 1:N relation with non-id source field", () => {
+        const table = createTable({
+            name: "users",
+            columns: [createColumn("id"), createColumn("email")],
+            foreignKeys: [],
+        });
+        const allForeignKeys = [
+            createForeignKey({
+                tableTo: "users",
+                columnsFrom: ["author_email"],
+                columnsTo: ["email"],
+            }),
+        ];
+        expect(renderRelations(table, allForeignKeys)).toBe('authorEmailPosts: { type: "1:N", model: "posts", fromField: "email", toField: "authorEmail" }');
+    });
+    it("renders 1:N relation for multi-column foreign key", () => {
+        const table = createTable({
+            name: "users",
+            columns: [createColumn("tenant_id"), createColumn("id")],
+            foreignKeys: [],
+        });
+        const allForeignKeys = [
+            createForeignKey({
+                tableTo: "users",
+                columnsFrom: ["tenant_id", "user_id"],
+                columnsTo: ["tenant_id", "id"],
+            }),
+        ];
+        expect(renderRelations(table, allForeignKeys)).toBe('tenantUserPosts: { type: "1:N", model: "posts", fromField: ["tenantId", "id"], toField: ["tenantId", "userId"] }');
+    });
+    it("renders both N:1 and 1:N relations", () => {
+        const outgoingFk = createForeignKey({
+            tableFrom: "posts",
+            tableTo: "users",
+        });
+        const incomingFk = createForeignKey({
+            tableFrom: "comments",
+            tableTo: "posts",
+            columnsFrom: ["post_id"],
+        });
+        const table = createTable({
+            foreignKeys: [outgoingFk],
+        });
+        const allForeignKeys = [outgoingFk, incomingFk];
+        const result = renderRelations(table, allForeignKeys);
+        expect(result).toBe('user: { type: "N:1", model: "users", fromField: "userId", toField: "id" },\n' +
+            '        comments: { type: "1:N", model: "comments", fromField: "id", toField: "postId" }');
+    });
+    it("filters 1:N relations by schema", () => {
+        const table = createTable({
+            schema: "public",
+            name: "users",
+            foreignKeys: [],
+        });
+        const allForeignKeys = [
+            createForeignKey({ schema: "public", tableTo: "users" }),
+            createForeignKey({ schema: "other", tableTo: "users" }),
+        ];
+        const result = renderRelations(table, allForeignKeys);
+        // Should only include the foreign key from the same schema
+        expect(result).toBe('posts: { type: "1:N", model: "posts", fromField: "id", toField: "userId" }');
+    });
+    it("handles self-referential relations", () => {
+        const fk = createForeignKey({
+            tableFrom: "categories",
+            tableTo: "categories",
+            columnsFrom: ["parent_id"],
+        });
+        const table = createTable({
+            name: "categories",
+            columns: [createColumn("id"), createColumn("parent_id", true)],
+            foreignKeys: [fk],
+        });
+        const allForeignKeys = [fk];
+        const result = renderRelations(table, allForeignKeys);
+        expect(result).toBe('parent: { type: "N:1", model: "categories", fromField: "parentId", toField: "id", optional: true },\n' +
+            '        parentCategories: { type: "1:N", model: "categories", fromField: "id", toField: "parentId" }');
+    });
+});

package/build/commands/db-pull/util/renderType.d.ts

@@ -0,0 +1,6 @@
+import type { Column } from "@casekit/orm2-migrate";
+/**
+ * Renders PostgreSQL column types for code generation
+ * Handles array types, SERIAL types, and passes through all other types unchanged
+ */
+export declare const renderType: (column: Column) => string;

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

@@ -0,0 +1,55 @@
+/**
+ * Renders PostgreSQL column types for code generation
+ * Handles array types, SERIAL types, and passes through all other types unchanged
+ */
+export const renderType = (column) => {
+    // Handle SERIAL columns first
+    if (column.isSerial) {
+        if (column.type === "smallint") {
+            return "smallserial";
+        }
+        else if (column.type === "integer") {
+            return "serial";
+        }
+        else if (column.type === "bigint") {
+            return "bigserial";
+        }
+    }
+    // Handle array types
+    if (column.type === "ARRAY" && column.elementType) {
+        return `${column.elementType}${"[]".repeat(column.cardinality ?? 1)}`;
+    }
+    // Handle PostgreSQL array shortcuts (e.g., _text, _int4)
+    // These are internal representations for array types
+    const arrayShortcuts = {
+        _text: "text[]",
+        _varchar: "varchar[]",
+        _int4: "integer[]",
+        _int8: "bigint[]",
+        _int2: "smallint[]",
+        _float4: "real[]",
+        _float8: "double precision[]",
+        _bool: "boolean[]",
+        _uuid: "uuid[]",
+        _json: "json[]",
+        _jsonb: "jsonb[]",
+        _bytea: "bytea[]",
+        _date: "date[]",
+        _timestamp: "timestamp[]",
+        _timestamptz: "timestamptz[]",
+        _time: "time[]",
+        _timetz: "timetz[]",
+        _numeric: "numeric[]",
+        _money: "money[]",
+        _inet: "inet[]",
+        _cidr: "cidr[]",
+        _macaddr: "macaddr[]",
+        _macaddr8: "macaddr8[]",
+    };
+    const shortcut = arrayShortcuts[column.type];
+    if (shortcut) {
+        return shortcut;
+    }
+    // Pass through all other types unchanged
+    return column.type;
+};

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

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

package/build/commands/db-pull/util/renderType.test.js

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "vitest";
+import { renderType } from "./renderType.js";
+describe("renderType", () => {
+    const createColumn = (type, elementType, cardinality) => ({
+        schema: "public",
+        table: "test",
+        column: "test_column",
+        ordinalPosition: 1,
+        type,
+        default: null,
+        nullable: false,
+        udtSchema: "pg_catalog",
+        udt: "test",
+        elementType: elementType ?? null,
+        elementTypeSchema: null,
+        cardinality: cardinality ?? 0,
+        size: null,
+        isSerial: false,
+    });
+    describe("Array types", () => {
+        test("renders ARRAY types with element types", () => {
+            expect(renderType(createColumn("ARRAY", "integer", 1))).toBe("integer[]");
+            expect(renderType(createColumn("ARRAY", "text", 1))).toBe("text[]");
+            expect(renderType(createColumn("ARRAY", "varchar", 2))).toBe("varchar[][]");
+            expect(renderType(createColumn("ARRAY", "boolean", 3))).toBe("boolean[][][]");
+        });
+        test("handles array type shortcuts", () => {
+            expect(renderType(createColumn("_text"))).toBe("text[]");
+            expect(renderType(createColumn("_int4"))).toBe("integer[]");
+            expect(renderType(createColumn("_varchar"))).toBe("varchar[]");
+            expect(renderType(createColumn("_bool"))).toBe("boolean[]");
+        });
+        test("handles ARRAY type without elementType", () => {
+            expect(renderType(createColumn("ARRAY", null))).toBe("ARRAY");
+        });
+    });
+    describe("Pass-through types", () => {
+        test("passes through all non-array types unchanged", () => {
+            expect(renderType(createColumn("integer"))).toBe("integer");
+            expect(renderType(createColumn("character varying"))).toBe("character varying");
+            expect(renderType(createColumn("timestamp with time zone"))).toBe("timestamp with time zone");
+            expect(renderType(createColumn("numeric(10,2)"))).toBe("numeric(10,2)");
+            expect(renderType(createColumn("custom_enum_type"))).toBe("custom_enum_type");
+        });
+    });
+});

package/build/commands/db-pull.d.ts

@@ -8,6 +8,11 @@ export declare const dbPull: {
             array: true;
             default: never[];
         };
+        force: {
+            type: "boolean";
+            desc: string;
+            default: boolean;
+        };
     };
     handler: import("../types.js").Handler<{
         schema: {
@@ -16,5 +21,10 @@ export declare const dbPull: {
             array: true;
             default: never[];
         };
+        force: {
+            type: "boolean";
+            desc: string;
+            default: boolean;
+        };
     }>;
 };