@zap-socket/server 0.0.16 → 0.0.18

package/dist/server.d.ts

@@ -1,9 +1,21 @@
 import { WebSocketServer, WebSocket } from "ws";
 import type { EventMap, ZapEvent, ZapServerEvent } from "@zap-socket/types";
-interface ZapServerConstructorT {
+import { ZodType, z } from "zod";
+type CorsOptions = {
+    origin: string[];
+    methods: string[];
+    headers: string[];
+    credentials: boolean;
+};
+type ZapServerConstructorT = {
     port: number;
     events?: EventMap;
-}
+    cors?: CorsOptions;
+    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;
     onconnect: (handler: (ctx: {
@@ -14,19 +26,22 @@ export declare class ZapServer<T extends EventMap> {
     private wsToId;
     private idToWs;
     private _events;
-    constructor({ port, events }: ZapServerConstructorT, callback?: () => void);
+    private heartbeatMiss;
+    constructor({ port, events, options }: ZapServerConstructorT, callback?: () => void);
     private removeClient;
+    private heartbeat;
+    private handleMessage;
     sendMessageRaw(clientId: string, data: any): void;
     sendMessage(event: keyof T, clientId: string, data: any): void;
     broadcastRaw(data: any): void;
     broadcast(event: keyof T, data: any): void;
     selectiveBroascast(event: string, data: any, connections: string[]): void;
     get events(): { [K in keyof T as T[K] extends ZapServerEvent<any> | ZapEvent<any, any> ? K : never]: {
-        send: (clientId: string, data?: (T[K] extends ZapServerEvent<any> ? T[K]["data"] : T[K] extends ZapEvent<any, any> ? ReturnType<T[K]["process"]> : never)) => void;
-        broadcast: (data?: (T[K] extends ZapServerEvent<any> ? T[K]["data"] : T[K] extends ZapEvent<any, any> ? ReturnType<T[K]["process"]> : never)) => void;
+        send: (clientId: string, data?: ExtractSendData<T, K>) => void;
+        broadcast: (data?: ExtractSendData<T, K>) => void;
     }; };
     get clients(): string[];
     get socketMap(): Map<string, WebSocket>;
 }
-export declare const createZapServer: <T extends EventMap>({ port, events }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;
+export declare const createZapServer: <T extends EventMap>({ port, events, cors, options }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;
 export {};

package/dist/server.js

@@ -4,13 +4,15 @@ const isClientEvent = (event) => {
     return "process" in event; // both zapEvent and zapStream have process in them.
 };
 export class ZapServer {
+    // public server: http.Server;
     wss;
     onconnect;
     onconnectHandler;
     wsToId;
     idToWs;
     _events = {};
-    constructor({ port, events = {} }, callback) {
+    heartbeatMiss = new Map();
+    constructor({ port, events = {}, options }, callback) {
         this.wss = new WebSocketServer({ port });
         this.wsToId = new Map();
         this.idToWs = new Map();
@@ -19,85 +21,16 @@ export class ZapServer {
         this.onconnect = (handler) => {
             this.onconnectHandler = handler;
         };
+        const seconds = options?.heartbeatPingFrequency ?? 5;
+        const frequency = (Number.isFinite(seconds) && seconds > 0 ? seconds : 5) * 1000;
+        setInterval(() => this.heartbeat(), frequency);
         this.wss.on("listening", () => {
             if (callback)
                 callback();
         });
         this.wss.on("connection", (ws, req) => {
             ws.on("message", (message) => {
-                if (!this.wsToId.get(ws) && message.toString() === "OPEN") {
-                    const id = generateId();
-                    this.wsToId.set(ws, id);
-                    this.idToWs.set(id, ws);
-                    ws.send("ID " + id);
-                    this.onconnectHandler({
-                        id,
-                        ws
-                    });
-                    return;
-                }
-                const clientId = this.wsToId.get(ws);
-                const parsedMessage = deserialize(message.toString());
-                if (!parsedMessage)
-                    return;
-                const { event, stream, data, requestId, streamId, batch } = parsedMessage;
-                const key = event || stream;
-                const eventObj = this._events[key];
-                if (!eventObj || !isClientEvent(eventObj))
-                    return;
-                const { process, middleware } = eventObj;
-                // Setup middleware context
-                const ctx = {};
-                if (middleware) {
-                    for (const m of middleware) {
-                        const metadata = {
-                            id: clientId,
-                            ip: req.socket.remoteAddress,
-                            timestamp: Date.now(),
-                            size: message.toString().length,
-                        };
-                        const msg = {
-                            event: key,
-                            data: parsedMessage,
-                            metadata,
-                        };
-                        if (!m(ctx, msg))
-                            return;
-                    }
-                }
-                // All middleware passed
-                const context = { server: this, id: this.wsToId.get(ws), buffer: ctx };
-                if (requestId) { // req-res premitive
-                    let result;
-                    if (batch) {
-                        if (!data) {
-                            ws.send("ACK " + requestId);
-                            return;
-                        }
-                        result = data.map((part) => process(part, context));
-                    }
-                    else {
-                        result = process(data, context);
-                    }
-                    if (result === undefined) { // just ACK the request process returns nothing
-                        ws.send("ACK " + requestId);
-                        return;
-                    }
-                    const serialized = serialize({ requestId, event: key, data: result });
-                    if (!serialized)
-                        return;
-                    ws.send(serialized);
-                }
-                else if (streamId) { // stream premitive
-                    const consumeStream = async () => {
-                        const result = process(data, context);
-                        for await (const fragment of result) {
-                            this.sendMessageRaw(clientId, { streamId, fragment });
-                        }
-                        this.sendMessageRaw(clientId, { streamId, done: true });
-                    };
-                    consumeStream();
-                }
+                this.handleMessage(ws, req, message);
             });
             ws.on("close", () => {
                 this.removeClient(ws);
@@ -114,6 +47,111 @@ export class ZapServer {
             this.idToWs.delete(clientId);
         }
     }
+    heartbeat() {
+        this.idToWs.forEach((ws, id) => {
+            const misses = this.heartbeatMiss.get(id) ?? 0;
+            if (misses > 2) {
+                if (ws)
+                    ws.close();
+                this.idToWs.delete(id);
+                this.heartbeatMiss.delete(id);
+            }
+            else {
+                this.heartbeatMiss.set(id, misses + 1);
+            }
+        });
+        this.broadcastRaw("heartbeat");
+    }
+    async handleMessage(ws, req, message) {
+        const id = this.wsToId.get(ws);
+        // setting up socket id
+        if (!id && message.toString() === "OPEN") {
+            const id = generateId();
+            this.wsToId.set(ws, id);
+            this.idToWs.set(id, ws);
+            ws.send("ID " + id);
+            this.onconnectHandler({
+                id,
+                ws
+            });
+            return;
+        }
+        else if (id && message.toString() === "heartbeat") {
+            this.heartbeatMiss.set(id, 0);
+        }
+        const clientId = this.wsToId.get(ws);
+        const parsedMessage = deserialize(message.toString());
+        if (!parsedMessage)
+            return;
+        const { event, stream, data, requestId, streamId, batch } = parsedMessage;
+        const key = event || stream;
+        const eventObj = this._events[key];
+        if (!eventObj || !isClientEvent(eventObj))
+            return;
+        // Type validation.
+        const inputType = eventObj.input;
+        const { success, error } = inputType.safeParse(data);
+        if (!success && error) {
+            // check if the message is of req-res
+            if (requestId) {
+            }
+            return;
+        }
+        const { process, middleware } = eventObj;
+        // Setup middleware context
+        const ctx = {};
+        if (middleware) {
+            for (const m of middleware) {
+                const metadata = {
+                    id: clientId,
+                    ip: req.socket.remoteAddress,
+                    timestamp: Date.now(),
+                    size: message.toString().length,
+                };
+                const msg = {
+                    event: key,
+                    data: parsedMessage,
+                    metadata,
+                };
+                let shouldPass = m(ctx, msg);
+                shouldPass = shouldPass instanceof Promise ? await shouldPass : shouldPass;
+                if (!shouldPass)
+                    return;
+            }
+        }
+        // All middleware passed
+        const context = { server: this, id: this.wsToId.get(ws), buffer: ctx };
+        if (requestId) { // req-res premitive
+            let result;
+            if (batch) {
+                result = data.map((part) => process(part, context));
+            }
+            else {
+                result = process(data, context);
+                if (result instanceof Promise) {
+                    result = await result;
+                }
+            }
+            if (result === undefined) { // just ACK the request process returns nothing
+                ws.send("ACK " + requestId);
+                return;
+            }
+            const serialized = serialize({ requestId, event: key, data: result });
+            if (!serialized)
+                return;
+            ws.send(serialized);
+        }
+        else if (streamId) { // stream premitive
+            const consumeStream = async () => {
+                const result = process(data, context);
+                for await (const fragment of result) {
+                    this.sendMessageRaw(clientId, { streamId, fragment });
+                }
+                this.sendMessageRaw(clientId, { streamId, done: true });
+            };
+            consumeStream();
+        }
+    }
     sendMessageRaw(clientId, data) {
         const ws = this.idToWs.get(clientId);
         //  TODO: throw a nice error
@@ -209,7 +247,7 @@ export class ZapServer {
         return this.idToWs;
     }
 }
-export const createZapServer = ({ port, events }, callback) => {
-    const server = new ZapServer({ port, events }, callback);
+export const createZapServer = ({ port, events, cors, options }, callback) => {
+    const server = new ZapServer({ port, events, cors, options }, callback);
     return server;
 };

package/dist/utils.js

@@ -13,6 +13,8 @@ export const safeJsonParse = (jsonString) => {
     }
 };
 export const serialize = (data) => {
+    if (typeof data === "string")
+        return data;
     try {
         return JSON.stringify(data);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-socket/server",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "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",
@@ -23,7 +23,8 @@
     "vitest": "^3.0.9"
   },
   "dependencies": {
-    "@zap-socket/types": "^0.0.7",
+    "@zap-socket/types": "^0.0.9",
+    "uWebSockets.js": "uNetworking/uWebSockets.js#v20.51.0",
     "zod": "^3.24.2"
   }
 }