@trigger.dev/sdk 2.2.5 → 2.2.6

package/dist/index.js

@@ -81,7 +81,8 @@ __export(src_exports, {
   redactString: () => redactString,
   retry: () => retry,
   verifyHmacSha256: () => verifyHmacSha256,
-  verifyRequestSignature: () => verifyRequestSignature
+  verifyRequestSignature: () => verifyRequestSignature,
+  waitForEventSchema: () => waitForEventSchema
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -397,6 +398,23 @@ var ApiClient = class {
       })
     });
   }
+  async sendEvents(events, options = {}) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Sending multiple events", {
+      events
+    });
+    return await zodfetch(import_core.ApiEventLogSchema.array(), `${__privateGet(this, _apiUrl)}/api/v1/events/bulk`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        events,
+        options
+      })
+    });
+  }
   async cancelEvent(eventId) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
     __privateGet(this, _logger).debug("Cancelling event", {
@@ -610,6 +628,21 @@ var ApiClient = class {
       body: JSON.stringify(body)
     });
   }
+  async createEphemeralEventDispatcher(payload) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Creating ephemeral event dispatcher", {
+      payload
+    });
+    const response = await zodfetch(import_core.EphemeralEventDispatcherResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/event-dispatchers/ephemeral`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    return response;
+  }
 };
 __name(ApiClient, "ApiClient");
 _apiUrl = new WeakMap();
@@ -933,6 +966,13 @@ var retry = {
     minTimeoutInMs: 500,
     maxTimeoutInMs: 3e4,
     randomize: true
+  },
+  exponentialBackoff: {
+    limit: 8,
+    factor: 2,
+    minTimeoutInMs: 1e3,
+    maxTimeoutInMs: 3e4,
+    randomize: true
   }
 };
 
@@ -970,7 +1010,29 @@ var TriggerStatus = class {
 };
 __name(TriggerStatus, "TriggerStatus");
 
+// src/types.ts
+var import_zod2 = require("zod");
+var EventSpecificationExampleSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  icon: import_zod2.z.string().optional(),
+  payload: import_zod2.z.any()
+});
+function waitForEventSchema(schema) {
+  return import_zod2.z.object({
+    id: import_zod2.z.string(),
+    name: import_zod2.z.string(),
+    source: import_zod2.z.string(),
+    payload: schema,
+    timestamp: import_zod2.z.coerce.date(),
+    context: import_zod2.z.any().optional(),
+    accountId: import_zod2.z.string().optional()
+  });
+}
+__name(waitForEventSchema, "waitForEventSchema");
+
 // src/io.ts
+var import_zod3 = require("zod");
 var JSONOutputSerializer = class {
   serialize(value) {
     return JSON.stringify(value);
@@ -1153,6 +1215,63 @@ var IO = class {
       }
     });
   }
+  async waitForEvent(cacheKey, event, options) {
+    const timeoutInSeconds = options?.timeoutInSeconds ?? 60 * 60;
+    return await this.runTask(cacheKey, async (task, io) => {
+      if (!task.callbackUrl) {
+        throw new Error("No callbackUrl found on task");
+      }
+      await this.triggerClient.createEphemeralEventDispatcher({
+        url: task.callbackUrl,
+        name: event.name,
+        filter: event.filter,
+        contextFilter: event.contextFilter,
+        source: event.source,
+        accountId: event.accountId,
+        timeoutInSeconds
+      });
+      return {};
+    }, {
+      name: "Wait for Event",
+      icon: "custom-event",
+      params: {
+        name: event.name,
+        source: event.source,
+        filter: event.filter,
+        contextFilter: event.contextFilter,
+        accountId: event.accountId
+      },
+      callback: {
+        enabled: true,
+        timeoutInSeconds
+      },
+      properties: [
+        {
+          label: "Event",
+          text: event.name
+        },
+        {
+          label: "Timeout",
+          text: `${timeoutInSeconds}s`
+        },
+        ...event.source ? [
+          {
+            label: "Source",
+            text: event.source
+          }
+        ] : [],
+        ...event.accountId ? [
+          {
+            label: "Account ID",
+            text: event.accountId
+          }
+        ] : []
+      ],
+      parseOutput: (output) => {
+        return waitForEventSchema(event.schema ?? import_zod3.z.any()).parse(output);
+      }
+    });
+  }
   async waitForRequest(cacheKey, callback, options) {
     const timeoutInSeconds = options?.timeoutInSeconds ?? 60 * 60;
     return await this.runTask(cacheKey, async (task, io) => {
@@ -1187,17 +1306,18 @@ var IO = class {
     await status.update(cacheKey, initialStatus);
     return status;
   }
-  async backgroundFetch(cacheKey, url, requestInit, retry2, timeout) {
+  async backgroundFetch(cacheKey, url, requestInit, options) {
     const urlObject = new URL(url);
     return await this.runTask(cacheKey, async (task) => {
+      console.log("task context", task.context);
       return task.output;
     }, {
       name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
       params: {
         url,
         requestInit,
-        retry: retry2,
-        timeout
+        retry: options?.retry,
+        timeout: options?.timeout
       },
       operation: "fetch",
       icon: "background",
@@ -1216,10 +1336,80 @@ var IO = class {
           label: "background",
           text: "true"
         },
-        ...timeout ? [
+        ...options?.timeout ? [
           {
             label: "timeout",
-            text: `${timeout.durationInMs}ms`
+            text: `${options.timeout.durationInMs}ms`
+          }
+        ] : []
+      ],
+      retry: {
+        limit: 0
+      }
+    });
+  }
+  async backgroundPoll(cacheKey, params) {
+    const urlObject = new URL(params.url);
+    return await this.runTask(cacheKey, async (task) => {
+      return task.output;
+    }, {
+      name: `poll ${urlObject.hostname}${urlObject.pathname}`,
+      params,
+      operation: "fetch-poll",
+      icon: "clock-bolt",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: params.url
+        },
+        {
+          label: "interval",
+          text: `${params.interval}s`
+        },
+        {
+          label: "timeout",
+          text: `${params.timeout}s`
+        }
+      ],
+      retry: {
+        limit: 0
+      }
+    });
+  }
+  async backgroundFetchResponse(cacheKey, url, requestInit, options) {
+    const urlObject = new URL(url);
+    return await this.runTask(cacheKey, async (task) => {
+      return task.output;
+    }, {
+      name: `fetch response ${urlObject.hostname}${urlObject.pathname}`,
+      params: {
+        url,
+        requestInit,
+        retry: options?.retry,
+        timeout: options?.timeout
+      },
+      operation: "fetch-response",
+      icon: "background",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: url,
+          url
+        },
+        {
+          label: "method",
+          text: requestInit?.method ?? "GET"
+        },
+        {
+          label: "background",
+          text: "true"
+        },
+        ...options?.timeout ? [
+          {
+            label: "timeout",
+            text: `${options.timeout.durationInMs}ms`
           }
         ] : []
       ],
@@ -1247,7 +1437,26 @@ var IO = class {
             label: "ID",
             text: event.id
           }
-        ] : []
+        ] : [],
+        ...sendEventOptionsProperties(options)
+      ]
+    });
+  }
+  async sendEvents(cacheKey, events, options) {
+    return await this.runTask(cacheKey, async (task) => {
+      return await this._triggerClient.sendEvents(events, options);
+    }, {
+      name: "sendEvents",
+      params: {
+        events,
+        options
+      },
+      properties: [
+        {
+          label: "Total Events",
+          text: String(events.length)
+        },
+        ...sendEventOptionsProperties(options)
       ]
     });
   }
@@ -1471,7 +1680,7 @@ var IO = class {
         idempotencyKey
       });
       this._stats.cachedTaskHits++;
-      return cachedTask.output;
+      return options?.parseOutput ? options.parseOutput(cachedTask.output) : cachedTask.output;
     }
     if (options?.noop && this._noopTasksBloomFilter) {
       if (this._noopTasksBloomFilter.test(idempotencyKey)) {
@@ -1482,11 +1691,15 @@ var IO = class {
         return {};
       }
     }
+    const runOptions = {
+      ...options ?? {},
+      parseOutput: void 0
+    };
     const response = await this._apiClient.runTask(this._id, {
       idempotencyKey,
       displayKey: typeof cacheKey === "string" ? cacheKey : void 0,
       noop: false,
-      ...options ?? {},
+      ...runOptions ?? {},
       parentId
     }, {
       cachedTasksCursor: this._cachedTasksCursor
@@ -1530,7 +1743,7 @@ var IO = class {
         this._stats.cachedTaskMisses++;
         __privateMethod(this, _addToCachedTasks, addToCachedTasks_fn).call(this, task);
       }
-      return task.output;
+      return options?.parseOutput ? options.parseOutput(task.output) : task.output;
     }
     if (task.status === "ERRORED") {
       this._logger.debug("Task errored", {
@@ -1571,7 +1784,8 @@ var IO = class {
           throw new CanceledWithTaskError(completedTask);
         }
         __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "after_complete_task", 500);
-        return this._outputSerializer.deserialize(output);
+        const deserializedOutput = this._outputSerializer.deserialize(output);
+        return options?.parseOutput ? options.parseOutput(deserializedOutput) : deserializedOutput;
       } catch (error) {
         if (isTriggerError(error)) {
           throw error;
@@ -1770,6 +1984,29 @@ async function spaceOut(callback, index, delay) {
   return await callback();
 }
 __name(spaceOut, "spaceOut");
+function sendEventOptionsProperties(options) {
+  return [
+    ...options?.accountId ? [
+      {
+        label: "Account ID",
+        text: options.accountId
+      }
+    ] : [],
+    ...options?.deliverAfter ? [
+      {
+        label: "Deliver After",
+        text: `${options.deliverAfter}s`
+      }
+    ] : [],
+    ...options?.deliverAt ? [
+      {
+        label: "Deliver At",
+        text: options.deliverAt.toISOString()
+      }
+    ] : []
+  ];
+}
+__name(sendEventOptionsProperties, "sendEventOptionsProperties");
 
 // src/ioWithIntegrations.ts
 function createIOWithIntegrations(io, auths, integrations) {
@@ -2161,7 +2398,7 @@ var DynamicSchedule = class {
 __name(DynamicSchedule, "DynamicSchedule");
 
 // package.json
-var version = "2.2.5";
+var version = "2.2.6";
 
 // src/triggerClient.ts
 var registerSourceEvent = {
@@ -2675,6 +2912,9 @@ var TriggerClient = class {
   async sendEvent(event, options) {
     return __privateGet(this, _client2).sendEvent(event, options);
   }
+  async sendEvents(events, options) {
+    return __privateGet(this, _client2).sendEvents(events, options);
+  }
   async cancelEvent(eventId) {
     return __privateGet(this, _client2).cancelEvent(eventId);
   }
@@ -2708,6 +2948,9 @@ var TriggerClient = class {
   async invokeJob(jobId, payload, options) {
     return __privateGet(this, _client2).invokeJob(jobId, payload, options);
   }
+  async createEphemeralEventDispatcher(payload) {
+    return __privateGet(this, _client2).createEphemeralEventDispatcher(payload);
+  }
   authorized(apiKey) {
     if (typeof apiKey !== "string") {
       return "missing-header";
@@ -3565,15 +3808,6 @@ function invokeTrigger(options) {
 }
 __name(invokeTrigger, "invokeTrigger");
 
-// src/types.ts
-var import_zod2 = require("zod");
-var EventSpecificationExampleSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  icon: import_zod2.z.string().optional(),
-  payload: import_zod2.z.any()
-});
-
 // src/security.ts
 var import_crypto = __toESM(require("crypto"));
 async function verifyRequestSignature({ request, headerName, secret, algorithm }) {
@@ -3653,6 +3887,7 @@ __name(redactString, "redactString");
   redactString,
   retry,
   verifyHmacSha256,
-  verifyRequestSignature
+  verifyRequestSignature,
+  waitForEventSchema
 });
 //# sourceMappingURL=index.js.map