uwebsockets 3.0.0 → 3.0.2

package/README.md

@@ -14,6 +14,8 @@
 
 - Browse the [documentation](https://unetworking.github.io/uwebsockets/generated/) and see the [main repo](https://github.com/NPM-Package-Jaykumar/uWebSockets). There are tons of [examples](examples) but here's the gist of it all:
 
+Example 1:
+
 ```javascript
 /* Non-SSL is simply App() */
 require("uwebsockets")
@@ -50,3 +52,148 @@ require("uwebsockets")
     }
   });
 ```
+
+Example 2:
+
+```javascript
+const uWS = require("uwebsockets");
+
+const WS_INSTANCES = {};
+
+// Below is a sample UWS server that listens for WebSocket connections and handles messages
+// from clients. It also includes a simple authentication mechanism based on a query parameter.
+// This is a basic example and should be adapted to your specific use case and security requirements.
+// This example uses uwebsockets for WebSocket handling.
+// You can install uwebsockets using npm:
+// npm install uwebsockets
+// Note: Make sure to replace the placeholder code with your actual logic.
+
+const wsApp = uWS.App().ws("/*", {
+  // Options for WebSocket server
+  compression: 0, // No compression
+  maxPayloadLength: 16 * 1024 * 1024, // 16 MB max payload size
+  idleTimeout: 8, // 8 seconds idle timeout
+
+  upgrade: (res, req, context) => {
+    // Check if the request has a valid "channel_id" query parameter
+    const channel_id = req.getQuery("channel_id");
+
+    // Check if the channel_id is valid (you can implement your own validation logic). below is an example
+    if (!channel_id) {
+      // Invalid channel_id, send a 400 Bad Request response
+      res
+        .writeStatus("400 Bad Request! missing channel_id in query parameter")
+        .end();
+      return;
+    }
+
+    // Store the channel_id in the WebSocket connection
+    res.upgrade(
+      { channel_id },
+      req.getHeader("sec-websocket-key"),
+      req.getHeader("sec-websocket-protocol"),
+      req.getHeader("sec-websocket-extensions"),
+      context
+    );
+  },
+
+  open: (ws) => {
+    // Check if the channel_id is already connected
+    const channel_id = ws.channel_id;
+
+    // Store the WebSocket connection in the WS_INSTANCES object
+    WS_INSTANCES[channel_id] = WS_INSTANCES[channel_id] || [];
+    WS_INSTANCES[channel_id].push(ws);
+
+    // Send a welcome message to the client
+    const welcomePayload = {
+      event: "welcome",
+      message: `Welcome ${channel_id} to the WebSocket server!`,
+      timestamp: Date.now(),
+    };
+    ws.send(JSON.stringify(welcomePayload));
+  },
+
+  message: (ws, message) => {
+    try {
+      // Parse the message and handle it
+      const channel_id = ws.channel_id;
+
+      // Buffer.from(message).toString() is used to convert the message to a string
+      // This is necessary because uwebsockets may send binary messages
+      // If you are sending text messages, you can directly use message.toString()
+      // If you are sending binary messages, you may need to convert them to a string first, Buffer.from(message).toString()
+      const msg = Buffer.from(message).toString();
+      const parsedMsg = JSON.parse(msg);
+
+      // Payload to be sent to the channel_id
+      // You can customize the payload structure based on your requirements
+      // For example, you can include the channel_id, event type, and data
+      const payload = {
+        event: "broadcast",
+        from: channel_id,
+        data: parsedMsg,
+        timestamp: Date.now(),
+      };
+
+      // Example: Echo the message back to the same user (or broadcast as needed)
+      ws.send(JSON.stringify(payload));
+    } catch (error) {
+      // Handle errors that occur during message processing
+      // For example, if the message is not a valid JSON string or if there is an error in your logic
+      // You can send an error message back to the client
+      // and log the error for debugging purposes
+      // Buffer.from(message).toString() is used to convert the message to a string
+      // This is necessary because uwebsockets may send binary messages
+      // If you are sending text messages, you can directly use message.toString()
+      const msg = Buffer.from(message).toString();
+
+      // error payload to be sent to the channel_id
+      // You can customize the error payload structure based on your requirements
+      const errorPayload = {
+        event: "error",
+        from: ws.channel_id,
+        message: error.message,
+        data: JSON.stringify(msg),
+        timestamp: Date.now(),
+      };
+
+      // Send the error message back to the client
+      ws.send(JSON.stringify(errorPayload));
+      console.error("Error processing message:", {
+        error,
+        message: JSON.stringify(msg),
+        ws: ws.channel_id,
+      });
+    }
+  },
+  close: (ws) => {
+    // Handle WebSocket disconnection
+    const channel_id = ws.channel_id;
+
+    // Remove the WebSocket connection from the WS_INSTANCES object
+    // This is done by filtering out the closed connection from the array of connections for the channel_id
+    // If there are no more connections for the channel_id, delete the channel_id entry from WS_INSTANCES
+    // This ensures that the server does not keep track of closed connections
+    // and helps to free up resources
+    WS_INSTANCES[channel_id] =
+      WS_INSTANCES[channel_id]?.filter((conn) => conn !== ws) || [];
+    if (WS_INSTANCES[channel_id].length === 0) delete WS_INSTANCES[channel_id];
+  },
+});
+
+// Start the WebSocket server
+// Listen using the properly defined wsApp instance
+wsApp.listen(9001, (token) => {
+  if (token) {
+    console.log(`WebSocket listening on ws://localhost:${9001}`);
+  } else {
+    console.error(`Failed to listen on port ${9001}`);
+  }
+});
+// Note: Make sure to handle errors and edge cases in your production code.
+// This example is a basic starting point and should be adapted to your specific use case.
+// You can also implement additional features such as authentication, authorization, and message validation
+// based on your requirements.
+// For more information on uwebsockets, refer to the official documentation
+```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "uwebsockets",
-  "version": "3.0.0",
-  "description": "µWebSockets.js is a web server bypass for Node.js that reimplements eventing, networking, encryption, web protocols, routing and pub/sub in highly optimized C++. As such, µWebSockets.js (websockets) delivers web serving for Node.js, 8.5x that of Fastify and at least 10x that of Socket.IO. It is also the built-in web server of Bun.",
+  "version": "3.0.2",
+  "description": "Fastest uWebSockets server for Node.js – µWebSockets outperforms Socket.IO & Fastify. Built in C++ for high-performance networking & pub/sub.",
   "main": "uws.js",
   "types": "./index.d.ts",
   "repository": {
@@ -9,12 +9,29 @@
     "url": "git+https://github.com/NPM-Package-Jaykumar/uWebSockets.git"
   },
   "keywords": [
+    "uWebSockets",
+    "uWebSockets npm",
+    "uWebSockets yarn",
+    "uWebSockets.js npm package",
+    "uWebSockets.js yarn package",
+    "fast websocket server",
     "websockets",
+    "websocket server",
+    "fast websocket",
+    "fastest websocket npm",
+    "node.js websocket server",
+    "socket.io alternative",
+    "fastify alternative",
+    "pubsub websocket",
+    "C++ networking",
+    "low latency server",
+    "high performance websocket",
     "socket",
     "node.js",
-    "web",
     "server",
     "µwebsockets",
+    "µwebsockets npm package",
+    "µwebsockets yarn package",
     "eventing",
     "networking",
     "encryption",
@@ -27,7 +44,13 @@
     "C++.",
     "fastify",
     "websocket",
-    "socket.IO."
+    "uws",
+    "socket.IO.",
+    "npm uWebSockets",
+    "yarn uWebSockets",
+    "yarn uWebSockets.js",
+    "jkg",
+    "jaykumar-gohil"
   ],
   "author": "",
   "license": "ISC",