@casekit/orm2-cli 1.0.6 → 1.0.7

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

@@ -1,4 +1,3 @@
-import { dir } from "console";
 import { camelCase } from "es-toolkit";
 import fs from "fs";
 import path from "path";
@@ -9,11 +8,11 @@ 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);
+    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(), `${dir}/models/index.ts`), generateModelsFile(models)), opts.force);
+    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

@@ -4,15 +4,4 @@ export declare const builder: {
         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

@@ -4,15 +4,4 @@ export const builder = {
         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

@@ -7,17 +7,6 @@ export declare const generateModel: {
             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: {
@@ -25,16 +14,5 @@ export declare const generateModel: {
             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.test.js

@@ -29,24 +29,19 @@ describe("orm generate model", () => {
                 `,
         }, "/project");
     });
-    test("it generates a model file merging the template and provided fields", async () => {
+    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 --fields title:text content:text");
+            .parseAsync("model --name post");
         const modelFile = vol.readFileSync("./app/db.server/models/post.ts", "utf8");
         expect(modelFile.trim()).toEqual(unindent `
-            import { type ModelDefinition, sql } from "@casekit/orm2";
+            import type { ModelDefinition } from "@casekit/orm2";
 
             export const post = {
-                fields: {
-                    id: { type: "uuid", primaryKey: true },
-                    createdAt: { type: "timestamp", default: sql\`now()\` },
-                    title: { type: "text" },
-                    content: { type: "text" },
-                },
+                fields: {},
             } as const satisfies ModelDefinition;
         `);
         const indexFile = vol.readFileSync("./app/db.server/models/index.ts", "utf8");

package/build/generators/generateModelFile.d.ts

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

package/build/generators/generateModelFile.js

@@ -1,112 +1,11 @@
-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 by parsing the import code string
-    // to ensure proper TypeScript type-only import syntax
-    let importCode;
-    if (hasSqlLiteral) {
-        // import { type ModelDefinition, sql }
-        importCode =
-            'import { type ModelDefinition, sql } from "@casekit/orm2";';
-    }
-    else {
-        // import type { ModelDefinition }
-        importCode = 'import type { ModelDefinition } from "@casekit/orm2";';
-    }
-    const importDeclaration = j(importCode)
-        .find(j.ImportDeclaration)
-        .get().node;
-    // 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);
+export const generateModelFile = async (name, directory) => {
+    const code = `import type { ModelDefinition } from "@casekit/orm2";
+
+export const ${name} = {
+    fields: {},
+} as const satisfies ModelDefinition;
+`;
+    return await prettify(path.join(process.cwd(), directory), code);
 };

package/build/generators/generateModelFile.test.js

@@ -4,64 +4,14 @@ 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 { type 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;
-        `);
+        vol.fromJSON({}, "/project");
     });
-    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",
-        });
+    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/orm2";
 
-            export const foo = {
+            export const book = {
                 fields: {},
             } as const satisfies ModelDefinition;
         `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@casekit/orm2-cli",
   "description": "",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "author": "",
   "bin": {
     "orm": "./build/cli.js"
@@ -14,19 +14,17 @@
     "camelcase": "^8.0.0",
     "dotenv": "^16.5.0",
     "es-toolkit": "^1.39.3",
-    "jscodeshift": "^17.3.0",
     "pluralize": "^8.0.0",
     "tsx": "^4.20.3",
     "yargs": "^18.0.0",
-    "@casekit/orm2": "1.0.6",
-    "@casekit/sql": "1.0.6",
-    "@casekit/toolbox": "1.0.6",
-    "@casekit/orm2-migrate": "1.0.6"
+    "@casekit/orm2-migrate": "1.0.7",
+    "@casekit/sql": "1.0.7",
+    "@casekit/orm2": "1.0.7",
+    "@casekit/toolbox": "1.0.7"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
     "@types/byline": "^4.2.36",
-    "@types/jscodeshift": "^17.3.0",
     "@types/node": "^24.0.3",
     "@types/pg": "^8.15.4",
     "@types/pluralize": "^0.0.33",
@@ -39,9 +37,9 @@
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
     "zod": "^4.0.17",
-    "@casekit/prettier-config": "1.0.6",
-    "@casekit/orm2-fixtures": "1.0.6",
-    "@casekit/tsconfig": "1.0.6"
+    "@casekit/orm2-fixtures": "1.0.7",
+    "@casekit/tsconfig": "1.0.7",
+    "@casekit/prettier-config": "1.0.7"
   },
   "exports": {
     ".": "./build/index.js"