@trigger.dev/core 3.0.0-beta.5 → 3.0.0-beta.51

package/dist/v3/zodSocket.d.ts

@@ -0,0 +1,93 @@
+import { Socket, ManagerOptions, SocketOptions } from 'socket.io-client';
+import { z } from 'zod';
+import { ZodMessageValueSchema, EventEmitterLike } from './zodMessageHandler.js';
+import { StructuredLogger } from './utils/structuredLogger.js';
+
+interface ZodSocketMessageCatalogSchema {
+    [key: string]: {
+        message: ZodMessageValueSchema<any>;
+    } | {
+        message: ZodMessageValueSchema<any>;
+        callback?: ZodMessageValueSchema<any>;
+    };
+}
+type ZodMessageCatalogToSocketIoEvents<TCatalog extends ZodSocketMessageCatalogSchema> = {
+    [K in keyof TCatalog]: SocketMessageHasCallback<TCatalog, K> extends true ? (message: z.infer<GetSocketMessageSchema<TCatalog, K>>, callback: (ack: z.infer<GetSocketCallbackSchema<TCatalog, K>>) => void) => void : (message: z.infer<GetSocketMessageSchema<TCatalog, K>>) => void;
+};
+type GetSocketMessageSchema<TRPCCatalog extends ZodSocketMessageCatalogSchema, TMessageType extends keyof TRPCCatalog> = TRPCCatalog[TMessageType]["message"];
+type InferSocketMessageSchema<TRPCCatalog extends ZodSocketMessageCatalogSchema, TMessageType extends keyof TRPCCatalog> = z.infer<GetSocketMessageSchema<TRPCCatalog, TMessageType>>;
+type GetSocketCallbackSchema<TRPCCatalog extends ZodSocketMessageCatalogSchema, TMessageType extends keyof TRPCCatalog> = TRPCCatalog[TMessageType] extends {
+    callback: any;
+} ? TRPCCatalog[TMessageType]["callback"] : never;
+type InferSocketCallbackSchema<TRPCCatalog extends ZodSocketMessageCatalogSchema, TMessageType extends keyof TRPCCatalog> = z.infer<GetSocketCallbackSchema<TRPCCatalog, TMessageType>>;
+type SocketMessageHasCallback<TRPCCatalog extends ZodSocketMessageCatalogSchema, TMessageType extends keyof TRPCCatalog> = GetSocketCallbackSchema<TRPCCatalog, TMessageType> extends never ? false : true;
+type ZodSocketMessageHandlers<TCatalogSchema extends ZodSocketMessageCatalogSchema> = Partial<{
+    [K in keyof TCatalogSchema]: (payload: z.infer<GetSocketMessageSchema<TCatalogSchema, K>>) => Promise<SocketMessageHasCallback<TCatalogSchema, K> extends true ? z.input<GetSocketCallbackSchema<TCatalogSchema, K>> : void>;
+}>;
+type ZodSocketMessageHandlerOptions<TMessageCatalog extends ZodSocketMessageCatalogSchema> = {
+    schema: TMessageCatalog;
+    handlers?: ZodSocketMessageHandlers<TMessageCatalog>;
+    logger?: StructuredLogger;
+};
+type MessageFromSocketSchema<K extends keyof TMessageCatalog, TMessageCatalog extends ZodSocketMessageCatalogSchema> = {
+    type: K;
+    payload: z.input<GetSocketMessageSchema<TMessageCatalog, K>>;
+};
+type MessagesFromSocketCatalog<TMessageCatalog extends ZodSocketMessageCatalogSchema> = {
+    [K in keyof TMessageCatalog]: MessageFromSocketSchema<K, TMessageCatalog>;
+}[keyof TMessageCatalog];
+declare class ZodSocketMessageHandler<TRPCCatalog extends ZodSocketMessageCatalogSchema> {
+    #private;
+    constructor(options: ZodSocketMessageHandlerOptions<TRPCCatalog>);
+    handleMessage(message: unknown): Promise<(SocketMessageHasCallback<TRPCCatalog, keyof TRPCCatalog> extends true ? z.input<GetSocketCallbackSchema<TRPCCatalog, keyof TRPCCatalog>> : void) | undefined>;
+    private parseMessage;
+    registerHandlers(emitter: EventEmitterLike, logger?: StructuredLogger): void;
+}
+type ZodSocketMessageSenderOptions<TMessageCatalog extends ZodSocketMessageCatalogSchema> = {
+    schema: TMessageCatalog;
+    socket: ZodSocket<any, TMessageCatalog>;
+    logger?: StructuredLogger;
+};
+type GetSocketMessagesWithCallback<TMessageCatalog extends ZodSocketMessageCatalogSchema> = {
+    [K in keyof TMessageCatalog]: SocketMessageHasCallback<TMessageCatalog, K> extends true ? K : never;
+}[keyof TMessageCatalog];
+type GetSocketMessagesWithoutCallback<TMessageCatalog extends ZodSocketMessageCatalogSchema> = {
+    [K in keyof TMessageCatalog]: SocketMessageHasCallback<TMessageCatalog, K> extends true ? never : K;
+}[keyof TMessageCatalog];
+declare class ZodSocketMessageSender<TMessageCatalog extends ZodSocketMessageCatalogSchema> {
+    #private;
+    constructor(options: ZodSocketMessageSenderOptions<TMessageCatalog>);
+    send<K extends GetSocketMessagesWithoutCallback<TMessageCatalog>>(type: K, payload: z.input<GetSocketMessageSchema<TMessageCatalog, K>>): void;
+    sendWithAck<K extends GetSocketMessagesWithCallback<TMessageCatalog>>(type: K, payload: z.input<GetSocketMessageSchema<TMessageCatalog, K>>): Promise<z.infer<GetSocketCallbackSchema<TMessageCatalog, K>>>;
+}
+type ZodSocket<TListenEvents extends ZodSocketMessageCatalogSchema, TEmitEvents extends ZodSocketMessageCatalogSchema> = Omit<Socket<ZodMessageCatalogToSocketIoEvents<TListenEvents>, ZodMessageCatalogToSocketIoEvents<TEmitEvents>>, "timeout"> & {
+    timeout: (timeout: number) => Socket<ZodMessageCatalogToSocketIoEvents<TListenEvents>, ZodMessageCatalogToSocketIoEvents<TEmitEvents>>;
+};
+interface ZodSocketConnectionOptions<TClientMessages extends ZodSocketMessageCatalogSchema, TServerMessages extends ZodSocketMessageCatalogSchema> {
+    host: string;
+    port?: number;
+    secure?: boolean;
+    namespace: string;
+    clientMessages: TClientMessages;
+    serverMessages: TServerMessages;
+    extraHeaders?: {
+        [header: string]: string;
+    };
+    handlers?: ZodSocketMessageHandlers<TServerMessages>;
+    authToken?: string;
+    ioOptions?: Partial<ManagerOptions & SocketOptions>;
+    onConnection?: (socket: ZodSocket<TServerMessages, TClientMessages>, handler: ZodSocketMessageHandler<TServerMessages>, sender: ZodSocketMessageSender<TClientMessages>, logger: StructuredLogger) => Promise<void>;
+    onDisconnect?: (socket: ZodSocket<TServerMessages, TClientMessages>, reason: Socket.DisconnectReason, description: any, logger: StructuredLogger) => Promise<void>;
+    onError?: (socket: ZodSocket<TServerMessages, TClientMessages>, err: Error, logger: StructuredLogger) => Promise<void>;
+}
+declare class ZodSocketConnection<TClientMessages extends ZodSocketMessageCatalogSchema, TServerMessages extends ZodSocketMessageCatalogSchema> {
+    #private;
+    socket: ZodSocket<TServerMessages, TClientMessages>;
+    constructor(opts: ZodSocketConnectionOptions<TClientMessages, TServerMessages>);
+    close(): void;
+    connect(): void;
+    get send(): <K extends GetSocketMessagesWithoutCallback<TClientMessages>>(type: K, payload: z.input<GetSocketMessageSchema<TClientMessages, K>>) => void;
+    get sendWithAck(): <K extends GetSocketMessagesWithCallback<TClientMessages>>(type: K, payload: z.input<GetSocketMessageSchema<TClientMessages, K>>) => Promise<z.TypeOf<GetSocketCallbackSchema<TClientMessages, K>>>;
+}
+
+export { type GetSocketCallbackSchema, type GetSocketMessageSchema, type GetSocketMessagesWithCallback, type GetSocketMessagesWithoutCallback, type InferSocketCallbackSchema, type InferSocketMessageSchema, type MessagesFromSocketCatalog, type SocketMessageHasCallback, type ZodMessageCatalogToSocketIoEvents, type ZodSocket, ZodSocketConnection, type ZodSocketMessageCatalogSchema, ZodSocketMessageHandler, type ZodSocketMessageHandlerOptions, type ZodSocketMessageHandlers, ZodSocketMessageSender, type ZodSocketMessageSenderOptions };

