@casekit/orm2-cli 0.0.0-20250322230249

package/build/cli.d.ts

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

package/build/cli.js

@@ -0,0 +1,20 @@
+import yargs from "yargs";
+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))
+    .strict(true)
+    .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();

package/build/commands/db-drop/handler.d.ts

@@ -0,0 +1,3 @@
+import { Handler } from "#types.js";
+import { builder } from "./options.js";
+export declare const handler: Handler<typeof builder>;

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

@@ -0,0 +1,19 @@
+import { migrate } from "@casekit/orm2-migrate";
+import { loadConfig } from "#util/loadConfig.js";
+export const handler = async (opts) => {
+    const { db } = await loadConfig(opts);
+    try {
+        console.log("Dropping database schemas");
+        await db.connect();
+        await migrate.drop(db);
+        console.log("✅ Done");
+    }
+    catch (e) {
+        console.error("Failed to drop schemas", e);
+        process.exitCode = 1;
+        throw e;
+    }
+    finally {
+        await db.close();
+    }
+};

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

@@ -0,0 +1 @@
+export declare const builder: {};

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

@@ -0,0 +1 @@
+export const builder = {};

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

@@ -0,0 +1,6 @@
+export declare const dbDrop: {
+    command: string;
+    desc: string;
+    builder: {};
+    handler: import("../types.js").Handler<{}>;
+};

package/build/commands/db-drop.js

@@ -0,0 +1,8 @@
+import { handler } from "./db-drop/handler.js";
+import { builder } from "./db-drop/options.js";
+export const dbDrop = {
+    command: "drop",
+    desc: "Drop the database schemas used by your models",
+    builder,
+    handler,
+};

package/build/commands/db-drop.test.d.ts

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

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

@@ -0,0 +1,21 @@
+import pg from "pg";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import yargs from "yargs";
+import { dbDrop } from "./db-drop.js";
+import { dbPush } from "./db-push.js";
+describe("db drop", () => {
+    let db;
+    beforeEach(async () => {
+        db = new pg.Client();
+        await db.connect();
+    });
+    afterEach(async () => {
+        await db.end();
+    });
+    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");
+        const result = await db.query("SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'orm_cli_test';");
+        expect(result.rows.length).toBe(0);
+    });
+});

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

@@ -0,0 +1,3 @@
+import { Handler } from "#types.js";
+import { builder } from "./options.js";
+export declare const handler: Handler<typeof builder>;

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

