4bnode 3.5.3 → 4.0.2

package/add-socket.js

@@ -1,33 +1,42 @@
 #!/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");
+import { input } from "@inquirer/prompts";
+import {
+  addImport,
+  insertBeforeRoutes,
+  replaceAppListen,
+} from "./lib/indexFile.js";
+import {
+  showHeader,
+  showTaskDone,
+  showError,
+  showFileAction,
+  installDeps,
+} from "./lib/ui.js";
+
+async function main() {
+  showHeader("add-socket", "Add Socket.IO real-time support");
+
+  const ipAddresses = await input({
+    message: "CORS origins (comma-separated, or * for all):",
+    default: "*",
+  });
 
-  const socketIoImport = `import { Server } from "socket.io";\n`;
-  const httpImport = `import http from "http";\n`;
+  console.log();
 
   let corsOrigins;
-
   if (ipAddresses.trim() === "*") {
-    corsOrigins = `["*"]`; // Allow all origins
+    corsOrigins = '["*"]';
   } else {
     const ipArray = ipAddresses.split(",").map((ip) => ip.trim());
     corsOrigins = `[${ipArray.map((ip) => `"http://${ip}"`).join(", ")}]`;
   }
 
-  const socketIoSetup = `
+  addImport('import { Server } from "socket.io";');
+  addImport('import http from "http";');
+  showFileAction("updated", "index.js");
+
+  const socketSetup = `
 const server = http.createServer(app);
 const io = new Server(server, {
   cors: {
@@ -44,40 +53,14 @@ io.on("connection", (socket) => {
   });
 });
 
-// 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;
-  }
+  insertBeforeRoutes(socketSetup);
 
-  // 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 += `
+  replaceAppListen(`
 server.listen(port, () => {
   const localIp = getLocalNetworkIp();
   console.log(\`App is running on http://localhost:\${port}\`);
@@ -86,25 +69,19 @@ server.listen(port, () => {
       \`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" });
+  await installDeps("socket.io");
 
-  console.log(chalk.green("Socket.io integration added successfully."));
+  showTaskDone("Socket.IO integration complete", [
+    `CORS: ${ipAddresses.trim()}`,
+    "Access via req.io in routes",
+    "Events: connection, disconnect",
+  ]);
 }
 
-rl.question(
-  chalk.yellow(
-    "Enter the IP addresses for socket.io (comma-separated or '*' to allow all): "
-  ),
-  (ipAddresses) => {
-    addSocketIo(ipAddresses);
-    rl.close();
-  }
-);
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});

package/add-websocket.js

@@ -1,54 +1,63 @@
 #!/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`;
+import { confirm, input } from "@inquirer/prompts";
+import { getProjectRoot } from "./lib/project.js";
+import { updateEnvFile } from "./lib/env.js";
+import {
+  addImport,
+  insertBeforeRoutes,
+  replaceAppListen,
+} from "./lib/indexFile.js";
+import {
+  showHeader,
+  showTaskDone,
+  showError,
+  showFileAction,
+  installDeps,
+} from "./lib/ui.js";
+
+async function main() {
+  showHeader("add-websocket", "Add native WebSocket support");
+
+  const samePort = await confirm({
+    message: "Use the server port for WebSocket?",
+    default: true,
+  });
 
-  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");
+  let wsPort = null;
+  if (!samePort) {
+    const serverPort = process.env.PORT || 3000;
+    wsPort = await input({
+      message: "Enter WebSocket port:",
+      default: "3001",
+      validate: (v) => {
+        const num = parseInt(v, 10);
+        if (isNaN(num) || num < 1 || num > 65535) return "Enter a valid port.";
+        if (num === Number(serverPort))
+          return "Cannot be the same as the server port.";
+        return true;
+      },
+    });
   }
-}
 
-function addWebSocket(samePort, wsPort = null) {
-  const projectRoot = process.cwd();
-  const indexPath = path.join(projectRoot, "index.js");
+  console.log();
 
-  let indexContent = fs.readFileSync(indexPath, "utf8");
-
-  const wsImport = `import { WebSocketServer } from 'ws';\nimport http from 'http';\n`;
+  addImport("import { WebSocketServer } from 'ws';");
+  if (samePort) {
+    addImport("import http from 'http';");
+  }
+  showFileAction("updated", "index.js");
 
-  // 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})\`);
-`
+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}\`);
-`;
+console.log(\`WebSocket server is running on WebSocket port \${wsPort}\`);`;
 
   const wsLogic = `
 wsServer.on('connection', (ws) => {
@@ -58,8 +67,7 @@ wsServer.on('connection', (ws) => {
     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));
@@ -78,12 +86,12 @@ wsServer.on('connection', (ws) => {
 app.use((req, res, next) => {
   req.wss = wsServer;
   next();
-});
-`;
+});`;
 
-  // Select correct `listen()` method
-  const listenSetup = samePort
-    ? `
+  insertBeforeRoutes(websocketSetup + "\n" + wsLogic);
+
+  if (samePort) {
+    replaceAppListen(`
 server.listen(port, () => {
   const localIp = getLocalNetworkIp();
   console.log(\`App is running on http://localhost:\${port}\`);
@@ -92,108 +100,28 @@ server.listen(port, () => {
       \`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);
+    const projectRoot = getProjectRoot();
+    updateEnvFile(path.join(projectRoot, ".env.development"), "WS_PORT", wsPort);
+    updateEnvFile(path.join(projectRoot, ".env.production"), "WS_PORT", wsPort);
+    showFileAction("updated", ".env.development");
+    showFileAction("updated", ".env.production");
   }
 
-  // Install ws library
-  console.log(chalk.green("Installing ws..."));
-  execSync("npm install ws", { stdio: "inherit" });
+  await installDeps("ws");
 
-  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();
-      }
-    }
-  );
+  showTaskDone("WebSocket integration complete", [
+    samePort ? "Sharing server port" : `WebSocket port: ${wsPort}`,
+    "Access via req.wss in routes",
+    "Auto-broadcasts to all clients",
+  ]);
 }
 
-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();
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});