4bnode 1.0.0

package/add-mongo-schema.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";
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const fieldTypes = [
+  "String",
+  "Number",
+  "Date",
+  "Boolean",
+  "Array",
+  "Buffer",
+  "Mixed",
+  "ObjectId",
+];
+
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+
+function toPascalCase(str) {
+  const camelCaseStr = toCamelCase(str);
+  return camelCaseStr.charAt(0).toUpperCase() + camelCaseStr.slice(1);
+}
+
+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;
+  }
+}
+
+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();
+                    }
+                  );
+                }
+              );
+            }
+          );
+        }
+      }
+    );
+  }
+
+  askField();
+}
+
+function generateSchemaFile(schemaName, fields) {
+  const projectRoot = process.cwd();
+  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
+      }`;
+      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;
+    })
+    .join(",\n  ")}
+}, { timestamps: true });
+
+const ${pascalSchemaName} = mongoose.model('${pascalSchemaName}', ${pascalSchemaName}Schema);
+
+export default ${pascalSchemaName};
+  `;
+
+  fs.writeFileSync(schemaFilePath, schemaContent.trim(), "utf8");
+  console.log(
+    chalk.green(`MongoDB schema ${schemaName} created successfully.`)
+  );
+}
+
+if (process.argv.length !== 3) {
+  console.error(chalk.red("Usage: add-mongo-schema <schemaName>"));
+  process.exit(0);
+}
+
+const schemaName = process.argv[2];
+
+promptSchemaDetails(schemaName);

package/add-mongo-update.js

@@ -0,0 +1,229 @@
+#!/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"));
+  if (routeFiles.length === 0) {
+    console.error(chalk.red("No route files found in src/routes"));
+    return null;
+  }
+  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"));
+  if (modelFiles.length === 0) {
+    console.error(chalk.red("No model files found in src/models"));
+    return null;
+  }
+  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;
+  }
+}
+
+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);
+
+  let updateTemplateImport = `import ${pascalModelName} from '../models/${modelName}.js';\n`;
+
+  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 (!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 = updateTemplateImport + routeContent;
+  }
+
+  // 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" });
+  }
+  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`;
+  }
+
+  fs.writeFileSync(routeFilePath, routeContent, "utf8");
+  console.log(chalk.green(`Update 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();
+const modelFiles = listModels();
+
+if (!routeFiles || !modelFiles) {
+  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);
+
+            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();
+    }
+  }
+);