@trigger.dev/core 2.2.5 → 2.2.6

package/dist/index.js

@@ -66,6 +66,8 @@ __export(src_exports, {
   DynamicTriggerMetadataSchema: () => DynamicTriggerMetadataSchema,
   EndpointHeadersSchema: () => EndpointHeadersSchema,
   EndpointIndexErrorSchema: () => EndpointIndexErrorSchema,
+  EphemeralEventDispatcherRequestBodySchema: () => EphemeralEventDispatcherRequestBodySchema,
+  EphemeralEventDispatcherResponseBodySchema: () => EphemeralEventDispatcherResponseBodySchema,
   ErrorWithStackSchema: () => ErrorWithStackSchema,
   EventExampleSchema: () => EventExampleSchema,
   EventFilterSchema: () => EventFilterSchema,
@@ -73,6 +75,7 @@ __export(src_exports, {
   EventSpecificationSchema: () => EventSpecificationSchema,
   FailTaskBodyInputSchema: () => FailTaskBodyInputSchema,
   FetchOperationSchema: () => FetchOperationSchema,
+  FetchPollOperationSchema: () => FetchPollOperationSchema,
   FetchRequestInitSchema: () => FetchRequestInitSchema,
   FetchRetryBackoffStrategySchema: () => FetchRetryBackoffStrategySchema,
   FetchRetryHeadersStrategySchema: () => FetchRetryHeadersStrategySchema,
@@ -141,6 +144,7 @@ __export(src_exports, {
   RegisterTriggerSourceSchema: () => RegisterTriggerSourceSchema,
   RequestFilterSchema: () => RequestFilterSchema,
   RequestWithRawBodySchema: () => RequestWithRawBodySchema,
+  ResponseFilterSchema: () => ResponseFilterSchema,
   RetryOptionsSchema: () => RetryOptionsSchema,
   RunJobAutoYieldExecutionErrorSchema: () => RunJobAutoYieldExecutionErrorSchema,
   RunJobAutoYieldWithCompletedTaskExecutionErrorSchema: () => RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
@@ -169,6 +173,7 @@ __export(src_exports, {
   ScheduledPayloadSchema: () => ScheduledPayloadSchema,
   ScheduledTriggerMetadataSchema: () => ScheduledTriggerMetadataSchema,
   SchemaErrorSchema: () => SchemaErrorSchema,
+  SendBulkEventsBodySchema: () => SendBulkEventsBodySchema,
   SendEventBodySchema: () => SendEventBodySchema,
   SendEventOptionsSchema: () => SendEventOptionsSchema,
   SerializableJsonSchema: () => SerializableJsonSchema,
@@ -190,6 +195,7 @@ __export(src_exports, {
   ValidateResponseSchema: () => ValidateResponseSchema,
   ValidateSuccessResponseSchema: () => ValidateSuccessResponseSchema,
   addMissingVersionField: () => addMissingVersionField,
+  calculateResetAt: () => calculateResetAt,
   calculateRetryAt: () => calculateRetryAt,
   currentDate: () => currentDate,
   currentTimestampMilliseconds: () => currentTimestampMilliseconds,
@@ -199,6 +205,7 @@ __export(src_exports, {
   parseEndpointIndexStats: () => parseEndpointIndexStats,
   replacements: () => replacements,
   requestFilterMatches: () => requestFilterMatches,
+  responseFilterMatches: () => responseFilterMatches,
   stringPatternMatchers: () => stringPatternMatchers,
   supportsFeature: () => supportsFeature,
   urlWithSearchParams: () => urlWithSearchParams
@@ -224,7 +231,7 @@ var _Logger = class _Logger {
     __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));
   }
   // 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)
@@ -273,7 +280,7 @@ structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, leve
     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 +307,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;
   }
@@ -533,7 +543,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 +628,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 +863,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({
@@ -1188,6 +1207,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 +1456,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 +1589,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 +1669,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 +1715,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 +1804,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 +2089,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;