@zap-socket/server 0.0.2 → 0.0.6

package/dist/events.d.ts

@@ -1,16 +1,21 @@
 import { z } from "zod";
-export type EventInput = z.ZodTypeAny | undefined;
-export type ZapEvent<T extends EventInput, R = any> = T extends z.ZodTypeAny ? {
-    input: T;
-    process: (input: z.infer<T>) => R;
-} : {
-    input: z.ZodVoid;
-    process: () => R;
-};
-export type EventMap = Record<string, ZapEvent<any, any>>;
+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;
-    process: (input: z.infer<T>) => R;
+    middleware?: MiddlewareType[];
+    process: (input: z.infer<T>, ctx: Context) => R;
 } : {
-    process: () => R;
+    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,3 +8,17 @@ 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,17 +1,27 @@
-import type { EventMap } from "./events";
+import { WebSocketServer, WebSocket } from "ws";
+import type { EventMap, ZapServerEvent } from "@zap-socket/types";
 interface ZapServerConstructorT {
     port: number;
+    events?: EventMap;
 }
-export declare class ZapServer {
-    private wss;
+export declare class ZapServer<T extends EventMap> {
+    wss: WebSocketServer;
     private wsToId;
     private idToWs;
-    private events;
-    constructor({ port }: ZapServerConstructorT);
+    private _events;
+    constructor({ port, events }: ZapServerConstructorT, callback?: () => void);
     private removeClient;
-    attachEvents<T extends EventMap>(events: T): void;
+    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: ({ port }: {
-    port: number;
-}) => ZapServer;
+export declare const createZapServer: <T extends EventMap>({ port, events }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;
 export {};

package/dist/server.js

@@ -1,18 +1,24 @@
 import { WebSocketServer } from "ws";
 import { serialize, deserialize, generateId } from "./utils";
+const isClientEvent = (event) => {
+    return "process" in event; // both zapEvent and zapStream have process in them.
+};
 export class ZapServer {
     wss;
     wsToId;
     idToWs;
-    events = {};
-    constructor({ port }) {
+    _events = {};
+    constructor({ port, events = {} }, callback) {
         this.wss = new WebSocketServer({ port });
         this.wsToId = new Map();
         this.idToWs = new Map();
-        this.wss.on("connection", (ws) => {
+        this._events = events;
+        this.wss.on("listening", () => {
+            if (callback)
+                callback();
+        });
+        this.wss.on("connection", (ws, req) => {
             ws.on("message", (message) => {
-                const parsedMessage = deserialize(message.toString());
-                console.log("got message: ", parsedMessage);
                 if (!this.wsToId.get(ws)) {
                     const id = generateId();
                     this.wsToId.set(ws, id);
@@ -21,18 +27,63 @@ export class ZapServer {
                     console.log(`client ${id} connected.`);
                     return;
                 }
-                for (const [event, { process }] of Object.entries(this.events)) {
+                const clientId = this.wsToId.get(ws);
+                for (const [event, eventObj] of Object.entries(this._events)) {
+                    if (!isClientEvent(eventObj))
+                        continue;
+                    const { process, middleware } = eventObj;
                     const parsedMessage = deserialize(message.toString());
                     if (parsedMessage &&
-                        parsedMessage["event"] === event) {
-                        const { data, requestId } = parsedMessage;
-                        const result = process(data);
-                        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);
+                        (parsedMessage["event"] === event || parsedMessage["stream"] === event)) {
+                        const { data, requestId, streamId } = 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
+                        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
                     }
                 }
             });
@@ -51,10 +102,104 @@ export class ZapServer {
             this.idToWs.delete(clientId);
         }
     }
-    attachEvents(events) {
-        this.events = events;
+    sendMessageRaw(clientId, data) {
+        const ws = this.idToWs.get(clientId);
+        //  TODO: throw a nice error
+        if (!ws)
+            return;
+        const serializedData = serialize(data);
+        //  TODO: throw a nice error
+        if (!serializedData)
+            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.
+            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));
+    }
+    get clients() {
+        return new Set(this.idToWs.keys());
+    }
+    get socketMap() {
+        return this.idToWs;
     }
 }
-export const createZapServer = ({ port }) => {
-    return new ZapServer({ port });
+export const createZapServer = ({ port, events }, callback) => {
+    const server = new ZapServer({ port, events }, callback);
+    return server;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-socket/server",
-  "version": "0.0.2",
+  "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,6 +23,7 @@
     "vitest": "^3.0.9"
   },
   "dependencies": {
+    "@zap-socket/types": "^0.0.3",
     "zod": "^3.24.2"
   }
 }