4bnode 3.5.2 → 4.0.0

package/add-mongo-schema.js

@@ -2,230 +2,462 @@
 
 import fs from "fs";
 import path from "path";
-import readline from "readline";
 import chalk from "chalk";
+import { input, select, checkbox } from "@inquirer/prompts";
+import { toCamelCase, toPascalCase, sanitizeName } from "./lib/names.js";
+import { getProjectRoot, listModels, getModelSchemaDetailed } from "./lib/project.js";
+import {
+  showHeader,
+  showTaskDone,
+  showWarning,
+  showError,
+  showFileAction,
+  showInfo,
+} from "./lib/ui.js";
 
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-});
+// ── Presets ────────────────────────────────────────
 
-const fieldTypes = [
-  "String",
-  "Number",
-  "Date",
-  "Boolean",
-  "Array",
-  "Buffer",
-  "Mixed",
-  "ObjectId",
-];
-
-function toCamelCase(str) {
-  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-}
+const presets = {
+  user: [
+    { name: "name", type: "String", required: true },
+    { name: "email", type: "String", required: true, unique: true },
+    { name: "password", type: "String", required: true },
+    { name: "role", type: "String", default: "user" },
+  ],
+  product: [
+    { name: "name", type: "String", required: true },
+    { name: "price", type: "Number", required: true },
+    { name: "description", type: "String" },
+    { name: "category", type: "String" },
+    { name: "inStock", type: "Boolean", default: true },
+  ],
+  post: [
+    { name: "title", type: "String", required: true },
+    { name: "content", type: "String", required: true },
+    { name: "author", type: "String" },
+    { name: "tags", type: "Array" },
+    { name: "published", type: "Boolean", default: false },
+  ],
+};
 
-function toPascalCase(str) {
-  const camelCaseStr = toCamelCase(str);
-  return camelCaseStr.charAt(0).toUpperCase() + camelCaseStr.slice(1);
-}
+const validTypes = ["String", "Number", "Boolean", "Date", "Array", "ObjectId", "Mixed", "Buffer"];
 
-function convertDefaultValue(fieldType, value) {
-  try {
-    switch (fieldType) {
-      case "Number":
-        if (isNaN(value)) throw new Error("Invalid number");
-        return parseFloat(value);
-      case "Date":
-        const date = new Date(value);
-        if (isNaN(date.getTime())) throw new Error("Invalid date");
-        return date;
-      case "Boolean":
-        if (value.toLowerCase() !== "true" && value.toLowerCase() !== "false") {
-          throw new Error("Invalid boolean");
-        }
-        return value.toLowerCase() === "true";
-      case "Array":
-        return JSON.parse(value);
-      case "ObjectId":
-        return value; // Keep as string; Mongoose will cast it
-      case "Buffer":
-        return Buffer.from(value);
-      default:
-        return value;
-    }
-  } catch (e) {
-    return null;
-  }
-}
+// ── Format field for display ───────────────────────
 
