@casekit/orm2-cli 0.0.0-20250331181319 → 0.0.0

package/build/cli.js

@@ -3,7 +3,6 @@ import { hideBin } from "yargs/helpers";
 import { dbDrop } from "#commands/db-drop.js";
 import { dbPush } from "#commands/db-push.js";
 import { dbPull } from "./commands/db-pull.js";
-import { generateModel } from "./commands/generate-model.js";
 import { init } from "./commands/init.js";
 import { globalOptions } from "./options.js";
 await yargs(hideBin(process.argv))
@@ -11,10 +10,10 @@ await yargs(hideBin(process.argv))
     .scriptName("orm")
     .options(globalOptions)
     .command("db", "Commands for managing your database", (yargs) => yargs.command(dbDrop).command(dbPush).command(dbPull))
-    .command("generate", "Commands for scaffolding files", (yargs) => yargs.command(generateModel))
     .command(init)
     .help()
     .showHelpOnFail(true)
     .demandCommand()
     .recommendCommands()
     .parse();
+process.exit();

package/build/commands/db-drop/handler.js

@@ -13,7 +13,4 @@ export const handler = async (opts) => {
         process.exitCode = 1;
         throw e;
     }
-    finally {
-        await db.close();
-    }
 };

package/build/commands/db-drop.test.js

