@casekit/orm2-cli 1.0.0 → 1.0.2

package/build/cli.js

@@ -3,6 +3,7 @@ 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))
@@ -10,6 +11,7 @@ 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 generating files", (yargs) => yargs.command(generateModel))
     .command(init)
     .help()
     .showHelpOnFail(true)

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

@@ -4,7 +4,6 @@ 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");
     }

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

@@ -4,14 +4,13 @@ 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 { prettify } from "#util/prettify.js";
+import { generateModelsFile } from "../../generators/generateModelsFile.js";
 import { renderModel } from "./util/renderModel.js";
 export const handler = async (opts) => {
     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");
         const tables = await migrate.pull(config.db, schema);
         console.log(`Found ${tables.length} tables`);

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

@@ -70,6 +70,10 @@ describe("db pull", () => {
         // Import the mocked config
         const path = "/project/orm.config.ts";
         const { default: config } = await import(path);
+        await config.db.connect();
+        process.on("exit", async function () {
+            await config.db.close();
+        });
         vi.spyOn(loadConfig, "loadConfig").mockResolvedValue(config);
     });
     afterEach(async () => {
@@ -503,6 +507,10 @@ describe("db pull", () => {
         // Import the mocked config
         const path = "/project/orm.config.ts";
         const { default: config } = await import(path);
+        await config.db.connect();
+        process.on("exit", async function () {
+            await config.db.close();
+        });
         vi.spyOn(loadConfig, "loadConfig").mockResolvedValue(config);
         // Push the kitchen sink model to the database
         await yargs()

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

@@ -3,7 +3,6 @@ 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");
     }

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,19 @@
+import { dir } from "console";
+import { camelCase } from "es-toolkit";
+import fs from "fs";
+import path from "path";
+import { generateModelFile } from "#generators/generateModelFile.js";
+import { generateModelsFile } from "#generators/generateModelsFile.js";
+import { createOrOverwriteFile } from "#util/createOrOverwriteFile.js";
+import { loadConfig } from "#util/loadConfig.js";
+import { prettify } from "#util/prettify.js";
+export const handler = async (opts) => {
+    const config = await loadConfig(opts);
+    const modelFile = await generateModelFile(opts, config);
+    await createOrOverwriteFile(`${config.directory}/models/${opts.name}.ts`, modelFile, opts.force);
+    const models = fs
+        .readdirSync(`${config.directory}/models`)
+        .filter((f) => f !== "index.ts")
+        .map((f) => camelCase(f.replace(/\.ts$/, "")));
+    await createOrOverwriteFile(`${config.directory}/models/index.ts`, await prettify(path.join(process.cwd(), `${dir}/models/index.ts`), generateModelsFile(models)), opts.force);
+};

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.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.js

@@ -0,0 +1,63 @@
+import * as prompts from "@inquirer/prompts";
+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(".");
+        vol.fromJSON({
+            "app/db.server/models/index.ts": unindent `
+                    import { user } from "./user";
+
+                    export const models = {
+                      user
+                    };
+                `,
+            "app/db.server/models/user.ts": unindent `
+                    import { ModelDefinition, sql } from "@casekit/orm2";
+
+                    export const user = {
+                        fields: {
+                            id: { type: "uuid", primaryKey: true },
+                            createdAt: { type: "timestamp", default: sql\`now()\` },
+                            name: { type: "text" },
+                        },
+                    } as const satisfies ModelDefinition;
+                `,
+        }, "/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 = vol.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 = vol.readFileSync("./app/db.server/models/index.ts", "utf8");
+        expect(indexFile.trim()).toEqual(unindent `
+            import { post } from "./post";
+            import { user } from "./user";
+
+            export const models = {
+                post,
+                user,
+            };
+        `);
+    });
+});

package/build/commands/init/handler.js

@@ -1,12 +1,11 @@
 import { input } from "@inquirer/prompts";
 import fs from "fs";
 import path from "path";
-import { unindent } from "@casekit/unindent";
+import { generateConfigFile } from "#generators/generateConfigFile.js";
+import { generateDbFile } from "#generators/generateDbFile.js";
+import { generateModelsFile } from "#generators/generateModelsFile.js";
 import { createOrOverwriteFile } from "#util/createOrOverwriteFile.js";
-import { prettify } from "../../util/prettify.js";
-import { generateConfigFile } from "./util/generateConfigFile.js";
-import { generateDbFile } from "./util/generateDbFile.js";
-import { generateModelsFile } from "./util/generateModelsFile.js";
+import { prettify } from "#util/prettify.js";
 export const handler = async (opts) => {
     const srcDir = ["src", "app", "lib"].find(fs.existsSync) ?? "src";
     const dir = opts.directory ??
@@ -16,16 +15,6 @@ export const handler = async (opts) => {
         }));
     const dbFile = generateDbFile();
     await createOrOverwriteFile(`${dir}/index.ts`, dbFile, opts.force);
