@3lineas/d1-orm 1.0.3 → 1.0.5

package/dist/cli/index.mjs

@@ -34,7 +34,7 @@ async function init() {
       console.log(`Directory already exists: ${folder}`);
     }
   });
-  const userModelContent = `import { Model } from 'd1-orm';
+  const userModelContent = `import { Model } from '@3lineas/d1-orm';
 
 export class User extends Model {
     // protected static table = 'users';
@@ -54,7 +54,7 @@ export class User extends Model {
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0].replace("T", "_");
   const migrationName = `${timestamp}_create_users_table.ts`;
-  const migrationContent = `import { Blueprint, Schema } from 'd1-orm';
+  const migrationContent = `import { Blueprint, Schema } from '@3lineas/d1-orm';
 
 export const up = async () => {
     return Schema.create('users', (table: Blueprint) => {
@@ -86,8 +86,8 @@ export const down = async () => {
 
 export const seed = async () => {
     await User.create({
-        name: 'Juan Perez',
-        email: 'juan@perez.com',
+        name: 'John Doe',
+        email: 'john@example.com',
         password: 'password'
     });
 };
@@ -101,6 +101,24 @@ export const seed = async () => {
     fs.writeFileSync(seederPath, seederContent);
     console.log(`Created seeder: ${seederPath}`);
   }
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      if (!packageJson.scripts) {
+        packageJson.scripts = {};
+      }
+      if (!packageJson.scripts.orm) {
+        packageJson.scripts.orm = "d1-orm";
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log('Added "orm" script to package.json');
+      } else {
+        console.log('"orm" script already exists in package.json');
+      }
+    } catch (e) {
+      console.error("Failed to update package.json:", e);
+    }
+  }
 }
 var init_init = __esm({
   "src/cli/commands/init.ts"() {
@@ -108,66 +126,154 @@ var init_init = __esm({
   }
 });
 
-// src/cli/commands/make-model.ts
+// src/cli/commands/make-migration.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-function makeModel(name) {
-  const filename = `${name}.ts`;
-  const targetPath = path2.join(process.cwd(), "models", filename);
-  const template = `import { Model } from 'd1-orm';
+import * as p from "@clack/prompts";
+async function makeMigration(name) {
+  let migrationName = name;
+  if (!migrationName) {
+    migrationName = await p.text({
+      message: "What should the migration be named?",
+      placeholder: "e.g. create_users_table",
+      validate: (value) => {
+        if (!value) return "Please enter a name.";
+      }
+    });
+    if (p.isCancel(migrationName)) {
+      p.cancel("Operation cancelled.");
+      return;
+    }
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0].replace("T", "_");
+  const filename = `${timestamp}_${migrationName}.ts`;
+  const targetPath = path2.join(process.cwd(), "database/migrations", filename);
+  const template = `import { Blueprint, Schema } from '@3lineas/d1-orm';
 
-export class ${name} extends Model {
-    // protected static table = '${name.toLowerCase()}s'; 
-    
-    // Define attributes explicitly for type safety if desired
-    // declare id: number;
-    // declare created_at: string;
-    // declare updated_at: string;
-}
+export const up = async () => {
+    return Schema.create('${migrationName.replace("create_", "").replace("_table", "")}', (table: Blueprint) => {
+        table.id();
+        table.timestamps();
+    });
+};
+
+export const down = async () => {
+    return Schema.dropIfExists('${migrationName.replace("create_", "").replace("_table", "")}');
+};
 `;
+  if (!fs2.existsSync(path2.join(process.cwd(), "database/migrations"))) {
+    fs2.mkdirSync(path2.join(process.cwd(), "database/migrations"), {
+      recursive: true
+    });
+  }
   if (fs2.existsSync(targetPath)) {
-    console.error(`Model ${filename} already exists.`);
-    process.exit(1);
+    p.log.error(`Migration ${filename} already exists.`);
+    return;
   }
   fs2.writeFileSync(targetPath, template);
-  console.log(`Created model: models/${filename}`);
+  p.log.success(`Created migration: database/migrations/${filename}`);
 }
-var init_make_model = __esm({
-  "src/cli/commands/make-model.ts"() {
+var init_make_migration = __esm({
+  "src/cli/commands/make-migration.ts"() {
     "use strict";
   }
 });
 
-// src/cli/commands/make-migration.ts
+// src/cli/commands/make-model.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
-function makeMigration(name) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0].replace("T", "_");
-  const filename = `${timestamp}_${name}.ts`;
-  const targetPath = path3.join(process.cwd(), "database/migrations", filename);
-  const template = `import { Blueprint, Schema } from 'd1-orm';
-
-export const up = async () => {
-    return Schema.create('${name}', (table: Blueprint) => {
-        table.id();
-        table.timestamps();
+import * as p2 from "@clack/prompts";
+async function makeModel(name) {
+  let modelName = name;
+  if (!modelName) {
+    modelName = await p2.text({
+      message: "What should the model be named?",
+      placeholder: "e.g. Flight",
+      validate: (value) => {
+        if (!value) return "Please enter a name.";
+      }
     });
-};
+    if (p2.isCancel(modelName)) {
+      p2.cancel("Operation cancelled.");
+      return;
+    }
+  }
+  const modelPath = await findModelsPath() || "src/models";
+  const filename = `${modelName}.ts`;
+  const targetPath = path3.join(process.cwd(), modelPath, filename);
+  const template = `import { Model } from '@3lineas/d1-orm';
 
-export const down = async () => {
-    return Schema.dropIfExists('${name}');
+export class ${modelName} extends Model {
+    // protected static table = '${modelName.toLowerCase()}s'; 
+    
+    // declare id: number;
+    // declare created_at: string;
+    // declare updated_at: string;
+}
+`;
+  if (fs3.existsSync(targetPath)) {
+    p2.log.error(`Model ${filename} already exists at ${modelPath}.`);
+    return;
+  }
+  if (!fs3.existsSync(path3.join(process.cwd(), modelPath))) {
+    fs3.mkdirSync(path3.join(process.cwd(), modelPath), { recursive: true });
+  }
+  fs3.writeFileSync(targetPath, template);
+  p2.log.success(`Created model: ${modelPath}/${filename}`);
+  const options = await p2.multiselect({
+    message: "Would you like to create any of the following?",
+    options: [
+      { value: "migration", label: "Migration" },
+      { value: "seeder", label: "Database Seeder" }
+    ],
+    required: false
+  });
+  if (p2.isCancel(options)) {
+    p2.cancel("Operation cancelled.");
+    return;
+  }
+  if (options.includes("migration")) {
+    const migrationName = `create_${modelName.toLowerCase()}s_table`;
+    await makeMigration(migrationName);
+  }
+  if (options.includes("seeder")) {
+    await makeSeeder(modelName, modelPath);
+  }
+}
+async function findModelsPath() {
+  const packageJsonPath = path3.join(process.cwd(), "package.json");
+  if (!fs3.existsSync(packageJsonPath)) return null;
+  const commonPaths = ["src/models", "models", "app/Models"];
+  for (const p3 of commonPaths) {
+    if (fs3.existsSync(path3.join(process.cwd(), p3))) return p3;
+  }
+  return null;
+}
+async function makeSeeder(modelName, modelPath) {
+  const seederDir = path3.join(process.cwd(), "database/seeders");
+  const seederName = `${modelName}Seeder.ts`;
+  const targetPath = path3.join(seederDir, seederName);
+  if (!fs3.existsSync(seederDir)) {
+    fs3.mkdirSync(seederDir, { recursive: true });
+  }
+  const relativeModelPath = path3.relative(seederDir, path3.join(process.cwd(), modelPath, modelName)).replace(/\\/g, "/");
+  const template = `import { ${modelName} } from '${relativeModelPath}';
+
+export const seed = async () => {
+    // await ${modelName}.create({ ... });
 };
 `;
   if (fs3.existsSync(targetPath)) {
-    console.error(`Migration ${filename} already exists.`);
-    process.exit(1);
+    p2.log.warn(`Seeder ${seederName} already exists.`);
+    return;
   }
   fs3.writeFileSync(targetPath, template);
-  console.log(`Created migration: database/migrations/${filename}`);
+  p2.log.success(`Created seeder: database/seeders/${seederName}`);
 }
-var init_make_migration = __esm({
-  "src/cli/commands/make-migration.ts"() {
+var init_make_model = __esm({
+  "src/cli/commands/make-model.ts"() {
     "use strict";
+    init_make_migration();
   }
 });
 
@@ -184,23 +290,22 @@ async function migrate(args) {
   }
   const files = fs4.readdirSync(migrationsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
   for (const file of files) {
-    console.log(`Processing ${file}...`);
+    console.log(`Processing migration: ${file}`);
     const filePath = path4.join(migrationsDir, file);
     try {
       const migration = await import(filePath);
       if (migration.up) {
         const sql = await migration.up();
         if (sql) {
-          console.log(`Executing SQL: ${sql}`);
           const isRemote = args.includes("--remote");
           const dbName = "DB";
           const command = isRemote ? "--remote" : "--local";
           try {
             const execCmd = `npx wrangler d1 execute ${dbName} --command "${sql.replace(/"/g, '\\"')}" ${command}`;
-            console.log(`Running: ${execCmd}`);
+            console.log(`Executing: ${execCmd}`);
             execSync(execCmd, { stdio: "inherit" });
           } catch (e) {
-            console.error(`Failed to execute migration ${file}.`);
+            console.error(`Failed to execute migration: ${file}`);
             throw e;
           }
         }
@@ -231,17 +336,9 @@ var require_cli = __commonJS({
         init();
         break;
       case "make:model":
-        if (!param) {
-          console.error("Usage: d1-orm make:model <Name>");
-          process.exit(1);
-        }
         makeModel(param);
         break;
       case "make:migration":
-        if (!param) {
-          console.error("Usage: d1-orm make:migration <Name>");
-          process.exit(1);
-        }
         makeMigration(param);
         break;
       case "migrate":