4bnode 3.5.3 → 4.0.0

package/add-mongo-update.js

@@ -1,229 +1,116 @@
 #!/usr/bin/env node
 
-import fs from "fs";
 import path from "path";
-import readline from "readline";
-import chalk from "chalk";
-import { execSync } from "child_process";
-
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-});
-
-function listRoutes() {
-  const projectRoot = process.cwd();
-  const routesDir = path.join(projectRoot, "src", "routes");
-  if (!fs.existsSync(routesDir)) {
-    console.error(chalk.red("No routes directory found in src/routes"));
-    return null;
-  }
-  const routeFiles = fs
-    .readdirSync(routesDir)
-    .filter((file) => file.endsWith(".js"));
+import { select } from "@inquirer/prompts";
+import { toPascalCase } from "./lib/names.js";
+import { listRoutes, listModels, getModelSchema } from "./lib/project.js";
+import {
+  getRouteFilePath,
+  addImportToRoute,
+  insertCodeIntoRoute,
+  detectHttpMethod,
+  getRequestDataSource,
+} from "./lib/routeFile.js";
+import {
+  showHeader,
+  showTaskDone,
+  showError,
+  showFileAction,
+  installDeps,
+} from "./lib/ui.js";
+
+async function main() {
+  showHeader("add-mongo-update", "Add data update route");
+
+  const routeFiles = listRoutes();
   if (routeFiles.length === 0) {
-    console.error(chalk.red("No route files found in src/routes"));
-    return null;
+    showError("No route files found in src/routes.");
+    process.exit(1);
   }
-  return routeFiles;
-}
 
-function listModels() {
-  const projectRoot = process.cwd();
-  const modelsDir = path.join(projectRoot, "src", "models");
-  if (!fs.existsSync(modelsDir)) {
-    console.error(chalk.red("No models directory found in src/models"));
-    return null;
-  }
-  const modelFiles = fs
-    .readdirSync(modelsDir)
-    .filter((file) => file.endsWith(".js"));
+  const modelFiles = listModels();
   if (modelFiles.length === 0) {
-    console.error(chalk.red("No model files found in src/models"));
-    return null;
+    showError("No model files found in src/models.");
+    process.exit(1);
   }
-  return modelFiles;
-}
 
-function getModelSchema(modelName) {
-  const projectRoot = process.cwd();
-  const modelFilePath = path.join(
-    projectRoot,
-    "src",
-    "models",
-    modelName + ".js"
-  );
-  const modelFileContent = fs.readFileSync(modelFilePath, "utf8");
-
-  // Improved regex to handle beautified code
-  const schemaRegex = /new\s+mongoose\.Schema\s*\(\s*\{([\s\S]*?)\}\s*\)/m;
-  const match = modelFileContent.match(schemaRegex);
-
-  if (match) {
-    try {
-      const schemaContent = match[1];
-      const fieldRegex = /(\w+):\s*\{/g;
-      const schemaKeys = [];
-      let fieldMatch;
-      while ((fieldMatch = fieldRegex.exec(schemaContent)) !== null) {
-        schemaKeys.push(fieldMatch[1]);
-      }
-      return schemaKeys;
-    } catch (error) {
-      console.error(chalk.red("Error parsing schema: "), error);
-      return null;
-    }
-  } else {
-    console.error(chalk.red("Schema not found in model file."));
-    return null;
-  }
-}
+  const selectedRoute = await select({
+    message: "Select route file to modify:",
+    choices: routeFiles.map((f) => ({ name: f, value: f })),
+  });
 
-function addUpdateTemplateToRoute(routeFile, fields, modelName) {
-  const projectRoot = process.cwd();
-  const routeFilePath = path.join(projectRoot, "src", "routes", routeFile);
-  const pascalModelName =
-    modelName.charAt(0).toUpperCase() + modelName.slice(1);
+  const selectedModelFile = await select({
+    message: "Select model file to use:",
+    choices: modelFiles.map((f) => ({ name: f, value: f })),
+  });
 
-  let updateTemplateImport = `import ${pascalModelName} from '../models/${modelName}.js';\n`;
+  const modelName = path.basename(selectedModelFile, ".js");
+  const pascalName = toPascalCase(modelName);
+  const fields = getModelSchema(modelName);
 
-  let passwordHashingLogic = "";
-  if (fields.includes("password")) {
-    updateTemplateImport =
-      `import bcrypt from 'bcrypt';\n` + updateTemplateImport;
-    passwordHashingLogic = `
-if (updatedData.password) {
-  const salt = await bcrypt.genSalt(10);
-  updatedData.password = await bcrypt.hash(updatedData.password, salt);
-}
-`;
+  if (fields.length === 0) {
+    showError("No fields found in the selected model.");
+    process.exit(1);
   }
 
-  if (!fs.existsSync(routeFilePath)) {
-    console.error(
-      chalk.red(`The specified route file does not exist: ${routeFilePath}`)
-    );
-    return;
-  }
+  console.log();
 
-  let routeContent = fs.readFileSync(routeFilePath, "utf8");
+  const routeFilePath = getRouteFilePath(selectedRoute);
+  const method = detectHttpMethod(routeFilePath);
+  const dataSource = getRequestDataSource(method);
 
-  if (!routeContent.includes(`import ${pascalModelName}`)) {
-    routeContent = updateTemplateImport + routeContent;
-  }
+  let importBlock = `import ${pascalName} from '../models/${modelName}.js';`;
+  let passwordLogic = "";
 
-  // Detect HTTP method type
-  const methodTypeRegex =
-    /router\.(get|post|put|patch|delete)\((['"`])\/.*?\2,\s*async\s*\(req,\s*res/;
-  const methodMatch = routeContent.match(methodTypeRegex);
-  const methodType = methodMatch ? methodMatch[1].toLowerCase() : "put";
-
-  // Determine whether to use req.body or req.query based on method type
-  const requestDataSource =
-    methodType === "get" || methodType === "delete" ? "req.query" : "req.body";
-
-  // Generate update logic
-  const updateTemplateFunction = `
-// Data update logic
-const updatedData = {
-  ${fields
-    .map((field) => `${field}: ${requestDataSource}.${field}`)
-    .join(",\n  ")}
-};
-${passwordHashingLogic}
-try {
-  const updatedDocument = await ${pascalModelName}.findByIdAndUpdate(req.params.id, updatedData, { new: true });
-  if (!updatedDocument) {
-    return res.status(404).json({ message: "Document not found" });
+  if (fields.includes("password")) {
+    importBlock = `import bcrypt from 'bcrypt';\n${importBlock}`;
+    passwordLogic = `
+  if (updatedData.password) {
+    const salt = await bcrypt.genSalt(10);
+    updatedData.password = await bcrypt.hash(updatedData.password, salt);
+  }`;
   }
-  res.json({ message: "Data updated successfully", data: updatedDocument });
-} catch (err) {
-  console.error(err);
-  res.status(500).json({ message: "Server error" });
-}
-`;
-
-  // Insert the logic before the last closing `});`
-  const lastCloseIndex = routeContent.lastIndexOf("});");
-  if (lastCloseIndex !== -1) {
-    const updatedContent = [
-      routeContent.slice(0, lastCloseIndex),
-      updateTemplateFunction,
-      routeContent.slice(lastCloseIndex),
-    ].join("\n");
-
-    routeContent = updatedContent;
-  } else {
-    routeContent += `\n${updateTemplateFunction}\n`;
+
+  addImportToRoute(routeFilePath, importBlock);
+
+  const fieldAssignments = fields
+    .map((f) => `    ${f}: ${dataSource}.${f}`)
+    .join(",\n");
+
+  const updateCode = `
+router.put('/:id', async (req, res) => {
+  const updatedData = {
+${fieldAssignments}
+  };
+${passwordLogic}
+  try {
+    const updatedDocument = await ${pascalName}.findByIdAndUpdate(req.params.id, updatedData, { new: true });
+    if (!updatedDocument) {
+      return res.status(404).json({ message: 'Document not found' });
+    }
+    res.json({ message: 'Data updated successfully', data: updatedDocument });
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Server error' });
   }
+});`;
 
-  fs.writeFileSync(routeFilePath, routeContent, "utf8");
-  console.log(chalk.green(`Update template added to ${routeFile}`));
+  insertCodeIntoRoute(routeFilePath, updateCode);
+  showFileAction("updated", `src/routes/${selectedRoute}`);
 
-  // Install bcrypt if needed
   if (fields.includes("password")) {
-    console.log(chalk.green("Installing bcrypt..."));
-    execSync("npm install bcrypt", { stdio: "inherit" });
+    await installDeps("bcrypt");
   }
-}
-
-const routeFiles = listRoutes();
-const modelFiles = listModels();
 
-if (!routeFiles || !modelFiles) {
-  rl.close();
-  process.exit(0);
+  showTaskDone("Update route added", [
+    `Route: PUT /:id in ${selectedRoute}`,
+    `Model: ${modelName}`,
+    `Fields: ${fields.join(", ")}`,
+  ]);
 }
 
-console.log(chalk.blue("Select the route file to modify:"));
-routeFiles.forEach((file, index) => {
-  console.log(chalk.yellow(`${index + 1}. ${file}`));
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
 });
-
-rl.question(
-  chalk.cyan("Enter the number of the route file: "),
-  (routeAnswer) => {
-    const routeIndex = parseInt(routeAnswer, 10) - 1;
-    if (routeIndex >= 0 && routeIndex < routeFiles.length) {
-      const selectedRoute = routeFiles[routeIndex];
-
-      console.log(chalk.blue("Select the model file to use:"));
-      modelFiles.forEach((file, index) => {
-        console.log(chalk.yellow(`${index + 1}. ${file}`));
-      });
-
-      rl.question(
-        chalk.cyan("Enter the number of the model file: "),
-        (modelAnswer) => {
-          const modelIndex = parseInt(modelAnswer, 10) - 1;
-          if (modelIndex >= 0 && modelIndex < modelFiles.length) {
-            const selectedModel = path.basename(modelFiles[modelIndex], ".js");
-            const schemaFields = getModelSchema(selectedModel);
-
-            if (!schemaFields) {
-              rl.close();
-              process.exit(0);
-            }
-
-            addUpdateTemplateToRoute(
-              selectedRoute,
-              schemaFields,
-              selectedModel
-            );
-            rl.close();
-          } else {
-            console.error(
-              chalk.red("Invalid selection. Please choose a valid number.")
-            );
-            rl.close();
-          }
-        }
-      );
-    } else {
-      console.error(
-        chalk.red("Invalid selection. Please choose a valid number.")
-      );
-      rl.close();
-    }
-  }
-);