@zap-socket/server 0.0.2 → 0.0.5

package/dist/events.d.ts

@@ -1,16 +1,13 @@
 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, 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 zapServerEvent: <T extends z.ZodTypeAny>(eventObj: {
+    data: T;
+}) => ZapServerEvent<T>;

package/dist/events.js

@@ -8,3 +8,8 @@ export const zapEvent = (eventObj) => {
         process: eventObj.process
     };
 };
+export const zapServerEvent = (eventObj) => {
+    return {
+        data: eventObj.data
+    };
+};

package/dist/server.d.ts

@@ -1,17 +1,19 @@
-import type { EventMap } from "./events";
+import type { EventMap, ZapServerEvent } from "@zap-socket/types";
 interface ZapServerConstructorT {
     port: number;
+    events?: EventMap;
 }
-export declare class ZapServer {
+export declare class ZapServer<T extends EventMap> {
     private wss;
     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;
+    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;
+    }; };
 }
-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 isZapEvent = (event) => {
+    return "process" in event;
+};
 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,44 @@ 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 (!isZapEvent(eventObj))
+                        continue; // skip server events
+                    const { process, middleware } = eventObj;
                     const parsedMessage = deserialize(message.toString());
                     if (parsedMessage &&
                         parsedMessage["event"] === event) {
                         const { data, requestId } = parsedMessage;
-                        const result = process(data);
+                        // 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)
                             return;
                         ws.send(serialized);
+                        return; // finally return to avoid looping through rest of events unneccessarily
                     }
                 }
             });
@@ -51,10 +83,37 @@ 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);
+    }
+    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);
+                        }
+                    }];
+            }
+            return null;
+        }).filter(entry => entry !== null));
     }
 }
-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.5",
   "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.2",
     "zod": "^3.24.2"
   }
 }