@wxn0brp/gloves-link-server 0.0.4 → 0.0.6

package/README.md

@@ -28,7 +28,7 @@ npm i @wxn0brp/gloves-link-server @wxn0brp/falcon-frame
 ## Usage
 
 ```typescript
-import { GlovesLinkServer } from '@wxn0brp/gloves-link/server';
+import { GlovesLinkServer } from '@wxn0brp/gloves-link-server';
 import { FalconFrame } from '@wxn0brp/falcon-frame';
 
 const app = new FalconFrame();

package/dist/index.d.ts

@@ -3,23 +3,21 @@ import { Server_Opts } from "./types.js";
 import { GLSocket } from "./socket.js";
 import FalconFrame from "@wxn0brp/falcon-frame";
 import { Room, Rooms } from "./room.js";
+import { Namespace } from "./namespace.js";
 export declare class GlovesLinkServer {
     wss: WebSocketServer;
-    private onConnectEvent;
     logs: boolean;
     opts: Server_Opts;
     initStatusTemp: {
         [key: string]: number;
     };
     rooms: Rooms;
-    globalRoom: Room;
+    private namespaces;
     constructor(opts: Partial<Server_Opts>);
     private saveSocketStatus;
-    onConnect(handler: (ws: GLSocket) => void): void;
-    broadcast(event: string, ...args: any[]): void;
+    of(path: string): Namespace;
     broadcastRoom(roomName: string, event: string, ...args: any[]): void;
-    broadcastWithoutSelf(socket: GLSocket, event: string, ...args: any[]): void;
     room(name: string): Room;
-    falconFrame(app: FalconFrame, clientDir?: string): void;
+    falconFrame(app: FalconFrame, clientDir?: string | false): void;
 }
-export { GLSocket };
+export { GLSocket, Namespace, Server_Opts };

package/dist/index.js

@@ -2,19 +2,18 @@ import { WebSocketServer } from "ws";
 import { GLSocket } from "./socket.js";
 import { Router } from "@wxn0brp/falcon-frame";
 import { Room } from "./room.js";
+import { Namespace } from "./namespace.js";
 export class GlovesLinkServer {
     wss;
-    onConnectEvent;
     logs = false;
     opts;
     initStatusTemp = {};
     rooms = new Map();
-    globalRoom = new Room();
+    namespaces = new Map();
     constructor(opts) {
         this.opts = {
             server: null,
             logs: false,
-            authFn: () => true,
             ...opts
         };
         if (!this.opts?.server) {
@@ -29,9 +28,17 @@ export class GlovesLinkServer {
                 const url = new URL(request.url, `http://${request.headers.host}`);
                 const token = url.searchParams.get("token");
                 socketSelfId = url.searchParams.get("id");
-                const isAuthenticated = await this.opts.authFn({ headers, url, token });
-                if (!isAuthenticated) {
-                    this.saveSocketStatus(socketSelfId, 401);
+                const { pathname } = url;
+                const namespace = this.namespaces.get(pathname);
+                if (!namespace) {
+                    this.saveSocketStatus(socketSelfId, pathname, 404);
+                    socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+                    socket.destroy();
+                    return;
+                }
+                const authResult = await namespace.authFn({ headers, url, token, request, socket, head });
+                if (!authResult) {
+                    this.saveSocketStatus(socketSelfId, pathname, 401);
                     socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
                     socket.destroy();
                     return;
@@ -39,12 +46,14 @@ export class GlovesLinkServer {
                 this.wss.handleUpgrade(request, socket, head, (ws) => {
                     const glSocket = new GLSocket(ws, this);
                     glSocket.logs = this.logs;
-                    this.globalRoom.join(glSocket);
-                    this.onConnectEvent(glSocket);
+                    if (typeof authResult === "object" && authResult !== null)
+                        glSocket.user = authResult;
+                    glSocket.namespace = pathname;
+                    namespace.room.join(glSocket);
+                    namespace.onConnectHandler(glSocket);
                     ws.on("close", () => {
                         glSocket.handlers?.disconnect?.();
-                        glSocket.leaveAllRooms();
-                        this.globalRoom.leave(glSocket);
+                        namespace.room.leave(glSocket);
                     });
                 });
             }
@@ -53,25 +62,28 @@ export class GlovesLinkServer {
                     console.error("[GlovesLinkServer]", err);
                 if (this.logs)
                     console.warn("[auth] Error during authentication:", err);
-                this.saveSocketStatus(socketSelfId, 500);
+                this.saveSocketStatus(socketSelfId, "/", 500);
                 socket.write("HTTP/1.1 500 Internal Server Error\r\n\r\n");
                 socket.destroy();
             }
         });
     }
