4bnode 1.0.0

package/add-mongo-delete.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import chalk from "chalk";
+
+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 [];
+  }
+  const routeFiles = fs
+    .readdirSync(routesDir)
+    .filter((file) => file.endsWith(".js"));
+  if (routeFiles.length === 0) {
+    console.error(chalk.red("No route files found in src/routes"));
+    return [];
+  }
+  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 [];
+  }
+  const modelFiles = fs
+    .readdirSync(modelsDir)
+    .filter((file) => file.endsWith(".js"));
+  if (modelFiles.length === 0) {
+    console.error(chalk.red("No model files found in src/models"));
+    return [];
+  }
+  return modelFiles;
+}
+
+function addDeleteTemplateToRoute(routeFile, modelName) {
+  const projectRoot = process.cwd();
+  const routeFilePath = path.join(projectRoot, "src", "routes", routeFile);
+  const pascalModelName =
+    modelName.charAt(0).toUpperCase() + modelName.slice(1);
+  const deleteTemplateImport = `
+import ${pascalModelName} from '../models/${modelName}.js';
+`;
+
+  const deleteTemplateFunction = `
+// Data deletion logic
+try {
+  const deletedDocument = await ${pascalModelName}.findByIdAndDelete(req.params.id);
+  if (!deletedDocument) {
+    return res.status(404).json({ message: "Document not found" });
+  }
+  res.json({ message: "Data deleted successfully", data: deletedDocument });
+} catch (err) {
+  console.error(err);
+  res.status(500).json({ message: "Server error" });
+}
+`;
+
+  if (!fs.existsSync(routeFilePath)) {
+    console.error(
+      chalk.red(`The specified route file does not exist: ${routeFilePath}`)
+    );
+    return;
+  }
+
+  let routeContent = fs.readFileSync(routeFilePath, "utf8");
+
+  if (!routeContent.includes(`import ${pascalModelName}`)) {
+    routeContent = deleteTemplateImport + routeContent;
+  }
+
+  const lastCloseIndex = routeContent.lastIndexOf("});");
+  if (lastCloseIndex !== -1) {
+    const updatedContent = [
+      routeContent.slice(0, lastCloseIndex),
+      deleteTemplateFunction,
+      routeContent.slice(lastCloseIndex),
+    ].join("\n");
+
+    routeContent = updatedContent;
+  } else {
+    routeContent += `\n${deleteTemplateFunction}\n`;
+  }
+
+  fs.writeFileSync(routeFilePath, routeContent, "utf8");
+  console.log(chalk.green(`Delete template added to ${routeFile}`));
+}
+
+const routeFiles = listRoutes();
+if (routeFiles.length === 0) {
+  rl.close();
+  process.exit(0);
+}
+
+const modelFiles = listModels();
+if (modelFiles.length === 0) {
+  rl.close();
+  process.exit(0);
+}
+
+console.log(chalk.cyan("Select the route file to modify:"));
+routeFiles.forEach((file, index) => {
+  console.log(chalk.cyan(`${index + 1}. ${file}`));
+});
+
+rl.question(
+  chalk.yellow("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.cyan("Select the model file to use:"));
+      modelFiles.forEach((file, index) => {
+        console.log(chalk.cyan(`${index + 1}. ${file}`));
+      });
+
+      rl.question(
+        chalk.yellow("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");
+
+            addDeleteTemplateToRoute(selectedRoute, 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();
+    }
+  }
+);

package/add-mongo-insert.js

@@ -0,0 +1,231 @@
+#!/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 [];
+  }
+  const routeFiles = fs
+    .readdirSync(routesDir)
+    .filter((file) => file.endsWith(".js"));
+  if (routeFiles.length === 0) {
+    console.error(chalk.red("No route files found in src/routes"));
+    return [];
+  }
+  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 [];
+  }
+  const modelFiles = fs
+    .readdirSync(modelsDir)
+    .filter((file) => file.endsWith(".js"));
+  if (modelFiles.length === 0) {
+    console.error(chalk.red("No model files found in src/models"));
+    return [];
+  }
+  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 mongoose\.Schema\s*\(\s*\{([\s\S]*?)\}\s*\)/m;
+  const match = modelFileContent.match(schemaRegex);
+
+  if (match) {
+    try {
+      const schemaContent = match[1];
+      const fieldRegex = /(\w+):\s*\{[\s\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 [];
+    }
+  } else {
+    console.error(chalk.red("Schema not found in model file."));
+    return [];
+  }
+}
+
+function addInsertTemplateToRoute(routeFile, fields, modelName) {
+  const projectRoot = process.cwd();
+  const routeFilePath = path.join(projectRoot, "src", "routes", routeFile);
+  const pascalModelName =
+    modelName.charAt(0).toUpperCase() + modelName.slice(1);
+
+  let insertTemplateImport = `import ${pascalModelName} from '../models/${modelName}.js';\n`;
+
+  let passwordHashingLogic = "";
+  if (fields.includes("password")) {
+    insertTemplateImport =
+      `import bcrypt from 'bcrypt';\n` + insertTemplateImport;
+    passwordHashingLogic = `
+if (newData.password) {
+  const salt = await bcrypt.genSalt(10);
+  newData.password = await bcrypt.hash(newData.password, salt);
+}
+`;
+  }
+
+  if (!fs.existsSync(routeFilePath)) {
+    console.error(
+      chalk.red(`The specified route file does not exist: ${routeFilePath}`)
+    );
+    return;
+  }
+
+  let routeContent = fs.readFileSync(routeFilePath, "utf8");
+
+  if (!routeContent.includes(`import ${pascalModelName}`)) {
+    routeContent = insertTemplateImport + routeContent;
+  }
+
+  // Detect the request method type (GET, POST, PUT, DELETE)
+  const methodTypeRegex =
+    /router\.(get|post|put|delete)\((['"`])\/.*?\2,\s*async\s*\(req,\s*res/;
+  const methodMatch = routeContent.match(methodTypeRegex);
+  const methodType = methodMatch ? methodMatch[1].toLowerCase() : "post";
+
+  // Determine whether to use req.body or req.query based on method type
+  const requestDataSource =
+    methodType === "get" || methodType === "delete" ? "req.query" : "req.body";
+
+  // Generate data insertion logic
+  const insertTemplateFunction = `
+// Data insertion logic
+const newData = {
+  ${fields
+    .map((field) => `${field}: ${requestDataSource}.${field}`)
+    .join(",\n  ")}
+};
+${passwordHashingLogic}
+try {
+  const newDocument = new ${pascalModelName}(newData);
+  await newDocument.save();
+  res.json({ message: "Data inserted successfully", data: newDocument });
+} 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),
+      insertTemplateFunction,
+      routeContent.slice(lastCloseIndex),
+    ].join("\n");
+
+    routeContent = updatedContent;
+  } else {
+    routeContent += `\n${insertTemplateFunction}\n`;
+  }
+
+  fs.writeFileSync(routeFilePath, routeContent, "utf8");
+  console.log(chalk.green(`Insert template added to ${routeFile}`));
+
+  // Install bcrypt if needed
+  if (fields.includes("password")) {
+    console.log(chalk.green("Installing bcrypt..."));
+    execSync("npm install bcrypt", { stdio: "inherit" });
+  }
+}
+
+const routeFiles = listRoutes();
+if (routeFiles.length === 0) {
+  rl.close();
+  process.exit(0);
+}
+
+const modelFiles = listModels();
+if (modelFiles.length === 0) {
+  rl.close();
+  process.exit(0);
+}
+
+console.log(chalk.cyan("Select the route file to modify:"));
+routeFiles.forEach((file, index) => {
+  console.log(chalk.cyan(`${index + 1}. ${file}`));
+});
+
+rl.question(
+  chalk.yellow("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.cyan("Select the model file to use:"));
+      modelFiles.forEach((file, index) => {
+        console.log(chalk.cyan(`${index + 1}. ${file}`));
+      });
+
+      rl.question(
+        chalk.yellow("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.length === 0) {
+              rl.close();
+              return;
+            }
+
+            addInsertTemplateToRoute(
+              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();
+    }
+  }
+);

package/add-mongo-read.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import chalk from "chalk";
+
+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 [];
+  }
+  return fs.readdirSync(routesDir).filter((file) => file.endsWith(".js"));
+}
+
+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 [];
+  }
+  return fs.readdirSync(modelsDir).filter((file) => file.endsWith(".js"));
+}
+
+function getModelSchema(modelName) {
+  const projectRoot = process.cwd();
+  const modelFilePath = path.join(
+    projectRoot,
+    "src",
+    "models",
+    modelName + ".js"
+  );
+
+  if (!fs.existsSync(modelFilePath)) {
+    console.error(chalk.red(`Model file not found: ${modelFilePath}`));
+    return [];
+  }
+
+  const modelFileContent = fs.readFileSync(modelFilePath, "utf8");
+  const schemaRegex = /new mongoose\.Schema\s*\(\s*\{([\s\S]*?)\}\s*\)/m;
+  const match = modelFileContent.match(schemaRegex);
+
+  if (match) {
+    try {
+      const schemaContent = match[1];
+      const fieldRegex = /(\w+):\s*\{[\s\S]*?\}/g;
+      const schemaKeys = ["_id"]; // Always include `_id`
+      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 ["_id"];
+    }
+  } else {
+    console.error(chalk.red("Schema not found in model file."));
+    return ["_id"];
+  }
+}
+
+function addReadTemplateToRoute(routeFile, modelName, selectedField = null) {
+  const projectRoot = process.cwd();
+  const routeFilePath = path.join(projectRoot, "src", "routes", routeFile);
+  const pascalModelName =
+    modelName.charAt(0).toUpperCase() + modelName.slice(1);
+  const readTemplateImport = `import ${pascalModelName} from '../models/${modelName}.js';\n`;
+
+  let readTemplateFunction;
+
+  if (selectedField) {
+    readTemplateFunction = `
+// Fetch data based on ${selectedField}
+try {
+  const documents = await ${pascalModelName}.find({ ${selectedField}: req.query.${selectedField} });
+  if (documents.length === 0) {
+    return res.status(404).json({ message: "No matching documents found" });
+  }
+  res.json({ data: documents });
+} catch (err) {
+  console.error(err);
+  res.status(500).json({ message: "Server error" });
+}
+`;
+  } else {
+    readTemplateFunction = `
+// Fetch all data
+try {
+  const documents = await ${pascalModelName}.find();
+  res.json({ data: documents });
+} catch (err) {
+  console.error(err);
+  res.status(500).json({ message: "Server error" });
+}
+`;
+  }
+
+  if (!fs.existsSync(routeFilePath)) {
+    console.error(
+      chalk.red(`The specified route file does not exist: ${routeFilePath}`)
+    );
+    return;
+  }
+
+  let routeContent = fs.readFileSync(routeFilePath, "utf8");
+
+  if (!routeContent.includes(`import ${pascalModelName}`)) {
+    routeContent = readTemplateImport + routeContent;
+  }
+
+  const lastCloseIndex = routeContent.lastIndexOf("});");
+  if (lastCloseIndex !== -1) {
+    const updatedContent = [
+      routeContent.slice(0, lastCloseIndex),
+      readTemplateFunction,
+      routeContent.slice(lastCloseIndex),
+    ].join("\n");
+
+    routeContent = updatedContent;
+  } else {
+    routeContent += `\n${readTemplateFunction}\n`;
+  }
+
+  fs.writeFileSync(routeFilePath, routeContent, "utf8");
+  console.log(chalk.green(`Read template added to ${routeFile}`));
+}
+
+// Main Logic
+const routeFiles = listRoutes();
+const modelFiles = listModels();
+
+if (routeFiles.length === 0 || modelFiles.length === 0) {
+  rl.close();
+  process.exit(0);
+}
+
+console.log(chalk.blue("Select the route file to modify:"));
+routeFiles.forEach((file, index) => {
+  console.log(chalk.yellow(`${index + 1}. ${file}`));
+});
+
+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);
+
+            console.log(chalk.green("Do you want to:"));
+            console.log(chalk.green("1. Fetch all data"));
+            console.log(chalk.green("2. Fetch data based on a specific field"));
+
+            rl.question(
+              chalk.cyan("Enter your choice (1 or 2): "),
+              (choiceAnswer) => {
+                if (choiceAnswer === "1") {
+                  addReadTemplateToRoute(selectedRoute, selectedModel);
+                  rl.close();
+                } else if (choiceAnswer === "2" && schemaFields.length > 0) {
+                  console.log(
+                    chalk.green(
+                      "Select a field to filter data by (_id is always available):"
+                    )
+                  );
+                  schemaFields.forEach((field, index) => {
+                    console.log(chalk.yellow(`${index + 1}. ${field}`));
+                  });
+
+                  rl.question(
+                    chalk.cyan("Enter the number of the field: "),
+                    (fieldAnswer) => {
+                      const fieldIndex = parseInt(fieldAnswer, 10) - 1;
+                      if (fieldIndex >= 0 && fieldIndex < schemaFields.length) {
+                        const selectedField = schemaFields[fieldIndex];
+                        addReadTemplateToRoute(
+                          selectedRoute,
+                          selectedModel,
+                          selectedField
+                        );
+                      } else {
+                        console.error(
+                          chalk.red(
+                            "Invalid selection. Please choose a valid field number."
+                          )
+                        );
+                      }
+                      rl.close();
+                    }
+                  );
+                } else {
+                  console.error(
+                    chalk.red("Invalid choice. Please enter 1 or 2.")
+                  );
+                  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();
+    }
+  }
+);