@trigger.dev/sdk 3.0.0-beta.50 → 3.0.0-beta.51

package/dist/v3/index.js

@@ -19,7 +19,7 @@ var __publicField = (obj, key, value) => {
 };
 
 // package.json
-var version = "3.0.0-beta.50";
+var version = "3.0.0-beta.51";
 
 // src/v3/tracer.ts
 var tracer = new v3.TriggerTracer({
@@ -686,16 +686,16 @@ function rescheduleRun(runId, body, requestOptions) {
 }
 __name(rescheduleRun, "rescheduleRun");
 var MAX_POLL_ATTEMPTS = 500;
-async function poll(handle, options, requestOptions) {
+async function poll(runId, options, requestOptions) {
   let attempts = 0;
   while (attempts++ < MAX_POLL_ATTEMPTS) {
-    const run = await runs.retrieve(handle, requestOptions);
+    const run = await runs.retrieve(runId, requestOptions);
     if (run.isCompleted) {
       return run;
     }
     await new Promise((resolve) => setTimeout(resolve, options?.pollIntervalMs ?? 1e3));
   }
-  throw new Error(`Run ${handle} did not complete after ${MAX_POLL_ATTEMPTS} attempts`);
+  throw new Error(`Run ${typeof runId === "string" ? runId : runId.id} did not complete after ${MAX_POLL_ATTEMPTS} attempts`);
 }
 __name(poll, "poll");
 var idempotencyKeys = {
@@ -749,265 +749,20 @@ function createTask(params) {
   const task3 = {
     id: params.id,
     trigger: async (payload, options) => {
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
       const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      const payloadPacket = await v3.stringifyIO(payload);
-      const handle = await apiClient.triggerTask(params.id, {
-        payload: payloadPacket.data,
-        options: {
-          queue: options?.queue ?? params.queue,
-          concurrencyKey: options?.concurrencyKey,
-          test: v3.taskContext.ctx?.run.isTest,
-          payloadType: payloadPacket.dataType,
-          idempotencyKey: await makeKey(options?.idempotencyKey),
-          delay: options?.delay,
-          ttl: options?.ttl,
-          maxAttempts: options?.maxAttempts
-        }
-      }, {
-        spanParentAsLink: true
-      }, {
-        name: taskMetadata ? `${taskMetadata.exportName}.trigger()` : `trigger()`,
-        tracer,
-        icon: "trigger",
-        attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.client_id"]: v3.taskContext.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          ...v3.accessoryAttributes({
-            items: [
-              {
-                text: params.id,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          })
-        },
-        onResponseBody: (body, span) => {
-          body && typeof body === "object" && !Array.isArray(body) && "id" in body && typeof body.id === "string" && span.setAttribute("messaging.message.id", body.id);
-        }
-      });
-      return handle;
+      return await trigger_internal(taskMetadata && taskMetadata.exportName ? `${taskMetadata.exportName}.trigger()` : `trigger()`, params.id, payload, options);
     },
     batchTrigger: async (items) => {
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
       const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      const response = await apiClient.batchTriggerTask(params.id, {
-        items: await Promise.all(items.map(async (item) => {
-          const payloadPacket = await v3.stringifyIO(item.payload);
-          return {
-            payload: payloadPacket.data,
-            options: {
-              queue: item.options?.queue ?? params.queue,
-              concurrencyKey: item.options?.concurrencyKey,
-              test: v3.taskContext.ctx?.run.isTest,
-              payloadType: payloadPacket.dataType,
-              idempotencyKey: await makeKey(item.options?.idempotencyKey),
-              delay: item.options?.delay,
-              ttl: item.options?.ttl,
-              maxAttempts: item.options?.maxAttempts
-            }
-          };
-        }))
-      }, {
-        spanParentAsLink: true
-      }, {
-        name: taskMetadata ? `${taskMetadata.exportName}.batchTrigger()` : `batchTrigger()`,
-        icon: "trigger",
-        tracer,
-        attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.batch.message_count"]: items.length,
-          ["messaging.client_id"]: v3.taskContext.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          ...v3.accessoryAttributes({
-            items: [
-              {
-                text: params.id,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          })
-        }
-      });
-      const handle = {
-        batchId: response.batchId,
-        runs: response.runs.map((id) => ({
-          id
-        }))
-      };
-      return handle;
+      return await batchTrigger_internal(taskMetadata && taskMetadata.exportName ? `${taskMetadata.exportName}.batchTrigger()` : `batchTrigger()`, params.id, items);
     },
     triggerAndWait: async (payload, options) => {
-      const ctx = v3.taskContext.ctx;
-      if (!ctx) {
-        throw new Error("triggerAndWait can only be used from inside a task.run()");
-      }
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
       const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      const payloadPacket = await v3.stringifyIO(payload);
-      return await tracer.startActiveSpan(taskMetadata ? `${taskMetadata.exportName}.triggerAndWait()` : `triggerAndWait()`, async (span) => {
-        const response = await apiClient.triggerTask(params.id, {
-          payload: payloadPacket.data,
-          options: {
-            dependentAttempt: ctx.attempt.id,
-            lockToVersion: v3.taskContext.worker?.version,
-            queue: options?.queue ?? params.queue,
-            concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContext.ctx?.run.isTest,
-            payloadType: payloadPacket.dataType,
-            idempotencyKey: await makeKey(options?.idempotencyKey),
-            delay: options?.delay,
-            ttl: options?.ttl,
-            maxAttempts: options?.maxAttempts
-          }
-        });
-        span.setAttribute("messaging.message.id", response.id);
-        if (options?.idempotencyKey) {
-          const result2 = await apiClient.getRunResult(response.id);
-          if (result2) {
-            v3.logger.log(`Result reused from previous task run with idempotency key '${options.idempotencyKey}'.`, {
-              runId: response.id,
-              idempotencyKey: options.idempotencyKey
-            });
-            return await handleTaskRunExecutionResult(result2);
-          }
-        }
-        const result = await v3.runtime.waitForTask({
-          id: response.id,
-          ctx
-        });
-        return await handleTaskRunExecutionResult(result);
-      }, {
-        kind: api.SpanKind.PRODUCER,
-        attributes: {
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.client_id"]: v3.taskContext.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          ...v3.accessoryAttributes({
-            items: [
-              {
-                text: params.id,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          })
-        }
-      });
+      return await triggerAndWait_internal(taskMetadata && taskMetadata.exportName ? `${taskMetadata.exportName}.triggerAndWait()` : `triggerAndWait()`, params.id, payload, options);
     },
     batchTriggerAndWait: async (items) => {
-      const ctx = v3.taskContext.ctx;
-      if (!ctx) {
-        throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
-      }
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
       const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      return await tracer.startActiveSpan(taskMetadata ? `${taskMetadata.exportName}.batchTriggerAndWait()` : `batchTriggerAndWait()`, async (span) => {
-        const response = await apiClient.batchTriggerTask(params.id, {
-          items: await Promise.all(items.map(async (item) => {
-            const payloadPacket = await v3.stringifyIO(item.payload);
-            return {
-              payload: payloadPacket.data,
-              options: {
-                lockToVersion: v3.taskContext.worker?.version,
-                queue: item.options?.queue ?? params.queue,
-                concurrencyKey: item.options?.concurrencyKey,
-                test: v3.taskContext.ctx?.run.isTest,
-                payloadType: payloadPacket.dataType,
-                idempotencyKey: await makeKey(item.options?.idempotencyKey),
-                delay: item.options?.delay,
-                ttl: item.options?.ttl,
-                maxAttempts: item.options?.maxAttempts
-              }
-            };
-          })),
-          dependentAttempt: ctx.attempt.id
-        });
-        span.setAttribute("messaging.message.id", response.batchId);
-        const getBatchResults = /* @__PURE__ */ __name(async () => {
-          const hasIdempotencyKey = items.some((item) => item.options?.idempotencyKey);
-          if (hasIdempotencyKey) {
-            const results = await apiClient.getBatchResults(response.batchId);
-            if (results) {
-              return results;
-            }
-          }
-          return {
-            id: response.batchId,
-            items: []
-          };
-        }, "getBatchResults");
-        const existingResults = await getBatchResults();
-        const incompleteRuns = response.runs.filter((runId) => !existingResults.items.some((item) => item.id === runId));
-        if (incompleteRuns.length === 0) {
-          v3.logger.log(`Results reused from previous task runs because of the provided idempotency keys.`);
-          const runs3 = await handleBatchTaskRunExecutionResult(existingResults.items);
-          return {
-            id: existingResults.id,
-            runs: runs3
-          };
-        }
-        const result = await v3.runtime.waitForBatch({
-          id: response.batchId,
-          runs: incompleteRuns,
-          ctx
-        });
-        const combinedItems = [];
-        for (const runId of response.runs) {
-          const existingItem = existingResults.items.find((item) => item.id === runId);
-          if (existingItem) {
-            combinedItems.push(existingItem);
-          } else {
-            const newItem = result.items.find((item) => item.id === runId);
-            if (newItem) {
-              combinedItems.push(newItem);
-            }
-          }
-        }
-        const runs2 = await handleBatchTaskRunExecutionResult(combinedItems);
-        return {
-          id: result.id,
-          runs: runs2
-        };
-      }, {
-        kind: api.SpanKind.PRODUCER,
-        attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.batch.message_count"]: items.length,
-          ["messaging.client_id"]: v3.taskContext.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ...v3.accessoryAttributes({
-            items: [
-              {
-                text: params.id,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          })
-        }
-      });
+      return await batchTriggerAndWait_internal(taskMetadata && taskMetadata.exportName ? `${taskMetadata.exportName}.batchTriggerAndWait()` : `batchTriggerAndWait()`, params.id, items);
     }
   };
   v3.taskCatalog.registerTaskMetadata({
@@ -1034,6 +789,27 @@ function createTask(params) {
 }
 __name(createTask, "createTask");
 async function trigger(id, payload, options, requestOptions) {
+  return await trigger_internal("tasks.trigger()", id, payload, options, requestOptions);
+}
+__name(trigger, "trigger");
+async function triggerAndWait(id, payload, options, requestOptions) {
+  return await triggerAndWait_internal("tasks.triggerAndWait()", id, payload, options, requestOptions);
+}
+__name(triggerAndWait, "triggerAndWait");
+async function batchTriggerAndWait(id, items, requestOptions) {
+  return await batchTriggerAndWait_internal("tasks.batchTriggerAndWait()", id, items, requestOptions);
+}
+__name(batchTriggerAndWait, "batchTriggerAndWait");
+async function triggerAndPoll(id, payload, options, requestOptions) {
+  const handle = await trigger(id, payload, options, requestOptions);
+  return runs.poll(handle, options, requestOptions);
+}
+__name(triggerAndPoll, "triggerAndPoll");
+async function batchTrigger(id, items, requestOptions) {
+  return await batchTrigger_internal("tasks.batchTrigger()", id, items, requestOptions);
+}
+__name(batchTrigger, "batchTrigger");
+async function trigger_internal(name2, id, payload, options, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
@@ -1049,12 +825,13 @@ async function trigger(id, payload, options, requestOptions) {
       idempotencyKey: await makeKey(options?.idempotencyKey),
       delay: options?.delay,
       ttl: options?.ttl,
+      tags: options?.tags,
       maxAttempts: options?.maxAttempts
     }
   }, {
     spanParentAsLink: true
   }, {
-    name: `tasks.trigger()`,
+    name: name2,
     tracer,
     icon: "trigger",
     attributes: {
@@ -1078,18 +855,72 @@ async function trigger(id, payload, options, requestOptions) {
   });
   return handle;
 }
-__name(trigger, "trigger");
-async function triggerAndWait(id, payload, options, requestOptions) {
+__name(trigger_internal, "trigger_internal");
+async function batchTrigger_internal(name2, id, items, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const response = await apiClient.batchTriggerTask(id, {
+    items: await Promise.all(items.map(async (item) => {
+      const payloadPacket = await v3.stringifyIO(item.payload);
+      return {
+        payload: payloadPacket.data,
+        options: {
+          queue: item.options?.queue,
+          concurrencyKey: item.options?.concurrencyKey,
+          test: v3.taskContext.ctx?.run.isTest,
+          payloadType: payloadPacket.dataType,
+          idempotencyKey: await makeKey(item.options?.idempotencyKey),
+          delay: item.options?.delay,
+          ttl: item.options?.ttl,
+          tags: item.options?.tags,
+          maxAttempts: item.options?.maxAttempts
+        }
+      };
+    }))
+  }, {
+    spanParentAsLink: true
+  }, {
+    name: name2,
+    tracer,
+    icon: "trigger",
+    attributes: {
+      [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+      ["messaging.client_id"]: v3.taskContext.worker?.id,
+      [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    },
+    ...requestOptions
+  });
+  const handle = {
+    batchId: response.batchId,
+    runs: response.runs.map((id2) => ({
+      id: id2
+    }))
+  };
+  return handle;
+}
+__name(batchTrigger_internal, "batchTrigger_internal");
+async function triggerAndWait_internal(name2, id, payload, options, requestOptions) {
   const ctx = v3.taskContext.ctx;
   if (!ctx) {
-    throw new Error("tasks.triggerAndWait can only be used from inside a task.run()");
+    throw new Error("triggerAndWait can only be used from inside a task.run()");
   }
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
   const payloadPacket = await v3.stringifyIO(payload);
-  return await tracer.startActiveSpan("tasks.triggerAndWait()", async (span) => {
+  return await tracer.startActiveSpan(name2, async (span) => {
     const response = await apiClient.triggerTask(id, {
       payload: payloadPacket.data,
       options: {
@@ -1102,6 +933,7 @@ async function triggerAndWait(id, payload, options, requestOptions) {
         idempotencyKey: await makeKey(options?.idempotencyKey),
         delay: options?.delay,
         ttl: options?.ttl,
+        tags: options?.tags,
         maxAttempts: options?.maxAttempts
       }
     }, {}, requestOptions);
@@ -1141,43 +973,92 @@ async function triggerAndWait(id, payload, options, requestOptions) {
     }
   });
 }
-__name(triggerAndWait, "triggerAndWait");
-async function triggerAndPoll(id, payload, options, requestOptions) {
-  const handle = await trigger(id, payload, options, requestOptions);
-  return runs.poll(handle, options, requestOptions);
-}
-__name(triggerAndPoll, "triggerAndPoll");
-async function batchTrigger(id, items, requestOptions) {
+__name(triggerAndWait_internal, "triggerAndWait_internal");
+async function batchTriggerAndWait_internal(name2, id, items, requestOptions) {
+  const ctx = v3.taskContext.ctx;
+  if (!ctx) {
+    throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
+  }
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  const response = await apiClient.batchTriggerTask(id, {
-    items: await Promise.all(items.map(async (item) => {
-      const payloadPacket = await v3.stringifyIO(item.payload);
-      return {
-        payload: payloadPacket.data,
-        options: {
-          queue: item.options?.queue,
-          concurrencyKey: item.options?.concurrencyKey,
-          test: v3.taskContext.ctx?.run.isTest,
-          payloadType: payloadPacket.dataType,
-          idempotencyKey: await makeKey(item.options?.idempotencyKey),
-          delay: item.options?.delay,
-          ttl: item.options?.ttl,
-          maxAttempts: item.options?.maxAttempts
+  return await tracer.startActiveSpan(name2, async (span) => {
+    const response = await apiClient.batchTriggerTask(id, {
+      items: await Promise.all(items.map(async (item) => {
+        const payloadPacket = await v3.stringifyIO(item.payload);
+        return {
+          payload: payloadPacket.data,
+          options: {
+            lockToVersion: v3.taskContext.worker?.version,
+            queue: item.options?.queue,
+            concurrencyKey: item.options?.concurrencyKey,
+            test: v3.taskContext.ctx?.run.isTest,
+            payloadType: payloadPacket.dataType,
+            idempotencyKey: await makeKey(item.options?.idempotencyKey),
+            delay: item.options?.delay,
+            ttl: item.options?.ttl,
+            tags: item.options?.tags,
+            maxAttempts: item.options?.maxAttempts
+          }
+        };
+      })),
+      dependentAttempt: ctx.attempt.id
+    }, {}, requestOptions);
+    span.setAttribute("messaging.message.id", response.batchId);
+    const getBatchResults = /* @__PURE__ */ __name(async () => {
+      const hasIdempotencyKey = items.some((item) => item.options?.idempotencyKey);
+      if (hasIdempotencyKey) {
+        const results = await apiClient.getBatchResults(response.batchId);
+        if (results) {
+          return results;
         }
+      }
+      return {
+        id: response.batchId,
+        items: []
       };
-    }))
-  }, {
-    spanParentAsLink: true
+    }, "getBatchResults");
+    const existingResults = await getBatchResults();
+    const incompleteRuns = response.runs.filter((runId) => !existingResults.items.some((item) => item.id === runId));
+    if (incompleteRuns.length === 0) {
+      v3.logger.log(`Results reused from previous task runs because of the provided idempotency keys.`);
+      const runs3 = await handleBatchTaskRunExecutionResult(existingResults.items);
+      return {
+        id: existingResults.id,
+        runs: runs3
+      };
+    }
+    const result = await v3.runtime.waitForBatch({
+      id: response.batchId,
+      runs: incompleteRuns,
+      ctx
+    });
+    const combinedItems = [];
+    for (const runId of response.runs) {
+      const existingItem = existingResults.items.find((item) => item.id === runId);
+      if (existingItem) {
+        combinedItems.push(existingItem);
+      } else {
+        const newItem = result.items.find((item) => item.id === runId);
+        if (newItem) {
+          combinedItems.push(newItem);
+        }
+      }
+    }
+    const runs2 = await handleBatchTaskRunExecutionResult(combinedItems);
+    return {
+      id: result.id,
+      runs: runs2
+    };
   }, {
-    name: `tasks.batchTrigger()`,
-    tracer,
-    icon: "trigger",
+    kind: api.SpanKind.PRODUCER,
     attributes: {
+      [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
+      ["messaging.batch.message_count"]: items.length,
       [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
       ["messaging.client_id"]: v3.taskContext.worker?.id,
+      [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: id,
       [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
       ...v3.accessoryAttributes({
         items: [
@@ -1188,18 +1069,10 @@ async function batchTrigger(id, items, requestOptions) {
         ],
         style: "codepath"
       })
-    },
-    ...requestOptions
+    }
   });
-  const handle = {
-    batchId: response.batchId,
-    runs: response.runs.map((id2) => ({
-      id: id2
-    }))
-  };
-  return handle;
 }
-__name(batchTrigger, "batchTrigger");
+__name(batchTriggerAndWait_internal, "batchTriggerAndWait_internal");
 async function handleBatchTaskRunExecutionResult(items) {
   const someObjectStoreOutputs = items.some((item) => item.ok && item.outputType === "application/store");
   if (!someObjectStoreOutputs) {
@@ -1275,7 +1148,8 @@ var tasks = {
   trigger,
   triggerAndPoll,
   batchTrigger,
-  triggerAndWait
+  triggerAndWait,
+  batchTriggerAndWait
 };
 var wait = {
   for: async (options) => {
@@ -1481,6 +1355,53 @@ var usage = {
     };
   }
 };
+var tags = {
+  add: addTags
+};
+async function addTags(tags2, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const run = v3.taskContext.ctx?.run;
+  if (!run) {
+    throw new Error("Can't set tags outside of a run. You can trigger a task and set tags in the options.");
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "tags.set()",
+    icon: "tag",
+    attributes: {
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: typeof tags2 === "string" ? tags2 : tags2.join(", "),
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  try {
+    await apiClient.addTags(run.id, {
+      tags: tags2
+    }, $requestOptions);
+  } catch (error) {
+    if (error instanceof v3.UnprocessableEntityError) {
+      v3.logger.error(error.message, {
+        existingTags: run.tags,
+        newTags: tags2
+      });
+      return;
+    }
+    v3.logger.error("Failed to set tags", {
+      error
+    });
+    throw error;
+  }
+}
+__name(addTags, "addTags");
 
 // src/v3/schedules/index.ts
 var schedules_exports = {};
@@ -1969,6 +1890,7 @@ exports.queue = queue;
 exports.retry = retry;
 exports.runs = runs;
 exports.schedules = schedules_exports;
+exports.tags = tags;
 exports.task = task;
 exports.tasks = tasks;
 exports.usage = usage;