-    saveSocketStatus(socketSelfId, status) {
+    saveSocketStatus(socketSelfId, namespace, status) {
         if (!socketSelfId)
             return;
-        this.initStatusTemp[socketSelfId] = status;
+        const id = namespace + "-" + socketSelfId;
+        this.initStatusTemp[id] = status;
         setTimeout(() => {
-            delete this.initStatusTemp[socketSelfId];
+            delete this.initStatusTemp[id];
         }, 10_000);
     }
-    onConnect(handler) {
-        this.onConnectEvent = handler;
-    }
-    broadcast(event, ...args) {
-        this.globalRoom.emit(event, ...args);
+    of(path) {
+        let namespace = this.namespaces.get(path);
+        if (!namespace) {
+            namespace = new Namespace(path, this);
+            this.namespaces.set(path, namespace);
+        }
+        return namespace;
     }
     broadcastRoom(roomName, event, ...args) {
         const room = this.room(roomName);
@@ -79,24 +91,24 @@ export class GlovesLinkServer {
             return;
         room.emit(event, ...args);
     }
-    broadcastWithoutSelf(socket, event, ...args) {
-        this.globalRoom.emitWithoutSelf(socket, event, ...args);
-    }
     room(name) {
         return this.rooms.get(name) || this.rooms.set(name, new Room()).get(name);
     }
     falconFrame(app, clientDir) {
-        clientDir = clientDir || "node_modules/@wxn0brp/gloves-link-client/dist/";
         const router = new Router();
         app.use("/gloves-link", router);
-        router.static("/", clientDir);
         router.get("/status", (req, res) => {
             const id = req.query.id;
             if (!id) {
                 res.status(400).json({ err: true, msg: "No id provided" });
                 return;
             }
-            const status = this.initStatusTemp[id];
+            const path = req.query.path;
+            if (!path) {
+                res.status(400).json({ err: true, msg: "No path provided" });
+                return;
+            }
+            const status = this.initStatusTemp[path + "-" + id];
             if (status === undefined) {
                 res.status(404).json({ err: true, msg: "Socket not found" });
                 return;
@@ -104,10 +116,14 @@ export class GlovesLinkServer {
             res.json({ status });
             delete this.initStatusTemp[id];
         });
+        if (clientDir === false)
+            return;
+        clientDir = clientDir || "node_modules/@wxn0brp/gloves-link-client/dist/";
+        router.static("/", clientDir);
         router.get("/*", (req, res) => {
             res.redirect("/gloves-link/GlovesLinkClient.js");
             res.end();
         });
     }
 }
-export { GLSocket };
+export { GLSocket, Namespace };

package/dist/namespace.d.ts

@@ -0,0 +1,17 @@
+import { AuthFn } from "./types.js";
+import { GLSocket } from "./socket.js";
+import { Room } from "./room.js";
+import { GlovesLinkServer } from "./index.js";
+export declare class Namespace {
+    name: string;
+    private server;
+    private onConnectEvent;
+    authFn: AuthFn;
+    room: Room;
+    constructor(name: string, server: GlovesLinkServer);
+    onConnect(handler: (ws: GLSocket) => void): this;
+    auth(authFn: AuthFn): this;
+    get onConnectHandler(): (ws: GLSocket) => void;
+    emit(event: string, ...args: any[]): void;
+    emitWithoutSelf(socket: GLSocket, event: string, ...args: any[]): void;
+}

package/dist/namespace.js

@@ -0,0 +1,30 @@
+export class Namespace {
+    name;
+    server;
+    onConnectEvent = () => { };
+    authFn = () => false;
+    room;
+    constructor(name, server) {
+        this.name = name;
+        this.server = server;
+        const roomName = `gls-namespace-${name}`;
+        this.room = this.server.room(roomName);
+    }
+    onConnect(handler) {
+        this.onConnectEvent = handler;
+        return this;
+    }
+    auth(authFn) {
+        this.authFn = authFn;
+        return this;
+    }
+    get onConnectHandler() {
+        return this.onConnectEvent;
+    }
+    emit(event, ...args) {
+        this.room.emit(event, ...args);
+    }
+    emitWithoutSelf(socket, event, ...args) {
+        this.room.emitWithoutSelf(socket, event, ...args);
+    }
+}

package/dist/room.d.ts

@@ -3,7 +3,7 @@ import { GLSocket } from "./socket.js";
 export type Rooms = Map<string, Room>;
 export declare class Room {
     clients: Set<GLSocket>;
-    eventEmitter: EventEmitter<[never]>;
+    eventEmitter: EventEmitter<any>;
     join(socket: GLSocket): void;
     leave(socket: GLSocket): void;
     leaveAll(): void;

package/dist/socket.d.ts

@@ -4,6 +4,8 @@ export declare class GLSocket {
     ws: WebSocket;
     server: GlovesLinkServer;
     id: string;
+    user: any;
+    namespace: string;
     ackIdCounter: number;
     ackCallbacks: Map<number, Function>;
     logs: boolean;

package/dist/socket.js

@@ -1,8 +1,10 @@
-import { joinSocketToRoom, leaveAllSocketFromRoom, leaveSocketFromRoom } from "./room.js";
+import { joinSocketToRoom, leaveSocketFromRoom } from "./room.js";
 export class GLSocket {
     ws;
     server;
     id;
+    user = {};
+    namespace;
     ackIdCounter = 1;
     ackCallbacks = new Map();
     logs = false;
@@ -85,7 +87,9 @@ export class GLSocket {
         this.rooms.delete(roomName);
     }
     leaveAllRooms() {
-        leaveAllSocketFromRoom(this);
+        for (const roomName of this.rooms) {
+            leaveSocketFromRoom(this, roomName);
+        }
         this.rooms.clear();
     }
 }

package/dist/types.d.ts

@@ -1,8 +1,8 @@
 import http from "http";
+import Stream from "stream";
 export interface Server_Opts {
     server: http.Server;
     logs: boolean;
-    authFn: AuthFn;
 }
 export interface Server_DataEvent {
     evt: string;
@@ -17,5 +17,8 @@ export interface Server_Auth_Opts {
     headers: http.IncomingHttpHeaders;
     url: URL;
     token?: string;
+    request: http.IncomingMessage;
+    socket: Stream.Duplex;
+    head: Buffer<ArrayBufferLike>;
 }
-export type AuthFn = (data: Server_Auth_Opts) => boolean | Promise<boolean>;
+export type AuthFn = (data: Server_Auth_Opts) => (Promise<object | boolean> | object | boolean);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/gloves-link-server",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",