4bnode 1.0.0

package/add-mongo.js

@@ -0,0 +1,257 @@
+#!/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 isDatabaseConfigured() {
+  const projectRoot = process.cwd();
+
+  const devEnvPath = path.join(projectRoot, ".env.development");
+  const prodEnvPath = path.join(projectRoot, ".env.production");
+
+  const isDevConfigured =
+    fs.existsSync(devEnvPath) &&
+    fs.readFileSync(devEnvPath, "utf8").includes("MONGO_URI=");
+  const isProdConfigured =
+    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");
+  }
+}
+
+function addMongoDB(devUri, prodUri) {
+  const projectRoot = process.cwd();
+
+  // Add MongoDB connection file
+  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 });
+  }
+  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`;
+
+  let indexContent = fs.readFileSync(indexPath, "utf8");
+  if (!indexContent.includes(dbImport)) {
+    indexContent = dbImport + indexContent;
+  }
+  if (!indexContent.includes(dbUse)) {
+    indexContent = indexContent.replace(
+      "const app = express();",
+      `${dbUse}const app = express();`
+    );
+  }
+  fs.writeFileSync(indexPath, indexContent, "utf8");
+
+  // Update .env files
+  updateEnvFile(path.join(projectRoot, ".env.development"), devUri);
+  updateEnvFile(path.join(projectRoot, ".env.production"), prodUri);
+
+  // Add mongoose to dependencies
+  execSync("npm install mongoose", { stdio: "inherit" });
+
+  console.log(
+    chalk.green(
+      `MongoDB integration added with development URI: ${devUri} and production URI: ${prodUri}`
+    )
+  );
+}
+
+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:`));
+
+    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);
+          }
+        }
+      );
+    }
+
+    askDatabaseName();
+  }
+
+  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);
+                    }
+
+                    // 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();
+
+                          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);
+                                                }
+
+                                                addMongoDB(devUri, prodUri);
+                                                rl.close();
+                                                process.exit(0);
+                                              }
+                                            );
+                                          }
+                                        );
+                                      }
+                                    );
+                                  }
+                                );
+                              }
+                            );
+                          } else {
+                            console.log(
+                              chalk.red(
+                                "Invalid input. Please enter Yes or No."
+                              )
+                            );
+                            askSameForProduction();
+                          }
+                        }
+                      );
+                    }
+
+                    askSameForProduction();
+                  }
+                );
+              }
+            );
+          }
+        );
+      }
+    );
+  });
+}

package/add-serialport.js

