@casekit/orm-cli 0.0.1-release-candidate

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,18 @@
+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.name, config.directory);
+    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(), `${config.directory}/models/index.ts`), generateModelsFile(models)), opts.force);
+};

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

@@ -0,0 +1,7 @@
+export declare const builder: {
+    readonly name: {
+        readonly type: "string";
+        readonly desc: "Name of the model";
+        readonly demandOption: true;
+    };
+};

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

@@ -0,0 +1,7 @@
+export const builder = {
+    name: {
+        type: "string",
+        desc: "Name of the model",
+        demandOption: true,
+    },
+};

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

@@ -0,0 +1,18 @@
+export declare const generateModel: {
+    command: string;
+    desc: string;
+    builder: {
+        readonly name: {
+            readonly type: "string";
+            readonly desc: "Name of the model";
+            readonly demandOption: true;
+        };
+    };
+    handler: import("../types.js").Handler<{
+        readonly name: {
+            readonly type: "string";
+            readonly desc: "Name of the model";
+            readonly demandOption: true;
+        };
+    }>;
+};

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,58 @@
+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 { type ModelDefinition, sql } from "@casekit/orm";
+
+                    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 and updates the index", async () => {
+        vi.spyOn(prompts, "confirm").mockResolvedValue(true);
+        vi.spyOn(process, "cwd").mockReturnValue("/project");
+        await yargs()
+            .options(globalOptions)
+            .command(generateModel)
+            .parseAsync("model --name post");
+        const modelFile = vol.readFileSync("./app/db.server/models/post.ts", "utf8");
+        expect(modelFile.trim()).toEqual(unindent `
+            import type { ModelDefinition } from "@casekit/orm";
+
+            export const post = {
+                fields: {},
+            } 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.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,22 @@
+import { input } from "@inquirer/prompts";
+import fs from "fs";
+import path from "path";
+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";
+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}/index.ts`, dbFile, 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);
+    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";
+    };
+};

package/build/commands/init/options.js

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

package/build/commands/init.d.ts

@@ -0,0 +1,28 @@
+export declare const init: {
+    command: string;
+    desc: string;
+    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";
+        };
+    };
+    handler: import("../types.js").Handler<{
+        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";
+        };
+    }>;
+};

package/build/commands/init.js

@@ -0,0 +1,8 @@
+import { handler } from "./init/handler.js";
+import { builder } from "./init/options.js";
+export const init = {
+    command: "init",
+    desc: "Configure your project for use with @casekit/orm",
+    builder,
+    handler,
+};

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

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

package/build/commands/init.test.js

@@ -0,0 +1,125 @@
+import * as prompts from "@inquirer/prompts";
+import { vol } from "memfs";
+import { describe, expect, test, vi } from "vitest";
+import yargs from "yargs";
+import { unindent } from "@casekit/unindent";
+import { init } from "./init.js";
+describe("init", () => {
+    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");
+        const dbFile = vol.readFileSync("./app/db.server/index.ts", "utf-8");
+        const modelFile = vol.readFileSync("./app/db.server/models/index.ts", "utf-8");
+        const configFile = vol.readFileSync("./orm.config.ts", "utf-8");
+        expect(dbFile).toEqual(unindent `
+            import { type Config, type ModelType, type Orm, orm } from "@casekit/orm";
+            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 };
+        `);
+        expect(modelFile.trim()).toEqual(unindent `
+            export const models = {};
+        `);
+        expect(configFile).toEqual(unindent `
+            import { type Config, orm } from "@casekit/orm";
+            import type { OrmCLIConfig } from "@casekit/orm-cli";
+
+            import { models } from "./app/db.server/models";
+
+            const config = {
+                models,
+            } as const satisfies Config;
+
+            export default {
+                db: orm(config),
+                directory: "./app/db.server",
+            } satisfies OrmCLIConfig;
+        `);
+    });
+    test("optionally overwriting existing files", async () => {
+        vol.fromJSON({
+            "package.json": JSON.stringify({ dependencies: {} }),
+            "app/db.server/models/index.ts": "original",
+            "orm.config.ts": "original",
+            "app/db.server/index.ts": "original",
+        }, "/project");
+        vi.spyOn(prompts, "input").mockResolvedValueOnce("./app/db.server");
+        vi.spyOn(prompts, "confirm")
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false)
+            .mockResolvedValueOnce(false);
+        await yargs().command(init).parseAsync("init");
+        const dbFile = vol.readFileSync("./app/db.server/index.ts", "utf-8");
+        const modelFile = vol.readFileSync("./app/db.server/models/index.ts", "utf-8");
+        const configFile = vol.readFileSync("./orm.config.ts", "utf-8");
+        expect(dbFile).toEqual(unindent `
+            import { type Config, type ModelType, type Orm, orm } from "@casekit/orm";
+            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 };
+        `);
+        expect(modelFile).toEqual("original");
+        expect(configFile).toEqual("original");
+    });
+});

package/build/generators/generateConfigFile.d.ts

@@ -0,0 +1 @@
+export declare const generateConfigFile: (directory: string) => string;

package/build/generators/generateConfigFile.js

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

package/build/generators/generateDbFile.d.ts

@@ -0,0 +1 @@
+export declare const generateDbFile: () => string;

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/orm";
+    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 @@
+export declare const generateModelFile: (name: string, directory: string) => Promise<string>;

package/build/generators/generateModelFile.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+import { prettify } from "#util/prettify.js";
+export const generateModelFile = async (name, directory) => {
+    const code = `import type { ModelDefinition } from "@casekit/orm";
+
+export const ${name} = {
+    fields: {},
+} as const satisfies ModelDefinition;
+`;
+    return await prettify(path.join(process.cwd(), directory), code);
+};

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

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

