@zap-socket/server 0.0.20 → 0.0.21

package/dist/adapters/types.d.ts

@@ -0,0 +1,18 @@
+import { IncomingMessage } from "http";
+export interface WebSocketAdapter {
+    send(data: string): void;
+    close(): void;
+    on(event: 'message', listener: (data: Buffer | string) => void): void;
+    on(event: 'close', listener: () => void): void;
+    on(event: 'error', listener: (err: Error) => void): void;
+}
+export interface WebSocketServerAdapter {
+    on(event: 'listening', listener: () => void): void;
+    on(event: 'connection', listener: (ws: WebSocketAdapter, req: IncomingMessage) => void): void;
+    close(): void;
+}
+export interface WebSocketBackend {
+    createServer(options: {
+        port: number;
+    }): WebSocketServerAdapter;
+}

package/dist/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/uWebSocketAdapter.js

@@ -0,0 +1 @@
+"use strict";

package/dist/adapters/wsAdapter.d.ts

@@ -0,0 +1,6 @@
+import { WebSocketServerAdapter, WebSocketBackend } from "./types.js";
+export declare class WSBackend implements WebSocketBackend {
+    createServer(options: {
+        port: number;
+    }): WebSocketServerAdapter;
+}

package/dist/adapters/wsAdapter.js

@@ -0,0 +1,48 @@
+import { WebSocketServer } from "ws";
+class WSAdapter {
+    ws;
+    constructor(ws) {
+        this.ws = ws;
+    }
+    send(data) {
+        this.ws.send(data);
+    }
+    close() {
+        this.ws.close();
+    }
+    on(event, listener) {
+        if (event === 'message') {
+            this.ws.on('message', (data) => {
+                listener(data.toString());
+            });
+        }
+        else {
+            this.ws.on(event, listener);
+        }
+    }
+}
+class WSServerAdapter {
+    wss;
+    constructor(wss) {
+        this.wss = wss;
+    }
+    on(event, listener) {
+        if (event === 'connection') {
+            this.wss.on('connection', (ws, req) => {
+                listener(new WSAdapter(ws), req);
+            });
+        }
+        else {
+            this.wss.on(event, listener);
+        }
+    }
+    close() {
+        this.wss.close();
+    }
+}
+export class WSBackend {
+    createServer(options) {
+        const wss = new WebSocketServer(options);
+        return new WSServerAdapter(wss);
+    }
+}

package/dist/server.d.ts

@@ -1,6 +1,6 @@
-import { WebSocketServer, WebSocket } from "ws";
 import type { EventMap, ZapEvent, ZapServerEvent } from "@zap-socket/types";
 import { ZodType, z } from "zod";
