@zap-socket/server 0.0.16 → 0.0.17

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,21 @@ 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;
     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,44 @@ 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.server = http.createServer((req, res) => {
+        //
+        //   if (cors) {
+        //     const origin = req.headers.origin;
+        //
+        //     if (origin && cors.origin && (cors.origin.includes(origin) || cors.origin.includes("*"))) {
+        //       res.setHeader('Access-Control-Allow-Origin', origin);
+        //     }
+        //     if (cors.methods) {
+        //       res.setHeader("Access-Control-Allow-Methods", cors.methods.join(", "));
+        //     }
+        //     if (cors.headers) {
+        //       res.setHeader("Access-Control-Allow-Headers", cors.headers.join(", "));
+        //     }
+        //     if (cors.credentials !== undefined) {
+        //       res.setHeader("Access-Control-Allow-Credentials", cors.credentials ? "true" : "false");
+        //     }
+        //   }
+        //
+        //   // pre-flight response
+        //   if (req.method === "OPTIONS") {
+        //     res.writeHead(204);
+        //     res.end();
+        //     return;
+        //   }
+        //
+        //   res.writeHead(404);
+        //   res.end();
+        // });
         this.wss = new WebSocketServer({ port });
         this.wsToId = new Map();
         this.idToWs = new Map();
@@ -19,13 +50,18 @@ 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") {
+            ws.on("message", async (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);
@@ -36,6 +72,9 @@ export class ZapServer {
                     });
                     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)
@@ -45,6 +84,15 @@ export class ZapServer {
                 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 = {};
@@ -61,7 +109,9 @@ export class ZapServer {
                             data: parsedMessage,
                             metadata,
                         };
-                        if (!m(ctx, msg))
+                        let shouldPass = m(ctx, msg);
+                        shouldPass = shouldPass instanceof Promise ? await shouldPass : shouldPass;
+                        if (!shouldPass)
                             return;
                     }
                 }
@@ -70,14 +120,13 @@ export class ZapServer {
                 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 instanceof Promise) {
+                            result = await result;
+                        }
                     }
                     if (result === undefined) { // just ACK the request process returns nothing
                         ws.send("ACK " + requestId);
@@ -114,6 +163,21 @@ 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");
+    }
     sendMessageRaw(clientId, data) {
         const ws = this.idToWs.get(clientId);
         //  TODO: throw a nice error
@@ -209,7 +273,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.17",
   "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,7 @@
     "vitest": "^3.0.9"
   },
   "dependencies": {
-    "@zap-socket/types": "^0.0.7",
+    "@zap-socket/types": "^0.0.9",
     "zod": "^3.24.2"
   }
 }