4bnode 3.5.3 → 4.0.2

package/add-mongo.js

@@ -2,256 +2,163 @@
 
 import fs from "fs";
 import path from "path";
-import readline from "readline";
-import { execSync } from "child_process";
-import chalk from "chalk";
-
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-});
+import { input, select, confirm } from "@inquirer/prompts";
+import { getProjectRoot } from "./lib/project.js";
+import { updateEnvFile } from "./lib/env.js";
+import { addImport, readIndex, writeIndex } from "./lib/indexFile.js";
+import {
+  showHeader,
+  showTaskDone,
+  showWarning,
+  showError,
+  showFileAction,
+  showInfo,
+  installDeps,
+} from "./lib/ui.js";
 
 function isDatabaseConfigured() {
-  const projectRoot = process.cwd();
-
+  const projectRoot = getProjectRoot();
   const devEnvPath = path.join(projectRoot, ".env.development");
   const prodEnvPath = path.join(projectRoot, ".env.production");
-
-  const isDevConfigured =
+  const hasDev =
     fs.existsSync(devEnvPath) &&
     fs.readFileSync(devEnvPath, "utf8").includes("MONGO_URI=");
-  const isProdConfigured =
+  const hasProd =
     fs.existsSync(prodEnvPath) &&
     fs.readFileSync(prodEnvPath, "utf8").includes("MONGO_URI=");
-
-  return isDevConfigured || isProdConfigured;
-}
-
-function updateEnvFile(filePath, uri) {
-  const mongoUriLine = `MONGO_URI=${uri}\n`;
-
-  if (fs.existsSync(filePath)) {
-    let envContent = fs.readFileSync(filePath, "utf8");
-    if (envContent.includes("MONGO_URI=")) {
-      envContent = envContent.replace(/MONGO_URI=.*/, mongoUriLine.trim());
-    } else {
-      envContent = envContent.trim() + "\n" + mongoUriLine;
-    }
-    fs.writeFileSync(filePath, envContent, "utf8");
-  } else {
-    fs.writeFileSync(filePath, mongoUriLine, "utf8");
-  }
+  return hasDev || hasProd;
 }
 
 function addMongoDB(devUri, prodUri) {
-  const projectRoot = process.cwd();
+  const projectRoot = getProjectRoot();
 
-  // Add MongoDB connection file
-  const dbContent = `
-  import mongoose from 'mongoose';
+  const dbContent = `import mongoose from 'mongoose';
 
-  const connectDB = async () => {
-    try {
-      const conn = await mongoose.connect(process.env.MONGO_URI);
-      console.log(\`MongoDB connected: \${conn.connection.host}\`);
-    } catch (err) {
-      console.error(err);
-      process.exit(1);
-    }
-  };
-
-  export default connectDB;
-  `;
-  if (!fs.existsSync(path.join(projectRoot, "src"))) {
-    fs.mkdirSync(path.join(projectRoot, "src"), { recursive: true });
+const connectDB = async () => {
+  try {
+    const conn = await mongoose.connect(process.env.MONGO_URI);
+    console.log(\`MongoDB connected: \${conn.connection.host}\`);
+  } catch (err) {
+    console.error(err);
+    process.exit(1);
   }
-  fs.writeFileSync(
-    path.join(projectRoot, "src", "db.js"),
-    dbContent.trim(),
-    "utf8"
-  );
+};
 
-  // Update index.js to import and use MongoDB connection
-  const indexPath = path.join(projectRoot, "index.js");
-  const dbImport = `import connectDB from './src/db.js';\n`;
-  const dbUse = `connectDB();\n`;
+export default connectDB;`;
 
-  let indexContent = fs.readFileSync(indexPath, "utf8");
-  if (!indexContent.includes(dbImport)) {
-    indexContent = dbImport + indexContent;
+  const srcDir = path.join(projectRoot, "src");
+  if (!fs.existsSync(srcDir)) {
+    fs.mkdirSync(srcDir, { recursive: true });
   }
-  if (!indexContent.includes(dbUse)) {
+  fs.writeFileSync(path.join(srcDir, "db.js"), dbContent + "\n", "utf8");
+  showFileAction("created", "src/db.js");
+
+  addImport("import connectDB from './src/db.js';");
+  let indexContent = readIndex();
+  const dbCall = "connectDB();";
+  if (!indexContent.includes(dbCall)) {
     indexContent = indexContent.replace(
       "const app = express();",
-      `${dbUse}const app = express();`
+      `${dbCall}\nconst app = express();`
     );
+    writeIndex(indexContent);
   }
-  fs.writeFileSync(indexPath, indexContent, "utf8");
+  showFileAction("updated", "index.js");
 
-  // Update .env files
-  updateEnvFile(path.join(projectRoot, ".env.development"), devUri);
-  updateEnvFile(path.join(projectRoot, ".env.production"), prodUri);
+  updateEnvFile(path.join(projectRoot, ".env.development"), "MONGO_URI", devUri);
+  showFileAction("updated", ".env.development");
+  updateEnvFile(path.join(projectRoot, ".env.production"), "MONGO_URI", prodUri);
+  showFileAction("updated", ".env.production");
+}
 
-  // Add mongoose to dependencies
-  execSync("npm install mongoose", { stdio: "inherit" });
+async function main() {
+  showHeader("add-mongo", "Configure MongoDB integration");
 
-  console.log(
-    chalk.green(
-      `MongoDB integration added with development URI: ${devUri} and production URI: ${prodUri}`
-    )
-  );
-}
+  if (isDatabaseConfigured()) {
+    showWarning("MongoDB is already configured. Aborting.");
+    process.exit(0);
+  }
 
-if (isDatabaseConfigured()) {
-  console.log(
-    chalk.yellow(
-      "MongoDB is already configured in your environment files. Aborting operation."
-    )
-  );
-  rl.close();
-  process.exit(0);
-} else {
-  function promptForDatabaseDetails(env, callback) {
-    console.log(chalk.cyan(`\nEnter details for the ${env} database:`));
+  const method = await select({
+    message: "How do you want to configure MongoDB?",
+    choices: [
+      { name: "Quick setup (just database name)", value: "quick" },
+      { name: "Paste a connection URI", value: "uri" },
+    ],
+  });
 
-    function askDatabaseName() {
-      rl.question(
-        chalk.yellow("Enter the MongoDB database name: "),
-        (dbName) => {
-          if (!dbName.trim()) {
-            console.log(chalk.red("Database name is required."));
-            askDatabaseName();
-          } else {
-            callback(dbName);
-          }
-        }
-      );
+  let devUri;
+
+  if (method === "quick") {
+    const dbName = await input({
+      message: "Database name:",
+      validate: (v) => (v.trim() ? true : "Required."),
+    });
+
+    let ip = "127.0.0.1";
+    let port = "27017";
+    let auth = "";
+
+    const customize = await confirm({
+      message: "Configure IP, port, or auth? (optional)",
+      default: false,
+    });
+
+    if (customize) {
+      ip = (await input({ message: "IP address:", default: "127.0.0.1" })).trim();
+      port = (await input({ message: "Port:", default: "27017" })).trim();
+      const user = (await input({ message: "Username (blank to skip):" })).trim();
+      if (user) {
+        const pass = (await input({ message: "Password:" })).trim();
+        auth = `${user}:${pass}@`;
+      }
     }
 
-    askDatabaseName();
+    devUri = `mongodb://${auth}${ip}:${port}/${dbName.trim()}`;
+    showInfo(`URI: ${devUri}`);
+  } else {
+    devUri = await input({
+      message: "MongoDB URI:",
+      default: "mongodb://127.0.0.1:27017/mydb",
+      validate: (v) =>
+        v.trim().startsWith("mongodb://") || v.trim().startsWith("mongodb+srv://")
+          ? true
+          : "Must start with mongodb:// or mongodb+srv://",
+    });
+    devUri = devUri.trim();
   }
 
-  promptForDatabaseDetails("development", (devDbName) => {
-    rl.question(
-      chalk.yellow("Enter the MongoDB IP address (default: 127.0.0.1): "),
-      (devIpAddress) => {
-        const devIp = devIpAddress.trim() || "127.0.0.1";
-        rl.question(
-          chalk.yellow("Enter the MongoDB port (default: 27017): "),
-          (devPort) => {
-            const devDbPort = devPort.trim() || "27017";
-            rl.question(
-              chalk.yellow("Enter the MongoDB user ID (leave blank if none): "),
-              (devUserId) => {
-                rl.question(
-                  chalk.yellow(
-                    "Enter the MongoDB password (leave blank if none): "
-                  ),
-                  (devPassword) => {
-                    let devUri = `mongodb://${devIp}:${devDbPort}/${devDbName}`;
-                    if (devUserId && devPassword) {
-                      devUri = `mongodb://${devUserId}:${devPassword}@${devIp}:${devDbPort}/${devDbName}`;
-                    } else if (devUserId || devPassword) {
-                      console.error(
-                        chalk.red(
-                          "Both user ID and password must be provided together."
-                        )
-                      );
-                      process.exit(1);
-                    }
+  const useSameForProd = await confirm({
+    message: "Use the same URI for production?",
+    default: true,
+  });
 
-                    // Ask if the same details should be used for production
-                    function askSameForProduction() {
-                      rl.question(
-                        chalk.blueBright(
-                          "\nUse the same database details for production? (Yes/No): "
-                        ),
-                        (answer) => {
-                          const response = answer.trim().toLowerCase();
+  let prodUri = devUri;
+  if (!useSameForProd) {
+    prodUri = await input({
+      message: "Production MongoDB URI:",
+      default: devUri,
+      validate: (v) =>
+        v.trim().startsWith("mongodb://") || v.trim().startsWith("mongodb+srv://")
+          ? true
+          : "Must start with mongodb:// or mongodb+srv://",
+    });
+    prodUri = prodUri.trim();
+  }
 
-                          if (response === "y" || response === "yes") {
-                            addMongoDB(devUri, devUri);
-                            rl.close();
-                            process.exit(0);
-                          } else if (response === "n" || response === "no") {
-                            promptForDatabaseDetails(
-                              "production",
-                              (prodDbName) => {
-                                rl.question(
-                                  chalk.yellow(
-                                    "Enter the MongoDB IP address (default: 127.0.0.1): "
-                                  ),
-                                  (prodIpAddress) => {
-                                    const prodIp =
-                                      prodIpAddress.trim() || "127.0.0.1";
-                                    rl.question(
-                                      chalk.yellow(
-                                        "Enter the MongoDB port (default: 27017): "
-                                      ),
-                                      (prodPort) => {
-                                        const prodDbPort =
-                                          prodPort.trim() || "27017";
-                                        rl.question(
-                                          chalk.yellow(
-                                            "Enter the MongoDB user ID (leave blank if none): "
-                                          ),
-                                          (prodUserId) => {
-                                            rl.question(
-                                              chalk.yellow(
-                                                "Enter the MongoDB password (leave blank if none): "
-                                              ),
-                                              (prodPassword) => {
-                                                let prodUri = `mongodb://${prodIp}:${prodDbPort}/${prodDbName}`;
-                                                if (
-                                                  prodUserId &&
-                                                  prodPassword
-                                                ) {
-                                                  prodUri = `mongodb://${prodUserId}:${prodPassword}@${prodIp}:${prodDbPort}/${prodDbName}`;
-                                                } else if (
-                                                  prodUserId ||
-                                                  prodPassword
-                                                ) {
-                                                  console.error(
-                                                    chalk.red(
-                                                      "Both user ID and password must be provided together."
-                                                    )
-                                                  );
-                                                  process.exit(1);
-                                                }
+  console.log();
+  addMongoDB(devUri, prodUri);
 
-                                                addMongoDB(devUri, prodUri);
-                                                rl.close();
-                                                process.exit(0);
-                                              }
-                                            );
-                                          }
-                                        );
-                                      }
-                                    );
-                                  }
-                                );
-                              }
-                            );
-                          } else {
-                            console.log(
-                              chalk.red(
-                                "Invalid input. Please enter Yes or No."
-                              )
-                            );
-                            askSameForProduction();
-                          }
-                        }
-                      );
-                    }
+  await installDeps("mongoose");
 
-                    askSameForProduction();
-                  }
-                );
-              }
-            );
-          }
-        );
-      }
-    );
-  });
+  showTaskDone("MongoDB integration complete", [
+    `Dev:  ${devUri}`,
+    `Prod: ${prodUri}`,
+  ]);
 }
+
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});

package/add-serialport.js

@@ -1,49 +1,37 @@
 #!/usr/bin/env node
 
-import fs from "fs";
 import path from "path";
-import readline from "readline";
-import { execSync } from "child_process";
-import chalk from "chalk";
-
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-});
-
-function updateEnvFile(filePath, serialPortPath, baudRate) {
-  const serialPortPathLine = `SERIALPORT_PATH=${serialPortPath}\n`;
-  const baudRateLine = `BAUDRATE=${baudRate}\n`;
+import { input } from "@inquirer/prompts";
+import { getProjectRoot } from "./lib/project.js";
+import { updateEnvFile } from "./lib/env.js";
+import { addImport, insertBeforeListen } from "./lib/indexFile.js";
+import {
+  showHeader,
+  showTaskDone,
+  showError,
+  showFileAction,
+  installDeps,
+} from "./lib/ui.js";
+
+async function main() {
+  showHeader("add-serialport", "Add serial port communication");
+
+  const serialPortPath = await input({
+    message: "Serial port path:",
+    default: "/dev/tty-usbserial1",
+  });
 
-  if (fs.existsSync(filePath)) {
-    let envContent = fs.readFileSync(filePath, "utf8");
-    if (envContent.includes("SERIALPORT_PATH=")) {
-      envContent = envContent.replace(
-        /SERIALPORT_PATH=.*/,
-        serialPortPathLine.trim()
-      );
-    } else {
-      envContent = envContent.trim() + "\n" + serialPortPathLine;
-    }
-    if (envContent.includes("BAUDRATE=")) {
-      envContent = envContent.replace(/BAUDRATE=.*/, baudRateLine.trim());
-    } else {
-      envContent = envContent.trim() + "\n" + baudRateLine;
-    }
-    fs.writeFileSync(filePath, envContent, "utf8");
-  } else {
-    fs.writeFileSync(filePath, serialPortPathLine + baudRateLine, "utf8");
-  }
-}
+  const baudRate = await input({
+    message: "Baud rate:",
+    default: "9600",
+    validate: (v) => (!isNaN(parseInt(v, 10)) ? true : "Enter a valid number."),
+  });
 
-function addSerialPort(serialPortPath, baudRate) {
-  const projectRoot = process.cwd();
-  const indexPath = path.join(projectRoot, "index.js");
+  console.log();
 
-  const serialportImport = `
-import { SerialPort } from 'serialport';
-import { ReadlineParser } from '@serialport/parser-readline';
-`;
+  addImport("import { SerialPort } from 'serialport';");
+  addImport("import { ReadlineParser } from '@serialport/parser-readline';");
+  showFileAction("updated", "index.js");
 
   const serialportSetup = `
 try {
@@ -62,63 +50,30 @@ try {
     console.error("SerialPort Error: ", err.message);
   });
 } catch (error) {
-  console.error("Error initializing SerialPort or Parser:", error);
-}
-`;
-
-  let indexContent = fs.readFileSync(indexPath, "utf8");
-
-  // Add imports if they don't already exist
-  if (!indexContent.includes("import { SerialPort }")) {
-    indexContent = serialportImport + indexContent;
-  }
-
-  // Ensure SerialPort setup is added just before app.listen or server.listen
-  const listenMatch = indexContent.match(/(app|server)\.listen\(.*\);/);
-  if (listenMatch) {
-    indexContent = indexContent.replace(
-      listenMatch[0],
-      serialportSetup + "\n" + listenMatch[0]
-    );
-  } else {
-    indexContent += serialportSetup;
-  }
-
-  fs.writeFileSync(indexPath, indexContent, "utf8");
-
-  // Update .env files
-  updateEnvFile(
-    path.join(projectRoot, ".env.development"),
-    serialPortPath,
-    baudRate
-  );
-  updateEnvFile(
-    path.join(projectRoot, ".env.production"),
-    serialPortPath,
-    baudRate
-  );
-
-  // Install serialport and @serialport/parser-readline
-  execSync("npm install serialport @serialport/parser-readline", {
-    stdio: "inherit",
-  });
-
-  console.log(chalk.green("SerialPort integration added successfully."));
+  console.error("Error initializing SerialPort:", error);
+}`;
+
+  insertBeforeListen(serialportSetup);
+
+  const projectRoot = getProjectRoot();
+  updateEnvFile(path.join(projectRoot, ".env.development"), "SERIALPORT_PATH", serialPortPath);
+  updateEnvFile(path.join(projectRoot, ".env.development"), "BAUDRATE", baudRate);
+  updateEnvFile(path.join(projectRoot, ".env.production"), "SERIALPORT_PATH", serialPortPath);
+  updateEnvFile(path.join(projectRoot, ".env.production"), "BAUDRATE", baudRate);
+  showFileAction("updated", ".env.development");
+  showFileAction("updated", ".env.production");
+
+  await installDeps(["serialport", "@serialport/parser-readline"]);
+
+  showTaskDone("SerialPort integration complete", [
+    `Path: ${serialPortPath}`,
+    `Baud rate: ${baudRate}`,
+    "Data logged to console on receive",
+  ]);
 }
 
-rl.question(
-  chalk.yellow(
-    "Enter the serial port path (e.g., /dev/tty-usbserial1) [default: /dev/tty-usbserial1]: "
-  ),
-  (serialPortPath) => {
-    serialPortPath = serialPortPath.trim() || "/dev/tty-usbserial1";
-    rl.question(
-      chalk.yellow("Enter the baud rate (e.g., 9600) [default: 9600]: "),
-      (baudRate) => {
-        baudRate = baudRate.trim() || "9600";
-        addSerialPort(serialPortPath, baudRate);
-        rl.close();
-      }
-    );
-  }
-);
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});