@3lineas/d1-orm 1.0.10 → 1.0.12

package/dist/cli/index.js

@@ -134,7 +134,7 @@ import * as p3 from "@clack/prompts";
 import * as fs2 from "fs";
 import * as path2 from "path";
 import * as p2 from "@clack/prompts";
-async function makeMigration(name) {
+async function makeMigration(name, fields) {
   const isStandalone = !name;
   if (isStandalone) {
     p2.intro("Creating a new migration...");
@@ -159,17 +159,38 @@ async function makeMigration(name) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0].replace("T", "_");
   const filename = `${timestamp}_${migrationName}.mts`;
   const targetPath = path2.join(process.cwd(), migrationsDir, filename);
+  const tableName = migrationName.replace("create_", "").replace("_table", "").replace("add_", "").replace("_to_", "").replace("_table", "");
+  const isAlter = migrationName.startsWith("add_");
+  let fieldsSql = "";
+  if (fields && fields.length > 0) {
+    fieldsSql = fields.map((f) => {
+      let line = "";
+      if (f.type === "enum") {
+        line = `        table.enum('${f.name}', ${JSON.stringify(f.values)})`;
+      } else {
+        line = `        table.${f.type}('${f.name}')`;
+      }
+      if (f.unique) line += ".unique()";
+      if (f.nullable) line += ".nullable()";
+      if (f.default !== void 0 && f.default !== "") {
+        const defVal = typeof f.default === "string" ? `'${f.default}'` : f.default;
+        line += `.default(${defVal})`;
+      }
+      return line + ";";
+    }).join("\n");
+  }
+  const method = isAlter ? "table" : "create";
+  const downSql = isAlter ? `// return Schema.table('${tableName}', (table: Blueprint) => { /* drop columns not supported in simple SQLite ALTER */ });` : `return Schema.dropIfExists('${tableName}');`;
   const template = `import { Blueprint, Schema } from '@3lineas/d1-orm';
 
 export const up = async () => {
-    return Schema.create('${migrationName.replace("create_", "").replace("_table", "")}', (table: Blueprint) => {
-        table.id();
-        table.timestamps();
-    });
+    return Schema.${method}('${tableName}', (table: Blueprint) => {
+${!isAlter ? "        table.id();\n" : ""}${fieldsSql}
+${!isAlter ? "        table.timestamps();\n" : ""}    });
 };
 
 export const down = async () => {
-    return Schema.dropIfExists('${migrationName.replace("create_", "").replace("_table", "")}');
+    ${downSql}
 };
 `;
   if (!fs2.existsSync(path2.join(process.cwd(), migrationsDir))) {
@@ -209,46 +230,245 @@ async function makeModel(name) {
   const modelPath = await findModelsPath() || "src/database/models";
   const filename = `${modelName}.mts`;
   const targetPath = path3.join(process.cwd(), modelPath, filename);
+  if (fs3.existsSync(targetPath)) {
+    p3.log.error(`Model ${filename} already exists at ${modelPath}.`);
+    p3.outro("Process aborted.");
+    return;
+  }
+  const fields = [];
+  const relations = [];
+  let addMore = true;
+  p3.log.step("Let's add some attributes to your model!");
+  while (addMore) {
+    const fieldName = await p3.text({
+      message: "New attribute or relation name (leave empty to stop):",
+      placeholder: "e.g. title or posts"
+    });
+    if (p3.isCancel(fieldName)) break;
+    if (!fieldName) break;
+    const fieldType = await p3.select({
+      message: `Type for ${fieldName}:`,
+      options: [
+        { value: "string", label: "String" },
+        { value: "integer", label: "Integer" },
+        { value: "boolean", label: "Boolean" },
+        { value: "text", label: "Text" },
+        { value: "float", label: "Float" },
+        { value: "json", label: "JSON" },
+        { value: "enum", label: "Enum" },
+        { value: "date", label: "Date" },
+        { value: "blob", label: "Blob" },
+        { value: "belongsToMany", label: "ManyToMany (Pivot Table)" },
+        { value: "relation", label: "Relation (1:1, 1:N)" }
+      ]
+    });
+    if (p3.isCancel(fieldType)) break;
+    if (fieldType === "relation" || fieldType === "belongsToMany") {
+      let relType = fieldType;
+      if (fieldType === "relation") {
+        relType = await p3.select({
+          message: `Relation type for ${fieldName}:`,
+          options: [
+            { value: "hasOne", label: "HasOne" },
+            { value: "hasMany", label: "HasMany" },
+            { value: "belongsTo", label: "BelongsTo" }
+          ]
+        });
+      }
+      if (p3.isCancel(relType)) break;
+      const modelsPath = await findModelsPath() || "src/database/models";
+      const availableModels = fs3.existsSync(
+        path3.join(process.cwd(), modelsPath)
+      ) ? fs3.readdirSync(path3.join(process.cwd(), modelPath)).map((f) => f.replace(".mts", "").replace(".ts", "")) : [];
+      const targetModel = await p3.text({
+        message: "Target model for this relation:",
+        placeholder: "e.g. Post",
+        validate: (v) => !v ? "Target model is required" : void 0
+      });
+      if (p3.isCancel(targetModel)) break;
+      let foreignKey = "";
+      let pivotTable = "";
+      if (relType === "belongsToMany") {
+        p3.log.info("Automatically creating a pivot table migration.");
+        pivotTable = await p3.text({
+          message: "Pivot table name:",
+          initialValue: [modelName.toLowerCase(), targetModel.toLowerCase()].sort().join("_")
+        });
+        if (p3.isCancel(pivotTable)) break;
+      } else if (relType === "belongsTo") {
+        foreignKey = await p3.text({
+          message: "Foreign key column name:",
+          placeholder: `e.g. ${targetModel.toLowerCase()}_id`,
+          initialValue: `${targetModel.toLowerCase()}_id`
+        });
+        if (p3.isCancel(foreignKey)) break;
+        fields.push({
+          name: foreignKey,
+          type: "foreign",
+          nullable: false,
+          unique: false
+        });
+      }
+      relations.push({
+        method: fieldName,
+        type: relType,
+        model: targetModel,
+        foreignKey,
+        pivotTable
+      });
+      const addInverse = await p3.confirm({
+        message: `Add the inverse relation in ${targetModel}.mts?`,
+        initialValue: true
+      });
+      if (addInverse && !p3.isCancel(addInverse)) {
+        let inverseType = "belongsTo";
+        if (relType === "belongsTo") inverseType = "hasMany";
+        if (relType === "hasOne") inverseType = "belongsTo";
+        if (relType === "belongsToMany") inverseType = "belongsToMany";
+        const inverseMethod = await p3.text({
+          message: "Inverse method name:",
+          initialValue: relType === "belongsTo" ? modelName.toLowerCase() + "s" : modelName.toLowerCase()
+        });
+        if (!p3.isCancel(inverseMethod)) {
+          await updateTargetModel(
+            targetModel,
+            inverseMethod,
+            inverseType,
+            modelName,
+            pivotTable
+          );
+        }
+      }
+    } else {
+      let enumValues = [];
+      if (fieldType === "enum") {
+        const valuesStr = await p3.text({
+          message: "Allowed values (comma separated):",
+          placeholder: "active, inactive, pending"
+        });
+        if (p3.isCancel(valuesStr)) break;
+        enumValues = valuesStr.split(",").map((v) => v.trim());
+      }
+      const isNullable = await p3.confirm({
+        message: "Is it nullable?",
+        initialValue: false
+      });
+      if (p3.isCancel(isNullable)) break;
+      const isUnique = await p3.confirm({
+        message: "Is it unique?",
+        initialValue: false
+      });
+      if (p3.isCancel(isUnique)) break;
+      fields.push({
+        name: fieldName,
+        type: fieldType,
+        nullable: isNullable,
+        unique: isUnique,
+        values: enumValues
+      });
+    }
+  }
+  const fieldProperties = fields.filter(
+    (f) => f.type !== "foreign" || !relations.some((r) => r.foreignKey === f.name)
+  ).map((f) => {
+    let tsType = "string";
+    if (f.type === "integer" || f.type === "float") tsType = "number";
+    else if (f.type === "boolean") tsType = "boolean";
+    else if (f.type === "json") tsType = "any";
+    else if (f.type === "blob") tsType = "Uint8Array";
+    return `    declare ${f.name}${f.nullable ? "?" : ""}: ${tsType};`;
+  }).join("\n");
+  const relationMethods = relations.map((r) => {
+    if (r.type === "belongsToMany") {
+      return `    ${r.method}() {
+        return this.belongsToMany(${r.model}, '${r.pivotTable}');
+    }`;
+    }
+    return `    ${r.method}() {
+        return this.${r.type}(${r.model});
+    }`;
+  }).join("\n\n");
   const template = `import { Model } from '@3lineas/d1-orm';
+${relations.map((r) => `import { ${r.model} } from './${r.model}.mts';`).join("\n")}
 
 export class ${modelName} extends Model {
     // protected static table = '${modelName.toLowerCase()}s'; 
     
-    // declare id: number;
-    // declare created_at: string;
-    // declare updated_at: string;
+    declare id: number;
+${fieldProperties}
+    declare created_at: string;
+    declare updated_at: string;
+
+${relationMethods}
 }
 `;
-  if (fs3.existsSync(targetPath)) {
-    p3.log.error(`Model ${filename} already exists at ${modelPath}.`);
-    p3.outro("Process aborted.");
-    return;
-  }
   if (!fs3.existsSync(path3.join(process.cwd(), modelPath))) {
     fs3.mkdirSync(path3.join(process.cwd(), modelPath), { recursive: true });
   }
   fs3.writeFileSync(targetPath, template);
   p3.log.success(`Created model: ${modelPath}/${filename}`);
-  const options = await p3.multiselect({
-    message: "Would you like to create any of the following?",
-    options: [
-      { value: "migration", label: "Migration" },
-      { value: "seeder", label: "Database Seeder" }
-    ],
-    required: false
+  const migrationName = `create_${modelName.toLowerCase()}s_table`;
+  await makeMigration(migrationName, fields);
+  for (const rel of relations) {
+    if (rel.type === "belongsToMany") {
+      const pivotMigrationName = `create_${rel.pivotTable}_table`;
+      const pivotFields = [
+        {
+          name: `${modelName.toLowerCase()}_id`,
+          type: "integer",
+          nullable: false
+        },
+        {
+          name: `${rel.model.toLowerCase()}_id`,
+          type: "integer",
+          nullable: false
+        }
+      ];
+      await makeMigration(pivotMigrationName, pivotFields);
+    }
+  }
+  const wantSeeder = await p3.confirm({
+    message: "Would you like to create a seeder for this model?",
+    initialValue: true
   });
-  if (p3.isCancel(options)) {
-    p3.cancel("Operation cancelled.");
+  if (wantSeeder) {
+    await makeSeeder(modelName, modelPath, fields);
+  }
+  p3.outro("Model generation complete!");
+}
+async function updateTargetModel(targetModel, methodName, relType, sourceModel, pivotTable = "") {
+  const modelPath = await findModelsPath() || "src/database/models";
+  const filename = `${targetModel}.mts`;
+  const targetPath = path3.join(process.cwd(), modelPath, filename);
+  if (!fs3.existsSync(targetPath)) {
+    p3.log.warn(
+      `Model ${targetModel} not found at ${modelPath}. Skipping inverse relation.`
+    );
     return;
   }
-  if (options.includes("migration")) {
-    const migrationName = `create_${modelName.toLowerCase()}s_table`;
-    await makeMigration(migrationName);
+  let content = fs3.readFileSync(targetPath, "utf-8");
+  if (!content.includes(`import { ${sourceModel} }`)) {
+    content = `import { ${sourceModel} } from './${sourceModel}.mts';
+` + content;
   }
-  if (options.includes("seeder")) {
-    await makeSeeder(modelName, modelPath);
+  let methodString = "";
+  if (relType === "belongsToMany") {
+    methodString = `    ${methodName}() {
+        return this.belongsToMany(${sourceModel}, '${pivotTable}');
+    }`;
+  } else {
+    methodString = `    ${methodName}() {
+        return this.${relType}(${sourceModel});
+    }`;
+  }
+  const lastBraceIndex = content.lastIndexOf("}");
+  if (lastBraceIndex !== -1) {
+    content = content.substring(0, lastBraceIndex) + "\n" + methodString + "\n" + content.substring(lastBraceIndex);
+    fs3.writeFileSync(targetPath, content);
+    p3.log.success(
+      `Updated ${targetModel}.mts with inverse relation: ${methodName}()`
+    );
   }
-  p3.outro("Model generation complete!");
 }
 async function findModelsPath() {
   const commonPaths = [
@@ -258,12 +478,12 @@ async function findModelsPath() {
     "models",
     "app/Models"
   ];
-  for (const p7 of commonPaths) {
-    if (fs3.existsSync(path3.join(process.cwd(), p7))) return p7;
+  for (const p8 of commonPaths) {
+    if (fs3.existsSync(path3.join(process.cwd(), p8))) return p8;
   }
   return null;
 }
-async function makeSeeder(modelName, modelPath) {
+async function makeSeeder(modelName, modelPath, fields = []) {
   const srcPath = path3.join(process.cwd(), "src");
   const useSrc = fs3.existsSync(srcPath) && fs3.lstatSync(srcPath).isDirectory();
   const seederDir = useSrc ? path3.join(process.cwd(), "src/database/seeders") : path3.join(process.cwd(), "database/seeders");
@@ -273,10 +493,25 @@ async function makeSeeder(modelName, modelPath) {
     fs3.mkdirSync(seederDir, { recursive: true });
   }
   const relativeModelPath = path3.relative(seederDir, path3.join(process.cwd(), modelPath, modelName)).replace(/\\/g, "/");
+  const dummyData = fields.map((f) => {
+    let val = "''";
+    if (f.type === "integer" || f.type === "foreign") val = "1";
+    if (f.type === "float") val = "1.5";
+    if (f.type === "boolean") val = "true";
+    if (f.type === "string" || f.type === "text") val = `'Sample ${f.name}'`;
+    if (f.type === "json") val = "'{}'";
+    if (f.type === "enum")
+      val = f.values && f.values.length > 0 ? `'${f.values[0]}'` : "''";
+    if (f.type === "date" || f.type === "datetime")
+      val = `'${(/* @__PURE__ */ new Date()).toISOString()}'`;
+    return `        ${f.name}: ${val},`;
+  }).join("\n");
   const template = `import { ${modelName} } from '${relativeModelPath}.mts';
 
 export const seed = async () => {
-    // await ${modelName}.create({ ... });
+    await ${modelName}.create({
+${dummyData}
+    });
 };
 `;
   if (fs3.existsSync(targetPath)) {
@@ -284,18 +519,281 @@ export const seed = async () => {
     return;
   }
   fs3.writeFileSync(targetPath, template);
-  p3.log.success(`Created seeder: database/seeders/${seederName}`);
+  p3.log.success(`Created seeder: ${seederDir}/${seederName}`);
+}
+
+// src/cli/commands/model-add.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as p4 from "@clack/prompts";
+async function modelAdd() {
+  p4.intro("Adding attributes to an existing model...");
+  const modelPath = await findModelsPath2() || "src/database/models";
+  const fullModelPath = path4.join(process.cwd(), modelPath);
+  if (!fs4.existsSync(fullModelPath)) {
+    p4.log.error(`Models directory not found at ${modelPath}.`);
+    return;
+  }
+  const modelFiles = fs4.readdirSync(fullModelPath).filter((f) => f.endsWith(".mts") || f.endsWith(".ts"));
+  const options = modelFiles.map((f) => ({
+    value: f,
+    label: f
+  }));
+  options.unshift({ value: "new", label: "[ Create new model ]" });
+  const selectedModel = await p4.select({
+    message: "Select a model to add attributes to:",
+    options
+  });
+  if (p4.isCancel(selectedModel)) {
+    p4.cancel("Operation cancelled.");
+    return;
+  }
+  if (selectedModel === "new") {
+    await makeModel();
+    return;
+  }
+  const modelName = selectedModel.replace(".mts", "").replace(".ts", "");
+  const targetPath = path4.join(fullModelPath, selectedModel);
+  const fields = [];
+  const relations = [];
+  let addMore = true;
+  p4.log.step(`Adding attributes to ${modelName}...`);
+  while (addMore) {
+    const fieldName = await p4.text({
+      message: "New attribute or relation name (leave empty to stop):",
+      placeholder: "e.g. description or comments"
+    });
+    if (p4.isCancel(fieldName)) break;
+    if (!fieldName) break;
+    const fieldType = await p4.select({
+      message: `Type for ${fieldName}:`,
+      options: [
+        { value: "string", label: "String" },
+        { value: "integer", label: "Integer" },
+        { value: "boolean", label: "Boolean" },
+        { value: "text", label: "Text" },
+        { value: "float", label: "Float" },
+        { value: "json", label: "JSON" },
+        { value: "enum", label: "Enum" },
+        { value: "date", label: "Date" },
+        { value: "blob", label: "Blob" },
+        { value: "belongsToMany", label: "ManyToMany (Pivot Table)" },
+        { value: "relation", label: "Relation (1:1, 1:N)" }
+      ]
+    });
+    if (p4.isCancel(fieldType)) break;
+    if (fieldType === "relation" || fieldType === "belongsToMany") {
+      let relType = fieldType;
+      if (fieldType === "relation") {
+        relType = await p4.select({
+          message: `Relation type for ${fieldName}:`,
+          options: [
+            { value: "hasOne", label: "HasOne" },
+            { value: "hasMany", label: "HasMany" },
+            { value: "belongsTo", label: "BelongsTo" }
+          ]
+        });
+      }
+      if (p4.isCancel(relType)) break;
+      const targetModel = await p4.text({
+        message: "Target model for this relation:",
+        placeholder: "e.g. Comment",
+        validate: (v) => !v ? "Target model is required" : void 0
+      });
+      if (p4.isCancel(targetModel)) break;
+      let foreignKey = "";
+      let pivotTable = "";
+      if (relType === "belongsToMany") {
+        p4.log.info("Automatically creating a pivot table migration.");
+        pivotTable = await p4.text({
+          message: "Pivot table name:",
+          initialValue: [modelName.toLowerCase(), targetModel.toLowerCase()].sort().join("_")
+        });
+        if (p4.isCancel(pivotTable)) break;
+      } else if (relType === "belongsTo") {
+        foreignKey = await p4.text({
+          message: "Foreign key column name:",
+          placeholder: `e.g. ${targetModel.toLowerCase()}_id`,
+          initialValue: `${targetModel.toLowerCase()}_id`
+        });
+        if (p4.isCancel(foreignKey)) break;
+        fields.push({
+          name: foreignKey,
+          type: "foreign",
+          nullable: false,
+          unique: false
+        });
+      }
+      relations.push({
+        method: fieldName,
+        type: relType,
+        model: targetModel,
+        foreignKey,
+        pivotTable
+      });
+      const addInverse = await p4.confirm({
+        message: `Add the inverse relation in ${targetModel}.mts?`,
+        initialValue: true
+      });
+      if (addInverse && !p4.isCancel(addInverse)) {
+        let inverseType = "belongsTo";
+        if (relType === "belongsTo") inverseType = "hasMany";
+        if (relType === "hasOne") inverseType = "belongsTo";
+        if (relType === "belongsToMany") inverseType = "belongsToMany";
+        const inverseMethod = await p4.text({
+          message: "Inverse method name:",
+          initialValue: relType === "belongsTo" ? modelName.toLowerCase() + "s" : modelName.toLowerCase()
+        });
+        if (!p4.isCancel(inverseMethod)) {
+          await updateTargetModel2(
+            targetModel,
+            inverseMethod,
+            inverseType,
+            modelName,
+            pivotTable
+          );
+        }
+      }
+    } else {
+      let enumValues = [];
+      if (fieldType === "enum") {
+        const valuesStr = await p4.text({
+          message: "Allowed values (comma separated):",
+          placeholder: "active, inactive, pending"
+        });
+        if (p4.isCancel(valuesStr)) break;
+        enumValues = valuesStr.split(",").map((v) => v.trim());
+      }
+      const isNullable = await p4.confirm({
+        message: "Is it nullable?",
+        initialValue: false
+      });
+      if (p4.isCancel(isNullable)) break;
+      const isUnique = await p4.confirm({
+        message: "Is it unique?",
+        initialValue: false
+      });
+      if (p4.isCancel(isUnique)) break;
+      fields.push({
+        name: fieldName,
+        type: fieldType,
+        nullable: isNullable,
+        unique: isUnique,
+        values: enumValues
+      });
+    }
+  }
+  if (fields.length === 0 && relations.length === 0) {
+    p4.outro("No changes made.");
+    return;
+  }
+  let modelContent = fs4.readFileSync(targetPath, "utf-8");
+  const newImports = relations.filter((r) => !modelContent.includes(`import { ${r.model} }`)).map((r) => `import { ${r.model} } from './${r.model}.mts';`).join("\n");
+  if (newImports) {
+    modelContent = newImports + "\n" + modelContent;
+  }
+  const fieldProperties = fields.filter(
+    (f) => f.type !== "foreign" || !relations.some((r) => r.foreignKey === f.name)
+  ).map((f) => {
+    let tsType = "string";
+    if (f.type === "integer" || f.type === "float") tsType = "number";
+    else if (f.type === "boolean") tsType = "boolean";
+    else if (f.type === "json") tsType = "any";
+    else if (f.type === "blob") tsType = "Uint8Array";
+    return `    declare ${f.name}${f.nullable ? "?" : ""}: ${tsType};`;
+  }).join("\n");
+  const relationMethods = relations.map((r) => {
+    return `    ${r.method}() {
+        return this.${r.type}(${r.model});
+    }`;
+  }).join("\n\n");
+  const lastBraceIndex = modelContent.lastIndexOf("}");
+  if (lastBraceIndex !== -1) {
+    modelContent = modelContent.substring(0, lastBraceIndex) + fieldProperties + "\n" + relationMethods + "\n" + modelContent.substring(lastBraceIndex);
+    fs4.writeFileSync(targetPath, modelContent);
+    p4.log.success(`Updated model: ${modelPath}/${selectedModel}`);
+  }
+  if (fields.length > 0) {
+    const migrationName = `add_fields_to_${modelName.toLowerCase()}s_table`;
+    await makeMigration(migrationName, fields);
+  }
+  for (const rel of relations) {
+    if (rel.type === "belongsToMany") {
+      const pivotMigrationName = `create_${rel.pivotTable}_table`;
+      const pivotFields = [
+        {
+          name: `${modelName.toLowerCase()}_id`,
+          type: "integer",
+          nullable: false
+        },
+        {
+          name: `${rel.model.toLowerCase()}_id`,
+          type: "integer",
+          nullable: false
+        }
+      ];
+      await makeMigration(pivotMigrationName, pivotFields);
+    }
+  }
+  p4.outro("Model update complete!");
+}
+async function updateTargetModel2(targetModel, methodName, relType, sourceModel, pivotTable = "") {
+  const modelPath = await findModelsPath2() || "src/database/models";
+  const filename = `${targetModel}.mts`;
+  const targetPath = path4.join(process.cwd(), modelPath, filename);
+  if (!fs4.existsSync(targetPath)) {
+    p4.log.warn(
+      `Model ${targetModel} not found at ${modelPath}. Skipping inverse relation.`
+    );
+    return;
+  }
+  let content = fs4.readFileSync(targetPath, "utf-8");
+  if (!content.includes(`import { ${sourceModel} }`)) {
+    content = `import { ${sourceModel} } from './${sourceModel}.mts';
+` + content;
+  }
+  let methodString = "";
+  if (relType === "belongsToMany") {
+    methodString = `    ${methodName}() {
+        return this.belongsToMany(${sourceModel}, '${pivotTable}');
+    }`;
+  } else {
+    methodString = `    ${methodName}() {
+        return this.${relType}(${sourceModel});
+    }`;
+  }
+  const lastBraceIndex = content.lastIndexOf("}");
+  if (lastBraceIndex !== -1) {
+    content = content.substring(0, lastBraceIndex) + "\n" + methodString + "\n" + content.substring(lastBraceIndex);
+    fs4.writeFileSync(targetPath, content);
+    p4.log.success(
+      `Updated ${targetModel}.mts with inverse relation: ${methodName}()`
+    );
+  }
+}
+async function findModelsPath2() {
+  const commonPaths = [
+    "src/database/models",
+    "database/models",
+    "src/models",
+    "models",
+    "app/Models"
+  ];
+  for (const p8 of commonPaths) {
+    if (fs4.existsSync(path4.join(process.cwd(), p8))) return p8;
+  }
+  return null;
 }
 
 // src/cli/commands/migrate.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import { execSync as execSync2 } from "child_process";
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 
 // src/cli/utils/config.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 var Config = class {
   /**
    * Detect the D1 database binding from Wrangler configuration or d1-orm config.
@@ -303,24 +801,24 @@ var Config = class {
    * @returns The binding name (e.g., "DB").
    */
   static getD1Binding() {
-    const srcConfig = path4.join(process.cwd(), "src/database/config.mts");
-    const srcConfigTs = path4.join(process.cwd(), "src/database/config.ts");
-    const rootConfig = path4.join(process.cwd(), "database/config.mts");
-    const rootConfigTs = path4.join(process.cwd(), "database/config.ts");
-    const configPath = fs4.existsSync(srcConfig) ? srcConfig : fs4.existsSync(srcConfigTs) ? srcConfigTs : fs4.existsSync(rootConfig) ? rootConfig : fs4.existsSync(rootConfigTs) ? rootConfigTs : null;
+    const srcConfig = path5.join(process.cwd(), "src/database/config.mts");
+    const srcConfigTs = path5.join(process.cwd(), "src/database/config.ts");
+    const rootConfig = path5.join(process.cwd(), "database/config.mts");
+    const rootConfigTs = path5.join(process.cwd(), "database/config.ts");
+    const configPath = fs5.existsSync(srcConfig) ? srcConfig : fs5.existsSync(srcConfigTs) ? srcConfigTs : fs5.existsSync(rootConfig) ? rootConfig : fs5.existsSync(rootConfigTs) ? rootConfigTs : null;
     if (configPath) {
-      const content = fs4.readFileSync(configPath, "utf-8");
+      const content = fs5.readFileSync(configPath, "utf-8");
       const match = content.match(/binding\s*:\s*["'](.+?)["']/);
       if (match) return match[1];
     }
     const wranglerPaths = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
     for (const configName of wranglerPaths) {
-      const fullPath = path4.join(process.cwd(), configName);
-      if (fs4.existsSync(fullPath)) {
-        const content = fs4.readFileSync(fullPath, "utf-8");
+      const fullPath = path5.join(process.cwd(), configName);
+      if (fs5.existsSync(fullPath)) {
+        const content = fs5.readFileSync(fullPath, "utf-8");
         if (configName.endsWith(".json") || configName.endsWith(".jsonc")) {
           try {
-            const jsonStr = content.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, "");
+            const jsonStr = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
             const config = JSON.parse(jsonStr);
             const d1Databases = config.d1_databases;
             if (Array.isArray(d1Databases) && d1Databases.length > 0) {
@@ -337,14 +835,28 @@ var Config = class {
     }
     return "DB";
   }
+  /**
+   * Get a filtered environment object to avoid system warnings.
+   * Filters out npm_config_* variables and sets NODE_NO_WARNINGS.
+   */
+  static getCleanEnv() {
+    const cleanEnv = { ...process.env };
+    Object.keys(cleanEnv).forEach((key) => {
+      if (key.startsWith("npm_config_")) {
+        delete cleanEnv[key];
+      }
+    });
+    cleanEnv.NODE_NO_WARNINGS = "1";
+    return cleanEnv;
+  }
   /**
    * Detect if the project is ESM.
    */
   static isESM() {
-    const pkgPath = path4.join(process.cwd(), "package.json");
-    if (fs4.existsSync(pkgPath)) {
+    const pkgPath = path5.join(process.cwd(), "package.json");
+    if (fs5.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
         return pkg.type === "module";
       } catch (e) {
         return false;
@@ -355,8 +867,8 @@ var Config = class {
 };
 
 // src/cli/commands/seed.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 
 // src/cli/cli-connection.ts
 import { execSync } from "child_process";
@@ -467,38 +979,38 @@ var CLIPREparedStatement = class {
 };
 
 // src/cli/commands/seed.ts
-import * as p4 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 async function seed(args2) {
-  p4.intro("Seeding database...");
-  const srcSeedersDir = path5.join(process.cwd(), "src/database/seeders");
-  const rootSeedersDir = path5.join(process.cwd(), "database/seeders");
-  const seedersDir = fs5.existsSync(srcSeedersDir) ? srcSeedersDir : rootSeedersDir;
-  if (!fs5.existsSync(seedersDir)) {
-    p4.log.warn(
+  p5.intro("Seeding database...");
+  const srcSeedersDir = path6.join(process.cwd(), "src/database/seeders");
+  const rootSeedersDir = path6.join(process.cwd(), "database/seeders");
+  const seedersDir = fs6.existsSync(srcSeedersDir) ? srcSeedersDir : rootSeedersDir;
+  if (!fs6.existsSync(seedersDir)) {
+    p5.log.warn(
       `No seeders directory found (checked ${srcSeedersDir} and ${rootSeedersDir}).`
     );
-    p4.outro("Nothing to seed.");
+    p5.outro("Nothing to seed.");
     return;
   }
   const isRemote = args2.includes("--remote");
   const dbName = Config.getD1Binding();
-  const s = p4.spinner();
+  const s = p5.spinner();
   s.start(`Initializing ORM (Binding: ${dbName})...`);
   try {
     const connection = new CLIConnection(dbName, isRemote);
     Database.setup(connection);
     s.stop(`ORM initialized successfully with binding "${dbName}".`);
-    const files = fs5.readdirSync(seedersDir).filter(
+    const files = fs6.readdirSync(seedersDir).filter(
       (f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mts") || f.endsWith(".mjs")
     ).sort();
     if (files.length === 0) {
-      p4.log.info("No seeder files found.");
-      p4.outro("Seeding complete.");
+      p5.log.info("No seeder files found.");
+      p5.outro("Seeding complete.");
       return;
     }
     for (const file of files) {
       s.start(`Running seeder: ${file}`);
-      const filePath = path5.join(seedersDir, file);
+      const filePath = path6.join(seedersDir, file);
       try {
         const seeder = await import(filePath);
         if (seeder.seed) {
@@ -509,59 +1021,62 @@ async function seed(args2) {
         }
       } catch (error) {
         s.stop(`Failed: ${file}`, 1);
-        p4.log.error(`Error running seeder ${file}: ${error}`);
+        p5.log.error(`Error running seeder ${file}: ${error}`);
       }
     }
-    p4.outro("Seeding completed successfully.");
+    p5.outro("Seeding completed successfully.");
   } catch (error) {
     s.stop("Initialization failed.", 1);
-    p4.log.error(`Seeding error: ${error}`);
+    p5.log.error(`Seeding error: ${error}`);
   }
 }
 
 // src/cli/commands/migrate.ts
 async function migrate(args2) {
-  p5.intro("Running migrations...");
-  const srcMigrationsDir = path6.join(process.cwd(), "src/database/migrations");
-  const rootMigrationsDir = path6.join(process.cwd(), "database/migrations");
-  const migrationsDir = fs6.existsSync(srcMigrationsDir) ? srcMigrationsDir : rootMigrationsDir;
-  if (!fs6.existsSync(migrationsDir)) {
-    p5.log.warn(
+  p6.intro("Running migrations...");
+  const srcMigrationsDir = path7.join(process.cwd(), "src/database/migrations");
+  const rootMigrationsDir = path7.join(process.cwd(), "database/migrations");
+  const migrationsDir = fs7.existsSync(srcMigrationsDir) ? srcMigrationsDir : rootMigrationsDir;
+  if (!fs7.existsSync(migrationsDir)) {
+    p6.log.warn(
       `No migrations directory found (checked ${srcMigrationsDir} and ${rootMigrationsDir}).`
     );
-    p5.outro("Nothing to migrate.");
+    p6.outro("Nothing to migrate.");
     return;
   }
-  const files = fs6.readdirSync(migrationsDir).filter(
+  const files = fs7.readdirSync(migrationsDir).filter(
     (f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mts") || f.endsWith(".mjs")
   ).sort();
   if (files.length === 0) {
-    p5.log.info("No migration files found.");
-    p5.outro("Migrations complete.");
+    p6.log.info("No migration files found.");
+    p6.outro("Migrations complete.");
     return;
   }
-  const s = p5.spinner();
+  const s = p6.spinner();
   const dbName = Config.getD1Binding();
   for (const file of files) {
     s.start(`Processing migration: ${file} (Binding: ${dbName})`);
-    const filePath = path6.join(migrationsDir, file);
+    const filePath = path7.join(migrationsDir, file);
     try {
       const migration = await import(filePath);
       if (migration.up) {
         const sql = await migration.up();
         if (sql) {
+          const sqlStatements = Array.isArray(sql) ? sql : [sql];
           const isRemote = args2.includes("--remote");
           const command2 = isRemote ? "--remote" : "--local";
           try {
-            const execCmd = `npx wrangler d1 execute ${dbName} --command "${sql.replace(/"/g, '\\"')}" ${command2}`;
-            execSync2(execCmd, {
-              stdio: "pipe",
-              env: { ...process.env, NODE_NO_WARNINGS: "1" }
-            });
+            for (const statement of sqlStatements) {
+              const execCmd = `npx wrangler d1 execute ${dbName} --command "${statement.replace(/"/g, '\\"')}" ${command2}`;
+              execSync2(execCmd, {
+                stdio: "pipe",
+                env: Config.getCleanEnv()
+              });
+            }
             s.stop(`Migrated: ${file}`);
           } catch (e) {
             s.stop(`Failed: ${file}`, 1);
-            p5.log.error(`Failed to execute migration: ${file}`);
+            p6.log.error(`Failed to execute migration: ${file}`);
             throw e;
           }
         } else {
@@ -572,10 +1087,10 @@ async function migrate(args2) {
       }
     } catch (error) {
       s.stop(`Error: ${file}`, 1);
-      p5.log.error(`Error processing migration ${file}: ${error}`);
+      p6.log.error(`Error processing migration ${file}: ${error}`);
     }
   }
-  p5.outro("All migrations executed.");
+  p6.outro("All migrations executed.");
   if (args2.includes("--seed")) {
     await seed(args2);
   }
@@ -583,19 +1098,20 @@ async function migrate(args2) {
 
 // src/cli/commands/migrate-fresh.ts
 import { execSync as execSync3 } from "child_process";
-import * as p6 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 async function migrateFresh(args2) {
-  p6.intro("Resetting database...");
+  p7.intro("Resetting database...");
   const isRemote = args2.includes("--remote");
   const dbName = Config.getD1Binding();
   const flag = isRemote ? "--remote" : "--local";
-  const s = p6.spinner();
+  const s = p7.spinner();
   s.start("Scanning for tables to drop...");
   try {
     const listTablesCmd = `npx wrangler d1 execute ${dbName} --command "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_cf_%'" ${flag} --json`;
     const output = execSync3(listTablesCmd, {
       encoding: "utf-8",
-      stdio: ["ignore", "pipe", "inherit"]
+      stdio: ["ignore", "pipe", "pipe"],
+      env: Config.getCleanEnv()
     });
     const jsonStart = output.indexOf("[");
     if (jsonStart !== -1) {
@@ -605,7 +1121,10 @@ async function migrateFresh(args2) {
         s.message(`Dropping ${tables.length} tables...`);
         const dropCommands = tables.map((t) => `DROP TABLE IF EXISTS ${t.name};`).join(" ");
         const dropCmd = `npx wrangler d1 execute ${dbName} --command "${dropCommands}" ${flag}`;
-        execSync3(dropCmd, { stdio: "pipe" });
+        execSync3(dropCmd, {
+          stdio: "pipe",
+          env: Config.getCleanEnv()
+        });
         s.stop("All tables dropped successfully.");
       } else {
         s.stop("No tables found to drop.");
@@ -616,7 +1135,7 @@ async function migrateFresh(args2) {
     await migrate(args2);
   } catch (error) {
     s.stop("Process failed.", 1);
-    p6.log.error(`Error during migrate:fresh: ${error}`);
+    p7.log.error(`Error during migrate:fresh: ${error}`);
   }
 }
 
@@ -634,6 +1153,9 @@ switch (command) {
   case "make:migration":
     makeMigration(param);
     break;
+  case "model:add":
+    modelAdd();
+    break;
   case "migrate":
     migrate(args);
     break;
@@ -645,7 +1167,7 @@ switch (command) {
     break;
   default:
     console.log(
-      "Available commands: init, make:model, make:migration, migrate, migrate:fresh, db:seed"
+      "Available commands: init, make:model, make:migration, model:add, migrate, migrate:fresh, db:seed"
     );
     break;
 }