package/dist/v3/zodSocket.js

@@ -0,0 +1,350 @@
+'use strict';
+
+var socket_ioClient = require('socket.io-client');
+var zod = require('zod');
+var zodValidationError = require('zod-validation-error');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/v3/utils/structuredLogger.ts
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["log"] = 0] = "log";
+  LogLevel2[LogLevel2["error"] = 1] = "error";
+  LogLevel2[LogLevel2["warn"] = 2] = "warn";
+  LogLevel2[LogLevel2["info"] = 3] = "info";
+  LogLevel2[LogLevel2["debug"] = 4] = "debug";
+})(LogLevel || (LogLevel = {}));
+var _structuredLog, structuredLog_fn;
+var _SimpleStructuredLogger = class _SimpleStructuredLogger {
+  constructor(name, level = [
+    "1",
+    "true"
+  ].includes(process.env.DEBUG ?? "") ? LogLevel.debug : LogLevel.info, fields) {
+    __privateAdd(this, _structuredLog);
+    this.name = name;
+    this.level = level;
+    this.fields = fields;
+  }
+  child(fields, level) {
+    return new _SimpleStructuredLogger(this.name, level, {
+      ...this.fields,
+      ...fields
+    });
+  }
+  log(message, ...args) {
+    if (this.level < LogLevel.log)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
+  }
+  error(message, ...args) {
+    if (this.level < LogLevel.error)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
+  }
+  warn(message, ...args) {
+    if (this.level < LogLevel.warn)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
+  }
+  info(message, ...args) {
+    if (this.level < LogLevel.info)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
+  }
+  debug(message, ...args) {
+    if (this.level < LogLevel.debug)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
+  }
+};
+_structuredLog = new WeakSet();
+structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
+  const structuredLog = {
+    ...args.length === 1 ? args[0] : args,
+    ...this.fields,
+    timestamp: /* @__PURE__ */ new Date(),
+    name: this.name,
+    message,
+    level
+  };
+  loggerFunction(JSON.stringify(structuredLog));
+}, "#structuredLog");
+__name(_SimpleStructuredLogger, "SimpleStructuredLogger");
+var SimpleStructuredLogger = _SimpleStructuredLogger;
+var messageSchema = zod.z.object({
+  version: zod.z.string(),
+  type: zod.z.string(),
+  payload: zod.z.unknown()
+});
+var _schema, _handlers, _logger;
+var _ZodSocketMessageHandler = class _ZodSocketMessageHandler {
+  constructor(options) {
+    __privateAdd(this, _schema, void 0);
+    __privateAdd(this, _handlers, void 0);
+    __privateAdd(this, _logger, void 0);
+    __privateSet(this, _schema, options.schema);
+    __privateSet(this, _handlers, options.handlers);
+    __privateSet(this, _logger, options.logger ?? new SimpleStructuredLogger("socket-message-handler", LogLevel.info));
+  }
+  async handleMessage(message) {
+    const parseResult = this.parseMessage(message);
+    if (!parseResult.success) {
+      __privateGet(this, _logger).error("Failed to parse message, skipping handler", {
+        rawMessage: message,
+        error: parseResult.reason
+      });
+      return;
+    }
+    if (!__privateGet(this, _handlers)) {
+      throw new Error("No handlers provided");
+    }
+    const { type, payload } = parseResult.data;
+    const handler = __privateGet(this, _handlers)[type];
+    if (!handler) {
+      console.error(`No handler for message type: ${String(type)}`);
+      return;
+    }
+    const ack = await handler(payload);
+    return ack;
+  }
+  parseMessage(message) {
+    const parsedMessage = messageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+      return {
+        success: false,
+        reason: `Failed to parse message: ${zodValidationError.fromZodError(parsedMessage.error).toString()}`
+      };
+    }
+    const schema = __privateGet(this, _schema)[parsedMessage.data.type]["message"];
+    if (!schema) {
+      return {
+        success: false,
+        reason: `Unknown message type: ${parsedMessage.data.type}`
+      };
+    }
+    const messageWithVersion = {
+      version: parsedMessage.data.version,
+      ...typeof parsedMessage.data.payload === "object" ? parsedMessage.data.payload : {}
+    };
+    const parsedPayload = schema.safeParse(messageWithVersion);
+    if (!parsedPayload.success) {
+      console.error("Failed to parse message payload", {
+        message,
+        payload: messageWithVersion
+      });
+      return {
+        success: false,
+        reason: zodValidationError.fromZodError(parsedPayload.error).toString()
+      };
+    }
+    return {
+      success: true,
+      data: {
+        type: parsedMessage.data.type,
+        payload: parsedPayload.data
+      }
+    };
+  }
+  registerHandlers(emitter, logger) {
+    const log = logger ?? console;
+    if (!__privateGet(this, _handlers)) {
+      log.info("No handlers provided");
+      return;
+    }
+    for (const eventName of Object.keys(__privateGet(this, _handlers))) {
+      emitter.on(eventName, async (message, callback) => {
+        log.info(`handling ${eventName}`, {
+          payload: message,
+          hasCallback: !!callback
+        });
+        let ack;
+        try {
+          if ("payload" in message) {
+            ack = await this.handleMessage({
+              type: eventName,
+              ...message
+            });
+          } else {
+            const { version, ...payload } = message;
+            ack = await this.handleMessage({
+              type: eventName,
+              version,
+              payload
+            });
+          }
+        } catch (error) {
+          log.error("Error while handling message", {
+            error: error instanceof Error ? {
+              message: error.message,
+              stack: error.stack
+            } : error
+          });
+          return;
+        }
+        if (callback && typeof callback === "function") {
+          callback(ack);
+        }
+      });
+    }
+  }
+};
+_schema = new WeakMap();
+_handlers = new WeakMap();
+_logger = new WeakMap();
+__name(_ZodSocketMessageHandler, "ZodSocketMessageHandler");
+var ZodSocketMessageHandler = _ZodSocketMessageHandler;
+var _schema2, _socket, _logger2;
+var _ZodSocketMessageSender = class _ZodSocketMessageSender {
+  constructor(options) {
+    __privateAdd(this, _schema2, void 0);
+    __privateAdd(this, _socket, void 0);
+    __privateAdd(this, _logger2, void 0);
+    __privateSet(this, _schema2, options.schema);
+    __privateSet(this, _socket, options.socket);
+    __privateSet(this, _logger2, options.logger ?? new SimpleStructuredLogger("zod-socket-sender", LogLevel.info));
+  }
+  send(type, payload) {
+    const schema = __privateGet(this, _schema2)[type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${type}`);
+    }
+    const parsedPayload = schema.safeParse(payload);
+    if (!parsedPayload.success) {
+      __privateGet(this, _logger2).error("Failed to parse message payload, will not send", {
+        error: parsedPayload.error
+      });
+      return;
+    }
+    __privateGet(this, _socket).emit(type, {
+      payload,
+      version: "v1"
+    });
+    return;
+  }
+  async sendWithAck(type, payload) {
+    const schema = __privateGet(this, _schema2)[type]["message"];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${type}`);
+    }
+    const parsedPayload = schema.safeParse(payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
+    const callbackResult = await __privateGet(this, _socket).emitWithAck(type, {
+      payload,
+      version: "v1"
+    });
+    return callbackResult;
+  }
+};
+_schema2 = new WeakMap();
+_socket = new WeakMap();
+_logger2 = new WeakMap();
+__name(_ZodSocketMessageSender, "ZodSocketMessageSender");
+var ZodSocketMessageSender = _ZodSocketMessageSender;
+var _sender, _handler, _logger3;
+var _ZodSocketConnection = class _ZodSocketConnection {
+  constructor(opts) {
+    __privateAdd(this, _sender, void 0);
+    __privateAdd(this, _handler, void 0);
+    __privateAdd(this, _logger3, void 0);
+    const uri = `${opts.secure ? "wss" : "ws"}://${opts.host}:${opts.port ?? (opts.secure ? "443" : "80")}/${opts.namespace}`;
+    const logger = new SimpleStructuredLogger(opts.namespace, LogLevel.info);
+    logger.log("new zod socket", {
+      uri
+    });
+    this.socket = socket_ioClient.io(uri, {
+      transports: [
+        "websocket"
+      ],
+      auth: {
+        token: opts.authToken
+      },
+      extraHeaders: opts.extraHeaders,
+      reconnectionDelay: 500,
+      reconnectionDelayMax: 1e3,
+      ...opts.ioOptions
+    });
+    __privateSet(this, _logger3, logger.child({
+      socketId: this.socket.id
+    }));
+    __privateSet(this, _handler, new ZodSocketMessageHandler({
+      schema: opts.serverMessages,
+      handlers: opts.handlers
+    }));
+    __privateGet(this, _handler).registerHandlers(this.socket, __privateGet(this, _logger3));
+    __privateSet(this, _sender, new ZodSocketMessageSender({
+      schema: opts.clientMessages,
+      socket: this.socket,
+      logger: __privateGet(this, _logger3)
+    }));
+    this.socket.on("connect_error", async (error) => {
+      __privateGet(this, _logger3).error(`connect_error: ${error}`);
+      if (opts.onError) {
+        await opts.onError(this.socket, error, __privateGet(this, _logger3));
+      }
+    });
+    this.socket.on("connect", async () => {
+      __privateGet(this, _logger3).info("connect");
+      if (opts.onConnection) {
+        await opts.onConnection(this.socket, __privateGet(this, _handler), __privateGet(this, _sender), __privateGet(this, _logger3));
+      }
+    });
+    this.socket.on("disconnect", async (reason, description) => {
+      __privateGet(this, _logger3).info("disconnect", {
+        reason,
+        description
+      });
+      if (opts.onDisconnect) {
+        await opts.onDisconnect(this.socket, reason, description, __privateGet(this, _logger3));
+      }
+    });
+  }
+  close() {
+    this.socket.close();
+  }
+  connect() {
+    this.socket.connect();
+  }
+  get send() {
+    return __privateGet(this, _sender).send.bind(__privateGet(this, _sender));
+  }
+  get sendWithAck() {
+    return __privateGet(this, _sender).sendWithAck.bind(__privateGet(this, _sender));
+  }
+};
+_sender = new WeakMap();
+_handler = new WeakMap();
+_logger3 = new WeakMap();
+__name(_ZodSocketConnection, "ZodSocketConnection");
+var ZodSocketConnection = _ZodSocketConnection;
+
+exports.ZodSocketConnection = ZodSocketConnection;
+exports.ZodSocketMessageHandler = ZodSocketMessageHandler;
+exports.ZodSocketMessageSender = ZodSocketMessageSender;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=zodSocket.js.map