@@ -0,0 +1,124 @@
+#!/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`;
+
+  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");
+  }
+}
+
+function addSerialPort(serialPortPath, baudRate) {
+  const projectRoot = process.cwd();
+  const indexPath = path.join(projectRoot, "index.js");
+
+  const serialportImport = `
+import { SerialPort } from 'serialport';
+import { ReadlineParser } from '@serialport/parser-readline';
+`;
+
+  const serialportSetup = `
+try {
+  const serialPort = new SerialPort({
+    baudRate: parseInt(process.env.BAUDRATE, 10) || ${baudRate},
+    path: process.env.SERIALPORT_PATH || '${serialPortPath}',
+  });
+
+  const parser = serialPort.pipe(new ReadlineParser({ delimiter: "\\r\\n" }));
+
+  parser.on("data", async (data) => {
+    console.log('Received data:', data);
+  });
+
+  serialPort.on("error", function (err) {
+    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."));
+}
+
+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();
+      }
+    );
+  }
+);

package/add-socket.js

@@ -0,0 +1,110 @@
+#!/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 addSocketIo(ipAddresses) {
+  const projectRoot = process.cwd();
+  const indexPath = path.join(projectRoot, "index.js");
+
+  const socketIoImport = `import { Server } from "socket.io";\n`;
+  const httpImport = `import http from "http";\n`;
+
+  let corsOrigins;
+
+  if (ipAddresses.trim() === "*") {
+    corsOrigins = `["*"]`; // Allow all origins
+  } else {
+    const ipArray = ipAddresses.split(",").map((ip) => ip.trim());
+    corsOrigins = `[${ipArray.map((ip) => `"http://${ip}"`).join(", ")}]`;
+  }
+
+  const socketIoSetup = `
+const server = http.createServer(app);
+const io = new Server(server, {
+  cors: {
+    origin: ${corsOrigins},
+    methods: ["GET", "POST"]
+  }
+});
+
+io.on("connection", (socket) => {
+  console.log("A user connected");
+
+  socket.on("disconnect", () => {
+    console.log("User disconnected");
+  });
+});
+
+// Middleware to pass io instance to routes
+app.use((req, res, next) => {
+  req.io = io;
+  next();
+});
+`;
+
+  let indexContent = fs.readFileSync(indexPath, "utf8");
+
+  // Add imports if they don't already exist
+  if (!indexContent.includes(socketIoImport)) {
+    indexContent = socketIoImport + indexContent;
+  }
+  if (!indexContent.includes(httpImport)) {
+    indexContent = httpImport + indexContent;
+  }
+
+  // Ensure Socket.io setup is placed before routes
+  const routesStart = indexContent.indexOf("app.use(");
+  if (routesStart !== -1) {
+    indexContent =
+      indexContent.slice(0, routesStart) +
+      socketIoSetup +
+      indexContent.slice(routesStart);
+  } else {
+    indexContent += socketIoSetup;
+  }
+
+  // Replace existing app.listen if it exists
+  indexContent = indexContent.replace(/app\.listen\(port,.*\);/s, "");
+
+  // Append server.listen at the end if not already present
+  if (!indexContent.includes("server.listen(port")) {
+    indexContent += `
+server.listen(port, () => {
+  const localIp = getLocalNetworkIp();
+  console.log(\`App is running on http://localhost:\${port}\`);
+  if (localIp) {
+    console.log(
+      \`App is also accessible on your local network at http://\${localIp}:\${port}\`
+    );
+  }
+});
+`;
+  }
+
+  fs.writeFileSync(indexPath, indexContent, "utf8");
+
+  // Install socket.io
+  console.log(chalk.green("Installing socket.io..."));
+  execSync("npm install socket.io", { stdio: "inherit" });
+
+  console.log(chalk.green("Socket.io integration added successfully."));
+}
+
+rl.question(
+  chalk.yellow(
+    "Enter the IP addresses for socket.io (comma-separated or '*' to allow all): "
+  ),
+  (ipAddresses) => {
+    addSocketIo(ipAddresses);
+    rl.close();
+  }
+);

package/add-websocket.js

@@ -0,0 +1,199 @@
+#!/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, wsPort) {
+  if (!wsPort) return; // Don't update .env if using the same port as the server
+
+  const wsPortLine = `WS_PORT=${wsPort}\n`;
+
+  if (fs.existsSync(filePath)) {
+    let envContent = fs.readFileSync(filePath, "utf8");
+    if (envContent.includes("WS_PORT=")) {
+      envContent = envContent.replace(/WS_PORT=.*/, wsPortLine.trim());
+    } else {
+      envContent = envContent.trim() + "\n" + wsPortLine;
+    }
+    fs.writeFileSync(filePath, envContent, "utf8");
+  } else {
+    fs.writeFileSync(filePath, wsPortLine, "utf8");
+  }
+}
+
+function addWebSocket(samePort, wsPort = null) {
+  const projectRoot = process.cwd();
+  const indexPath = path.join(projectRoot, "index.js");
+
+  let indexContent = fs.readFileSync(indexPath, "utf8");
+
+  const wsImport = `import { WebSocketServer } from 'ws';\nimport http from 'http';\n`;
+
+  // Define WebSocket setup based on `samePort`
+  const websocketSetup = samePort
+    ? `
+const server = http.createServer(app);
+const wsServer = new WebSocketServer({ server });
+console.log(\`WebSocket server is running on the same port as the server (\${port})\`);
+`
+    : `
+const wsPort = process.env.WS_PORT || ${wsPort};
+const wsServer = new WebSocketServer({ port: wsPort });
+console.log(\`WebSocket server is running on WebSocket port \${wsPort}\`);
+`;
+
+  const wsLogic = `
+wsServer.on('connection', (ws) => {
+  console.log('A client connected');
+
+  ws.on('message', (message) => {
+    try {
+      const parsedMessage = JSON.parse(message);
+      console.log('Received:', parsedMessage);
+      
+      // Broadcast to all clients except sender
+      wsServer.clients.forEach((client) => {
+        if (client !== ws && client.readyState === ws.OPEN) {
+          client.send(JSON.stringify(parsedMessage));
+        }
+      });
+    } catch (error) {
+      console.error('Invalid message format:', error);
+    }
+  });
+
+  ws.on('close', () => {
+    console.log('Client disconnected');
+  });
+});
+
+app.use((req, res, next) => {
+  req.wss = wsServer;
+  next();
+});
+`;
+
+  // Select correct `listen()` method
+  const listenSetup = samePort
+    ? `
+server.listen(port, () => {
+  const localIp = getLocalNetworkIp();
+  console.log(\`App is running on http://localhost:\${port}\`);
+  if (localIp) {
+    console.log(
+      \`App is also accessible on your local network at http://\${localIp}:\${port}\`
+    );
+  }
+});
+`
+    : `
+app.listen(port, () => {
+  const localIp = getLocalNetworkIp();
+  console.log(\`App is running on http://localhost:\${port}\`);
+  if (localIp) {
+    console.log(
+      \`App is also accessible on your local network at http://\${localIp}:\${port}\`
+    );
+  }
+});
+`;
+
+  // Add imports if they don't already exist
+  if (!indexContent.includes(wsImport)) {
+    indexContent = wsImport + indexContent;
+  }
+
+  // Remove existing `app.listen()` or `server.listen()`
+  indexContent = indexContent.replace(/server\.listen\(port.*\);/s, "");
+  indexContent = indexContent.replace(/app\.listen\(port.*\);/s, "");
+
+  // Ensure WebSocket setup is placed before routes
+  if (!indexContent.includes("const wsServer = new WebSocketServer({")) {
+    const routesStart = indexContent.indexOf("app.use(");
+    if (routesStart !== -1) {
+      indexContent =
+        indexContent.slice(0, routesStart) +
+        websocketSetup +
+        wsLogic +
+        indexContent.slice(routesStart);
+    } else {
+      indexContent += websocketSetup + wsLogic;
+    }
+  }
+
+  // Append the correct `listen()` function
+  if (
+    !indexContent.includes("app.listen(port)") &&
+    !indexContent.includes("server.listen(port)")
+  ) {
+    indexContent += listenSetup;
+  }
+
+  fs.writeFileSync(indexPath, indexContent, "utf8");
+
+  // Update `.env` files only if using a separate WebSocket port
+  if (!samePort) {
+    updateEnvFile(path.join(projectRoot, ".env.development"), wsPort);
+    updateEnvFile(path.join(projectRoot, ".env.production"), wsPort);
+  }
+
+  // Install ws library
+  console.log(chalk.green("Installing ws..."));
+  execSync("npm install ws", { stdio: "inherit" });
+
+  console.log(chalk.green("WebSocket integration added successfully."));
+}
+
+// Get the server port from environment variables, default to 3000 if undefined
+const serverPort = process.env.PORT || 3000;
+
+function askWebSocketPort() {
+  rl.question(
+    chalk.yellow("Enter a different WebSocket port (default: 3001): "),
+    (wsPortInput) => {
+      let wsPort = parseInt(wsPortInput.trim()) || 3001;
+
+      if (wsPort === serverPort) {
+        console.log(
+          chalk.red("WebSocket port cannot be the same as the server port.")
+        );
+        askWebSocketPort(); // Re-prompt if user enters the same port
+      } else {
+        addWebSocket(false, wsPort); // samePort = false, pass wsPort
+        rl.close();
+      }
+    }
+  );
+}
+
+function askUseSamePort() {
+  rl.question(
+    chalk.yellow(
+      "Do you want to use the server port for WebSocket? (Yes/No): "
+    ),
+    (useSamePort) => {
+      const answer = useSamePort.trim().toLowerCase();
+
+      if (answer === "y" || answer === "yes") {
+        addWebSocket(true); // samePort = true, no wsPort needed
+        rl.close();
+      } else if (answer === "n" || answer === "no") {
+        askWebSocketPort(); // Ask for a different WebSocket port
+      } else {
+        console.log(chalk.red("Invalid input. Please enter Yes or No."));
+        askUseSamePort(); // Re-prompt if invalid input
+      }
+    }
+  );
+}
+
+// Start asking user input
+askUseSamePort();