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

package/dist/v3/zodMessageHandler.mjs

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+
+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 _ZodSchemaParsedError = class _ZodSchemaParsedError extends Error {
+  constructor(error, payload) {
+    super(error.message);
+    this.error = error;
+    this.payload = payload;
+  }
+};
+__name(_ZodSchemaParsedError, "ZodSchemaParsedError");
+var ZodSchemaParsedError = _ZodSchemaParsedError;
+var ZodMessageSchema = z.object({
+  version: z.literal("v1").default("v1"),
+  type: z.string(),
+  payload: z.unknown()
+});
+var _schema, _handlers, _logger;
+var _ZodMessageHandler = class _ZodMessageHandler {
+  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.messages);
+    __privateSet(this, _logger, options.logger ?? console);
+  }
+  async handleMessage(message) {
+    const parsedMessage = this.parseMessage(message);
+    if (!parsedMessage.success) {
+      __privateGet(this, _logger).error(parsedMessage.error, {
+        message
+      });
+      return {
+        success: false,
+        error: parsedMessage.error
+      };
+    }
+    if (!__privateGet(this, _handlers)) {
+      __privateGet(this, _logger).error("No handlers provided", {
+        message
+      });
+      return {
+        success: false,
+        error: "No handlers provided"
+      };
+    }
+    const handler = __privateGet(this, _handlers)[parsedMessage.data.type];
+    if (!handler) {
+      const error = `No handler for message type: ${String(parsedMessage.data.type)}`;
+      __privateGet(this, _logger).error(error, {
+        message
+      });
+      return {
+        success: false,
+        error
+      };
+    }
+    const ack = await handler(parsedMessage.data.payload);
+    return {
+      success: true,
+      data: ack
+    };
+  }
+  parseMessage(message) {
+    const parsedMessage = ZodMessageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+      return {
+        success: false,
+        error: `Failed to parse message: ${JSON.stringify(parsedMessage.error)}`
+      };
+    }
+    const schema = __privateGet(this, _schema)[parsedMessage.data.type];
+    if (!schema) {
+      return {
+        success: false,
+        error: `Unknown message type: ${parsedMessage.data.type}`
+      };
+    }
+    const parsedPayload = schema.safeParse(parsedMessage.data.payload);
+    if (!parsedPayload.success) {
+      return {
+        success: false,
+        error: `Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`
+      };
+    }
+    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, _schema))) {
+      emitter.on(eventName, async (message, callback) => {
+        log.info(`handling ${eventName}`, {
+          payload: message,
+          hasCallback: !!callback
+        });
+        let ack;
+        if ("payload" in message) {
+          ack = await this.handleMessage({
+            type: eventName,
+            ...message
+          });
+        } else {
+          const { version, ...payload } = message;
+          ack = await this.handleMessage({
+            type: eventName,
+            version,
+            payload
+          });
+        }
+        if (callback && typeof callback === "function") {
+          if (!ack.success) {
+            log.error("Failed to handle message, skipping callback", {
+              message,
+              error: ack.error
+            });
+            return;
+          }
+          callback(ack.data);
+        }
+      });
+    }
+  }
+};
+_schema = new WeakMap();
+_handlers = new WeakMap();
+_logger = new WeakMap();
+__name(_ZodMessageHandler, "ZodMessageHandler");
+var ZodMessageHandler = _ZodMessageHandler;
+var _schema2, _sender;
+var _ZodMessageSender = class _ZodMessageSender {
+  constructor(options) {
+    __privateAdd(this, _schema2, void 0);
+    __privateAdd(this, _sender, void 0);
+    __privateSet(this, _schema2, options.schema);
+    __privateSet(this, _sender, options.sender);
+  }
+  async send(type, payload) {
+    const schema = __privateGet(this, _schema2)[type];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${type}`);
+    }
+    const parsedPayload = schema.safeParse(payload);
+    if (!parsedPayload.success) {
+      throw new ZodSchemaParsedError(parsedPayload.error, payload);
+    }
+    try {
+      await __privateGet(this, _sender).call(this, {
+        type,
+        payload,
+        version: "v1"
+      });
+    } catch (error) {
+      console.error("[ZodMessageSender] Failed to send message", error);
+    }
+  }
+  async forwardMessage(message) {
+    const parsedMessage = ZodMessageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+      throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);
+    }
+    const schema = __privateGet(this, _schema2)[parsedMessage.data.type];
+    if (!schema) {
+      throw new Error(`Unknown message type: ${parsedMessage.data.type}`);
+    }
+    const parsedPayload = schema.safeParse(parsedMessage.data.payload);
+    if (!parsedPayload.success) {
+      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);
+    }
+    try {
+      await __privateGet(this, _sender).call(this, {
+        type: parsedMessage.data.type,
+        payload: parsedPayload.data,
+        version: "v1"
+      });
+    } catch (error) {
+      console.error("[ZodMessageSender] Failed to forward message", error);
+    }
+  }
+};
+_schema2 = new WeakMap();
+_sender = new WeakMap();
+__name(_ZodMessageSender, "ZodMessageSender");
+var ZodMessageSender = _ZodMessageSender;
+
+export { ZodMessageHandler, ZodMessageSchema, ZodMessageSender, ZodSchemaParsedError };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=zodMessageHandler.mjs.map

package/dist/v3/zodMessageHandler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/v3/zodMessageHandler.ts"],"names":["z","ZodSchemaParsedError","Error","constructor","error","payload","message","ZodMessageSchema","object","version","literal","default","type","string","unknown","ZodMessageHandler","options","schema","messages","logger","console","handleMessage","parsedMessage","parseMessage","success","handler","data","String","ack","safeParse","JSON","stringify","parsedPayload","registerHandlers","emitter","log","info","eventName","Object","keys","on","callback","hasCallback","_schema","ZodMessageSender","sender","send","forwardMessage"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,SAAS;AAGX,IAAMC,wBAAN,MAAMA,8BAA6BC,MAAAA;EACxCC,YACSC,OACAC,SACP;AACA,UAAMD,MAAME,OAAO;iBAHZF;mBACAC;EAGT;AACF;AAP0CH;AAAnC,IAAMD,uBAAN;AAuCA,IAAMM,mBAAmBP,EAAEQ,OAAO;EACvCC,SAAST,EAAEU,QAAQ,IAAA,EAAMC,QAAQ,IAAA;EACjCC,MAAMZ,EAAEa,OAAM;EACdR,SAASL,EAAEc,QAAO;AACpB,CAAA;AA9CA;AAoDO,IAAMC,qBAAN,MAAMA,mBAAAA;EAKXZ,YAAYa,SAAoD;AAJhE;AACA;AACA;AAGE,uBAAK,SAAUA,QAAQC;AACvB,uBAAK,WAAYD,QAAQE;AACzB,uBAAK,SAAUF,QAAQG,UAAUC;EACnC;EAEA,MAAaC,cAAcf,SASzB;AACA,UAAMgB,gBAAgB,KAAKC,aAAajB,OAAAA;AAExC,QAAI,CAACgB,cAAcE,SAAS;AAC1B,yBAAK,SAAQpB,MAAMkB,cAAclB,OAAO;QAAEE;MAAQ,CAAA;AAElD,aAAO;QACLkB,SAAS;QACTpB,OAAOkB,cAAclB;MACvB;IACF;AAEA,QAAI,CAAC,mBAAK,YAAW;AACnB,yBAAK,SAAQA,MAAM,wBAAwB;QAAEE;MAAQ,CAAA;AAErD,aAAO;QACLkB,SAAS;QACTpB,OAAO;MACT;IACF;AAEA,UAAMqB,UAAU,mBAAK,WAAUH,cAAcI,KAAKd,IAAI;AAEtD,QAAI,CAACa,SAAS;AACZ,YAAMrB,QAAQ,gCAAgCuB,OAAOL,cAAcI,KAAKd,IAAI,CAAA;AAE5E,yBAAK,SAAQR,MAAMA,OAAO;QAAEE;MAAQ,CAAA;AAEpC,aAAO;QACLkB,SAAS;QACTpB;MACF;IACF;AAEA,UAAMwB,MAAM,MAAMH,QAAQH,cAAcI,KAAKrB,OAAO;AAEpD,WAAO;MACLmB,SAAS;MACTE,MAAME;IACR;EACF;EAEOL,aAAajB,SAQd;AACJ,UAAMgB,gBAAgBf,iBAAiBsB,UAAUvB,OAAAA;AAEjD,QAAI,CAACgB,cAAcE,SAAS;AAC1B,aAAO;QACLA,SAAS;QACTpB,OAAO,4BAA4B0B,KAAKC,UAAUT,cAAclB,KAAK,CAAA;MACvE;IACF;AAEA,UAAMa,SAAS,mBAAK,SAAQK,cAAcI,KAAKd,IAAI;AAEnD,QAAI,CAACK,QAAQ;AACX,aAAO;QACLO,SAAS;QACTpB,OAAO,yBAAyBkB,cAAcI,KAAKd,IAAI;MACzD;IACF;AAEA,UAAMoB,gBAAgBf,OAAOY,UAAUP,cAAcI,KAAKrB,OAAO;AAEjE,QAAI,CAAC2B,cAAcR,SAAS;AAC1B,aAAO;QACLA,SAAS;QACTpB,OAAO,oCAAoC0B,KAAKC,UAAUC,cAAc5B,KAAK,CAAA;MAC/E;IACF;AAEA,WAAO;MACLoB,SAAS;MACTE,MAAM;QACJd,MAAMU,cAAcI,KAAKd;QACzBP,SAAS2B,cAAcN;MACzB;IACF;EACF;EAEOO,iBAAiBC,SAA2Bf,QAA2B;AAC5E,UAAMgB,MAAMhB,UAAUC;AAEtB,QAAI,CAAC,mBAAK,YAAW;AACnBe,UAAIC,KAAK,sBAAA;AACT;IACF;AAEA,eAAWC,aAAaC,OAAOC,KAAK,mBAAK,QAAO,GAAG;AACjDL,cAAQM,GAAGH,WAAW,OAAO/B,SAAcmC,aAAkC;AAC3EN,YAAIC,KAAK,YAAYC,SAAAA,IAAa;UAChChC,SAASC;UACToC,aAAa,CAAC,CAACD;QACjB,CAAA;AAEA,YAAIb;AAGJ,YAAI,aAAatB,SAAS;AACxBsB,gBAAM,MAAM,KAAKP,cAAc;YAAET,MAAMyB;YAAW,GAAG/B;UAAQ,CAAA;QAC/D,OAAO;AAEL,gBAAM,EAAEG,SAAS,GAAGJ,QAAAA,IAAYC;AAChCsB,gBAAM,MAAM,KAAKP,cAAc;YAAET,MAAMyB;YAAW5B;YAASJ;UAAQ,CAAA;QACrE;AAEA,YAAIoC,YAAY,OAAOA,aAAa,YAAY;AAC9C,cAAI,CAACb,IAAIJ,SAAS;AAEhBW,gBAAI/B,MAAM,+CAA+C;cAAEE;cAASF,OAAOwB,IAAIxB;YAAM,CAAA;AACrF;UACF;AAEAqC,mBAASb,IAAIF,IAAI;QACnB;MACF,CAAA;IACF;EACF;AACF;AAhJE;AACA;AACA;AAHWX;AAAN,IAAMA,oBAAN;AApDP,IAAA4B,UAAA;AAkNO,IAAMC,oBAAN,MAAMA,kBAAAA;EAIXzC,YAAYa,SAAmD;AAH/D,uBAAA2B,UAAA;AACA;AAGE,uBAAKA,UAAU3B,QAAQC;AACvB,uBAAK,SAAUD,QAAQ6B;EACzB;EAEA,MAAaC,KACXlC,MACAP,SACA;AACA,UAAMY,SAAS,mBAAK0B,UAAQ/B,IAAAA;AAE5B,QAAI,CAACK,QAAQ;AACX,YAAM,IAAIf,MAAM,yBAAyBU,IAAAA,EAAgB;IAC3D;AAEA,UAAMoB,gBAAgBf,OAAOY,UAAUxB,OAAAA;AAEvC,QAAI,CAAC2B,cAAcR,SAAS;AAC1B,YAAM,IAAIvB,qBAAqB+B,cAAc5B,OAAOC,OAAAA;IACtD;AAEA,QAAI;AACF,YAAM,mBAAK,SAAL,WAAa;QAAEO;QAAMP;QAASI,SAAS;MAAK;IACpD,SAASL,OAAO;AACdgB,cAAQhB,MAAM,6CAA6CA,KAAAA;IAC7D;EACF;EAEA,MAAa2C,eAAezC,SAAkB;AAC5C,UAAMgB,gBAAgBf,iBAAiBsB,UAAUvB,OAAAA;AAEjD,QAAI,CAACgB,cAAcE,SAAS;AAC1B,YAAM,IAAItB,MAAM,4BAA4B4B,KAAKC,UAAUT,cAAclB,KAAK,CAAA,EAAG;IACnF;AAEA,UAAMa,SAAS,mBAAK0B,UAAQrB,cAAcI,KAAKd,IAAI;AAEnD,QAAI,CAACK,QAAQ;AACX,YAAM,IAAIf,MAAM,yBAAyBoB,cAAcI,KAAKd,IAAI,EAAE;IACpE;AAEA,UAAMoB,gBAAgBf,OAAOY,UAAUP,cAAcI,KAAKrB,OAAO;AAEjE,QAAI,CAAC2B,cAAcR,SAAS;AAC1B,YAAM,IAAItB,MAAM,oCAAoC4B,KAAKC,UAAUC,cAAc5B,KAAK,CAAA,EAAG;IAC3F;AAEA,QAAI;AACF,YAAM,mBAAK,SAAL,WAAa;QACjBQ,MAAMU,cAAcI,KAAKd;QACzBP,SAAS2B,cAAcN;QACvBjB,SAAS;MACX;IACF,SAASL,OAAO;AACdgB,cAAQhB,MAAM,gDAAgDA,KAAAA;IAChE;EACF;AACF;AA5DEuC,WAAA;AACA;AAFWC;AAAN,IAAMA,mBAAN","sourcesContent":["import { z } from \"zod\";\nimport { StructuredLogger } from \"./utils/structuredLogger\";\n\nexport class ZodSchemaParsedError extends Error {\n  constructor(\n    public error: z.ZodError,\n    public payload: unknown\n  ) {\n    super(error.message);\n  }\n}\n\nexport type ZodMessageValueSchema<TDiscriminatedUnion extends z.ZodDiscriminatedUnion<any, any>> =\n  | z.ZodFirstPartySchemaTypes\n  | TDiscriminatedUnion;\n\nexport interface ZodMessageCatalogSchema {\n  [key: string]: ZodMessageValueSchema<any>;\n}\n\nexport type ZodMessageHandlers<TCatalogSchema extends ZodMessageCatalogSchema> = Partial<{\n  [K in keyof TCatalogSchema]: (payload: z.infer<TCatalogSchema[K]>) => Promise<any>;\n}>;\n\nexport type ZodMessageHandlerOptions<TMessageCatalog extends ZodMessageCatalogSchema> = {\n  schema: TMessageCatalog;\n  messages?: ZodMessageHandlers<TMessageCatalog>;\n  logger?: StructuredLogger;\n};\n\nexport type MessageFromSchema<\n  K extends keyof TMessageCatalog,\n  TMessageCatalog extends ZodMessageCatalogSchema,\n> = {\n  type: K;\n  payload: z.input<TMessageCatalog[K]>;\n};\n\nexport type MessageFromCatalog<TMessageCatalog extends ZodMessageCatalogSchema> = {\n  [K in keyof TMessageCatalog]: MessageFromSchema<K, TMessageCatalog>;\n}[keyof TMessageCatalog];\n\nexport const ZodMessageSchema = z.object({\n  version: z.literal(\"v1\").default(\"v1\"),\n  type: z.string(),\n  payload: z.unknown(),\n});\n\nexport interface EventEmitterLike {\n  on(eventName: string | symbol, listener: (...args: any[]) => void): this;\n}\n\nexport class ZodMessageHandler<TMessageCatalog extends ZodMessageCatalogSchema> {\n  #schema: TMessageCatalog;\n  #handlers: ZodMessageHandlers<TMessageCatalog> | undefined;\n  #logger: StructuredLogger | Console;\n\n  constructor(options: ZodMessageHandlerOptions<TMessageCatalog>) {\n    this.#schema = options.schema;\n    this.#handlers = options.messages;\n    this.#logger = options.logger ?? console;\n  }\n\n  public async handleMessage(message: unknown): Promise<\n    | {\n        success: true;\n        data: unknown;\n      }\n    | {\n        success: false;\n        error: string;\n      }\n  > {\n    const parsedMessage = this.parseMessage(message);\n\n    if (!parsedMessage.success) {\n      this.#logger.error(parsedMessage.error, { message });\n\n      return {\n        success: false,\n        error: parsedMessage.error,\n      };\n    }\n\n    if (!this.#handlers) {\n      this.#logger.error(\"No handlers provided\", { message });\n\n      return {\n        success: false,\n        error: \"No handlers provided\",\n      };\n    }\n\n    const handler = this.#handlers[parsedMessage.data.type];\n\n    if (!handler) {\n      const error = `No handler for message type: ${String(parsedMessage.data.type)}`;\n\n      this.#logger.error(error, { message });\n\n      return {\n        success: false,\n        error,\n      };\n    }\n\n    const ack = await handler(parsedMessage.data.payload);\n\n    return {\n      success: true,\n      data: ack,\n    };\n  }\n\n  public parseMessage(message: unknown):\n    | {\n        success: true;\n        data: MessageFromCatalog<TMessageCatalog>;\n      }\n    | {\n        success: false;\n        error: string;\n      } {\n    const parsedMessage = ZodMessageSchema.safeParse(message);\n\n    if (!parsedMessage.success) {\n      return {\n        success: false,\n        error: `Failed to parse message: ${JSON.stringify(parsedMessage.error)}`,\n      };\n    }\n\n    const schema = this.#schema[parsedMessage.data.type];\n\n    if (!schema) {\n      return {\n        success: false,\n        error: `Unknown message type: ${parsedMessage.data.type}`,\n      };\n    }\n\n    const parsedPayload = schema.safeParse(parsedMessage.data.payload);\n\n    if (!parsedPayload.success) {\n      return {\n        success: false,\n        error: `Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`,\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.#schema)) {\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: Awaited<ReturnType<ZodMessageHandler<TMessageCatalog>[\"handleMessage\"]>>;\n\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\n        if (callback && typeof callback === \"function\") {\n          if (!ack.success) {\n            // We don't know the callback type, so we can't do anything else - not all callbacks may accept a success prop\n            log.error(\"Failed to handle message, skipping callback\", { message, error: ack.error });\n            return;\n          }\n\n          callback(ack.data);\n        }\n      });\n    }\n  }\n}\n\ntype ZodMessageSenderCallback<TMessageCatalog extends ZodMessageCatalogSchema> = (message: {\n  type: keyof TMessageCatalog;\n  payload: z.infer<TMessageCatalog[keyof TMessageCatalog]>;\n  version: \"v1\";\n}) => Promise<void>;\n\nexport type ZodMessageSenderOptions<TMessageCatalog extends ZodMessageCatalogSchema> = {\n  schema: TMessageCatalog;\n  sender: ZodMessageSenderCallback<TMessageCatalog>;\n};\n\nexport class ZodMessageSender<TMessageCatalog extends ZodMessageCatalogSchema> {\n  #schema: TMessageCatalog;\n  #sender: ZodMessageSenderCallback<TMessageCatalog>;\n\n  constructor(options: ZodMessageSenderOptions<TMessageCatalog>) {\n    this.#schema = options.schema;\n    this.#sender = options.sender;\n  }\n\n  public async send<K extends keyof TMessageCatalog>(\n    type: K,\n    payload: z.input<TMessageCatalog[K]>\n  ) {\n    const schema = this.#schema[type];\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 ZodSchemaParsedError(parsedPayload.error, payload);\n    }\n\n    try {\n      await this.#sender({ type, payload, version: \"v1\" });\n    } catch (error) {\n      console.error(\"[ZodMessageSender] Failed to send message\", error);\n    }\n  }\n\n  public async forwardMessage(message: unknown) {\n    const parsedMessage = ZodMessageSchema.safeParse(message);\n\n    if (!parsedMessage.success) {\n      throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`);\n    }\n\n    const schema = this.#schema[parsedMessage.data.type];\n\n    if (!schema) {\n      throw new Error(`Unknown message type: ${parsedMessage.data.type}`);\n    }\n\n    const parsedPayload = schema.safeParse(parsedMessage.data.payload);\n\n    if (!parsedPayload.success) {\n      throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`);\n    }\n\n    try {\n      await this.#sender({\n        type: parsedMessage.data.type,\n        payload: parsedPayload.data,\n        version: \"v1\",\n      });\n    } catch (error) {\n      console.error(\"[ZodMessageSender] Failed to forward message\", error);\n    }\n  }\n}\n\nexport type MessageCatalogToSocketIoEvents<TCatalog extends ZodMessageCatalogSchema> = {\n  [K in keyof TCatalog]: (message: z.infer<TCatalog[K]>) => void;\n};\n"]}