@zap-socket/server 0.0.7 → 0.0.8

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 import { WebSocketServer, WebSocket } from "ws";
-import type { EventMap, ZapServerEvent } from "@zap-socket/types";
+import type { EventMap, ZapEvent, ZapServerEvent } from "@zap-socket/types";
 interface ZapServerConstructorT {
     port: number;
     events?: EventMap;
@@ -21,9 +21,9 @@ export declare class ZapServer<T extends EventMap> {
     broadcastRaw(data: any): void;
     broadcast(event: keyof T, data: any): void;
     selectiveBroascast(event: string, data: any, connections: string[]): void;
-    get event(): { [K in keyof T as T[K] extends ZapServerEvent<any> ? K : never]: {
-        send: (clientId: string, data?: (T[K] extends ZapServerEvent<any> ? T[K]["data"] : never)) => void;
-        broadcast: (data?: (T[K] extends ZapServerEvent<any> ? T[K]["data"] : never)) => 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;
     }; };
     get clients(): Set<string>;
     get socketMap(): Map<string, WebSocket>;

package/dist/server.js

@@ -40,7 +40,7 @@ export class ZapServer {
                 const parsedMessage = deserialize(message.toString());
                 if (!parsedMessage)
                     return;
-                const { event, stream, data, requestId, streamId } = parsedMessage;
+                const { event, stream, data, requestId, streamId, batch } = parsedMessage;
                 const key = event || stream;
                 const eventObj = this._events[key];
                 if (!eventObj || !isClientEvent(eventObj))
@@ -68,7 +68,17 @@ export class ZapServer {
                 // All middleware passed
                 const context = { server: this, id: this.wsToId.get(ws), buffer: ctx };
                 if (requestId) { // req-res premitive
-                    const result = process(data, context);
+                    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;
@@ -169,30 +179,28 @@ export class ZapServer {
             ws.send(serializedPacket);
         });
     }
-    get event() {
+    get events() {
         return Object.fromEntries(Object.keys(this._events).map((eventName) => {
-            //  HACK: use a better method to determine the type of event.
-            if ("data" in this._events[eventName]) {
-                // event is server event
-                return [eventName, {
-                        send: (clientId, data) => {
-                            const packet = {
-                                event: eventName,
-                                data
-                            };
-                            this.sendMessageRaw(clientId, packet);
-                        },
-                        broadcast: (data) => {
-                            const packet = {
-                                event: eventName,
-                                data
-                            };
-                            this.broadcastRaw(packet);
-                        }
-                    }];
-            }
-            return null;
-        }).filter(entry => entry !== null));
+            return [
+                eventName,
+                {
+                    send: (clientId, data) => {
+                        const packet = {
+                            event: eventName,
+                            data
+                        };
+                        this.sendMessageRaw(clientId, packet);
+                    },
+                    broadcast: (data) => {
+                        const packet = {
+                            event: eventName,
+                            data
+                        };
+                        this.broadcastRaw(packet);
+                    }
+                }
+            ];
+        }));
     }
     get clients() {
         return new Set(this.idToWs.keys());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-socket/server",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "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.3",
+    "@zap-socket/types": "^0.0.4",
     "zod": "^3.24.2"
   }
 }