-function promptSchemaDetails(schemaName) {
-  const fields = [];
-
-  function askField() {
-    rl.question(
-      chalk.yellow("\nEnter field name (or press enter to finish): "),
-      (fieldName) => {
-        if (!fieldName.trim()) {
-          generateSchemaFile(schemaName, fields);
-          rl.close();
-        } else {
-          console.log(chalk.cyan("Choose field type:"));
-          fieldTypes.forEach((type, index) => {
-            console.log(chalk.cyan(`${index + 1}. ${type}`));
-          });
-
-          rl.question(
-            chalk.yellow("Enter the number for the field type: "),
-            (fieldTypeIndex) => {
-              const fieldType = fieldTypes[parseInt(fieldTypeIndex, 10) - 1];
-              if (!fieldType) {
-                console.error(
-                  chalk.red("Invalid selection. Please choose a valid number.")
-                );
-                askField();
-                return;
-              }
-
-              rl.question(
-                chalk.yellow("Is this field required? (y/n): "),
-                (isRequired) => {
-                  const required = isRequired.trim().toLowerCase();
-                  if (required !== "y" && required !== "n") {
-                    console.error(
-                      chalk.red("Invalid selection. Please enter 'y' or 'n'.")
-                    );
-                    askField();
-                    return;
-                  }
-
-                  rl.question(
-                    chalk.yellow("Is this field unique? (y/n): "),
-                    (isUnique) => {
-                      const unique = isUnique.trim().toLowerCase();
-                      if (unique !== "y" && unique !== "n") {
-                        console.error(
-                          chalk.red(
-                            "Invalid selection. Please enter 'y' or 'n'."
-                          )
-                        );
-                        askField();
-                        return;
-                      }
-
-                      function askDefaultValue() {
-                        rl.question(
-                          chalk.yellow(
-                            `Enter default value${
-                              fieldType === "Boolean" ? " (true/false)" : ""
-                            }${
-                              fieldType === "Date"
-                                ? " (e.g., 2023-01-01T00:00:00Z)"
-                                : ""
-                            } (or press enter to skip): `
-                          ),
-                          (defaultValue) => {
-                            if (defaultValue.trim()) {
-                              const convertedDefaultValue = convertDefaultValue(
-                                fieldType,
-                                defaultValue.trim()
-                              );
-                              if (convertedDefaultValue === null) {
-                                console.error(
-                                  chalk.red(
-                                    "Invalid default value. Please enter a valid value."
-                                  )
-                                );
-                                askDefaultValue();
-                                return;
-                              }
-                              fields.push({
-                                name: fieldName.trim(),
-                                type: fieldType,
-                                required: required === "y",
-                                unique: unique === "y",
-                                default: convertedDefaultValue,
-                              });
-                            } else {
-                              fields.push({
-                                name: fieldName.trim(),
-                                type: fieldType,
-                                required: required === "y",
-                                unique: unique === "y",
-                              });
-                            }
-                            askField();
-                          }
-                        );
-                      }
-
-                      askDefaultValue();
-                    }
-                  );
-                }
-              );
-            }
-          );
-        }
-      }
-    );
-  }
+function formatField(f) {
+  const c = chalk.hex("#00c6ff");
+  const d = chalk.gray;
+  const g = chalk.hex("#22c55e");
+  const y = chalk.hex("#ffd200");
 
-  askField();
+  let line = `  ${c(f.name)} ${d(":")} ${g(f.type)}`;
+  const tags = [];
+  if (f.required) tags.push(y("required"));
+  if (f.unique) tags.push(y("unique"));
+  if (f.default !== undefined) tags.push(d(`default=${f.default}`));
+  if (tags.length > 0) line += `  ${tags.join(" ")}`;
+  return line;
 }
 
+// ── Generate schema file ───────────────────────────
+
 function generateSchemaFile(schemaName, fields) {
-  const projectRoot = process.cwd();
+  const projectRoot = getProjectRoot();
   const modelsDir = path.join(projectRoot, "src", "models");
 
   if (!fs.existsSync(modelsDir)) {
     fs.mkdirSync(modelsDir, { recursive: true });
   }
 
-  const schemaFilePath = path.join(modelsDir, `${toCamelCase(schemaName)}.js`);
-  const pascalSchemaName = toPascalCase(schemaName);
-  const schemaContent = `
-import mongoose from 'mongoose';
-
-const ${pascalSchemaName}Schema = new mongoose.Schema({
-  ${fields
-    .map((field) => {
-      let fieldDef = `${field.name}: { type: ${
-        field.type === "ObjectId"
-          ? "mongoose.Schema.Types.ObjectId"
-          : field.type
+  const camelName = toCamelCase(schemaName);
+  const pascalName = toPascalCase(schemaName);
+  const schemaFilePath = path.join(modelsDir, `${camelName}.js`);
+
+  const fieldDefs = fields
+    .map((f) => {
+      let def = `  ${f.name}: { type: ${
+        f.type === "ObjectId" ? "mongoose.Schema.Types.ObjectId" : f.type
       }`;
-      if (field.required) {
-        fieldDef += `, required: true`;
-      }
-      if (field.unique) {
-        fieldDef += `, unique: true`;
-      }
-      if (field.default !== undefined) {
-        fieldDef += `, default: ${JSON.stringify(field.default)}`;
-      }
-      fieldDef += ` }`;
-      return fieldDef;
+      if (f.required) def += ", required: true";
+      if (f.unique) def += ", unique: true";
+      if (f.default !== undefined) def += `, default: ${JSON.stringify(f.default)}`;
+      def += " }";
+      return def;
     })
-    .join(",\n  ")}
+    .join(",\n");
+
+  const content = `import mongoose from 'mongoose';
+
+const ${pascalName}Schema = new mongoose.Schema({
+${fieldDefs}
 }, { timestamps: true });
 
-const ${pascalSchemaName} = mongoose.model('${pascalSchemaName}', ${pascalSchemaName}Schema);
+const ${pascalName} = mongoose.model('${pascalName}', ${pascalName}Schema);
+
+export default ${pascalName};
+`;
+
+  fs.writeFileSync(schemaFilePath, content, "utf8");
+  return schemaFilePath;
+}
+
+// ── View models ────────────────────────────────────
+
+function viewModel(modelFile) {
+  const modelName = path.basename(modelFile, ".js");
+  const pascalName = toPascalCase(modelName);
+  const fields = getModelSchemaDetailed(modelName);
+
+  console.log();
+  console.log(chalk.hex("#ffd200").bold(`  ${pascalName} Schema`));
+  console.log(chalk.gray("  ─────────────────────────────────"));
+
+  if (fields.length === 0) {
+    console.log(chalk.gray("  No fields found."));
+  } else {
+    fields.forEach((f) => console.log(formatField(f)));
+  }
+
+  console.log(chalk.gray("  ─────────────────────────────────"));
+  console.log(chalk.gray(`  timestamps: true`));
+  console.log(chalk.gray(`  file: src/models/${modelFile}`));
+  console.log();
+}
+
+// ── Edit model ─────────────────────────────────────
+
+async function editModel(modelFile) {
+  const modelName = path.basename(modelFile, ".js");
+  const pascalName = toPascalCase(modelName);
+  const fields = getModelSchemaDetailed(modelName);
+
+  viewModel(modelFile);
+
+  let editing = true;
+  while (editing) {
+    const action = await select({
+      message: `Edit ${pascalName}:`,
+      choices: [
+        { name: "Add field", value: "add" },
+        ...(fields.length > 0
+          ? [
+              { name: "Remove field", value: "remove" },
+              { name: "Toggle required", value: "required" },
+              { name: "Toggle unique", value: "unique" },
+            ]
+          : []),
+        { name: "Done — save & exit", value: "done" },
+      ],
+    });
+
+    if (action === "add") {
+      const typeChoices = validTypes.map((t) => ({ name: t, value: t }));
+      showInfo("Add fields one by one. Press enter with empty name to stop.");
+
+      const added = [];
+      while (true) {
+        const fieldName = await input({ message: "Field name (enter to stop):" });
+        if (!fieldName.trim()) break;
+
+        if (fields.find((f) => f.name === fieldName.trim())) {
+          showWarning(`Field "${fieldName.trim()}" already exists, skipping.`);
+          continue;
+        }
+
+        const fieldType = await select({
+          message: `Type for "${fieldName.trim()}":`,
+          choices: typeChoices,
+        });
+
+        const isRequired = await select({
+          message: `Required?`,
+          choices: [
+            { name: "No", value: false },
+            { name: "Yes", value: true },
+          ],
+        });
+
+        const isUnique = await select({
+          message: `Unique?`,
+          choices: [
+            { name: "No", value: false },
+            { name: "Yes", value: true },
+          ],
+        });
+
+        const nf = { name: fieldName.trim(), type: fieldType, required: isRequired, unique: isUnique };
+        fields.push(nf);
+        added.push(nf);
+        console.log(chalk.hex("#22c55e")(`  + ${nf.name}: ${nf.type}${nf.required ? " (required)" : ""}${nf.unique ? " (unique)" : ""}`));
+      }
+
+    } else if (action === "remove") {
+      const toRemove = await checkbox({
+        message: "Select fields to remove:",
+        choices: fields.map((f) => ({ name: `${f.name}: ${f.type}`, value: f.name })),
+        validate: (v) => (v.length > 0 ? true : "Select at least one."),
+      });
+      for (const name of toRemove) {
+        const idx = fields.findIndex((f) => f.name === name);
+        if (idx !== -1) {
+          fields.splice(idx, 1);
+          console.log(chalk.hex("#ef4444")(`  - ${name} removed`));
+        }
+      }
+
+    } else if (action === "required") {
+      const toggled = await checkbox({
+        message: "Toggle required (checked = required):",
+        choices: fields.map((f) => ({
+          name: f.name,
+          value: f.name,
+          checked: f.required || false,
+        })),
+      });
+      fields.forEach((f) => {
+        f.required = toggled.includes(f.name);
+      });
+      showInfo("Required fields updated.");
+
+    } else if (action === "unique") {
+      const toggled = await checkbox({
+        message: "Toggle unique (checked = unique):",
+        choices: fields.map((f) => ({
+          name: f.name,
+          value: f.name,
+          checked: f.unique || false,
+        })),
+      });
+      fields.forEach((f) => {
+        f.unique = toggled.includes(f.name);
+      });
+      showInfo("Unique fields updated.");
+
+    } else {
+      editing = false;
+    }
+  }
+
+  if (fields.length === 0) {
+    showWarning("No fields left. Schema not saved.");
+    return;
+  }
 
-export default ${pascalSchemaName};
-  `;
+  console.log();
+  generateSchemaFile(modelName, fields);
+  showFileAction("updated", `src/models/${modelFile}`);
 
-  fs.writeFileSync(schemaFilePath, schemaContent.trim(), "utf8");
-  console.log(
-    chalk.green(`MongoDB schema ${schemaName} created successfully.`)
+  const fieldList = fields.map(
+    (f) => `${f.name}: ${f.type}${f.required ? " (required)" : ""}${f.unique ? " (unique)" : ""}`
   );
+  showTaskDone(`Schema "${modelName}" updated`, fieldList);
 }
 
-if (process.argv.length !== 3) {
-  console.error(chalk.red("Usage: add-mongo-schema <schemaName>"));
-  process.exit(0);
+// ── Create new schema ──────────────────────────────
+
+async function createSchema(schemaName) {
+  const presetKey = schemaName.toLowerCase();
+  const hasPreset = presets[presetKey];
+
+  let fields = [];
+
+  // Offer preset if available
+  if (hasPreset) {
+    const usePreset = await select({
+      message: `Use "${presetKey}" preset (${hasPreset.length} fields)?`,
+      choices: [
+        { name: `Yes — ${hasPreset.map((f) => f.name).join(", ")}`, value: true },
+        { name: "No — define fields manually", value: false },
+      ],
+    });
+
+    if (usePreset) {
+      fields = hasPreset.map((f) => ({ ...f }));
+      fields.forEach((f) => console.log(chalk.hex("#22c55e")(
+        `  + ${f.name}: ${f.type}${f.required ? " (required)" : ""}${f.unique ? " (unique)" : ""}`
+      )));
+    }
+  }
+
+  // Manual field entry — fully selection-based
+  if (fields.length === 0) {
+    showInfo("Add fields one by one. Press enter with empty name to finish.");
+    const typeChoices = validTypes.map((t) => ({ name: t, value: t }));
+
+    while (true) {
+      const fieldName = await input({ message: "Field name (enter to finish):" });
+      if (!fieldName.trim()) break;
+
+      if (fields.find((f) => f.name === fieldName.trim())) {
+        showWarning(`Field "${fieldName.trim()}" already exists, skipping.`);
+        continue;
+      }
+
+      const fieldType = await select({
+        message: `Type for "${fieldName.trim()}":`,
+        choices: typeChoices,
+      });
+
+      const isRequired = await select({
+        message: "Required?",
+        choices: [
+          { name: "No", value: false },
+          { name: "Yes", value: true },
+        ],
+      });
+
+      const isUnique = await select({
+        message: "Unique?",
+        choices: [
+          { name: "No", value: false },
+          { name: "Yes", value: true },
+        ],
+      });
+
+      const nf = { name: fieldName.trim(), type: fieldType, required: isRequired, unique: isUnique };
+      fields.push(nf);
+      console.log(chalk.hex("#22c55e")(
+        `  + ${nf.name}: ${nf.type}${nf.required ? " (required)" : ""}${nf.unique ? " (unique)" : ""}`
+      ));
+    }
+  }
+
+  if (fields.length === 0) {
+    showWarning("No fields defined. Schema not created.");
+    process.exit(0);
+  }
+
+  console.log();
+  generateSchemaFile(schemaName, fields);
+  showFileAction("created", `src/models/${toCamelCase(schemaName)}.js`);
+
+  const fieldList = fields.map(
+    (f) => `${f.name}: ${f.type}${f.required ? " (required)" : ""}${f.unique ? " (unique)" : ""}`
+  );
+  showTaskDone(`Schema "${schemaName}" created`, fieldList);
 }
 
-const schemaName = process.argv[2];
+// ── Main ───────────────────────────────────────────
+
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  const isEditMode = rawArgs.includes("--edit");
+  const positionalArgs = rawArgs.filter((a) => !a.startsWith("--"));
+  const existingModels = listModels();
 
-promptSchemaDetails(schemaName);
+  // ── Direct edit mode (from 4bnode edit) ──────────
+  if (isEditMode) {
+    if (existingModels.length === 0) {
+      showError("No models found. Create one first with: 4bnode schema");
+      process.exit(1);
+    }
+
+    showHeader("edit", "Edit a schema");
+
+    let modelFile;
+    if (positionalArgs[0]) {
+      // Try to match the given name to an existing model
+      const target = positionalArgs[0].toLowerCase();
+      modelFile = existingModels.find(
+        (f) => path.basename(f, ".js").toLowerCase() === target
+      );
+      if (!modelFile) {
+        showError(`Model "${positionalArgs[0]}" not found.`);
+        console.log();
+        showInfo(`Available models: ${existingModels.map((f) => path.basename(f, ".js")).join(", ")}`);
+        process.exit(1);
+      }
+    } else {
+      modelFile = await select({
+        message: "Select model to edit:",
+        choices: existingModels.map((f) => ({
+          name: path.basename(f, ".js"),
+          value: f,
+        })),
+      });
+    }
+
+    await editModel(modelFile);
+    return;
+  }
+
+  // ── Normal schema flow ───────────────────────────
+  let schemaName = positionalArgs[0];
+
+  // If models exist and no name given, show action menu
+  if (existingModels.length > 0 && !schemaName) {
+    showHeader("schema", "Manage schemas");
+
+    const action = await select({
+      message: "What do you want to do?",
+      choices: [
+        { name: "Create new schema", value: "create" },
+        { name: "View existing schema", value: "view" },
+        { name: "Edit existing schema", value: "edit" },
+      ],
+    });
+
+    if (action === "view") {
+      if (existingModels.length === 1) {
+        viewModel(existingModels[0]);
+      } else {
+        const modelFile = await select({
+          message: "Select model to view:",
+          choices: existingModels.map((f) => ({
+            name: path.basename(f, ".js"),
+            value: f,
+          })),
+        });
+        viewModel(modelFile);
+      }
+      return;
+    }
+
+    if (action === "edit") {
+      if (existingModels.length === 1) {
+        await editModel(existingModels[0]);
+      } else {
+        const modelFile = await select({
+          message: "Select model to edit:",
+          choices: existingModels.map((f) => ({
+            name: path.basename(f, ".js"),
+            value: f,
+          })),
+        });
+        await editModel(modelFile);
+      }
+      return;
+    }
+
+    // action === "create" — fall through to create flow
+    schemaName = await input({
+      message: "Enter schema name:",
+      validate: (v) => {
+        try { sanitizeName(v); return true; } catch (e) { return e.message; }
+      },
+    });
+    schemaName = sanitizeName(schemaName);
+
+  } else if (!schemaName) {
+    showHeader("schema", "Create a new schema");
+    schemaName = await input({
+      message: "Enter schema name:",
+      validate: (v) => {
+        try { sanitizeName(v); return true; } catch (e) { return e.message; }
+      },
+    });
+    schemaName = sanitizeName(schemaName);
+
+  } else {
+    schemaName = sanitizeName(schemaName);
+    showHeader("schema", `Schema: ${schemaName}`);
+  }
+
+  await createSchema(schemaName);
+}
+
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});