@zap-socket/server 0.0.1 → 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 ? {
+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;
 } : {
-    input: z.ZodVoid;
-    process: () => R;
-};
-export type EventMap = Record<string, ZapEvent<any, any>>;
-export declare const createZapEvent: <T extends EventInput, R>(eventObj: T extends z.ZodTypeAny ? {
-    input: T;
-    process: (input: z.infer<T>) => 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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export const createZapEvent = (eventObj) => {
+export const zapEvent = (eventObj) => {
     if ("input" in eventObj) {
         return eventObj;
     }
@@ -8,3 +8,8 @@ export const createZapEvent = (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,31 +1,70 @@
 import { WebSocketServer } from "ws";
-import { generateId } from "./utils";
+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) => {
-            const clientId = generateId();
-            console.log(`client ${clientId} connected`);
-            this.wsToId.set(ws, clientId);
-            this.idToWs.set(clientId, ws);
+        this._events = events;
+        this.wss.on("listening", () => {
+            if (callback)
+                callback();
+        });
+        this.wss.on("connection", (ws, req) => {
             ws.on("message", (message) => {
                 if (!this.wsToId.get(ws)) {
                     const id = generateId();
                     this.wsToId.set(ws, id);
                     this.idToWs.set(id, ws);
                     ws.send("ID " + id);
+                    console.log(`client ${id} connected.`);
+                    return;
                 }
-                for (const [event, { process }] of Object.entries(this.events)) {
-                    const parsedMessage = JSON.parse(message.toString());
-                    if (parsedMessage["type"] === event) {
-                        const { input } = parsedMessage;
-                        process(input);
+                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)
+                            return;
+                        ws.send(serialized);
+                        return; // finally return to avoid looping through rest of events unneccessarily
                     }
                 }
             });
@@ -33,7 +72,7 @@ export class ZapServer {
                 this.removeClient(ws);
             });
             ws.on("error", (err) => {
-                console.error(`WebSocket error for ${clientId}:`, err);
+                console.error(`WebSocket error for ${this.wsToId.get(ws)}:`, err);
             });
         });
     }
@@ -44,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/dist/utils.d.ts

@@ -1 +1,4 @@
 export declare const generateId: (length?: number) => string;
+export declare const safeJsonParse: (jsonString: string) => Record<string, any> | null;
+export declare const serialize: <T>(data: T) => string | null;
+export declare const deserialize: <T>(data: string) => T | null;

package/dist/utils.js

@@ -1,10 +1,25 @@
-export const generateId = (length = 6) => {
+export const generateId = (length = 8) => {
     const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    let id = "";
     const randomValues = new Uint8Array(length);
     crypto.getRandomValues(randomValues);
-    randomValues.forEach((num) => {
-        id += chars[num % chars.length];
-    });
-    return id;
+    return Array.from(randomValues, (num) => chars[num % chars.length]).join('');
+};
+export const safeJsonParse = (jsonString) => {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch {
+        return null;
+    }
+};
+export const serialize = (data) => {
+    try {
+        return JSON.stringify(data);
+    }
+    catch {
+        return null;
+    }
+};
+export const deserialize = (data) => {
+    return safeJsonParse(data);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-socket/server",
-  "version": "0.0.1",
+  "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"
   }
 }