package/build/generators/generateModelFile.test.js

@@ -0,0 +1,19 @@
+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({}, "/project");
+    });
+    test("generates an empty model definition", async () => {
+        const result = await generateModelFile("book", "./app/db.server");
+        expect(result.trim()).toBe(unindent `
+            import type { ModelDefinition } from "@casekit/orm";
+
+            export const book = {
+                fields: {},
+            } as const satisfies ModelDefinition;
+        `);
+    });
+});

package/build/generators/generateModelsFile.d.ts

@@ -0,0 +1 @@
+export declare const generateModelsFile: (models: string[]) => string;

package/build/generators/generateModelsFile.js

@@ -0,0 +1,8 @@
+import { unindent } from "@casekit/unindent";
+export const generateModelsFile = (models) => unindent `
+    ${models.map((m) => `import { ${m} } from "./${m}";`).join("\n")};
+
+    export const models = {
+        ${models.map((m) => `${m},`).join("\n")}
+    }
+`;

package/build/index.d.ts

@@ -0,0 +1 @@
+export { OrmCLIConfig } from "./types.js";

package/build/index.js

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

package/build/options.d.ts

@@ -0,0 +1,12 @@
+export declare const globalOptions: {
+    readonly config: {
+        readonly type: "string";
+        readonly alias: "c";
+        readonly describe: "Path to the orm CLIs configuration file";
+        readonly default: "orm.config.ts";
+    };
+    readonly force: {
+        readonly type: "boolean";
+        readonly desc: "Skip all prompts, use defaults, and overwrite existing files without asking for confirmation";
+    };
+};

package/build/options.js

@@ -0,0 +1,12 @@
+export const globalOptions = {
+    config: {
+        type: "string",
+        alias: "c",
+        describe: "Path to the orm CLIs configuration file",
+        default: "orm.config.ts",
+    },
+    force: {
+        type: "boolean",
+        desc: "Skip all prompts, use defaults, and overwrite existing files without asking for confirmation",
+    },
+};

package/build/test/setup.d.ts

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

package/build/test/setup.js

@@ -0,0 +1,35 @@
+import { vol } from "memfs";
+import pg from "pg";
+import { register } from "tsx/esm/api";
+import { afterAll, afterEach, beforeAll, beforeEach, vi } from "vitest";
+import * as loadConfig from "#util/loadConfig.js";
+vi.mock("fs");
+vi.mock("prettier");
+vi.mock("@inquirer/prompts");
+let unregister;
+beforeAll(async () => {
+    const client = new pg.Client();
+    await client.connect();
+    await client.query("DROP SCHEMA IF EXISTS orm_cli_test CASCADE");
+    unregister = register();
+});
+afterAll(async () => {
+    await unregister();
+});
+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");
+    const prettierConfig = originalFs.readFileSync("../../.prettierrc.json", "utf8");
+    vol.fromJSON({ "orm.config.ts": ormConfig, ".prettierrc.json": prettierConfig }, "/project");
+    vi.spyOn(process, "cwd").mockReturnValue("/project");
+});
+afterEach(() => {
+    vol.reset();
+});

package/build/types.d.ts

@@ -0,0 +1,14 @@
+import { ConnectionConfig } from "pg";
+import { ArgumentsCamelCase, InferredOptionTypes, Options } from "yargs";
+import { Orm } from "@casekit/orm";
+import { globalOptions } from "#options.js";
+export interface OrmCLIConfig {
+    db: Orm;
+    directory: string;
+    migrate?: {
+        connection?: ConnectionConfig;
+    };
+}
+export type Builder = Record<string, Options>;
+export type CommandOptions<T extends Builder = Record<string, never>> = ArgumentsCamelCase<InferredOptionTypes<T & typeof globalOptions>>;
+export type Handler<T extends Builder = Record<string, never>> = (opts: ArgumentsCamelCase<InferredOptionTypes<T & typeof globalOptions>>) => void | Promise<void>;

package/build/types.js

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

package/build/util/createOrOverwriteFile.d.ts

@@ -0,0 +1 @@
+export declare const createOrOverwriteFile: (filePath: string, content: string, force?: boolean) => Promise<string | undefined>;

package/build/util/createOrOverwriteFile.js

@@ -0,0 +1,17 @@
+import { confirm } from "@inquirer/prompts";
+import fs from "fs";
+import path from "path";
+export const createOrOverwriteFile = async (filePath, content, force) => {
+    const fullPath = path.join(process.cwd(), filePath);
+    if (fs.existsSync(fullPath) && !force) {
+        const overwrite = await confirm({
+            message: `${filePath} already exists - overwrite it?`,
+            default: false,
+        });
+        if (!overwrite)
+            return;
+    }
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+    return fullPath;
+};

package/build/util/loadConfig.d.ts

@@ -0,0 +1,3 @@
+import { globalOptions } from "#options.js";
+import { CommandOptions, OrmCLIConfig } from "#types.js";
+export declare const loadConfig: (options: CommandOptions<typeof globalOptions>) => Promise<OrmCLIConfig>;

package/build/util/loadConfig.js

@@ -0,0 +1,21 @@
+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();
+        });
+        return c;
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+};

package/build/util/prettify.d.ts

@@ -0,0 +1 @@
+export declare const prettify: (path: string, content: string) => Promise<string>;

package/build/util/prettify.js

@@ -0,0 +1,8 @@
+import * as prettier from "prettier";
+export const prettify = async (path, content) => {
+    const prettierOptions = await prettier.resolveConfig(path);
+    return await prettier.format(content, {
+        ...prettierOptions,
+        parser: "typescript",
+    });
+};