@trigger.dev/core 2.2.5 → 2.2.7

package/dist/index.js

@@ -66,13 +66,18 @@ __export(src_exports, {
   DynamicTriggerMetadataSchema: () => DynamicTriggerMetadataSchema,
   EndpointHeadersSchema: () => EndpointHeadersSchema,
   EndpointIndexErrorSchema: () => EndpointIndexErrorSchema,
+  EphemeralEventDispatcherRequestBodySchema: () => EphemeralEventDispatcherRequestBodySchema,
+  EphemeralEventDispatcherResponseBodySchema: () => EphemeralEventDispatcherResponseBodySchema,
   ErrorWithStackSchema: () => ErrorWithStackSchema,
   EventExampleSchema: () => EventExampleSchema,
   EventFilterSchema: () => EventFilterSchema,
   EventRuleSchema: () => EventRuleSchema,
   EventSpecificationSchema: () => EventSpecificationSchema,
+  ExecuteJobHeadersSchema: () => ExecuteJobHeadersSchema,
+  ExecuteJobRunMetadataSchema: () => ExecuteJobRunMetadataSchema,
   FailTaskBodyInputSchema: () => FailTaskBodyInputSchema,
   FetchOperationSchema: () => FetchOperationSchema,
+  FetchPollOperationSchema: () => FetchPollOperationSchema,
   FetchRequestInitSchema: () => FetchRequestInitSchema,
   FetchRetryBackoffStrategySchema: () => FetchRetryBackoffStrategySchema,
   FetchRetryHeadersStrategySchema: () => FetchRetryHeadersStrategySchema,
@@ -141,6 +146,7 @@ __export(src_exports, {
   RegisterTriggerSourceSchema: () => RegisterTriggerSourceSchema,
   RequestFilterSchema: () => RequestFilterSchema,
   RequestWithRawBodySchema: () => RequestWithRawBodySchema,
+  ResponseFilterSchema: () => ResponseFilterSchema,
   RetryOptionsSchema: () => RetryOptionsSchema,
   RunJobAutoYieldExecutionErrorSchema: () => RunJobAutoYieldExecutionErrorSchema,
   RunJobAutoYieldWithCompletedTaskExecutionErrorSchema: () => RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
@@ -169,6 +175,7 @@ __export(src_exports, {
   ScheduledPayloadSchema: () => ScheduledPayloadSchema,
   ScheduledTriggerMetadataSchema: () => ScheduledTriggerMetadataSchema,
   SchemaErrorSchema: () => SchemaErrorSchema,
+  SendBulkEventsBodySchema: () => SendBulkEventsBodySchema,
   SendEventBodySchema: () => SendEventBodySchema,
   SendEventOptionsSchema: () => SendEventOptionsSchema,
   SerializableJsonSchema: () => SerializableJsonSchema,
@@ -190,6 +197,7 @@ __export(src_exports, {
   ValidateResponseSchema: () => ValidateResponseSchema,
   ValidateSuccessResponseSchema: () => ValidateSuccessResponseSchema,
   addMissingVersionField: () => addMissingVersionField,
+  calculateResetAt: () => calculateResetAt,
   calculateRetryAt: () => calculateRetryAt,
   currentDate: () => currentDate,
   currentTimestampMilliseconds: () => currentTimestampMilliseconds,
@@ -199,6 +207,7 @@ __export(src_exports, {
   parseEndpointIndexStats: () => parseEndpointIndexStats,
   replacements: () => replacements,
   requestFilterMatches: () => requestFilterMatches,
+  responseFilterMatches: () => responseFilterMatches,
   stringPatternMatchers: () => stringPatternMatchers,
   supportsFeature: () => supportsFeature,
   urlWithSearchParams: () => urlWithSearchParams
@@ -213,18 +222,20 @@ var logLevels = [
   "info",
   "debug"
 ];
-var _name, _level, _filteredKeys, _jsonReplacer, _structuredLog, structuredLog_fn;
+var _name, _level, _filteredKeys, _jsonReplacer, _additionalFields, _structuredLog, structuredLog_fn;
 var _Logger = class _Logger {
-  constructor(name, level = "info", filteredKeys = [], jsonReplacer) {
+  constructor(name, level = "info", filteredKeys = [], jsonReplacer, additionalFields) {
     __privateAdd(this, _structuredLog);
     __privateAdd(this, _name, void 0);
     __privateAdd(this, _level, void 0);
     __privateAdd(this, _filteredKeys, []);
     __privateAdd(this, _jsonReplacer, void 0);
+    __privateAdd(this, _additionalFields, void 0);
     __privateSet(this, _name, name);
     __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
     __privateSet(this, _filteredKeys, filteredKeys);
-    __privateSet(this, _jsonReplacer, jsonReplacer);
+    __privateSet(this, _jsonReplacer, createReplacer(jsonReplacer));
+    __privateSet(this, _additionalFields, additionalFields ?? (() => ({})));
   }
   // Return a new Logger instance with the same name and a new log level
   // but filter out the keys from the log messages (at any level)
@@ -264,16 +275,18 @@ _name = new WeakMap();
 _level = new WeakMap();
 _filteredKeys = new WeakMap();
 _jsonReplacer = new WeakMap();
+_additionalFields = new WeakMap();
 _structuredLog = new WeakSet();
 structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
   const structuredLog = {
     ...structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys)),
+    ...__privateGet(this, _additionalFields).call(this),
     timestamp: /* @__PURE__ */ new Date(),
     name: __privateGet(this, _name),
     message,
     level
   };
-  loggerFunction(JSON.stringify(structuredLog, createReplacer(__privateGet(this, _jsonReplacer))));
+  loggerFunction(JSON.stringify(structuredLog, __privateGet(this, _jsonReplacer)));
 }, "#structuredLog");
 __name(_Logger, "Logger");
 var Logger = _Logger;
@@ -300,11 +313,14 @@ function safeJsonClone(obj) {
   try {
     return JSON.parse(JSON.stringify(obj, bigIntReplacer));
   } catch (e) {
-    return obj;
+    return;
   }
 }
 __name(safeJsonClone, "safeJsonClone");
 function structureArgs(args, filteredKeys = []) {
+  if (!args) {
+    return;
+  }
   if (args.length === 0) {
     return;
   }
@@ -364,7 +380,7 @@ function getSizeInBytes(value) {
 __name(getSizeInBytes, "getSizeInBytes");
 
 // src/schemas/api.ts
-var import_ulid = require("ulid");
+var import_ulidx = require("ulidx");
 var import_zod12 = require("zod");
 
 // src/schemas/addMissingVersionField.ts
@@ -533,7 +549,9 @@ var DisplayPropertySchema = import_zod5.z.object({
   /** The value of the property */
   text: import_zod5.z.string(),
   /** The URL to link to when the property is clicked */
-  url: import_zod5.z.string().optional()
+  url: import_zod5.z.string().optional(),
+  /** The URL to a list of images to display next to the property */
+  imageUrl: import_zod5.z.array(import_zod5.z.string()).optional()
 });
 var DisplayPropertiesSchema = import_zod5.z.array(DisplayPropertySchema);
 var StyleSchema = import_zod5.z.object({
@@ -616,6 +634,7 @@ var TaskSchema = import_zod7.z.object({
   outputProperties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
   params: DeserializedJsonSchema.optional().nullable(),
   output: DeserializedJsonSchema.optional().nullable(),
+  context: DeserializedJsonSchema.optional().nullable(),
   error: import_zod7.z.string().optional().nullable(),
   parentId: import_zod7.z.string().optional().nullable(),
   style: StyleSchema.optional().nullable(),
@@ -850,6 +869,12 @@ var RequestFilterSchema = import_zod11.z.object({
   */
   body: EventFilterSchema.optional()
 });
+var ResponseFilterSchema = RequestFilterSchema.omit({
+  method: true,
+  query: true
+}).extend({
+  status: import_zod11.z.array(import_zod11.z.number()).optional()
+});
 
 // src/schemas/api.ts
 var UpdateTriggerSourceBodyV1Schema = import_zod12.z.object({
@@ -1116,6 +1141,13 @@ var EndpointHeadersSchema = import_zod12.z.object({
   "trigger-version": import_zod12.z.string().optional(),
   "trigger-sdk-version": import_zod12.z.string().optional()
 });
+var ExecuteJobRunMetadataSchema = import_zod12.z.object({
+  successSubscription: import_zod12.z.boolean().optional(),
+  failedSubscription: import_zod12.z.boolean().optional()
+});
+var ExecuteJobHeadersSchema = EndpointHeadersSchema.extend({
+  "x-trigger-run-metadata": import_zod12.z.preprocess((val) => typeof val === "string" && JSON.parse(val), ExecuteJobRunMetadataSchema).optional()
+});
 var RawEventSchema = import_zod12.z.object({
   /** The `name` property must exactly match any subscriptions you want to
     trigger. */
@@ -1131,7 +1163,7 @@ var RawEventSchema = import_zod12.z.object({
   context: import_zod12.z.any().optional(),
   /** The `id` property uniquely identify this particular event. If unset it
     will be set automatically using `ulid`. */
-  id: import_zod12.z.string().default(() => (0, import_ulid.ulid)()),
+  id: import_zod12.z.string().default(() => (0, import_ulidx.ulid)()),
   /** This is optional, it defaults to the current timestamp. Usually you would
     only set this if you have a timestamp that you wish to pass through, e.g.
     you receive a timestamp from a service and you want the same timestamp to
@@ -1188,6 +1220,10 @@ var SendEventBodySchema = import_zod12.z.object({
   event: RawEventSchema,
   options: SendEventOptionsSchema.optional()
 });
+var SendBulkEventsBodySchema = import_zod12.z.object({
+  events: RawEventSchema.array(),
+  options: SendEventOptionsSchema.optional()
+});
 var DeliverEventResponseSchema = import_zod12.z.object({
   deliveredAt: import_zod12.z.string().datetime()
 });
@@ -1433,9 +1469,11 @@ var RunTaskOptionsSchema = import_zod12.z.object({
   }).partial().optional(),
   /** Allows you to link the Integration connection in the logs. This is handled automatically in integrations.  */
   connectionKey: import_zod12.z.string().optional(),
-  /** An operation you want to perform on the Trigger.dev platform, current only "fetch" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
+  /** An operation you want to perform on the Trigger.dev platform, current only "fetch", "fetch-response", and "fetch-poll" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
   operation: import_zod12.z.enum([
-    "fetch"
+    "fetch",
+    "fetch-response",
+    "fetch-poll"
   ]).optional(),
   /** A No Operation means that the code won't be executed. This is used internally to implement features like [io.wait()](https://trigger.dev/docs/sdk/io/wait).  */
   noop: import_zod12.z.boolean().default(false),
@@ -1564,6 +1602,18 @@ var InvokeOptionsSchema = import_zod12.z.object({
   context: import_zod12.z.any().optional(),
   callbackUrl: import_zod12.z.string().optional()
 });
+var EphemeralEventDispatcherRequestBodySchema = import_zod12.z.object({
+  url: import_zod12.z.string(),
+  name: import_zod12.z.string().or(import_zod12.z.array(import_zod12.z.string())),
+  source: import_zod12.z.string().optional(),
+  filter: EventFilterSchema.optional(),
+  contextFilter: EventFilterSchema.optional(),
+  accountId: import_zod12.z.string().optional(),
+  timeoutInSeconds: import_zod12.z.number().int().positive().min(10).max(60 * 60 * 24 * 365).default(3600)
+});
+var EphemeralEventDispatcherResponseBodySchema = import_zod12.z.object({
+  id: import_zod12.z.string()
+});
 
 // src/schemas/notifications.ts
 var import_zod13 = require("zod");
@@ -1632,11 +1682,22 @@ var FetchRetryHeadersStrategySchema = import_zod14.z.object({
   /** The header to use to determine the number of remaining retries. */
   remainingHeader: import_zod14.z.string(),
   /** The header to use to determine the time when the number of remaining retries will be reset. */
-  resetHeader: import_zod14.z.string()
+  resetHeader: import_zod14.z.string(),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilterSchema.optional(),
+  /** The format of the `resetHeader` value. */
+  resetFormat: import_zod14.z.enum([
+    "unix_timestamp",
+    "unix_timestamp_in_ms",
+    "iso_8601",
+    "iso_8601_duration_openai_variant"
+  ]).default("unix_timestamp")
 });
 var FetchRetryBackoffStrategySchema = RetryOptionsSchema.extend({
   /** The `backoff` strategy retries the request with an exponential backoff. */
-  strategy: import_zod14.z.literal("backoff")
+  strategy: import_zod14.z.literal("backoff"),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilterSchema.optional()
 });
 var FetchRetryStrategySchema = import_zod14.z.discriminatedUnion("strategy", [
   FetchRetryHeadersStrategySchema,
@@ -1667,6 +1728,14 @@ var FetchOperationSchema = import_zod14.z.object({
   retry: import_zod14.z.record(FetchRetryStrategySchema).optional(),
   timeout: FetchTimeoutOptionsSchema.optional()
 });
+var FetchPollOperationSchema = import_zod14.z.object({
+  url: import_zod14.z.string(),
+  interval: import_zod14.z.number().int().positive().min(10).max(600).default(10),
+  timeout: import_zod14.z.number().int().positive().min(30).max(3600).default(600),
+  responseFilter: ResponseFilterSchema,
+  requestInit: FetchRequestInitSchema.optional(),
+  requestTimeout: FetchTimeoutOptionsSchema.optional()
+});
 
 // src/schemas/events.ts
 var import_zod15 = require("zod");
@@ -1748,6 +1817,73 @@ function calculateRetryAt(retryOptions, attempts) {
   return new Date(Date.now() + timeoutInMs);
 }
 __name(calculateRetryAt, "calculateRetryAt");
+function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return;
+  switch (format) {
+    case "iso_8601_duration_openai_variant": {
+      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
+    }
+    case "iso_8601": {
+      return calculateISO8601ResetAt(resets, now);
+    }
+    case "unix_timestamp": {
+      return calculateUnixTimestampResetAt(resets, now);
+    }
+    case "unix_timestamp_in_ms": {
+      return calculateUnixTimestampInMsResetAt(resets, now);
+    }
+  }
+}
+__name(calculateResetAt, "calculateResetAt");
+function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt * 1e3);
+}
+__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
+function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt);
+}
+__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
+function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = new Date(resets);
+  if (isNaN(resetAt.getTime()))
+    return void 0;
+  return resetAt;
+}
+__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
+function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
+  const match = resets.match(pattern);
+  if (!match)
+    return void 0;
+  const days = parseInt(match[1], 10) || 0;
+  const hours = parseInt(match[2], 10) || 0;
+  const minutes = parseInt(match[3], 10) || 0;
+  const seconds = parseFloat(match[4]) || 0;
+  const milliseconds = parseInt(match[5], 10) || 0;
+  const resetAt = new Date(now);
+  resetAt.setDate(resetAt.getDate() + days);
+  resetAt.setHours(resetAt.getHours() + hours);
+  resetAt.setMinutes(resetAt.getMinutes() + minutes);
+  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
+  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
+  return resetAt;
+}
+__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
 
 // src/replacements.ts
 var currentDate = {
@@ -1966,6 +2102,39 @@ async function requestFilterMatches(request, filter) {
   return true;
 }
 __name(requestFilterMatches, "requestFilterMatches");
+async function responseFilterMatches(response, filter) {
+  if (filter.headers && !eventFilterMatches(response.headers, filter.headers)) {
+    return {
+      match: false
+    };
+  }
+  try {
+    const json = await response.json();
+    if (filter.body && !eventFilterMatches(json, filter.body)) {
+      return {
+        match: false,
+        body: json
+      };
+    } else {
+      return {
+        match: true,
+        body: json
+      };
+    }
+  } catch (e) {
+    if (filter.body) {
+      return {
+        match: false,
+        body: void 0
+      };
+    }
+  }
+  return {
+    match: true,
+    body: void 0
+  };
+}
+__name(responseFilterMatches, "responseFilterMatches");
 function requestMethodMatches(method, filter) {
   if (!filter) {
     return true;