@zap-socket/server 0.0.5 → 0.0.7

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,32 @@
+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;
+    onconnect: (handler: (ctx: {
+        id: string;
+        ws: WebSocket;
+    }) => void) => void;
+    private onconnectHandler;
     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,10 +1,12 @@
 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;
+    onconnect;
+    onconnectHandler;
     wsToId;
     idToWs;
     _events = {};
@@ -13,60 +15,79 @@ export class ZapServer {
         this.wsToId = new Map();
         this.idToWs = new Map();
         this._events = events;
+        this.onconnectHandler = () => { };
+        this.onconnect = (handler) => {
+            this.onconnectHandler = handler;
+        };
         this.wss.on("listening", () => {
             if (callback)
                 callback();
         });
         this.wss.on("connection", (ws, req) => {
             ws.on("message", (message) => {
-                if (!this.wsToId.get(ws)) {
+                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);
-                    console.log(`client ${id} connected.`);
+                    this.onconnectHandler({
+                        id,
+                        ws
+                    });
                     return;
                 }
                 const clientId = this.wsToId.get(ws);
-                for (const [event, eventObj] of Object.entries(this._events)) {
-                    if (!isZapEvent(eventObj))
-                        continue; // skip server events
-                    const { process, middleware } = eventObj;
-                    const parsedMessage = deserialize(message.toString());
-                    if (parsedMessage &&
-                        parsedMessage["event"] === event) {
-                        const { data, requestId } = parsedMessage;
-                        // Do middleware checks
-                        const ctx = {};
-                        if (middleware) {
-                            middleware.forEach((m) => {
-                                const metadata = {
-                                    id: clientId,
-                                    ip: req.socket.remoteAddress,
-                                    timestamp: Date.now(),
-                                    size: message.toString().length
-                                };
-                                const msg = {
-                                    event,
-                                    data: parsedMessage,
-                                    metadata
-                                };
-                                if (!m(ctx, msg)) {
-                                    return;
-                                }
-                            });
-                        }
-                        // 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)
+                const parsedMessage = deserialize(message.toString());
+                if (!parsedMessage)
+                    return;
+                const { event, stream, data, requestId, streamId } = 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;
-                        ws.send(serialized);
-                        return; // finally return to avoid looping through rest of events unneccessarily
                     }
                 }
+                // All middleware passed
+                const context = { server: this, id: this.wsToId.get(ws), buffer: ctx };
+                if (requestId) { // req-res premitive
+                    const 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();
+                }
             });
             ws.on("close", () => {
                 this.removeClient(ws);
@@ -94,6 +115,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 +181,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.7",
   "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"
   }
 }