package/dist/v3/zodSocket.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/v3/zodSocket.ts","../../src/v3/utils/structuredLogger.ts"],"names":["io","z","LogLevel","SimpleStructuredLogger","constructor","name","level","includes","process","env","DEBUG","debug","info","fields","child","log","message","args","console","error","warn","loggerFunction","structuredLog","length","timestamp","Date","JSON","stringify","fromZodError","messageSchema","object","version","string","type","payload","unknown","ZodSocketMessageHandler","options","schema","handlers","logger","handleMessage","parseResult","parseMessage","success","rawMessage","reason","Error","data","handler","String","ack","parsedMessage","safeParse","toString","messageWithVersion","parsedPayload","registerHandlers","emitter","eventName","Object","keys","on","callback","hasCallback","stack","_schema","_logger","ZodSocketMessageSender","socket","send","emit","sendWithAck","callbackResult","emitWithAck","ZodSocketConnection","opts","uri","secure","host","port","namespace","transports","auth","token","authToken","extraHeaders","reconnectionDelay","reconnectionDelayMax","ioOptions","socketId","id","serverMessages","clientMessages","onError","onConnection","description","onDisconnect","close","connect","bind"],"mappings":"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","sourcesContent":["import type { ManagerOptions, Socket, SocketOptions } from \"socket.io-client\";\nimport { io } from \"socket.io-client\";\nimport { ZodError, z } from \"zod\";\nimport { EventEmitterLike, ZodMessageValueSchema } from \"./zodMessageHandler\";\nimport { LogLevel, SimpleStructuredLogger, StructuredLogger } from \"./utils/structuredLogger\";\nimport { fromZodError } from \"zod-validation-error\";\n\nexport interface ZodSocketMessageCatalogSchema {\n  [key: string]:\n    | {\n        message: ZodMessageValueSchema<any>;\n      }\n    | {\n        message: ZodMessageValueSchema<any>;\n        callback?: ZodMessageValueSchema<any>;\n      };\n}\n\nexport type ZodMessageCatalogToSocketIoEvents<TCatalog extends ZodSocketMessageCatalogSchema> = {\n  [K in keyof TCatalog]: SocketMessageHasCallback<TCatalog, K> extends true\n    ? (\n        message: z.infer<GetSocketMessageSchema<TCatalog, K>>,\n        callback: (ack: z.infer<GetSocketCallbackSchema<TCatalog, K>>) => void\n      ) => void\n    : (message: z.infer<GetSocketMessageSchema<TCatalog, K>>) => void;\n};\n\nexport type GetSocketMessageSchema<\n  TRPCCatalog extends ZodSocketMessageCatalogSchema,\n  TMessageType extends keyof TRPCCatalog,\n> = TRPCCatalog[TMessageType][\"message\"];\n\nexport type InferSocketMessageSchema<\n  TRPCCatalog extends ZodSocketMessageCatalogSchema,\n  TMessageType extends keyof TRPCCatalog,\n> = z.infer<GetSocketMessageSchema<TRPCCatalog, TMessageType>>;\n\nexport type GetSocketCallbackSchema<\n  TRPCCatalog extends ZodSocketMessageCatalogSchema,\n  TMessageType extends keyof TRPCCatalog,\n> = TRPCCatalog[TMessageType] extends { callback: any }\n  ? TRPCCatalog[TMessageType][\"callback\"]\n  : never;\n\nexport type InferSocketCallbackSchema<\n  TRPCCatalog extends ZodSocketMessageCatalogSchema,\n  TMessageType extends keyof TRPCCatalog,\n> = z.infer<GetSocketCallbackSchema<TRPCCatalog, TMessageType>>;\n\nexport type SocketMessageHasCallback<\n  TRPCCatalog extends ZodSocketMessageCatalogSchema,\n  TMessageType extends keyof TRPCCatalog,\n> = GetSocketCallbackSchema<TRPCCatalog, TMessageType> extends never ? false : true;\n\nexport type ZodSocketMessageHandlers<TCatalogSchema extends ZodSocketMessageCatalogSchema> =\n  Partial<{\n    [K in keyof TCatalogSchema]: (\n      payload: z.infer<GetSocketMessageSchema<TCatalogSchema, K>>\n    ) => Promise<\n      SocketMessageHasCallback<TCatalogSchema, K> extends true\n        ? z.input<GetSocketCallbackSchema<TCatalogSchema, K>>\n        : void\n    >;\n  }>;\n\nexport type ZodSocketMessageHandlerOptions<TMessageCatalog extends ZodSocketMessageCatalogSchema> =\n  {\n    schema: TMessageCatalog;\n    handlers?: ZodSocketMessageHandlers<TMessageCatalog>;\n    logger?: StructuredLogger;\n  };\n\ntype MessageFromSocketSchema<\n  K extends keyof TMessageCatalog,\n  TMessageCatalog extends ZodSocketMessageCatalogSchema,\n> = {\n  type: K;\n  payload: z.input<GetSocketMessageSchema<TMessageCatalog, K>>;\n};\n\nexport type MessagesFromSocketCatalog<TMessageCatalog extends ZodSocketMessageCatalogSchema> = {\n  [K in keyof TMessageCatalog]: MessageFromSocketSchema<K, TMessageCatalog>;\n}[keyof TMessageCatalog];\n\nconst messageSchema = z.object({\n  version: z.string(),\n  type: z.string(),\n  payload: z.unknown(),\n});\n\nexport class ZodSocketMessageHandler<TRPCCatalog extends ZodSocketMessageCatalogSchema> {\n  #schema: TRPCCatalog;\n  #handlers: ZodSocketMessageHandlers<TRPCCatalog> | undefined;\n  #logger: StructuredLogger;\n\n  constructor(options: ZodSocketMessageHandlerOptions<TRPCCatalog>) {\n    this.#schema = options.schema;\n    this.#handlers = options.handlers;\n    this.#logger =\n      options.logger ?? new SimpleStructuredLogger(\"socket-message-handler\", LogLevel.info);\n  }\n\n  public async handleMessage(message: unknown) {\n    const parseResult = this.parseMessage(message);\n\n    if (!parseResult.success) {\n      this.#logger.error(\"Failed to parse message, skipping handler\", {\n        rawMessage: message,\n        error: parseResult.reason,\n      });\n      return;\n    }\n\n    if (!this.#handlers) {\n      throw new Error(\"No handlers provided\");\n    }\n\n    const { type, payload } = parseResult.data;\n\n    const handler = this.#handlers[type];\n\n    if (!handler) {\n      console.error(`No handler for message type: ${String(type)}`);\n      return;\n    }\n\n    const ack = await handler(payload);\n\n    return ack;\n  }\n\n  private parseMessage(message: unknown):\n    | {\n        success: true;\n        data: MessagesFromSocketCatalog<TRPCCatalog>;\n      }\n    | {\n        success: false;\n        reason?: string;\n      } {\n    const parsedMessage = messageSchema.safeParse(message);\n\n    if (!parsedMessage.success) {\n      return {\n        success: false,\n        reason: `Failed to parse message: ${fromZodError(parsedMessage.error).toString()}`,\n      };\n    }\n\n    const schema = this.#schema[parsedMessage.data.type][\"message\"];\n\n    if (!schema) {\n      return {\n        success: false,\n        reason: `Unknown message type: ${parsedMessage.data.type}`,\n      };\n    }\n\n    const messageWithVersion = {\n      version: parsedMessage.data.version,\n      ...(typeof parsedMessage.data.payload === \"object\" ? parsedMessage.data.payload : {}),\n    };\n\n    const parsedPayload = schema.safeParse(messageWithVersion);\n\n    if (!parsedPayload.success) {\n      console.error(\"Failed to parse message payload\", {\n        message,\n        payload: messageWithVersion,\n      });\n\n      return {\n        success: false,\n        reason: fromZodError(parsedPayload.error).toString(),\n      };\n    }\n\n    return {\n      success: true,\n      data: {\n        type: parsedMessage.data.type,\n        payload: parsedPayload.data,\n      },\n    };\n  }\n\n  public registerHandlers(emitter: EventEmitterLike, logger?: StructuredLogger) {\n    const log = logger ?? console;\n\n    if (!this.#handlers) {\n      log.info(\"No handlers provided\");\n      return;\n    }\n\n    for (const eventName of Object.keys(this.#handlers)) {\n      emitter.on(eventName, async (message: any, callback?: any): Promise<void> => {\n        log.info(`handling ${eventName}`, {\n          payload: message,\n          hasCallback: !!callback,\n        });\n\n        let ack;\n\n        try {\n          // FIXME: this only works if the message doesn't have genuine payload prop\n          if (\"payload\" in message) {\n            ack = await this.handleMessage({ type: eventName, ...message });\n          } else {\n            // Handle messages not sent by ZodMessageSender\n            const { version, ...payload } = message;\n            ack = await this.handleMessage({ type: eventName, version, payload });\n          }\n        } catch (error) {\n          log.error(\"Error while handling message\", {\n            error:\n              error instanceof Error\n                ? {\n                    message: error.message,\n                    stack: error.stack,\n                  }\n                : error,\n          });\n          return;\n        }\n\n        if (callback && typeof callback === \"function\") {\n          callback(ack);\n        }\n      });\n    }\n  }\n}\n\nexport type ZodSocketMessageSenderOptions<TMessageCatalog extends ZodSocketMessageCatalogSchema> = {\n  schema: TMessageCatalog;\n  socket: ZodSocket<any, TMessageCatalog>;\n  logger?: StructuredLogger;\n};\n\nexport type GetSocketMessagesWithCallback<TMessageCatalog extends ZodSocketMessageCatalogSchema> = {\n  [K in keyof TMessageCatalog]: SocketMessageHasCallback<TMessageCatalog, K> extends true\n    ? K\n    : never;\n}[keyof TMessageCatalog];\n\nexport type GetSocketMessagesWithoutCallback<\n  TMessageCatalog extends ZodSocketMessageCatalogSchema,\n> = {\n  [K in keyof TMessageCatalog]: SocketMessageHasCallback<TMessageCatalog, K> extends true\n    ? never\n    : K;\n}[keyof TMessageCatalog];\n\nexport class ZodSocketMessageSender<TMessageCatalog extends ZodSocketMessageCatalogSchema> {\n  #schema: TMessageCatalog;\n  #socket: ZodSocket<any, TMessageCatalog>;\n  #logger: StructuredLogger;\n\n  constructor(options: ZodSocketMessageSenderOptions<TMessageCatalog>) {\n    this.#schema = options.schema;\n    this.#socket = options.socket;\n    this.#logger = options.logger ?? new SimpleStructuredLogger(\"zod-socket-sender\", LogLevel.info);\n  }\n\n  public send<K extends GetSocketMessagesWithoutCallback<TMessageCatalog>>(\n    type: K,\n    payload: z.input<GetSocketMessageSchema<TMessageCatalog, K>>\n  ): void {\n    const schema = this.#schema[type][\"message\"];\n\n    if (!schema) {\n      throw new Error(`Unknown message type: ${type as string}`);\n    }\n\n    const parsedPayload = schema.safeParse(payload);\n\n    if (!parsedPayload.success) {\n      this.#logger.error(\"Failed to parse message payload, will not send\", {\n        error: parsedPayload.error,\n      });\n      return;\n    }\n\n    // @ts-expect-error\n    this.#socket.emit(type, { payload, version: \"v1\" });\n\n    return;\n  }\n\n  public async sendWithAck<K extends GetSocketMessagesWithCallback<TMessageCatalog>>(\n    type: K,\n    payload: z.input<GetSocketMessageSchema<TMessageCatalog, K>>\n  ): Promise<z.infer<GetSocketCallbackSchema<TMessageCatalog, K>>> {\n    const schema = this.#schema[type][\"message\"];\n\n    if (!schema) {\n      throw new Error(`Unknown message type: ${type as string}`);\n    }\n\n    const parsedPayload = schema.safeParse(payload);\n\n    if (!parsedPayload.success) {\n      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);\n    }\n\n    // @ts-expect-error\n    const callbackResult = await this.#socket.emitWithAck(type, { payload, version: \"v1\" });\n\n    return callbackResult;\n  }\n}\n\nexport type ZodSocket<\n  TListenEvents extends ZodSocketMessageCatalogSchema,\n  TEmitEvents extends ZodSocketMessageCatalogSchema,\n> = Omit<\n  Socket<\n    ZodMessageCatalogToSocketIoEvents<TListenEvents>,\n    ZodMessageCatalogToSocketIoEvents<TEmitEvents>\n  >,\n  \"timeout\"\n> & {\n  timeout: (\n    timeout: number\n  ) => Socket<\n    ZodMessageCatalogToSocketIoEvents<TListenEvents>,\n    ZodMessageCatalogToSocketIoEvents<TEmitEvents>\n  >;\n};\n\ninterface ZodSocketConnectionOptions<\n  TClientMessages extends ZodSocketMessageCatalogSchema,\n  TServerMessages extends ZodSocketMessageCatalogSchema,\n> {\n  host: string;\n  port?: number;\n  secure?: boolean;\n  namespace: string;\n  clientMessages: TClientMessages;\n  serverMessages: TServerMessages;\n  extraHeaders?: {\n    [header: string]: string;\n  };\n  handlers?: ZodSocketMessageHandlers<TServerMessages>;\n  authToken?: string;\n  ioOptions?: Partial<ManagerOptions & SocketOptions>;\n  onConnection?: (\n    socket: ZodSocket<TServerMessages, TClientMessages>,\n    handler: ZodSocketMessageHandler<TServerMessages>,\n    sender: ZodSocketMessageSender<TClientMessages>,\n    logger: StructuredLogger\n  ) => Promise<void>;\n  onDisconnect?: (\n    socket: ZodSocket<TServerMessages, TClientMessages>,\n    reason: Socket.DisconnectReason,\n    description: any,\n    logger: StructuredLogger\n  ) => Promise<void>;\n  onError?: (\n    socket: ZodSocket<TServerMessages, TClientMessages>,\n    err: Error,\n    logger: StructuredLogger\n  ) => Promise<void>;\n}\n\nexport class ZodSocketConnection<\n  TClientMessages extends ZodSocketMessageCatalogSchema,\n  TServerMessages extends ZodSocketMessageCatalogSchema,\n> {\n  #sender: ZodSocketMessageSender<TClientMessages>;\n  socket: ZodSocket<TServerMessages, TClientMessages>;\n\n  #handler: ZodSocketMessageHandler<TServerMessages>;\n  #logger: StructuredLogger;\n\n  constructor(opts: ZodSocketConnectionOptions<TClientMessages, TServerMessages>) {\n    const uri = `${opts.secure ? \"wss\" : \"ws\"}://${opts.host}:${\n      opts.port ?? (opts.secure ? \"443\" : \"80\")\n    }/${opts.namespace}`;\n\n    const logger = new SimpleStructuredLogger(opts.namespace, LogLevel.info);\n    logger.log(\"new zod socket\", { uri });\n\n    this.socket = io(uri, {\n      transports: [\"websocket\"],\n      auth: {\n        token: opts.authToken,\n      },\n      extraHeaders: opts.extraHeaders,\n      reconnectionDelay: 500,\n      reconnectionDelayMax: 1000,\n      ...opts.ioOptions,\n    });\n\n    this.#logger = logger.child({\n      socketId: this.socket.id,\n    });\n\n    this.#handler = new ZodSocketMessageHandler({\n      schema: opts.serverMessages,\n      handlers: opts.handlers,\n    });\n    this.#handler.registerHandlers(this.socket, this.#logger);\n\n    this.#sender = new ZodSocketMessageSender({\n      schema: opts.clientMessages,\n      socket: this.socket,\n      logger: this.#logger,\n    });\n\n    this.socket.on(\"connect_error\", async (error) => {\n      this.#logger.error(`connect_error: ${error}`);\n\n      if (opts.onError) {\n        await opts.onError(this.socket, error, this.#logger);\n      }\n    });\n\n    this.socket.on(\"connect\", async () => {\n      this.#logger.info(\"connect\");\n\n      if (opts.onConnection) {\n        await opts.onConnection(this.socket, this.#handler, this.#sender, this.#logger);\n      }\n    });\n\n    this.socket.on(\"disconnect\", async (reason, description) => {\n      this.#logger.info(\"disconnect\", { reason, description });\n\n      if (opts.onDisconnect) {\n        await opts.onDisconnect(this.socket, reason, description, this.#logger);\n      }\n    });\n  }\n\n  close() {\n    this.socket.close();\n  }\n\n  connect() {\n    this.socket.connect();\n  }\n\n  get send() {\n    return this.#sender.send.bind(this.#sender);\n  }\n\n  get sendWithAck() {\n    return this.#sender.sendWithAck.bind(this.#sender);\n  }\n}\n","type StructuredArgs = (Record<string, unknown> | undefined)[];\n\nexport interface StructuredLogger {\n  log: (message: string, ...args: StructuredArgs) => any;\n  error: (message: string, ...args: StructuredArgs) => any;\n  warn: (message: string, ...args: StructuredArgs) => any;\n  info: (message: string, ...args: StructuredArgs) => any;\n  debug: (message: string, ...args: StructuredArgs) => any;\n  child: (fields: Record<string, unknown>) => StructuredLogger;\n}\n\nexport enum LogLevel {\n  \"log\",\n  \"error\",\n  \"warn\",\n  \"info\",\n  \"debug\",\n}\n\nexport class SimpleStructuredLogger implements StructuredLogger {\n  constructor(\n    private name: string,\n    private level: LogLevel = [\"1\", \"true\"].includes(process.env.DEBUG ?? \"\")\n      ? LogLevel.debug\n      : LogLevel.info,\n    private fields?: Record<string, unknown>\n  ) {}\n\n  child(fields: Record<string, unknown>, level?: LogLevel) {\n    return new SimpleStructuredLogger(this.name, level, { ...this.fields, ...fields });\n  }\n\n  log(message: string, ...args: StructuredArgs) {\n    if (this.level < LogLevel.log) return;\n\n    this.#structuredLog(console.log, message, \"log\", ...args);\n  }\n\n  error(message: string, ...args: StructuredArgs) {\n    if (this.level < LogLevel.error) return;\n\n    this.#structuredLog(console.error, message, \"error\", ...args);\n  }\n\n  warn(message: string, ...args: StructuredArgs) {\n    if (this.level < LogLevel.warn) return;\n\n    this.#structuredLog(console.warn, message, \"warn\", ...args);\n  }\n\n  info(message: string, ...args: StructuredArgs) {\n    if (this.level < LogLevel.info) return;\n\n    this.#structuredLog(console.info, message, \"info\", ...args);\n  }\n\n  debug(message: string, ...args: StructuredArgs) {\n    if (this.level < LogLevel.debug) return;\n\n    this.#structuredLog(console.debug, message, \"debug\", ...args);\n  }\n\n  #structuredLog(\n    loggerFunction: (message: string, ...args: any[]) => void,\n    message: string,\n    level: string,\n    ...args: StructuredArgs\n  ) {\n    const structuredLog = {\n      ...(args.length === 1 ? args[0] : args),\n      ...this.fields,\n      timestamp: new Date(),\n      name: this.name,\n      message,\n      level,\n    };\n\n    loggerFunction(JSON.stringify(structuredLog));\n  }\n}\n"]}