@zap-socket/server 0.0.11 → 0.0.12

package/dist/events.d.ts

@@ -1,18 +1,20 @@
 import { z } from "zod";
-import type { EventInput, ZapEvent, ZapStream, ZapServerEvent, MiddlewareType, ZapServerType, MiddlwareContext } from "@zap-socket/types";
+import type { EventInput, ZapEvent, ZapStream, ZapServerEvent, MiddlewareType, MiddlwareContext } from "@zap-socket/types";
 import { ZapServer } from "./server";
 export type Context = {
-    server: ZapServer<any> & ZapServerType<any>;
+    server: ZapServer<any>;
     id: string;
     buffer: MiddlwareContext;
 };
-export declare const zapEvent: <T extends EventInput, R>(eventObj: T extends z.ZodTypeAny ? {
+export declare const zapEvent: <T extends EventInput, R, E>(eventObj: T extends z.ZodTypeAny ? {
     input: T;
     middleware?: MiddlewareType[];
     process: (input: z.infer<T>, ctx: Context) => R;
+    emitType?: E;
 } : {
     middleware?: MiddlewareType[];
     process: (ctx: Context) => R;
+    emitType?: E;
 }) => ZapEvent<T, R>;
 export declare const zapStream: <T extends EventInput, R>(eventObj: T extends z.ZodTypeAny ? {
     input: T;

package/dist/events.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
 export const zapEvent = (eventObj) => {
     if ("input" in eventObj) {
-        return eventObj;
+        // Explicitly construct the return object to match ZapEvent structure
+        return {
+            input: eventObj.input,
+            middleware: eventObj.middleware,
+            process: eventObj.process
+        };
     }
     return {
         input: z.void(),
+        middleware: eventObj.middleware,
         process: eventObj.process
     };
 };

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./events";
 export * from "./server";
-export * from "./utils";

package/dist/index.js

@@ -1,3 +1,2 @@
 export * from "./events";
 export * from "./server";
-export * from "./utils";

package/dist/server.d.ts

@@ -25,7 +25,7 @@ export declare class ZapServer<T extends EventMap> {
         send: (clientId: string, data?: (T[K] extends ZapServerEvent<any> ? T[K]["data"] : T[K] extends ZapEvent<any, any> ? ReturnType<T[K]["process"]> : never)) => void;
         broadcast: (data?: (T[K] extends ZapServerEvent<any> ? T[K]["data"] : T[K] extends ZapEvent<any, any> ? ReturnType<T[K]["process"]> : never)) => void;
     }; };
-    get clients(): Set<string>;
+    get clients(): string[];
     get socketMap(): Map<string, WebSocket>;
 }
 export declare const createZapServer: <T extends EventMap>({ port, events }: ZapServerConstructorT, callback?: () => void) => ZapServer<T>;

package/dist/server.js

@@ -203,7 +203,7 @@ export class ZapServer {
         }));
     }
     get clients() {
-        return new Set(this.idToWs.keys());
+        return this.idToWs.keys().toArray();
     }
     get socketMap() {
         return this.idToWs;

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-socket/server",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "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.4",
+    "@zap-socket/types": "^0.0.6",
     "zod": "^3.24.2"
   }
 }