@zap-socket/server 0.0.21 → 0.0.23

package/dist/server.d.ts

@@ -1,6 +1,6 @@
+import { WebSocketServer, WebSocket } from "ws";
 import type { EventMap, ZapEvent, ZapServerEvent } from "@zap-socket/types";
 import { ZodType, z } from "zod";
-import { WebSocketAdapter } from "./adapters/types.js";
 type CorsOptions = {
     origin: string[];
     methods: string[];
@@ -11,18 +11,16 @@ type ZapServerConstructorT = {
     port: number;
     events?: EventMap;
     cors?: CorsOptions;
-    backend?: 'ws' | 'uws';
     options?: {
         heartbeatPingFrequency: number;
     };
 };
 type ExtractSendData<T, K extends keyof T> = T[K] extends ZapServerEvent<any> ? T[K]['data'] : T[K] extends ZapEvent<any, any> ? T[K]['emitType'] extends ZodType<any, any, any> ? z.infer<T[K]['emitType']> : ReturnType<T[K]['process']> extends undefined ? undefined : ReturnType<T[K]['process']> : never;
 export declare class ZapServer<T extends EventMap> {
-    private wss;
-    private backend;
+    wss: WebSocketServer;
     onconnect: (handler: (ctx: {
         id: string;
-        ws: WebSocketAdapter;
+        ws: WebSocket;
     }) => void) => void;
     private onconnectHandler;
     private wsToId;
@@ -30,7 +28,7 @@ export declare class ZapServer<T extends EventMap> {
     private persistantContext;
     private _events;
     private heartbeatMiss;
-    constructor({ port, events, backend, options }: ZapServerConstructorT, callback?: () => void);
+    constructor({ port, events, options }: ZapServerConstructorT, callback?: () => void);
     private removeClient;
     private heartbeat;
     private handleMessage;
@@ -44,7 +42,7 @@ export declare class ZapServer<T extends EventMap> {
         broadcast: (data?: ExtractSendData<T, K>) => void;
     }; };
     get clients(): string[];
-    get socketMap(): Map<string, WebSocketAdapter>;
+    get socketMap(): Map<string, WebSocket>;
 }
-export declare const createZapServer: <T extends EventMap>({ port, events, cors, backend, options }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;
+export declare const createZapServer: <T extends EventMap>({ port, events, cors, options }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;
 export {};

package/dist/server.js

@@ -1,11 +1,15 @@
+import { WebSocketServer } from "ws";
 import { serialize, deserialize, generateId } from "./utils.js";
-import { WSBackend } from "./adapters/wsAdapter.js";
 const isClientEvent = (event) => {
-    return "process" in event;
+    return "process" in event; // both zapEvent and zapStream have process in them.
 };
+// make the server class abstracted away
+// or atleast the ws interactions
+// so that we can change the backends
+// with ease (ws & uWebSocket).
 export class ZapServer {
+    // public server: http.Server;
     wss;
-    backend;
     onconnect;
     onconnectHandler;
     wsToId;
@@ -13,18 +17,8 @@ export class ZapServer {
     persistantContext;
     _events = {};
     heartbeatMiss = new Map();
-    constructor({ port, events = {}, backend = 'ws', options }, callback) {
-        // Select backend
-        switch (backend) {
-            // case 'uws':
-            //   this.backend = new UWSBackend();
-            //   break;
-            case 'ws':
-            default:
-                this.backend = new WSBackend();
-                break;
-        }
-        this.wss = this.backend.createServer({ port });
+    constructor({ port, events = {}, options }, callback) {
+        this.wss = new WebSocketServer({ port });
         this.wsToId = new Map();
         this.idToWs = new Map();
         this.persistantContext = new Map();
@@ -75,10 +69,9 @@ export class ZapServer {
         this.broadcastRaw("heartbeat");
     }
     async handleMessage(ws, req, message) {
-        const messageStr = message.toString();
         const id = this.wsToId.get(ws);
         // setting up socket id
-        if (!id && messageStr === "OPEN") {
+        if (!id && message.toString() === "OPEN") {
             const id = generateId();
             this.wsToId.set(ws, id);
             this.idToWs.set(id, ws);
@@ -89,11 +82,11 @@ export class ZapServer {
             });
             return;
         }
-        else if (id && messageStr === "heartbeat") {
+        else if (id && message.toString() === "heartbeat") {
             this.heartbeatMiss.set(id, 0);
         }
         const clientId = this.wsToId.get(ws);
-        const parsedMessage = deserialize(messageStr);
+        const parsedMessage = deserialize(message.toString());
         if (!parsedMessage)
             return;
         const { event, stream, data, requestId, streamId, batch } = parsedMessage;
@@ -105,8 +98,8 @@ export class ZapServer {
         const inputType = eventObj.input;
         const { success, error } = inputType.safeParse(data);
         if (!success && error) {
+            // check if the message is of req-res
             if (requestId) {
-                // Handle validation error response
             }
             return;
         }
@@ -123,7 +116,7 @@ export class ZapServer {
                     id: clientId,
                     ip: req.socket.remoteAddress,
                     timestamp: Date.now(),
-                    size: messageStr.length,
+                    size: message.toString().length,
                 };
                 const msg = {
                     event: key,
@@ -138,7 +131,7 @@ export class ZapServer {
         }
         // All middleware passed
         const context = { server: this, id: this.wsToId.get(ws), buffer: ctx };
-        if (requestId) { // req-res primitive
+        if (requestId) { // req-res premitive
             let result;
             if (batch) {
                 result = data.map((part) => process(part, context));
@@ -158,7 +151,7 @@ export class ZapServer {
                 return;
             ws.send(serialized);
         }
-        else if (streamId) { // stream primitive
+        else if (streamId) { // stream premitive
             const consumeStream = async () => {
                 const result = process(data, context);
                 for await (const fragment of result) {
@@ -171,15 +164,18 @@ export class ZapServer {
     }
     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 = {
@@ -187,6 +183,7 @@ export class ZapServer {
             data
         };
         const serializedPacket = serialize(packet);
+        //  TODO: throw a nice error
         if (!serializedPacket)
             return;
         ws.send(serializedPacket);
@@ -194,6 +191,7 @@ export class ZapServer {
     broadcastRaw(data) {
         const serializedData = serialize(data);
         if (!serializedData) {
+            //  TODO: throw a nice error
             return;
         }
         this.idToWs.forEach((ws) => {
@@ -215,13 +213,14 @@ export class ZapServer {
     selectiveBroascast(event, data, connections) {
         const serialized = serialize(data);
         if (!serialized) {
+            //  TODO: throw a nice error
             return;
         }
         const packet = {
             event,
             data
         };
-        const serializedPacket = serialize(packet);
+        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) => {
@@ -252,13 +251,13 @@ export class ZapServer {
         }));
     }
     get clients() {
-        return Array.from(this.idToWs.keys());
+        return this.idToWs.keys().toArray();
     }
     get socketMap() {
         return this.idToWs;
     }
 }
-export const createZapServer = ({ port, events, cors, backend = 'ws', options }, callback) => {
-    const server = new ZapServer({ port, events, cors, backend, options }, callback);
+export const createZapServer = ({ port, events, cors, options }, callback) => {
+    const server = new ZapServer({ port, events, cors, options }, callback);
     return server;
 };

package/package.json

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

package/dist/adapters/types.d.ts

@@ -1,18 +0,0 @@
-import { IncomingMessage } from "http";
-export interface WebSocketAdapter {
-    send(data: string): void;
-    close(): void;
-    on(event: 'message', listener: (data: Buffer | string) => void): void;
-    on(event: 'close', listener: () => void): void;
-    on(event: 'error', listener: (err: Error) => void): void;
-}
-export interface WebSocketServerAdapter {
-    on(event: 'listening', listener: () => void): void;
-    on(event: 'connection', listener: (ws: WebSocketAdapter, req: IncomingMessage) => void): void;
-    close(): void;
-}
-export interface WebSocketBackend {
-    createServer(options: {
-        port: number;
-    }): WebSocketServerAdapter;
-}

package/dist/adapters/types.js

@@ -1 +0,0 @@
-export {};

package/dist/adapters/uWebSocketAdapter.js

@@ -1 +0,0 @@
-"use strict";

package/dist/adapters/wsAdapter.d.ts

@@ -1,6 +0,0 @@
-import { WebSocketServerAdapter, WebSocketBackend } from "./types.js";
-export declare class WSBackend implements WebSocketBackend {
-    createServer(options: {
-        port: number;
-    }): WebSocketServerAdapter;
-}

package/dist/adapters/wsAdapter.js

@@ -1,48 +0,0 @@
-import { WebSocketServer } from "ws";
-class WSAdapter {
-    ws;
-    constructor(ws) {
-        this.ws = ws;
-    }
-    send(data) {
-        this.ws.send(data);
-    }
-    close() {
-        this.ws.close();
-    }
-    on(event, listener) {
-        if (event === 'message') {
-            this.ws.on('message', (data) => {
-                listener(data.toString());
-            });
-        }
-        else {
-            this.ws.on(event, listener);
-        }
-    }
-}
-class WSServerAdapter {
-    wss;
-    constructor(wss) {
-        this.wss = wss;
-    }
-    on(event, listener) {
-        if (event === 'connection') {
-            this.wss.on('connection', (ws, req) => {
-                listener(new WSAdapter(ws), req);
-            });
-        }
-        else {
-            this.wss.on(event, listener);
-        }
-    }
-    close() {
-        this.wss.close();
-    }
-}
-export class WSBackend {
-    createServer(options) {
-        const wss = new WebSocketServer(options);
-        return new WSServerAdapter(wss);
-    }
-}

package/dist/types.d.ts

@@ -1,52 +0,0 @@
-import { z } from 'zod';
-export type ZapServerType<T extends EventMap> = {
-    sendMessageRaw: (clientId: string, data: any) => void;
-    event: {
-        [K in keyof T as T[K] extends (ZapServerEvent<any> | ZapEvent<any, any>) ? K : never]: {
-            send: (clientId: string, data?: (T[K] extends ZapServerEvent<any> ? T[K]["data"] : T[K] extends ZapEvent<any, any> ? ReturnType<T[K]["process"]> : never)) => void;
-        };
-    };
-};
-export type Context = {
-    server: any;
-    id: string;
-    buffer: MiddlwareContext;
-};
-export type MiddlwareContext = Record<string, any>;
-export type MiddlewareMetadata = {
-    id: string;
-    ip: string;
-    timestamp: number;
-    size: number;
-};
-export type MiddlwareMsg = {
-    event: string;
-    data: any;
-    metadata: MiddlewareMetadata;
-};
-export type MiddlewareType = (ctx: MiddlwareContext, msg: MiddlwareMsg) => boolean;
-export type EventInput = z.ZodTypeAny | undefined;
-export type ZapEvent<T extends EventInput, R = any, E = unknown> = T extends z.ZodTypeAny ? {
-    input: T;
-    middleware?: MiddlewareType[];
-    process: (input: z.infer<T>, ctx: Context) => R;
-    emitType?: E;
-} : {
-    input: z.ZodVoid;
-    middleware?: MiddlewareType[];
-    process: (ctx: Context) => R;
-    emitType?: E;
-};
-export type ZapStream<T extends EventInput, R> = T extends z.ZodTypeAny ? {
-    input: T;
-    middleware?: MiddlewareType[];
-    process: (input: z.infer<T>, ctx: Context) => AsyncGenerator<R, void, unknown>;
-} : {
-    input: z.ZodVoid;
-    middleware?: MiddlewareType[];
-    process: (ctx: Context) => AsyncGenerator<R, void, unknown>;
-};
-export type ZapServerEvent<T extends z.ZodTypeAny> = {
-    data: z.infer<T>;
-};
-export type EventMap = Record<string, ZapEvent<any, any> | ZapServerEvent<any> | ZapStream<any, any>>;

package/dist/types.js

@@ -1 +0,0 @@
-export {};