4bnode 3.5.2 → 4.0.0

package/add-login.js

@@ -2,219 +2,42 @@
 
 import fs from "fs";
 import path from "path";
-import readline from "readline";
 import crypto from "crypto";
-import { execSync } from "child_process";
-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"));
-    process.exit(0);
-  }
-  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"));
-    process.exit(0);
-  }
-  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"));
-    process.exit(0);
-  }
-  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"));
-    process.exit(0);
-  }
-  return modelFiles;
-}
-
-function getModelSchema(modelName) {
-  const projectRoot = process.cwd();
-  const modelFilePath = path.join(
-    projectRoot,
-    "src",
-    "models",
-    modelName + ".js"
-  );
-  const modelFileContent = fs.readFileSync(modelFilePath, "utf8");
-
-  const schemaRegex = /new mongoose\.Schema\(\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);
-      process.exit(0);
-    }
-  } else {
-    console.error(chalk.red("Schema not found in model file."));
-    process.exit(0);
-  }
-}
-
-function promptSelectFields(fields, callback) {
-  console.log(
-    chalk.yellow(
-      "Select the fields to include in the data insertion (space-separated list of numbers):"
-    )
-  );
-  fields.forEach((field, index) => {
-    console.log(chalk.cyan(`${index + 1}. ${field}`));
-  });
-
-  rl.question(
-    chalk.yellow("Enter the numbers of the fields: "),
-    (fieldAnswer) => {
-      const selectedIndexes = fieldAnswer
-        .split(" ")
-        .map((index) => parseInt(index.trim(), 10) - 1);
-      const selectedFields = selectedIndexes
-        .map((index) => fields[index])
-        .filter((field) => field !== undefined);
-      callback(selectedFields);
-      rl.close();
-    }
-  );
-}
-
-function generateJwtSecret() {
-  return crypto.randomBytes(32).toString("hex");
-}
-
-function updateEnvFile(filePath, jwtSecret) {
-  const jwtSecretLine = `JWT_SECRET=${jwtSecret}\n`;
-
-  if (fs.existsSync(filePath)) {
-    let envContent = fs.readFileSync(filePath, "utf8");
-    if (envContent.includes("JWT_SECRET=")) {
-      envContent = envContent.replace(/JWT_SECRET=.*/, jwtSecretLine.trim());
-    } else {
-      envContent = envContent.trim() + "\n" + jwtSecretLine;
-    }
-    fs.writeFileSync(filePath, envContent, "utf8");
-  } else {
-    fs.writeFileSync(filePath, jwtSecretLine, "utf8");
-  }
-}
-
-function installDependencies() {
-  console.log(chalk.green("Installing dependencies: jsonwebtoken, bcrypt..."));
-  execSync("npm install jsonwebtoken bcrypt", { stdio: "inherit" });
-}
-
-function addLoginTemplateToRoute(routeFile, fields, modelName, useExpiry) {
-  const projectRoot = process.cwd();
-  const routeFilePath = path.join(projectRoot, "src", "routes", routeFile);
-  const pascalModelName =
-    modelName.charAt(0).toUpperCase() + modelName.slice(1);
-  const loginTemplateImport = `
-import bcrypt from 'bcrypt';
-import jwt from 'jsonwebtoken';  
-import ${pascalModelName} from '../models/${modelName}.js';
-`;
-
-  const loginTemplateFunction = `
-// Login logic
-const { ${fields.join(", ")} } = req.body;
-try {
-  const user = await ${pascalModelName}.findOne({ ${fields[0]}: ${fields[0]} });
-  if (!user) {
-    return res.status(404).json({ message: 'User not found' });
-  }
-  ${
-    fields.includes("password")
-      ? `
-  const isMatch = await bcrypt.compare(password, user.password);
-  if (!isMatch) {
-    return res.status(400).json({ message: 'Invalid credentials' });
-  }`
-      : ""
-  }
-  const payload = { id: user._id };
-  ${
-    useExpiry
-      ? `
-  const token = jwt.sign(payload, process.env.JWT_SECRET, { expiresIn: '15m' });
-  const refreshToken = jwt.sign(payload, process.env.JWT_SECRET, { expiresIn: '7d' });
-  res.json({ token, refreshToken });`
-      : `
-  const token = jwt.sign(payload, process.env.JWT_SECRET);
-  res.json({ token });`
-  }
-} 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}`)
-    );
-    process.exit(0);
-  }
-
-  let routeContent = fs.readFileSync(routeFilePath, "utf8");
-
-  if (!routeContent.includes("import bcrypt")) {
-    routeContent = loginTemplateImport + routeContent;
-  }
-
-  const lastCloseIndex = routeContent.lastIndexOf("});");
-  if (lastCloseIndex !== -1) {
-    const updatedContent = [
-      routeContent.slice(0, lastCloseIndex),
-      loginTemplateFunction,
-      routeContent.slice(lastCloseIndex),
-    ].join("\n");
-
-    routeContent = updatedContent;
-  } else {
-    routeContent += `\n${loginTemplateFunction}\n`;
-  }
-
-  fs.writeFileSync(routeFilePath, routeContent, "utf8");
-  console.log(chalk.green(`Login template added to ${routeFile}`));
-}
+import { select, confirm, checkbox } from "@inquirer/prompts";
+import { toPascalCase } from "./lib/names.js";
+import {
+  getProjectRoot,
+  listRoutes,
+  listModels,
+  getModelSchema,
+} from "./lib/project.js";
+import { updateEnvFile } from "./lib/env.js";
+import { addRouteRegistration } from "./lib/indexFile.js";
+import {
+  getRouteFilePath,
+  addImportToRoute,
+  insertCodeIntoRoute,
+} from "./lib/routeFile.js";
+import {
+  showHeader,
+  showTaskDone,
+  showError,
+  showInfo,
+  showFileAction,
+  installDeps,
+} from "./lib/ui.js";
 
 function addAuthMiddleware() {
-  const projectRoot = process.cwd();
-  const authFilePath = path.join(projectRoot, "src", "middleware", "auth.js");
+  const projectRoot = getProjectRoot();
+  const authDir = path.join(projectRoot, "src", "middleware");
+  const authFilePath = path.join(authDir, "auth.js");
 
   if (fs.existsSync(authFilePath)) {
-    console.log(chalk.yellow("Auth middleware already exists."));
+    showInfo("Auth middleware already exists.");
     return;
   }
 
-  const authMiddlewareContent = `
-import jwt from 'jsonwebtoken';
+  const content = `import jwt from 'jsonwebtoken';
 
 const auth = (req, res, next) => {
   const token = req.header('Authorization')?.replace('Bearer ', '');
@@ -234,25 +57,22 @@ const auth = (req, res, next) => {
 export default auth;
 `;
 
-  fs.mkdirSync(path.join(projectRoot, "src", "middleware"), {
-    recursive: true,
-  });
-  fs.writeFileSync(authFilePath, authMiddlewareContent.trim(), "utf8");
-  console.log(chalk.green("Auth middleware created successfully."));
+  fs.mkdirSync(authDir, { recursive: true });
+  fs.writeFileSync(authFilePath, content, "utf8");
+  showFileAction("created", "src/middleware/auth.js");
 }
 
 function addRefreshTokenRoute() {
-  const projectRoot = process.cwd();
+  const projectRoot = getProjectRoot();
   const routesDir = path.join(projectRoot, "src", "routes");
-  const refreshTokenFilePath = path.join(routesDir, "refresh-token.js");
+  const filePath = path.join(routesDir, "refresh-token.js");
 
-  if (fs.existsSync(refreshTokenFilePath)) {
-    console.log(chalk.yellow("Refresh token route already exists."));
+  if (fs.existsSync(filePath)) {
+    showInfo("Refresh token route already exists.");
     return;
   }
 
-  const refreshTokenContent = `
-import express from 'express';
+  const content = `import express from 'express';
 import jwt from 'jsonwebtoken';
 
 const router = express.Router();
@@ -278,118 +98,131 @@ export default router;
 `;
 
   fs.mkdirSync(routesDir, { recursive: true });
-  fs.writeFileSync(refreshTokenFilePath, refreshTokenContent.trim(), "utf8");
+  fs.writeFileSync(filePath, content, "utf8");
+  showFileAction("created", "src/routes/refresh-token.js");
+
+  addRouteRegistration(
+    "import refreshToken from './src/routes/refresh-token.js';",
+    "app.use('/refresh-token', refreshToken);"
+  );
+  showFileAction("updated", "index.js");
+}
 
-  // Update index.js to include the new route
-  const indexPath = path.join(projectRoot, "index.js");
-  const routeImport = `import refreshToken from './src/routes/refresh-token.js';\n`;
-  const routeUse = `app.use('/refresh-token', refreshToken);\n`;
+async function main() {
+  showHeader("add-login", "Setup authentication & login");
 
-  let indexContent = fs.readFileSync(indexPath, "utf8");
-  if (!indexContent.includes(routeImport)) {
-    indexContent = routeImport + indexContent;
+  const routeFiles = listRoutes();
+  if (routeFiles.length === 0) {
+    showError("No route files found in src/routes.");
+    process.exit(1);
   }
 
-  if (!indexContent.includes(routeUse)) {
-    if (indexContent.includes("app.listen(port")) {
-      indexContent = indexContent.replace(
-        "app.listen(port",
-        routeUse + "app.listen(port"
-      );
-    } else if (indexContent.includes("server.listen(port")) {
-      indexContent = indexContent.replace(
-        "server.listen(port",
-        routeUse + "server.listen(port"
-      );
-    }
+  const modelFiles = listModels();
+  if (modelFiles.length === 0) {
+    showError("No model files found in src/models.");
+    process.exit(1);
   }
 
-  fs.writeFileSync(indexPath, indexContent, "utf8");
+  const selectedRoute = await select({
+    message: "Select route file to modify:",
+    choices: routeFiles.map((f) => ({ name: f, value: f })),
+  });
 
-  console.log(chalk.green("Refresh token route created successfully."));
-}
+  const selectedModelFile = await select({
+    message: "Select model file to use:",
+    choices: modelFiles.map((f) => ({ name: f, value: f })),
+  });
 
-const routeFiles = listRoutes();
-const modelFiles = listModels();
+  const modelName = path.basename(selectedModelFile, ".js");
+  const pascalName = toPascalCase(modelName);
+  const schemaFields = getModelSchema(modelName);
 
-console.log(chalk.yellow("Select the route file to modify:"));
-routeFiles.forEach((file, index) => {
-  console.log(chalk.cyan(`${index + 1}. ${file}`));
-});
+  if (schemaFields.length === 0) {
+    showError("No fields found in the selected model.");
+    process.exit(1);
+  }
+
+  const useExpiry = await confirm({
+    message: "Use token expiry? (15m access + 7d refresh)",
+    default: false,
+  });
+
+  const selectedFields = await checkbox({
+    message: "Select login fields:",
+    choices: schemaFields.map((f) => ({ name: f, value: f })),
+    validate: (v) => (v.length > 0 ? true : "Select at least one field."),
+  });
 
-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.yellow("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);
-
-            rl.question(
-              chalk.yellow(
-                "Do you want to use expiry date for JWT token? (y/n): "
-              ),
-              (expiryAnswer) => {
-                const useExpiry = expiryAnswer.trim().toLowerCase() === "y";
-                promptSelectFields(schemaFields, (fields) => {
-                  addLoginTemplateToRoute(
-                    selectedRoute,
-                    fields,
-                    selectedModel,
-                    useExpiry
-                  );
-
-                  const jwtSecret = generateJwtSecret();
-                  const projectRoot = process.cwd();
-                  updateEnvFile(
-                    path.join(projectRoot, ".env.development"),
-                    jwtSecret
-                  );
-                  updateEnvFile(
-                    path.join(projectRoot, ".env.production"),
-                    jwtSecret
-                  );
-                  console.log(
-                    chalk.green(
-                      "JWT_SECRET has been added to .env.development and .env.production files."
-                    )
-                  );
-
-                  installDependencies();
-                  addAuthMiddleware();
-                  if (useExpiry) {
-                    addRefreshTokenRoute();
-                  }
-                });
-              }
-            );
-          } else {
-            console.error(
-              chalk.red("Invalid selection. Please choose a valid number.")
-            );
-            rl.close();
-            process.exit(0);
-          }
-        }
-      );
-    } else {
-      console.error(
-        chalk.red("Invalid selection. Please choose a valid number.")
-      );
-      rl.close();
-      process.exit(0);
+  console.log();
+
+  const routeFilePath = getRouteFilePath(selectedRoute);
+
+  addImportToRoute(
+    routeFilePath,
+    `import bcrypt from 'bcrypt';\nimport jwt from 'jsonwebtoken';\nimport ${pascalName} from '../models/${modelName}.js';`
+  );
+
+  const loginCode = `
+router.post('/login', async (req, res) => {
+  const { ${selectedFields.join(", ")} } = req.body;
+  try {
+    const user = await ${pascalName}.findOne({ ${selectedFields[0]}: ${selectedFields[0]} });
+    if (!user) {
+      return res.status(404).json({ message: 'User not found' });
+    }
+    ${
+      selectedFields.includes("password")
+        ? `const isMatch = await bcrypt.compare(password, user.password);
+    if (!isMatch) {
+      return res.status(400).json({ message: 'Invalid credentials' });
+    }`
+        : ""
     }
+    const payload = { id: user._id };
+    ${
+      useExpiry
+        ? `const token = jwt.sign(payload, process.env.JWT_SECRET, { expiresIn: '15m' });
+    const refreshToken = jwt.sign(payload, process.env.JWT_SECRET, { expiresIn: '7d' });
+    res.json({ token, refreshToken });`
+        : `const token = jwt.sign(payload, process.env.JWT_SECRET);
+    res.json({ token });`
+    }
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ message: 'Server error' });
   }
-);
+});`;
+
+  insertCodeIntoRoute(routeFilePath, loginCode);
+  showFileAction("updated", `src/routes/${selectedRoute}`);
+
+  const projectRoot = getProjectRoot();
+  const devSecret = crypto.randomBytes(32).toString("hex");
+  const prodSecret = crypto.randomBytes(32).toString("hex");
+  updateEnvFile(path.join(projectRoot, ".env.development"), "JWT_SECRET", devSecret);
+  showFileAction("updated", ".env.development");
+  updateEnvFile(path.join(projectRoot, ".env.production"), "JWT_SECRET", prodSecret);
+  showFileAction("updated", ".env.production");
+
+  await installDeps(["jsonwebtoken", "bcrypt"]);
+
+  addAuthMiddleware();
+
+  if (useExpiry) {
+    addRefreshTokenRoute();
+  }
+
+  const details = [
+    `Route: ${selectedRoute}`,
+    `Model: ${modelName}`,
+    `Fields: ${selectedFields.join(", ")}`,
+    useExpiry ? "JWT with 15m expiry + refresh token" : "JWT without expiry",
+  ];
+  showTaskDone("Login & auth configured", details);
+}
+
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});