@@ -0,0 +1,20 @@
+import { migrate } from "@casekit/orm2-migrate";
+import { loadConfig } from "#util/loadConfig.js";
+export const handler = async (opts) => {
+    const { db } = await loadConfig(opts);
+    const schema = opts.schema.length > 0 ? opts.schema : [db.config.schema];
+    try {
+        console.log("Pulling schema from database");
+        await db.connect();
+        const pulledSchemas = await migrate.pull(db, schema);
+        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

@@ -0,0 +1,8 @@
+export declare const builder: {
+    schema: {
+        type: "string";
+        desc: string;
+        array: true;
+        default: never[];
+    };
+};

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

@@ -0,0 +1,8 @@
+export const builder = {
+    schema: {
+        type: "string",
+        desc: "The name of the schema to pull in the database",
+        array: true,
+        default: [],
+    },
+};

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

@@ -0,0 +1,20 @@
+export declare const dbPull: {
+    command: string;
+    desc: string;
+    builder: {
+        schema: {
+            type: "string";
+            desc: string;
+            array: true;
+            default: never[];
+        };
+    };
+    handler: import("../types.js").Handler<{
+        schema: {
+            type: "string";
+            desc: string;
+            array: true;
+            default: never[];
+        };
+    }>;
+};

package/build/commands/db-pull.js

@@ -0,0 +1,8 @@
+import { handler } from "./db-pull/handler.js";
+import { builder } from "./db-pull/options.js";
+export const dbPull = {
+    command: "pull",
+    desc: "Introspect and pull the current schema from the database",
+    builder,
+    handler,
+};

package/build/commands/db-push/handler.d.ts

@@ -0,0 +1,3 @@
+import { Handler } from "#types.js";
+import { builder } from "./options.js";
+export declare const handler: Handler<typeof builder>;

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

@@ -0,0 +1,18 @@
+import { migrate } from "@casekit/orm2-migrate";
+import { loadConfig } from "#util/loadConfig.js";
+export const handler = async (opts) => {
+    const { db } = await loadConfig(opts);
+    try {
+        await db.connect();
+        await migrate.push(db);
+        console.log("✅ Done");
+    }
+    catch (e) {
+        console.error("Error pushing schema to database", e);
+        process.exitCode = 1;
+        throw e;
+    }
+    finally {
+        await db.close();
+    }
+};

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

@@ -0,0 +1,2 @@
+import { Builder } from "#types.js";
+export declare const builder: Builder;

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

@@ -0,0 +1 @@
+export const builder = {};

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

@@ -0,0 +1,6 @@
+export declare const dbPush: {
+    command: string;
+    desc: string;
+    builder: import("../types.js").Builder;
+    handler: import("../types.js").Handler<import("../types.js").Builder>;
+};

package/build/commands/db-push.js

@@ -0,0 +1,8 @@
+import { handler } from "./db-push/handler.js";
+import { builder } from "./db-push/options.js";
+export const dbPush = {
+    command: "push",
+    desc: "Forcibly push the current schema to the database",
+    builder,
+    handler,
+};

package/build/commands/db-push.test.d.ts

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

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

@@ -0,0 +1,21 @@
+import pg from "pg";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import yargs from "yargs";
+import { dbDrop } from "./db-drop.js";
+import { dbPush } from "./db-push.js";
+describe("db push", () => {
+    let db;
+    beforeEach(async () => {
+        db = new pg.Client();
+        await db.connect();
+    });
+    afterEach(async () => {
+        await db.end();
+    });
+    test("creates the schema for the models defined in the config", async () => {
+        await yargs().command(dbDrop).parseAsync("drop");
+        await yargs().command(dbPush).parseAsync("push");
+        const result = await db.query("SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'orm';");
+        expect(result.rows.length).toBe(1);
+    });
+});

package/build/commands/generate-model/handler.d.ts

@@ -0,0 +1,3 @@
+import { Handler } from "#types.js";
+import { builder } from "./options.js";
+export declare const handler: Handler<typeof builder>;

package/build/commands/generate-model/handler.js

@@ -0,0 +1,10 @@
+import { createOrOverwriteFile } from "#util/createOrOverwriteFile.js";
+import { loadConfig } from "#util/loadConfig.js";
+import { generateModelFile } from "./util/generateModelFile.js";
+import { regenerateModelsFile } from "./util/regenerateModelsFile.js";
+export const handler = async (opts) => {
+    const config = await loadConfig(opts);
+    const modelFile = await generateModelFile(opts);
+    await createOrOverwriteFile(`${config.directory}/models/${opts.name}.ts`, modelFile, opts.force);
+    await regenerateModelsFile(config, opts.name);
+};

package/build/commands/generate-model/options.d.ts

@@ -0,0 +1,18 @@
+export declare const builder: {
+    readonly name: {
+        readonly type: "string";
+        readonly desc: "Name of the model";
+        readonly demandOption: true;
+    };
+    readonly template: {
+        readonly type: "string";
+        readonly desc: "Template to use to generate the model. Pass --template none if you have a default template defined but don't want to use it.";
+        readonly default: "default";
+    };
+    readonly fields: {
+        readonly type: "string";
+        readonly desc: "Fields to generate for the model, in the format 'name:type name:type'";
+        readonly array: true;
+        readonly default: readonly [];
+    };
+};

package/build/commands/generate-model/options.js

@@ -0,0 +1,18 @@
+export const builder = {
+    name: {
+        type: "string",
+        desc: "Name of the model",
+        demandOption: true,
+    },
+    template: {
+        type: "string",
+        desc: "Template to use to generate the model. Pass --template none if you have a default template defined but don't want to use it.",
+        default: "default",
+    },
+    fields: {
+        type: "string",
+        desc: "Fields to generate for the model, in the format 'name:type name:type'",
+        array: true,
+        default: [],
+    },
+};

package/build/commands/generate-model/util/generateModelFile.d.ts

@@ -0,0 +1,3 @@
+import { CommandOptions } from "#types.js";
+import { builder } from "../options.js";
+export declare const generateModelFile: (opts: Pick<CommandOptions<typeof builder>, "name" | "config" | "template" | "fields">) => Promise<string>;

package/build/commands/generate-model/util/generateModelFile.js

@@ -0,0 +1,59 @@
+import fs from "fs";
+import jscodeshift from "jscodeshift";
+import { prettify } from "#util/prettify.js";
+export const generateModelFile = async (opts) => {
+    const config = fs.readFileSync(opts.config, "utf-8");
+    const j = jscodeshift.withParser("ts");
+    const root = j(config);
+    const templateContent = root
+        .find(j.ExportDefaultDeclaration)
+        .find(j.ObjectExpression)
+        .find(j.ObjectProperty, { key: { name: "templates" } })
+        .find(j.ObjectExpression)
+        .find(j.ObjectProperty, { key: { name: opts.template } })
+        .find(j.ObjectExpression);
+    if (templateContent.length === 0) {
+        if (opts.template !== "default") {
+            console.warn(`Template "${opts.template}" not found.`);
+        }
+    }
+    const templateAst = templateContent.length === 0
+        ? j("{ fields: {} }")
+        : j(templateContent.get().node);
+    const fieldsObj = templateAst
+        .find(j.ObjectProperty, {
+        key: { name: "fields" },
+    })
+        .find(j.ObjectExpression);
+    for (const field of opts.fields) {
+        const [name, type] = field.split(":");
+        if (!name || !type) {
+            console.error("Invalid field definition:", field);
+            process.exit(1);
+        }
+        const existingProperties = fieldsObj.get().node.properties ?? [];
+        const filteredProperties = existingProperties.filter((prop) => prop.type === "ObjectProperty" &&
+            prop.key.type === "Identifier" &&
+            prop.key.name !== name);
+        fieldsObj.replaceWith(j.objectExpression([
+            ...filteredProperties.map((prop) => j.objectProperty(prop.key, prop.value)),
+            j.objectProperty(j.identifier(name), j.objectExpression([
+                j.objectProperty(j.identifier("type"), j.stringLiteral(type)),
+            ])),
+        ]));
+    }
+    templateAst.find(j.EmptyStatement).remove();
+    const usesSqlLiteral = templateAst.find(j.TaggedTemplateExpression).length > 0;
+    // we avoid trailing commas and strip newlines so
+    // prettier won't break code onto multiple lines unless necessary.
+    // trailing commas will be added in again by prettier.
+    const definition = templateAst.toSource({
+        trailingComma: false,
+        lineTerminator: " ",
+    });
+    const result = `
+        import { ModelDefinition ${usesSqlLiteral ? ", sql" : ""} } from "@casekit/orm2";
+
+        export const ${opts.name} = ${definition} as const satisfies ModelDefinition;`;
+    return await prettify(process.cwd(), result);
+};

package/build/commands/generate-model/util/generateModelFile.test.d.ts

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

package/build/commands/generate-model/util/generateModelFile.test.js

@@ -0,0 +1,67 @@
+import { vol } from "memfs";
+import { beforeAll, describe, expect, test, vi } from "vitest";
+import { unindent } from "@casekit/unindent";
+import { generateModelFile } from "./generateModelFile.js";
+describe("generateModelFile", () => {
+    beforeAll(() => {
+        vol.fromJSON({
+            "orm.config.ts": unindent `
+                import { sql } from "@casekit/orm2";
+                import { type OrmCLIConfig } from "@casekit/orm2-cli";
+
+                export default {
+                    directory: "./app/db.server",
+                    generate: {
+                        templates: {
+                            default: {
+                                fields: {
+                                    id: { type: "uuid", primaryKey: true },
+                                    createdAt: { type: "timestamp", default: sql\`now()\` },
+                                },
+                            },
+                            foo: {
+                                fields: {
+                                    name: { type: "text" },
+                                },
+                            },
+                        },
+                    },
+                } satisfies OrmCLIConfig;
+            `,
+        }, "/project");
+    });
+    test("merges fields from the passed `fields` argument, overwriting same-named fields in the template", async () => {
+        const result = await generateModelFile({
+            config: "orm.config.ts",
+            name: "bar",
+            template: "default",
+            fields: ["id:serial", "name:text"],
+        });
+        expect(result.trim()).toBe(unindent `
+            import { ModelDefinition, sql } from "@casekit/orm2";
+
+            export const bar = {
+                fields: {
+                    createdAt: { type: "timestamp", default: sql\`now()\` },
+                    id: { type: "serial" },
+                    name: { type: "text" },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+    });
+    test("works if the template does not exist - but logs a warning", async () => {
+        const warnSpy = vi.spyOn(console, "warn").mockReturnValue();
+        const result = await generateModelFile({
+            config: "orm.config.ts",
+            name: "foo",
+            template: "wrong",
+            fields: [],
+        });
+        expect(warnSpy).toHaveBeenCalledWith(`Template "wrong" not found.`);
+        expect(result.trim()).toBe(unindent `
+            import { ModelDefinition } from "@casekit/orm2";
+
+            export const foo = { fields: {} } as const satisfies ModelDefinition;
+        `);
+    });
+});

package/build/commands/generate-model/util/regenerateModelsFile.d.ts

@@ -0,0 +1,2 @@
+import { OrmCLIConfig } from "#types.js";
+export declare const regenerateModelsFile: (config: OrmCLIConfig, name: string) => Promise<void>;

package/build/commands/generate-model/util/regenerateModelsFile.js

@@ -0,0 +1,50 @@
+import fs from "fs";
+import jscodeshift from "jscodeshift";
+import path from "path";
+import { prettify } from "#util/prettify.js";
+export const regenerateModelsFile = async (config, name) => {
+    console.log(`- Regenerating models/index.ts file: ${config.directory}`);
+    const filename = path.join(config.directory, "models/index.ts");
+    const source = fs.readFileSync(path.join(process.cwd(), filename), "utf-8");
+    const j = jscodeshift.withParser("ts");
+    const root = j(source);
+    const modelsExport = root
+        .find(j.ExportNamedDeclaration)
+        .filter((path) => path.node.declaration?.type === "VariableDeclaration" &&
+        path.node.declaration?.declarations[0]?.type ===
+            "VariableDeclarator" &&
+        path.node.declaration?.declarations[0]?.id.type ===
+            "Identifier" &&
+        path.node.declaration?.declarations[0]?.id.name === "models" &&
+        path.node.declaration?.declarations[0]?.init?.type ===
+            "ObjectExpression" &&
+        path.node.declaration?.declarations[0]?.init?.type ===
+            "ObjectExpression")
+        .at(0);
+    if (modelsExport.size() === 0) {
+        console.log(`- No \`models\` object found in models/index.ts. Cannot inject \${name}\` export.`);
+        return;
+    }
+    const modelsObject = modelsExport.get().node.declaration.declarations[0].init;
+    // Add an import for `name` from `./name` if not already imported
+    const existingImport = root
+        .find(j.ImportDeclaration)
+        .filter((path) => path.node.source.value === `./${name}` &&
+        !!path.node.specifiers?.some((specifier) => specifier.type === "ImportSpecifier" &&
+            specifier.imported.name === name));
+    if (existingImport.size() === 0) {
+        const newImport = j.importDeclaration([j.importSpecifier(j.identifier(name))], j.literal(`./${name}`));
+        root.get().node.program.body.unshift(newImport);
+        modelsObject.properties.push(j.property.from({
+            key: j.identifier(name),
+            value: j.identifier(name),
+            shorthand: true,
+            kind: "init",
+        }));
+        console.log(`- Injected export into ${filename}`);
+    }
+    else {
+        console.log("- Model already exported from index file, skipping");
+    }
+    fs.writeFileSync(path.join(process.cwd(), filename), await prettify(path.join(process.cwd(), filename), root.toSource()));
+};

package/build/commands/generate-model.d.ts

@@ -0,0 +1,40 @@
+export declare const generateModel: {
+    command: string;
+    desc: string;
+    builder: {
+        readonly name: {
+            readonly type: "string";
+            readonly desc: "Name of the model";
+            readonly demandOption: true;
+        };
+        readonly template: {
+            readonly type: "string";
+            readonly desc: "Template to use to generate the model. Pass --template none if you have a default template defined but don't want to use it.";
+            readonly default: "default";
+        };
+        readonly fields: {
+            readonly type: "string";
+            readonly desc: "Fields to generate for the model, in the format 'name:type name:type'";
+            readonly array: true;
+            readonly default: readonly [];
+        };
+    };
+    handler: import("../types.js").Handler<{
+        readonly name: {
+            readonly type: "string";
+            readonly desc: "Name of the model";
+            readonly demandOption: true;
+        };
+        readonly template: {
+            readonly type: "string";
+            readonly desc: "Template to use to generate the model. Pass --template none if you have a default template defined but don't want to use it.";
+            readonly default: "default";
+        };
+        readonly fields: {
+            readonly type: "string";
+            readonly desc: "Fields to generate for the model, in the format 'name:type name:type'";
+            readonly array: true;
+            readonly default: readonly [];
+        };
+    }>;
+};

package/build/commands/generate-model.js

@@ -0,0 +1,8 @@
+import { handler } from "./generate-model/handler.js";
+import { builder } from "./generate-model/options.js";
+export const generateModel = {
+    command: "model",
+    desc: "Generate a skeleton model file",
+    builder,
+    handler,
+};

package/build/commands/generate-model.test.d.ts

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

package/build/commands/generate-model.test.js

@@ -0,0 +1,55 @@
+import * as prompts from "@inquirer/prompts";
+import fs from "fs";
+import { vol } from "memfs";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import yargs from "yargs";
+import { unindent } from "@casekit/unindent";
+import { globalOptions } from "#options.js";
+import { generateModel } from "./generate-model.js";
+describe("orm generate model", () => {
+    beforeEach(() => {
+        vi.spyOn(process, "cwd").mockReturnValue(".");
+    });
+    beforeEach(() => {
+        vol.fromJSON({
+            "app/db.server/models/index.ts": unindent `
+                import { user } from "./user";
+
+                export const models = {
+                    user
+                };
+            `,
+        }, "/project");
+    });
+    test("it generates a model file merging the template and provided fields", async () => {
+        vi.spyOn(prompts, "confirm").mockResolvedValue(true);
+        vi.spyOn(process, "cwd").mockReturnValue("/project");
+        await yargs()
+            .options(globalOptions)
+            .command(generateModel)
+            .parseAsync("model --name post --fields title:text content:text");
+        const modelFile = fs.readFileSync("./app/db.server/models/post.ts", "utf8");
+        expect(modelFile.trim()).toEqual(unindent `
+            import { ModelDefinition, sql } from "@casekit/orm2";
+
+            export const post = {
+                fields: {
+                    id: { type: "uuid", primaryKey: true },
+                    createdAt: { type: "timestamp", default: sql\`now()\` },
+                    title: { type: "text" },
+                    content: { type: "text" },
+                },
+            } as const satisfies ModelDefinition;
+        `);
+        const indexFile = fs.readFileSync("./app/db.server/models/index.ts", "utf8");
+        expect(indexFile.trim()).toEqual(unindent `
+                    import { post } from "./post";
+                    import { user } from "./user";
+
+                    export const models = {
+                        user,
+                        post,
+                    };
+                `);
+    });
+});

package/build/commands/init/handler.d.ts

@@ -0,0 +1,3 @@
+import { Handler } from "#types.js";
+import { builder } from "./options.js";
+export declare const handler: Handler<typeof builder>;

package/build/commands/init/handler.js

@@ -0,0 +1,20 @@
+import { input } from "@inquirer/prompts";
+import fs from "fs";
+import { createOrOverwriteFile } from "#util/createOrOverwriteFile.js";
+import { generateConfigFile } from "./util/generateConfigFile.js";
+import { generateDbFile } from "./util/generateDbFile.js";
+import { generateModelsFile } from "./util/generateModelsFile.js";
+export const handler = async (opts) => {
+    const srcDir = ["src", "app", "lib"].find(fs.existsSync) ?? "src";
+    const dir = opts.directory ??
+        (await input({
+            message: "Where do you want to keep your database configuration?",
+            default: `./${srcDir}/db.server`,
+        }));
+    const dbFile = generateDbFile();
+    await createOrOverwriteFile(`${dir}/db.ts`, dbFile, opts.force);
+    const modelsFile = generateModelsFile();
+    await createOrOverwriteFile(`${dir}/models/index.ts`, modelsFile, opts.force);
+    const configFile = generateConfigFile(dir);
+    await createOrOverwriteFile(`orm.config.ts`, configFile, opts.force);
+};

package/build/commands/init/options.d.ts

@@ -0,0 +1,12 @@
+export declare const builder: {
+    readonly force: {
+        readonly type: "boolean";
+        readonly desc: "Overwrite existing files without asking for confirmation";
+        readonly default: false;
+    };
+    readonly directory: {
+        readonly alias: "d";
+        readonly type: "string";
+        readonly desc: "Location to keep your database configuration";
+    };
+};