+import { WebSocketAdapter } from "./adapters/types.js";
 type CorsOptions = {
     origin: string[];
     methods: string[];
@@ -11,16 +11,18 @@ type ZapServerConstructorT = {
     port: number;
     events?: EventMap;
     cors?: CorsOptions;
+    backend?: 'ws' | 'uws';
     options?: {
         heartbeatPingFrequency: number;
     };
 };
 type ExtractSendData<T, K extends keyof T> = T[K] extends ZapServerEvent<any> ? T[K]['data'] : T[K] extends ZapEvent<any, any> ? T[K]['emitType'] extends ZodType<any, any, any> ? z.infer<T[K]['emitType']> : ReturnType<T[K]['process']> extends undefined ? undefined : ReturnType<T[K]['process']> : never;
 export declare class ZapServer<T extends EventMap> {
-    wss: WebSocketServer;
+    private wss;
+    private backend;
     onconnect: (handler: (ctx: {
         id: string;
-        ws: WebSocket;
+        ws: WebSocketAdapter;
     }) => void) => void;
     private onconnectHandler;
     private wsToId;
@@ -28,7 +30,7 @@ export declare class ZapServer<T extends EventMap> {
     private persistantContext;
     private _events;
     private heartbeatMiss;
-    constructor({ port, events, options }: ZapServerConstructorT, callback?: () => void);
+    constructor({ port, events, backend, options }: ZapServerConstructorT, callback?: () => void);
     private removeClient;
     private heartbeat;
     private handleMessage;
@@ -42,7 +44,7 @@ export declare class ZapServer<T extends EventMap> {
         broadcast: (data?: ExtractSendData<T, K>) => void;
     }; };
     get clients(): string[];
-    get socketMap(): Map<string, WebSocket>;
+    get socketMap(): Map<string, WebSocketAdapter>;
 }
-export declare const createZapServer: <T extends EventMap>({ port, events, cors, options }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;
+export declare const createZapServer: <T extends EventMap>({ port, events, cors, backend, options }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;
 export {};

package/dist/server.js

@@ -1,15 +1,11 @@
-import { WebSocketServer } from "ws";
 import { serialize, deserialize, generateId } from "./utils.js";
+import { WSBackend } from "./adapters/wsAdapter.js";
 const isClientEvent = (event) => {
-    return "process" in event; // both zapEvent and zapStream have process in them.
+    return "process" in event;
 };
-// make the server class abstracted away
-// or atleast the ws interactions
-// so that we can change the backends
-// with ease (ws & uWebSocket).
 export class ZapServer {
-    // public server: http.Server;
     wss;
+    backend;
     onconnect;
     onconnectHandler;
     wsToId;
@@ -17,8 +13,18 @@ export class ZapServer {
     persistantContext;
     _events = {};
     heartbeatMiss = new Map();
-    constructor({ port, events = {}, options }, callback) {
-        this.wss = new WebSocketServer({ port });
+    constructor({ port, events = {}, backend = 'ws', options }, callback) {
+        // Select backend
+        switch (backend) {
+            // case 'uws':
+            //   this.backend = new UWSBackend();
+            //   break;
+            case 'ws':
+            default:
+                this.backend = new WSBackend();
+                break;
+        }
+        this.wss = this.backend.createServer({ port });
         this.wsToId = new Map();
         this.idToWs = new Map();
         this.persistantContext = new Map();
@@ -69,9 +75,10 @@ export class ZapServer {
         this.broadcastRaw("heartbeat");
     }
     async handleMessage(ws, req, message) {
+        const messageStr = message.toString();
         const id = this.wsToId.get(ws);
         // setting up socket id
-        if (!id && message.toString() === "OPEN") {
+        if (!id && messageStr === "OPEN") {
             const id = generateId();
             this.wsToId.set(ws, id);
             this.idToWs.set(id, ws);
@@ -82,11 +89,11 @@ export class ZapServer {
             });
             return;
         }
-        else if (id && message.toString() === "heartbeat") {
+        else if (id && messageStr === "heartbeat") {
             this.heartbeatMiss.set(id, 0);
         }
         const clientId = this.wsToId.get(ws);
-        const parsedMessage = deserialize(message.toString());
+        const parsedMessage = deserialize(messageStr);
         if (!parsedMessage)
             return;
         const { event, stream, data, requestId, streamId, batch } = parsedMessage;
@@ -98,8 +105,8 @@ export class ZapServer {
         const inputType = eventObj.input;
         const { success, error } = inputType.safeParse(data);
         if (!success && error) {
-            // check if the message is of req-res
             if (requestId) {
+                // Handle validation error response
             }
             return;
         }
@@ -116,7 +123,7 @@ export class ZapServer {
                     id: clientId,
                     ip: req.socket.remoteAddress,
                     timestamp: Date.now(),
-                    size: message.toString().length,
+                    size: messageStr.length,
                 };
                 const msg = {
                     event: key,
@@ -131,7 +138,7 @@ export class ZapServer {
         }
         // All middleware passed
         const context = { server: this, id: this.wsToId.get(ws), buffer: ctx };
-        if (requestId) { // req-res premitive
+        if (requestId) { // req-res primitive
             let result;
             if (batch) {
                 result = data.map((part) => process(part, context));
@@ -151,7 +158,7 @@ export class ZapServer {
                 return;
             ws.send(serialized);
         }
-        else if (streamId) { // stream premitive
+        else if (streamId) { // stream primitive
             const consumeStream = async () => {
                 const result = process(data, context);
                 for await (const fragment of result) {
@@ -164,18 +171,15 @@ export class ZapServer {
     }
     sendMessageRaw(clientId, data) {
         const ws = this.idToWs.get(clientId);
-        //  TODO: throw a nice error
         if (!ws)
             return;
         const serializedData = serialize(data);
-        //  TODO: throw a nice error
         if (!serializedData)
             return;
         ws.send(serializedData);
     }
     sendMessage(event, clientId, data) {
         const ws = this.idToWs.get(clientId);
-        //  TODO: throw a nice error
         if (!ws)
             return;
         const packet = {
@@ -183,7 +187,6 @@ export class ZapServer {
             data
         };
         const serializedPacket = serialize(packet);
-        //  TODO: throw a nice error
         if (!serializedPacket)
             return;
         ws.send(serializedPacket);
@@ -191,7 +194,6 @@ export class ZapServer {
     broadcastRaw(data) {
         const serializedData = serialize(data);
         if (!serializedData) {
-            //  TODO: throw a nice error
             return;
         }
         this.idToWs.forEach((ws) => {
@@ -213,14 +215,13 @@ export class ZapServer {
     selectiveBroascast(event, data, connections) {
         const serialized = serialize(data);
         if (!serialized) {
-            //  TODO: throw a nice error
             return;
         }
         const packet = {
             event,
             data
         };
-        const serializedPacket = serialize(packet); // if data is serializable then packet is too, so no need to check
+        const serializedPacket = serialize(packet);
         connections
             .flatMap(x => this.idToWs.get(x) ?? [])
             .forEach((ws) => {
@@ -251,13 +252,13 @@ export class ZapServer {
         }));
     }
     get clients() {
-        return this.idToWs.keys().toArray();
+        return Array.from(this.idToWs.keys());
     }
     get socketMap() {
         return this.idToWs;
     }
 }
-export const createZapServer = ({ port, events, cors, options }, callback) => {
-    const server = new ZapServer({ port, events, cors, options }, callback);
+export const createZapServer = ({ port, events, cors, backend = 'ws', options }, callback) => {
+    const server = new ZapServer({ port, events, cors, backend, options }, callback);
     return server;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-socket/server",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "A fully typesafe tRPC-inspired WebSocket library with Zod validation, req-res model, and native subscriptions.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",