@@ -12,6 +12,7 @@ describe("db drop", () => {
     afterEach(async () => {
         await db.end();
     });
+    // TODO: does this actually test anything?
     test("drops the schema(s) for the models defined in the config", async () => {
         await yargs().command(dbPush).parseAsync("push");
         await yargs().command(dbDrop).parseAsync("drop");

package/build/commands/db-pull/handler.js

@@ -1,20 +1,33 @@
+import { dir } from "console";
+import { camelCase } from "es-toolkit/string";
+import path from "path";
 import { migrate } from "@casekit/orm2-migrate";
+import { createOrOverwriteFile } from "#util/createOrOverwriteFile.js";
 import { loadConfig } from "#util/loadConfig.js";
+import { prettify } from "../../util/prettify.js";
+import { generateModelsFile } from "../init/util/generateModelsFile.js";
+import { renderModel } from "./util/renderModel.js";
 export const handler = async (opts) => {
-    const { db } = await loadConfig(opts);
-    const schema = opts.schema.length > 0 ? opts.schema : [db.config.schema];
+    const config = await loadConfig(opts);
+    const schema = opts.schema.length > 0 ? opts.schema : [config.db.config.schema];
     try {
+        await config.db.connect();
         console.log("Pulling schema from database");
-        await db.connect();
-        const pulledSchemas = await migrate.pull(db, schema);
+        const tables = await migrate.pull(config.db, schema);
+        console.log(`Found ${tables.length} tables`);
+        // Generate model files for each table
+        for (const table of tables) {
+            console.log(`Generating model for table: ${table.name}`);
+            const modelName = camelCase(table.name);
+            const modelFile = await renderModel(table, tables);
+            await createOrOverwriteFile(`${config.directory}/models/${modelName}.ts`, modelFile, opts.force);
+        }
+        const modelsFile = generateModelsFile(tables.map((t) => camelCase(t.name)));
+        await createOrOverwriteFile(`${dir}/models/index.ts`, await prettify(path.join(process.cwd(), `${dir}/models/index.ts`), modelsFile), opts.force);
         console.log("✅ Done");
-        console.log({ pulledSchemas });
     }
     catch (e) {
         console.error("Error pulling schema from database", e);
         process.exitCode = 1;
     }
-    finally {
-        await db.close();
-    }
 };

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

@@ -5,4 +5,9 @@ export declare const builder: {
         array: true;
         default: never[];
     };
+    force: {
+        type: "boolean";
+        desc: string;
+        default: boolean;
+    };
 };

package/build/commands/db-pull/options.js

@@ -5,4 +5,9 @@ export const builder = {
         array: true,
         default: [],
     },
+    force: {
+        type: "boolean",
+        desc: "Force overwrite existing model files without prompting",
+        default: false,
+    },
 };

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

@@ -0,0 +1,3 @@
+import type { ForeignKey } from "@casekit/orm2-migrate";
+export declare const guessManyToOneRelationName: (fk: ForeignKey) => string;
+export declare const guessOneToManyRelationName: (fk: ForeignKey) => string;

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

@@ -0,0 +1,14 @@
+import { camelCase, lowerFirst, pascalCase, upperFirst, } from "es-toolkit/string";
+import pluralize from "pluralize";
+export const guessManyToOneRelationName = (fk) => {
+    return lowerFirst(fk.columnsFrom.map((c) => pascalCase(c).replace(/Id$/, "")).join(""));
+};
+export const guessOneToManyRelationName = (fk) => {
+    const foreignName = lowerFirst(fk.columnsFrom.map((c) => pascalCase(c).replace(/Id$/, "")).join(""));
+    const tableTo = camelCase(pluralize.singular(fk.tableTo));
+    const tableFrom = camelCase(pluralize.plural(fk.tableFrom));
+    if (tableTo === foreignName) {
+        return pluralize.plural(tableFrom);
+    }
+    return `${foreignName}${upperFirst(pluralize.plural(tableFrom))}`;
+};

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

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { guessManyToOneRelationName, guessOneToManyRelationName, } from "./relationNames.js";
+describe("guessManyToOneRelationName", () => {
+    const createForeignKey = (columnsFrom, tableFrom, tableTo) => ({
+        constraintName: "test_fk",
+        schema: "public",
+        tableFrom,
+        tableTo,
+        columnsFrom,
+        columnsTo: ["id"],
+    });
+    it("handles single column foreign keys", () => {
+        expect(guessManyToOneRelationName(createForeignKey(["user_id"], "posts", "users"))).toBe("user");
+        expect(guessManyToOneRelationName(createForeignKey(["author_id"], "posts", "users"))).toBe("author");
+        expect(guessManyToOneRelationName(createForeignKey(["created_by_id"], "posts", "users"))).toBe("createdBy");
+    });
+    it("handles foreign key columns without _id suffix", () => {
+        expect(guessManyToOneRelationName(createForeignKey(["user"], "posts", "users"))).toBe("user");
+        expect(guessManyToOneRelationName(createForeignKey(["author"], "posts", "users"))).toBe("author");
+    });
+    it("handles multi-column foreign keys", () => {
+        expect(guessManyToOneRelationName(createForeignKey(["tenant_id", "user_id"], "posts", "users"))).toBe("tenantUser");
+        expect(guessManyToOneRelationName(createForeignKey(["org_id", "dept_id", "user_id"], "posts", "users"))).toBe("orgDeptUser");
+    });
+    it("converts snake_case to camelCase", () => {
+        expect(guessManyToOneRelationName(createForeignKey(["parent_category_id"], "categories", "categories"))).toBe("parentCategory");
+        expect(guessManyToOneRelationName(createForeignKey(["primary_contact_id"], "accounts", "contacts"))).toBe("primaryContact");
+    });
+});
+describe("guessOneToManyRelationName", () => {
+    const createForeignKey = (columnsFrom, tableFrom, tableTo) => ({
+        constraintName: "test_fk",
+        schema: "public",
+        tableFrom,
+        tableTo,
+        columnsFrom,
+        columnsTo: ["id"],
+    });
+    it("handles standard one-to-many relationships", () => {
+        expect(guessOneToManyRelationName(createForeignKey(["user_id"], "posts", "users"))).toBe("posts");
+        expect(guessOneToManyRelationName(createForeignKey(["author_id"], "posts", "users"))).toBe("authorPosts");
+        expect(guessOneToManyRelationName(createForeignKey(["category_id"], "posts", "categories"))).toBe("posts");
+    });
+    it("handles self-referential relationships", () => {
+        expect(guessOneToManyRelationName(createForeignKey(["parent_id"], "categories", "categories"))).toBe("parentCategories");
+        expect(guessOneToManyRelationName(createForeignKey(["manager_id"], "users", "users"))).toBe("managerUsers");
+    });
+    it("handles multi-column foreign keys", () => {
+        expect(guessOneToManyRelationName(createForeignKey(["tenant_id", "user_id"], "posts", "users"))).toBe("tenantUserPosts");
+        expect(guessOneToManyRelationName(createForeignKey(["org_id", "dept_id"], "employees", "departments"))).toBe("orgDeptEmployees");
+    });
+    it("pluralizes table names correctly", () => {
+        expect(guessOneToManyRelationName(createForeignKey(["user_id"], "comment", "users"))).toBe("comments");
+        expect(guessOneToManyRelationName(createForeignKey(["user_id"], "reply", "users"))).toBe("replies");
+        expect(guessOneToManyRelationName(createForeignKey(["user_id"], "child", "users"))).toBe("children");
+    });
+    it("converts snake_case to camelCase and adds proper spacing", () => {
+        expect(guessOneToManyRelationName(createForeignKey(["created_by_id"], "posts", "users"))).toBe("createdByPosts");
+        expect(guessOneToManyRelationName(createForeignKey(["assigned_to_id"], "tasks", "users"))).toBe("assignedToTasks");
+    });
+});

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

@@ -0,0 +1,3 @@
+export declare const isNumeric: (value: string) => boolean;
+export declare const renderDefaultValue: (type: string, d: string | null) => string | boolean | null;
+export declare const renderDefault: (type: string, d: string | null) => string;

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

@@ -0,0 +1,46 @@
+export const isNumeric = (value) => {
+    return /^-?\d+(\.\d+)?$/.test(value);
+};
+export const renderDefaultValue = (type, d) => {
+    if (d === null) {
+        return null;
+    }
+    else if (type === "bigint" && isNumeric(d)) {
+        return `"${d.replace(/^'(.*)'::bigint$/, "$1")}"`;
+    }
+    else if (isNumeric(d)) {
+        return d;
+    }
+    else if (d.toLowerCase() === "true") {
+        return true;
+    }
+    else if (d.toLowerCase() === "false") {
+        return false;
+    }
+    else if (/^'.*'$/.test(d)) {
+        return `"${d.replace(/^'(.*)'$/, "$1")}"`;
+    }
+    else if (/NULL::.*/.test(d)) {
+        return null;
+    }
+    else if (/'.*'::text$/.test(d)) {
+        return d.replace(/^'(.*)'::text$/, '"$1"');
+    }
+    else if (/'.*'::numeric/.test(d)) {
+        return d.replace(/^'(.*)'::numeric$/, "$1");
+    }
+    else if (/.*::numeric$/.test(d)) {
+        return d.replace(/^(.*)::numeric$/, "$1");
+    }
+    else {
+        return `sql\`${d}\``;
+    }
+};
+export const renderDefault = (type, d) => {
+    if (type.endsWith("SERIAL"))
+        return "";
+    const value = renderDefaultValue(type, d);
+    if (value === null)
+        return "";
+    return `default: ${value},`;
+};

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

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

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

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "vitest";
+import { isNumeric, renderDefault } from "./renderDefault.js";
+describe("isNumeric", () => {
+    test("should return true for integers", () => {
+        expect(isNumeric("42")).toBe(true);
+        expect(isNumeric("-123")).toBe(true);
+        expect(isNumeric("0")).toBe(true);
+    });
+    test("should return true for decimal numbers", () => {
+        expect(isNumeric("3.14")).toBe(true);
+        expect(isNumeric("-0.5")).toBe(true);
+        expect(isNumeric("0.0")).toBe(true);
+    });
+    test("should return false for non-numeric strings", () => {
+        expect(isNumeric("abc")).toBe(false);
+        expect(isNumeric("12.34.56")).toBe(false);
+        expect(isNumeric("12abc")).toBe(false);
+        expect(isNumeric("")).toBe(false);
+        expect(isNumeric(" ")).toBe(false);
+    });
+});
+describe("renderDefault", () => {
+    test("should return empty string for SERIAL types", () => {
+        expect(renderDefault("SERIAL", "1")).toBe("");
+        expect(renderDefault("BIGSERIAL", "1")).toBe("");
+    });
+    test("should return empty string for null values", () => {
+        expect(renderDefault("TEXT", null)).toBe("");
+    });
+    test("should handle numeric defaults", () => {
+        expect(renderDefault("INTEGER", "42")).toBe("default: 42,");
+        expect(renderDefault("DECIMAL", "-1.5")).toBe("default: -1.5,");
+    });
+    test("should handle boolean defaults", () => {
+        expect(renderDefault("BOOLEAN", "true")).toBe("default: true,");
+        expect(renderDefault("BOOLEAN", "false")).toBe("default: false,");
+        expect(renderDefault("BOOLEAN", "TRUE")).toBe("default: true,");
+        expect(renderDefault("BOOLEAN", "FALSE")).toBe("default: false,");
+    });
+    test("should handle text defaults", () => {
+        expect(renderDefault("TEXT", "'hello'::text")).toBe('default: "hello",');
+    });
+    test("should handle numeric with type specifier", () => {
+        expect(renderDefault("NUMERIC", "'123'::numeric")).toBe("default: 123,");
+        expect(renderDefault("NUMERIC", "456::numeric")).toBe("default: 456,");
+    });
+    test("should wrap functions in sql tag", () => {
+        expect(renderDefault("TIMESTAMP", "now()")).toBe("default: sql`now()`,");
+        expect(renderDefault("UUID", "gen_random_uuid()")).toBe("default: sql`gen_random_uuid()`,");
+    });
+    test("should handle array defaults", () => {
+        expect(renderDefault("INTEGER[]", "ARRAY[1, 2, 3]")).toBe("default: sql`ARRAY[1, 2, 3]`,");
+        expect(renderDefault("TEXT[]", "ARRAY['foo', 'bar']")).toBe("default: sql`ARRAY['foo', 'bar']`,");
+    });
+    test("should handle JSON defaults", () => {
+        expect(renderDefault("JSONB", `'{"key": "value"}'::jsonb`)).toBe(`default: sql\`'{"key": "value"}'::jsonb\`,`);
+        expect(renderDefault("JSON", "'[]'::json")).toBe("default: sql`'[]'::json`,");
+    });
+    test("should handle enum defaults", () => {
+        expect(renderDefault("mood", "'happy'::mood")).toBe("default: sql`'happy'::mood`,");
+        expect(renderDefault("user_role", "'admin'::user_role")).toBe("default: sql`'admin'::user_role`,");
+    });
+    test("should handle compound defaults", () => {
+        expect(renderDefault("point", "'(0,0)'::point")).toBe("default: sql`'(0,0)'::point`,");
+        expect(renderDefault("interval", "'1 day'::interval")).toBe("default: sql`'1 day'::interval`,");
+    });
+});

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

@@ -0,0 +1,2 @@
+import type { Column, Table } from "@casekit/orm2-migrate";
+export declare const renderFieldDefinition: (column: Column, table: Table) => string;

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

@@ -0,0 +1,50 @@
+import { camelCase } from "es-toolkit/string";
+import { renderDefaultValue } from "./renderDefault.js";
+import { renderType } from "./renderType.js";
+export const renderFieldDefinition = (column, table) => {
+    const parts = [];
+    // Column name if different from field name
+    const fieldName = camelCase(column.column);
+    if (fieldName !== column.column) {
+        parts.push(`column: "${column.column}"`);
+    }
+    // Type
+    parts.push(`type: "${renderType(column)}"`);
+    // Primary key (single column)
+    const isPrimaryKey = table.primaryKey &&
+        table.primaryKey.columns.length === 1 &&
+        table.primaryKey.columns[0] === column.column;
+    if (isPrimaryKey) {
+        parts.push("primaryKey: true");
+    }
+    // Unique constraint (single column)
+    const uniqueConstraint = table.uniqueConstraints.find((uc) => uc.definition.includes(`(${column.column})`) ||
+        uc.definition.includes(`("${column.column}")`));
+    if (uniqueConstraint) {
+        const hasNullsNotDistinct = uniqueConstraint.definition.includes("NULLS NOT DISTINCT");
+        if (hasNullsNotDistinct) {
+            parts.push("unique: { nullsNotDistinct: true }");
+        }
+        else {
+            parts.push("unique: true");
+        }
+    }
+    // Nullable
+    if (column.nullable) {
+        parts.push("nullable: true");
+    }
+    // Default (skip for SERIAL columns as they handle their own default)
+    if (column.default && !column.isSerial) {
+        const defaultValue = renderDefaultValue(column.type, column.default);
+        if (defaultValue !== null) {
+            parts.push(`default: ${defaultValue}`);
+        }
+    }
+    // Foreign key reference (single column)
+    const foreignKey = table.foreignKeys.find((fk) => fk.columnsFrom.length === 1 && fk.columnsFrom[0] === column.column);
+    if (foreignKey) {
+        const toField = foreignKey.columnsTo[0];
+        parts.push(`references: { model: "${camelCase(foreignKey.tableTo)}", field: "${camelCase(toField)}" }`);
+    }
+    return `{ ${parts.join(", ")} }`;
+};

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

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

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

@@ -0,0 +1,182 @@
+import { describe, expect, it } from "vitest";
+import { renderFieldDefinition } from "./renderFieldDefinition.js";
+describe("renderFieldDefinition", () => {
+    const createColumn = (overrides) => ({
+        schema: "public",
+        table: "test",
+        column: "test_column",
+        ordinalPosition: 1,
+        type: "text",
+        default: null,
+        nullable: false,
+        udtSchema: "pg_catalog",
+        udt: "text",
+        elementType: null,
+        elementTypeSchema: null,
+        cardinality: 0,
+        size: null,
+        isSerial: false,
+        ...overrides,
+    });
+    const createTable = (overrides = {}) => ({
+        schema: "public",
+        name: "test",
+        columns: [],
+        primaryKey: null,
+        uniqueConstraints: [],
+        foreignKeys: [],
+        ...overrides,
+    });
+    it("renders basic field definition", () => {
+        const column = createColumn({ column: "name", type: "text" });
+        const table = createTable();
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "text" }');
+    });
+    it("handles nullable fields", () => {
+        const column = createColumn({
+            column: "email",
+            type: "text",
+            nullable: true,
+        });
+        const table = createTable();
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "text", nullable: true }');
+    });
+    it("handles default values", () => {
+        const column = createColumn({
+            column: "status",
+            type: "text",
+            default: "'active'::text",
+        });
+        const table = createTable();
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "text", default: "active" }');
+    });
+    it("marks single-column primary keys", () => {
+        const column = createColumn({ column: "id", type: "integer" });
+        const table = createTable({
+            primaryKey: {
+                schema: "public",
+                table: "test",
+                constraintName: "test_pkey",
+                columns: ["id"],
+            },
+        });
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "integer", primaryKey: true }');
+    });
+    it("doesn't mark primary key for multi-column primary keys", () => {
+        const column = createColumn({ column: "id", type: "integer" });
+        const table = createTable({
+            primaryKey: {
+                schema: "public",
+                table: "test",
+                constraintName: "test_pkey",
+                columns: ["id", "tenant_id"],
+            },
+        });
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "integer" }');
+    });
+    it("marks single-column unique constraints", () => {
+        const column = createColumn({ column: "email", type: "text" });
+        const table = createTable({
+            uniqueConstraints: [
+                {
+                    schema: "public",
+                    table: "test",
+                    name: "test_email_key",
+                    definition: "UNIQUE (email)",
+                },
+            ],
+        });
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "text", unique: true }');
+    });
+    it("handles unique constraints with NULLS NOT DISTINCT", () => {
+        const column = createColumn({ column: "email", type: "text" });
+        const table = createTable({
+            uniqueConstraints: [
+                {
+                    schema: "public",
+                    table: "test",
+                    name: "test_email_key",
+                    definition: "UNIQUE NULLS NOT DISTINCT (email)",
+                },
+            ],
+        });
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "text", unique: { nullsNotDistinct: true } }');
+    });
+    it("handles single-column foreign key references", () => {
+        const column = createColumn({ column: "user_id", type: "integer" });
+        const table = createTable({
+            foreignKeys: [
+                {
+                    constraintName: "test_user_id_fkey",
+                    schema: "public",
+                    tableFrom: "test",
+                    tableTo: "users",
+                    columnsFrom: ["user_id"],
+                    columnsTo: ["id"],
+                },
+            ],
+        });
+        expect(renderFieldDefinition(column, table)).toBe('{ column: "user_id", type: "integer", references: { model: "users", field: "id" } }');
+    });
+    it("handles foreign key references to non-id fields", () => {
+        const column = createColumn({ column: "email", type: "text" });
+        const table = createTable({
+            foreignKeys: [
+                {
+                    constraintName: "test_email_fkey",
+                    schema: "public",
+                    tableFrom: "test",
+                    tableTo: "users",
+                    columnsFrom: ["email"],
+                    columnsTo: ["email"],
+                },
+            ],
+        });
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "text", references: { model: "users", field: "email" } }');
+    });
+    it("doesn't add references for multi-column foreign keys", () => {
+        const column = createColumn({ column: "user_id", type: "integer" });
+        const table = createTable({
+            foreignKeys: [
+                {
+                    constraintName: "test_user_tenant_fkey",
+                    schema: "public",
+                    tableFrom: "test",
+                    tableTo: "users",
+                    columnsFrom: ["user_id", "tenant_id"],
+                    columnsTo: ["id", "tenant_id"],
+                },
+            ],
+        });
+        expect(renderFieldDefinition(column, table)).toBe('{ column: "user_id", type: "integer" }');
+    });
+    it("handles complex field with multiple attributes", () => {
+        const column = createColumn({
+            column: "email",
+            type: "varchar",
+            nullable: true,
+            default: "'default@example.com'::text",
+        });
+        const table = createTable({
+            uniqueConstraints: [
+                {
+                    schema: "public",
+                    table: "test",
+                    name: "test_email_key",
+                    definition: 'UNIQUE ("email")',
+                },
+            ],
+        });
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "varchar", unique: true, nullable: true, default: "default@example.com" }');
+    });
+    it("handles array types correctly", () => {
+        const column = createColumn({
+            column: "tags",
+            type: "ARRAY",
+            elementType: "text",
+            cardinality: 1,
+        });
+        const table = createTable();
+        expect(renderFieldDefinition(column, table)).toBe('{ type: "text[]" }');
+    });
+});

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

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