-    await createOrOverwriteFile(`${dir}/config.ts`, unindent `
-            import { type Config } from "@casekit/orm2";
-            import { models } from "./models";
-
-            export const config = {
-                models,
-                schema: "public",
-                connection: { connectionString: process.env.DATABASE_URL },
-            } as const satisfies Config;
-        `, opts.force);
     const modelsFile = generateModelsFile([]);
     await createOrOverwriteFile(`${dir}/models/index.ts`, await prettify(path.join(process.cwd(), `${dir}/models/index.ts`), modelsFile), opts.force);
     const configFile = generateConfigFile(dir);

package/build/commands/init.test.js

@@ -5,14 +5,7 @@ import yargs from "yargs";
 import { unindent } from "@casekit/unindent";
 import { init } from "./init.js";
 describe("init", () => {
-    test("creating config files for a react-router app", async () => {
-        vol.fromJSON({
-            "package.json": JSON.stringify({
-                dependencies: {
-                    "react-router": "^6.0.0",
-                },
-            }),
-        }, "/project");
+    test("scaffolding config files", async () => {
         vi.spyOn(prompts, "input").mockResolvedValueOnce("./app/db.server");
         vi.spyOn(prompts, "confirm").mockResolvedValueOnce(true);
         await yargs().command(init).parseAsync("init");
@@ -21,32 +14,36 @@ describe("init", () => {
         const configFile = vol.readFileSync("./orm.config.ts", "utf-8");
         expect(dbFile).toEqual(unindent `
             import { type Config, type ModelType, type Orm, orm } from "@casekit/orm2";
+            import { models } from "./models";
 
-            import { type Models, config } from "./config";
+            const config = {
+                models,
+            } as const satisfies Config;
 
             let db: Orm<typeof config>;
 
             declare global {
-                // eslint-disable-next-line no-var
-                var __db: Orm<typeof config>;
+            	// eslint-disable-next-line no-var
+            	var __db: Orm<typeof config>;
             }
 
             // we do this because in development we don't want to restart
             // the server with every change, but we want to make sure we don't
             // create a new connection to the DB with every change either.
             if (process.env.NODE_ENV === "production") {
-                db = orm(config);
-                await db.connect();
+            	db = orm(config);
+            	await db.connect();
             } else {
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                if (!global.__db) {
-                    global.__db = orm(config);
-                    await global.__db.connect();
-                }
-                db = global.__db;
+            	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            	if (!global.__db) {
+            		global.__db = orm(config);
+            		await global.__db.connect();
+            	}
+            	db = global.__db;
             }
 
             export type DB = Orm<typeof config>;
+            export type Models = typeof models;
             export type Model<M extends keyof Models> = ModelType<Models[M]>;
 
             export { db };
@@ -55,9 +52,14 @@ describe("init", () => {
             export const models = {};
         `);
         expect(configFile).toEqual(unindent `
+            import { type Config, orm } from "@casekit/orm2";
             import type { OrmCLIConfig } from "@casekit/orm2-cli";
 
-            import { config } from "./app/db.server/config";
+            import { models } from "./app/db.server/models";
+
+            const config = {
+                models,
+            } as const satisfies Config;
 
             export default {
                 db: orm(config),
@@ -83,13 +85,36 @@ describe("init", () => {
         const configFile = vol.readFileSync("./orm.config.ts", "utf-8");
         expect(dbFile).toEqual(unindent `
             import { type Config, type ModelType, type Orm, orm } from "@casekit/orm2";
+            import { models } from "./models";
+
+            const config = {
+                models,
+            } as const satisfies Config;
 
-            import { type Models, config } from "./config";
+            let db: Orm<typeof config>;
+
+            declare global {
+            	// eslint-disable-next-line no-var
+            	var __db: Orm<typeof config>;
+            }
 
-            const db: Orm<typeof config> = orm(config);
-            await db.connect();
+            // we do this because in development we don't want to restart
+            // the server with every change, but we want to make sure we don't
+            // create a new connection to the DB with every change either.
+            if (process.env.NODE_ENV === "production") {
+            	db = orm(config);
+            	await db.connect();
+            } else {
+            	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            	if (!global.__db) {
+            		global.__db = orm(config);
+            		await global.__db.connect();
+            	}
+            	db = global.__db;
+            }
 
             export type DB = Orm<typeof config>;
+            export type Models = typeof models;
             export type Model<M extends keyof Models> = ModelType<Models[M]>;
 
             export { db };

package/build/{commands/init/util → generators}/generateConfigFile.js

@@ -1,8 +1,13 @@
 import { unindent } from "@casekit/unindent";
 export const generateConfigFile = (directory) => unindent `
+    import { type Config, orm } from "@casekit/orm2";
     import type { OrmCLIConfig } from "@casekit/orm2-cli";
 
-    import { config } from "./${directory.replace(/^\.\//, "")}/config";
+    import { models } from "./${directory.replace(/^\.\//, "")}/models";
+
+    const config = {
+        models,
+    } as const satisfies Config;
 
     export default {
         db: orm(config),

package/build/generators/generateDbFile.js

@@ -0,0 +1,37 @@
+import { unindent } from "@casekit/unindent";
+export const generateDbFile = () => unindent `
+    import { type Config, type ModelType, type Orm, orm } from "@casekit/orm2";
+    import { models } from "./models";
+
+    const config = {
+        models,
+    } as const satisfies Config;
+
+    let db: Orm<typeof config>;
+
+    declare global {
+    	// eslint-disable-next-line no-var
+    	var __db: Orm<typeof config>;
+    }
+
+    // we do this because in development we don't want to restart
+    // the server with every change, but we want to make sure we don't
+    // create a new connection to the DB with every change either.
+    if (process.env.NODE_ENV === "production") {
+    	db = orm(config);
+    	await db.connect();
+    } else {
+    	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    	if (!global.__db) {
+    		global.__db = orm(config);
+    		await global.__db.connect();
+    	}
+    	db = global.__db;
+    }
+
+    export type DB = Orm<typeof config>;
+    export type Models = typeof models;
+    export type Model<M extends keyof Models> = ModelType<Models[M]>;
+
+    export { db };
+`;

package/build/generators/generateModelFile.d.ts

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

package/build/generators/generateModelFile.js

@@ -0,0 +1,105 @@
+import { camelCase } from "es-toolkit";
+import jscodeshift from "jscodeshift";
+import fs from "node:fs";
+import path from "node:path";
+import { prettify } from "#util/prettify.js";
+export const generateModelFile = async (opts, { directory }) => {
+    const config = fs.readFileSync(opts.config, "utf-8");
+    const j = jscodeshift.withParser("ts");
+    const root = j(config);
+    // Find the template in the config
+    const templatePath = root
+        .find(j.ExportDefaultDeclaration)
+        .find(j.ObjectExpression)
+        .find(j.ObjectProperty, {
+        key: { type: "Identifier", name: "generate" },
+    })
+        .find(j.ObjectProperty, {
+        key: { type: "Identifier", name: "templates" },
+    })
+        .find(j.ObjectProperty, {
+        key: { type: "Identifier", name: opts.template },
+    });
+    let modelDefinition;
+    if (templatePath.length > 0) {
+        // Get the template node directly
+        modelDefinition = templatePath.find(j.ObjectExpression).get().node;
+    }
+    else {
+        console.warn(`Template "${opts.template}" not found.`);
+        // Create a minimal model definition with just fields
+        modelDefinition = j.objectExpression([
+            j.objectProperty(j.identifier("fields"), j.objectExpression([])),
+        ]);
+    }
+    // Find or create the fields property
+    let fieldsProperty = modelDefinition.properties.find((prop) => prop.type === "ObjectProperty" &&
+        prop.key.type === "Identifier" &&
+        prop.key.name === "fields");
+    if (!fieldsProperty) {
+        fieldsProperty = j.objectProperty(j.identifier("fields"), j.objectExpression([]));
+        modelDefinition.properties.push(fieldsProperty);
+    }
+    const fieldsObject = fieldsProperty.value;
+    // Collect existing fields from template by converting them to source code
+    const templateFieldsCode = new Map();
+    for (const prop of fieldsObject.properties) {
+        if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
+            // Extract the field code by converting the property to source
+            const fieldCode = j(prop.value).toSource({ quote: "double" });
+            templateFieldsCode.set(prop.key.name, fieldCode);
+        }
+    }
+    // Process command-line fields - they override template fields but should be added at the end
+    const newFields = new Map();
+    for (const field of opts.fields) {
+        const [originalName, type] = field.split(":");
+        if (!originalName || !type) {
+            console.error("Invalid field definition:", field);
+            process.exit(1);
+        }
+        const camelCasedName = camelCase(originalName);
+        // Build a code string for the new field
+        let fieldCode = `{ type: "${type}" }`;
+        if (camelCasedName !== originalName) {
+            fieldCode = `{ column: "${originalName}", type: "${type}" }`;
+        }
+        // Remove from template if it exists, add to new fields
+        templateFieldsCode.delete(camelCasedName);
+        newFields.set(camelCasedName, fieldCode);
+    }
+    // Merge: template fields first (excluding overridden ones), then new fields
+    const allFieldsCode = new Map([...templateFieldsCode, ...newFields]);
+    // Rebuild the fields object with all properties
+    const newFieldsProps = [];
+    for (const [name, code] of allFieldsCode.entries()) {
+        // Parse the field code back into an AST node
+        const parsed = j(`const x = ${code}`);
+        const value = parsed.find(j.VariableDeclarator).get("init")
+            .node;
+        newFieldsProps.push(j.objectProperty(j.identifier(name), value));
+    }
+    fieldsObject.properties = newFieldsProps;
+    // Check if sql import is needed by traversing the AST
+    const hasSqlLiteral = j(modelDefinition).find(j.TaggedTemplateExpression, {
+        tag: { type: "Identifier", name: "sql" },
+    }).length > 0;
+    // Build the import statement
+    const importSpecifiers = [
+        j.importSpecifier(j.identifier("ModelDefinition")),
+    ];
+    if (hasSqlLiteral) {
+        importSpecifiers.push(j.importSpecifier(j.identifier("sql")));
+    }
+    const importDeclaration = j.importDeclaration(importSpecifiers, j.literal("@casekit/orm2"));
+    // Build the export statement with type assertion
+    const exportDeclaration = j.exportNamedDeclaration(j.variableDeclaration("const", [
+        j.variableDeclarator(j.identifier(opts.name), j.tsSatisfiesExpression(j.tsAsExpression(modelDefinition, j.tsTypeReference(j.identifier("const"))), j.tsTypeReference(j.identifier("ModelDefinition")))),
+    ]));
+    const program = j.program([importDeclaration, exportDeclaration]);
+    const result = j(program).toSource({
+        quote: "double",
+        objectCurlySpacing: false,
+    });
+    return await prettify(path.join(process.cwd(), directory), result);
+};

package/build/generators/generateModelFile.test.d.ts

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

package/build/generators/generateModelFile.test.js

@@ -0,0 +1,69 @@
+import { vol } from "memfs";
+import { beforeAll, describe, expect, test } 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"],
+        }, { directory: "./app/db.server" });
+        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", async () => {
+        const result = await generateModelFile({
+            config: "orm.config.ts",
+            name: "foo",
+            template: "wrong",
+            fields: [],
+        }, {
+            directory: "./app/db.server",
+        });
+        expect(result.trim()).toBe(unindent `
+            import { ModelDefinition } from "@casekit/orm2";
+
+            export const foo = {
+                fields: {},
+            } as const satisfies ModelDefinition;
+        `);
+    });
+});

package/build/test/setup.js

@@ -19,6 +19,10 @@ afterAll(async () => {
 beforeEach(async () => {
     const path = "./orm.config.ts";
     const { default: config } = await import(path);
+    await config.db.connect();
+    process.on("exit", async function () {
+        await config.db.close();
+    });
     vi.spyOn(loadConfig, "loadConfig").mockResolvedValue(config);
     const originalFs = await vi.importActual("fs");
     const ormConfig = originalFs.readFileSync("./src/test/orm.config.ts", "utf8");

package/build/util/loadConfig.js

@@ -1,11 +1,14 @@
+import dotenv from "dotenv";
 import path from "path";
 import { register } from "tsx/esm/api";
 export const loadConfig = async (options) => {
     try {
+        dotenv.config();
         const unregister = register();
         const { default: config } = await import(path.join(process.cwd(), options.config));
         await unregister();
         const c = "default" in config ? config.default : config;
+        await c.db.connect();
         process.on("exit", async function () {
             await c.db.close();
         });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@casekit/orm2-cli",
   "description": "",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "author": "",
   "bin": {
     "orm": "./build/cli.js"
@@ -17,10 +17,10 @@
     "pluralize": "^8.0.0",
     "tsx": "^4.20.3",
     "yargs": "^18.0.0",
-    "@casekit/orm2": "1.0.0",
-    "@casekit/orm2-migrate": "1.0.0",
-    "@casekit/sql": "1.0.0",
-    "@casekit/toolbox": "1.0.0"
+    "@casekit/orm2": "1.0.2",
+    "@casekit/sql": "1.0.2",
+    "@casekit/toolbox": "1.0.2",
+    "@casekit/orm2-migrate": "1.0.2"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
@@ -39,9 +39,9 @@
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
     "zod": "^4.0.17",
-    "@casekit/tsconfig": "1.0.0",
-    "@casekit/orm2-fixtures": "1.0.0",
-    "@casekit/prettier-config": "1.0.0"
+    "@casekit/orm2-fixtures": "1.0.2",
+    "@casekit/tsconfig": "1.0.2",
+    "@casekit/prettier-config": "1.0.2"
   },
   "exports": {
     ".": "./build/index.js"

package/build/commands/init/util/generateDbFile.js

@@ -1,50 +0,0 @@
-import { unindent } from "@casekit/unindent";
-import { usesDevServer } from "#util/usesDevServer.js";
-export const generateDbFile = () => {
-    return usesDevServer()
-        ? unindent `
-            import { type Config, type ModelType, type Orm, orm } from "@casekit/orm2";
-
-            import { type Models, config } from "./config";
-
-            let db: Orm<typeof config>;
-
-            declare global {
-                // eslint-disable-next-line no-var
-                var __db: Orm<typeof config>;
-            }
-
-            // we do this because in development we don't want to restart
-            // the server with every change, but we want to make sure we don't
-            // create a new connection to the DB with every change either.
-            if (process.env.NODE_ENV === "production") {
-                db = orm(config);
-                await db.connect();
-            } else {
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                if (!global.__db) {
-                    global.__db = orm(config);
-                    await global.__db.connect();
-                }
-                db = global.__db;
-            }
-
-            export type DB = Orm<typeof config>;
-            export type Model<M extends keyof Models> = ModelType<Models[M]>;
-
-            export { db };
-        `
-        : unindent `
-            import { type Config, type ModelType, type Orm, orm } from "@casekit/orm2";
-
-            import { type Models, config } from "./config";
-
-            const db: Orm<typeof config> = orm(config);
-            await db.connect();
-
-            export type DB = Orm<typeof config>;
-            export type Model<M extends keyof Models> = ModelType<Models[M]>;
-
-            export { db };
-        `;
-};

package/build/util/usesDevServer.d.ts

@@ -1 +0,0 @@
-export declare const usesDevServer: () => boolean;

package/build/util/usesDevServer.js

@@ -1,10 +0,0 @@
-import fs from "fs";
-export const usesDevServer = () => {
-    try {
-        const manifest = JSON.parse(fs.readFileSync("./package.json", "utf-8"));
-        return !!Object.keys(manifest.dependencies).find((dep) => /(^react-router$|^@remix-run|^next$)/.test(dep));
-    }
-    catch {
-        return false;
-    }
-};

package/build/util/usesDevServer.test.js

@@ -1,54 +0,0 @@
-import { vol } from "memfs";
-import { describe, expect, test } from "vitest";
-import { usesDevServer } from "./usesDevServer.js";
-describe("usesDevServer", () => {
-    test("returns true when package.json has react-router dependency", () => {
-        vol.fromJSON({
-            "package.json": JSON.stringify({
-                dependencies: {
-                    "react-router": "^6.0.0",
-                },
-            }),
-        }, "/project");
-        expect(usesDevServer()).toBe(true);
-    });
-    test("returns true when package.json has @remix-run dependency", () => {
-        vol.fromJSON({
-            "package.json": JSON.stringify({
-                dependencies: {
-                    "@remix-run/react": "^1.0.0",
-                },
-            }),
-        }, "/project");
-        expect(usesDevServer()).toBe(true);
-    });
-    test("returns true when package.json has next.js dependency", () => {
-        vol.fromJSON({
-            "package.json": JSON.stringify({
-                dependencies: {
-                    next: "^12.0.0",
-                },
-            }),
-        }, "/project");
-        expect(usesDevServer()).toBe(true);
-    });
-    test("returns false when package.json has no next, remix, or react-router dependencies", () => {
-        vol.fromJSON({
-            "package.json": JSON.stringify({
-                dependencies: {
-                    lodash: "^4.0.0",
-                },
-            }),
-        }, "/project");
-        expect(usesDevServer()).toBe(false);
-    });
-    test("returns false when package.json is missing", () => {
-        expect(usesDevServer()).toBe(false);
-    });
-    test("returns false when package.json is invalid JSON", () => {
-        vol.fromJSON({
-            "package.json": "invalid json",
-        }, "/project");
-        expect(usesDevServer()).toBe(false);
-    });
-});