@zap-socket/server 0.0.5 → 0.0.6

package/dist/events.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { EventInput, Context, ZapEvent, ZapServerEvent, MiddlewareType } from "@zap-socket/types";
+import type { EventInput, Context, ZapEvent, ZapStream, ZapServerEvent, MiddlewareType } from "@zap-socket/types";
 export declare const zapEvent: <T extends EventInput, R>(eventObj: T extends z.ZodTypeAny ? {
     input: T;
     middleware?: MiddlewareType[];
@@ -8,6 +8,14 @@ export declare const zapEvent: <T extends EventInput, R>(eventObj: T extends z.Z
     middleware?: MiddlewareType[];
     process: (ctx: Context) => R;
 }) => ZapEvent<T, R>;
+export declare const zapStream: <T extends EventInput, R>(eventObj: T extends z.ZodTypeAny ? {
+    input: T;
+    middleware?: MiddlewareType[];
+    process: (input: z.infer<T>, ctx: Context) => AsyncGenerator<R, void, unknown>;
+} : {
+    middleware?: MiddlewareType[];
+    process: (ctx: Context) => AsyncGenerator<R, void, unknown>;
+}) => ZapStream<T, R>;
 export declare const zapServerEvent: <T extends z.ZodTypeAny>(eventObj: {
     data: T;
 }) => ZapServerEvent<T>;

package/dist/events.js

@@ -8,6 +8,15 @@ export const zapEvent = (eventObj) => {
         process: eventObj.process
     };
 };
+export const zapStream = (eventObj) => {
+    if ("input" in eventObj) {
+        return eventObj;
+    }
+    return {
+        input: z.void(),
+        process: eventObj.process
+    };
+};
 export const zapServerEvent = (eventObj) => {
     return {
         data: eventObj.data

package/dist/server.d.ts

@@ -1,19 +1,27 @@
+import { WebSocketServer, WebSocket } from "ws";
 import type { EventMap, ZapServerEvent } from "@zap-socket/types";
 interface ZapServerConstructorT {
     port: number;
     events?: EventMap;
 }
 export declare class ZapServer<T extends EventMap> {
-    private wss;
+    wss: WebSocketServer;
     private wsToId;
     private idToWs;
     private _events;
     constructor({ port, events }: ZapServerConstructorT, callback?: () => void);
     private removeClient;
     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 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 clients(): Set<string>;
+    get socketMap(): Map<string, WebSocket>;
 }
 export declare const createZapServer: <T extends EventMap>({ port, events }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;
 export {};

package/dist/server.js

@@ -1,7 +1,7 @@
 import { WebSocketServer } from "ws";
 import { serialize, deserialize, generateId } from "./utils";
-const isZapEvent = (event) => {
-    return "process" in event;
+const isClientEvent = (event) => {
+    return "process" in event; // both zapEvent and zapStream have process in them.
 };
 export class ZapServer {
     wss;
@@ -29,13 +29,13 @@ export class ZapServer {
                 }
                 const clientId = this.wsToId.get(ws);
                 for (const [event, eventObj] of Object.entries(this._events)) {
-                    if (!isZapEvent(eventObj))
-                        continue; // skip server events
+                    if (!isClientEvent(eventObj))
+                        continue;
                     const { process, middleware } = eventObj;
                     const parsedMessage = deserialize(message.toString());
                     if (parsedMessage &&
-                        parsedMessage["event"] === event) {
-                        const { data, requestId } = parsedMessage;
+                        (parsedMessage["event"] === event || parsedMessage["stream"] === event)) {
+                        const { data, requestId, streamId } = parsedMessage;
                         // Do middleware checks
                         const ctx = {};
                         if (middleware) {
@@ -57,13 +57,32 @@ export class ZapServer {
                             });
                         }
                         // By this point all the middlewares allow to pass through
-                        const result = process(data, { server: this, id: this.wsToId.get(ws), buffer: ctx });
-                        const serialized = serialize({ requestId, event, data: result });
-                        //  TODO: throw some nice error: only return stuff that is serializable
-                        // i.e. primary data types and objects
-                        if (!serialized)
-                            return;
-                        ws.send(serialized);
+                        if (requestId) {
+                            const result = process(data, { server: this, id: this.wsToId.get(ws), buffer: ctx });
+                            const serialized = serialize(requestId ? { requestId, event, data: result } : { event, data: result });
+                            //  TODO: throw some nice error: only return stuff that is serializable
+                            // i.e. primary data types and objects
+                            if (!serialized)
+                                return;
+                            ws.send(serialized);
+                        }
+                        else if (streamId) {
+                            const consumeStream = async () => {
+                                const result = process(data, { server: this, id: this.wsToId.get(ws), buffer: ctx });
+                                for await (const x of result) {
+                                    const packet = {
+                                        streamId,
+                                        fragment: x
+                                    };
+                                    this.sendMessageRaw(clientId, packet);
+                                }
+                                this.sendMessageRaw(clientId, {
+                                    streamId,
+                                    done: true
+                                });
+                            };
+                            consumeStream();
+                        }
                         return; // finally return to avoid looping through rest of events unneccessarily
                     }
                 }
@@ -94,6 +113,60 @@ export class ZapServer {
             return;
         ws.send(serializedData);
     }
+    sendMessage(event, clientId, data) {
+        const ws = this.idToWs.get(clientId);
+        //  TODO: throw a nice error
+        if (!ws)
+            return;
+        const packet = {
+            event,
+            data
+        };
+        const serializedPacket = serialize(packet);
+        //  TODO: throw a nice error
+        if (!serializedPacket)
+            return;
+        ws.send(serializedPacket);
+    }
+    broadcastRaw(data) {
+        const serializedData = serialize(data);
+        if (!serializedData) {
+            //  TODO: throw a nice error
+            return;
+        }
+        this.idToWs.forEach((ws) => {
+            ws.send(serializedData);
+        });
+    }
+    broadcast(event, data) {
+        const packet = {
+            event,
+            data
+        };
+        const serializedPacket = serialize(packet);
+        if (!serializedPacket)
+            return;
+        this.idToWs.forEach((ws) => {
+            ws.send(serializedPacket);
+        });
+    }
+    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
+        connections
+            .flatMap(x => this.idToWs.get(x) ?? [])
+            .forEach((ws) => {
+            ws.send(serializedPacket);
+        });
+    }
     get event() {
         return Object.fromEntries(Object.keys(this._events).map((eventName) => {
             //  HACK: use a better method to determine the type of event.
@@ -106,12 +179,25 @@ export class ZapServer {
                                 data
                             };
                             this.sendMessageRaw(clientId, packet);
+                        },
+                        broadcast: (data) => {
+                            const packet = {
+                                event: eventName,
+                                data
+                            };
+                            this.broadcastRaw(packet);
                         }
                     }];
             }
             return null;
         }).filter(entry => entry !== null));
     }
+    get clients() {
+        return new Set(this.idToWs.keys());
+    }
+    get socketMap() {
+        return this.idToWs;
+    }
 }
 export const createZapServer = ({ port, events }, callback) => {
     const server = new ZapServer({ port, events }, callback);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-socket/server",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "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.2",
+    "@zap-socket/types": "^0.0.3",
     "zod": "^3.24.2"
   }
 }