@trigger.dev/sdk 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/v3/index.js

@@ -8,51 +8,59 @@ var node_async_hooks = require('node:async_hooks');
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 
 // package.json
-var version = "3.0.0-beta.2";
+var version = "3.0.0-beta.21";
 var tracer = new v3.TriggerTracer({
   name: "@trigger.dev/sdk",
   version
 });
 
 // src/v3/shared.ts
+function queue(options) {
+  return options;
+}
+__name(queue, "queue");
 function createTask(params) {
-  const task2 = {
-    trigger: async ({ payload, options }) => {
+  const task3 = {
+    id: params.id,
+    trigger: async (payload, options) => {
       const apiClient = v3.apiClientManager.client;
       if (!apiClient) {
         throw apiClientMissingError();
       }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      const payloadPacket = await v3.stringifyIO(payload);
       const handle = await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} trigger()`, async (span) => {
         const response = await apiClient.triggerTask(params.id, {
-          payload,
+          payload: payloadPacket.data,
           options: {
             queue: params.queue,
             concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContextManager.ctx?.run.isTest
+            test: v3.taskContext.ctx?.run.isTest,
+            payloadType: payloadPacket.dataType,
+            idempotencyKey: options?.idempotencyKey
           }
         }, {
           spanParentAsLink: true
         });
-        if (!response.ok) {
-          throw new Error(response.error);
-        }
-        span.setAttribute("messaging.message.id", response.data.id);
-        return response.data;
+        span.setAttribute("messaging.message.id", response.id);
+        return response;
       }, {
         kind: api.SpanKind.PRODUCER,
         attributes: {
           [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
           [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ["messaging.client_id"]: v3.taskContextManager.worker?.id,
+          ["messaging.client_id"]: v3.taskContext.worker?.id,
           [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          ["messaging.message.body.size"]: JSON.stringify(payload).length,
           [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
           ...taskMetadata ? v3.accessoryAttributes({
             items: [
@@ -67,38 +75,39 @@ function createTask(params) {
       });
       return handle;
     },
-    batchTrigger: async ({ items }) => {
+    batchTrigger: async (items) => {
       const apiClient = v3.apiClientManager.client;
       if (!apiClient) {
         throw apiClientMissingError();
       }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
       const response = await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTrigger()`, async (span) => {
         const response2 = await apiClient.batchTriggerTask(params.id, {
-          items: items.map((item) => ({
-            payload: item.payload,
-            options: {
-              queue: item.options?.queue ?? params.queue,
-              concurrencyKey: item.options?.concurrencyKey,
-              test: v3.taskContextManager.ctx?.run.isTest
-            }
+          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: item.options?.idempotencyKey
+              }
+            };
           }))
         }, {
           spanParentAsLink: true
         });
-        if (!response2.ok) {
-          throw new Error(response2.error);
-        }
-        span.setAttribute("messaging.message.id", response2.data.batchId);
-        return response2.data;
+        span.setAttribute("messaging.message.id", response2.batchId);
+        return response2;
       }, {
         kind: api.SpanKind.PRODUCER,
         attributes: {
           [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
           ["messaging.batch.message_count"]: items.length,
-          ["messaging.client_id"]: v3.taskContextManager.worker?.id,
+          ["messaging.client_id"]: v3.taskContext.worker?.id,
           [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          ["messaging.message.body.size"]: items.map((item) => JSON.stringify(item.payload)).join("").length,
           [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
           [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
           ...taskMetadata ? v3.accessoryAttributes({
@@ -114,8 +123,8 @@ function createTask(params) {
       });
       return response;
     },
-    triggerAndWait: async ({ payload, options }) => {
-      const ctx = v3.taskContextManager.ctx;
+    triggerAndWait: async (payload, options) => {
+      const ctx = v3.taskContext.ctx;
       if (!ctx) {
         throw new Error("triggerAndWait can only be used from inside a task.run()");
       }
@@ -123,37 +132,43 @@ function createTask(params) {
       if (!apiClient) {
         throw apiClientMissingError();
       }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      const payloadPacket = await v3.stringifyIO(payload);
       return await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} triggerAndWait()`, async (span) => {
         const response = await apiClient.triggerTask(params.id, {
-          payload,
+          payload: payloadPacket.data,
           options: {
             dependentAttempt: ctx.attempt.id,
-            lockToVersion: v3.taskContextManager.worker?.version,
+            lockToVersion: v3.taskContext.worker?.version,
             queue: params.queue,
             concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContextManager.ctx?.run.isTest
+            test: v3.taskContext.ctx?.run.isTest,
+            payloadType: payloadPacket.dataType,
+            idempotencyKey: options?.idempotencyKey
           }
         });
-        if (!response.ok) {
-          throw new Error(response.error);
+        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);
+          }
         }
-        span.setAttribute("messaging.message.id", response.data.id);
         const result = await v3.runtime.waitForTask({
-          id: response.data.id,
+          id: response.id,
           ctx
         });
-        const runResult = await handleTaskRunExecutionResult(result);
-        if (!runResult.ok) {
-          throw runResult.error;
-        }
-        return runResult.output;
+        return await handleTaskRunExecutionResult(result);
       }, {
         kind: api.SpanKind.PRODUCER,
         attributes: {
           [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
           [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.client_id"]: v3.taskContextManager.worker?.id,
+          ["messaging.client_id"]: v3.taskContext.worker?.id,
           [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
           [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
           ...taskMetadata ? v3.accessoryAttributes({
@@ -168,8 +183,8 @@ function createTask(params) {
         }
       });
     },
-    batchTriggerAndWait: async ({ items }) => {
-      const ctx = v3.taskContextManager.ctx;
+    batchTriggerAndWait: async (items) => {
+      const ctx = v3.taskContext.ctx;
       if (!ctx) {
         throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
       }
@@ -177,42 +192,78 @@ function createTask(params) {
       if (!apiClient) {
         throw apiClientMissingError();
       }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
       return await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTriggerAndWait()`, async (span) => {
         const response = await apiClient.batchTriggerTask(params.id, {
-          items: items.map((item) => ({
-            payload: item.payload,
-            options: {
-              lockToVersion: v3.taskContextManager.worker?.version,
-              queue: item.options?.queue ?? params.queue,
-              concurrencyKey: item.options?.concurrencyKey,
-              test: v3.taskContextManager.ctx?.run.isTest
-            }
+          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: item.options?.idempotencyKey
+              }
+            };
           })),
           dependentAttempt: ctx.attempt.id
         });
-        if (!response.ok) {
-          throw new Error(response.error);
+        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
+          };
         }
-        span.setAttribute("messaging.message.id", response.data.batchId);
         const result = await v3.runtime.waitForBatch({
-          id: response.data.batchId,
-          runs: response.data.runs,
+          id: response.batchId,
+          runs: incompleteRuns,
           ctx
         });
-        const runs = await handleBatchTaskRunExecutionResult(result.items);
+        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
+          runs: runs2
         };
       }, {
         kind: api.SpanKind.PRODUCER,
         attributes: {
           [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
           ["messaging.batch.message_count"]: items.length,
-          ["messaging.client_id"]: v3.taskContextManager.worker?.id,
+          ["messaging.client_id"]: v3.taskContext.worker?.id,
           [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          ["messaging.message.body.size"]: items.map((item) => JSON.stringify(item.payload)).join("").length,
           [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
           [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
           ...taskMetadata ? v3.accessoryAttributes({
@@ -228,27 +279,27 @@ function createTask(params) {
       });
     }
   };
-  Object.defineProperty(task2, "__trigger", {
-    value: {
-      id: params.id,
-      packageVersion: version,
-      queue: params.queue,
-      retry: params.retry ? {
-        ...v3.defaultRetryOptions,
-        ...params.retry
-      } : void 0,
-      machine: params.machine,
-      fns: {
-        run: params.run,
-        init: params.init,
-        cleanup: params.cleanup,
-        middleware: params.middleware,
-        handleError: params.handleError
-      }
-    },
-    enumerable: false
+  v3.taskCatalog.registerTaskMetadata({
+    id: params.id,
+    packageVersion: version,
+    queue: params.queue,
+    retry: params.retry ? {
+      ...v3.defaultRetryOptions,
+      ...params.retry
+    } : void 0,
+    machine: params.machine,
+    fns: {
+      run: params.run,
+      init: params.init,
+      cleanup: params.cleanup,
+      middleware: params.middleware,
+      handleError: params.handleError,
+      onSuccess: params.onSuccess,
+      onFailure: params.onFailure,
+      onStart: params.onStart
+    }
   });
-  return task2;
+  return task3;
 }
 __name(createTask, "createTask");
 async function handleBatchTaskRunExecutionResult(items) {
@@ -878,14 +929,150 @@ var retry = {
   fetch: retryFetch,
   interceptFetch
 };
+var runs = {
+  replay: replayRun,
+  cancel: cancelRun
+};
+async function replayRun(runId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return await apiClient.replayRun(runId);
+}
+__name(replayRun, "replayRun");
+async function cancelRun(runId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return await apiClient.cancelRun(runId);
+}
+__name(cancelRun, "cancelRun");
 
+// src/v3/schedules/index.ts
+var schedules_exports = {};
+__export(schedules_exports, {
+  activate: () => activate,
+  create: () => create,
+  deactivate: () => deactivate,
+  del: () => del,
+  list: () => list,
+  retrieve: () => retrieve,
+  task: () => task2,
+  update: () => update
+});
+function task2(params) {
+  const task3 = createTask(params);
+  v3.taskCatalog.updateTaskMetadata(task3.id, {
+    triggerSource: "schedule"
+  });
+  return task3;
+}
+__name(task2, "task");
+async function create(options) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.createSchedule(options);
+}
+__name(create, "create");
+async function retrieve(scheduleId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.retrieveSchedule(scheduleId);
+}
+__name(retrieve, "retrieve");
+async function update(scheduleId, options) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.updateSchedule(scheduleId, options);
+}
+__name(update, "update");
+async function del(scheduleId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.deleteSchedule(scheduleId);
+}
+__name(del, "del");
+async function deactivate(scheduleId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.deactivateSchedule(scheduleId);
+}
+__name(deactivate, "deactivate");
+async function activate(scheduleId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.activateSchedule(scheduleId);
+}
+__name(activate, "activate");
+async function list(options) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.listSchedules(options);
+}
+__name(list, "list");
+
+Object.defineProperty(exports, 'APIError', {
+  enumerable: true,
+  get: function () { return v3.APIError; }
+});
+Object.defineProperty(exports, 'AuthenticationError', {
+  enumerable: true,
+  get: function () { return v3.AuthenticationError; }
+});
+Object.defineProperty(exports, 'BadRequestError', {
+  enumerable: true,
+  get: function () { return v3.BadRequestError; }
+});
+Object.defineProperty(exports, 'ConflictError', {
+  enumerable: true,
+  get: function () { return v3.ConflictError; }
+});
+Object.defineProperty(exports, 'InternalServerError', {
+  enumerable: true,
+  get: function () { return v3.InternalServerError; }
+});
+Object.defineProperty(exports, 'NotFoundError', {
+  enumerable: true,
+  get: function () { return v3.NotFoundError; }
+});
+Object.defineProperty(exports, 'PermissionDeniedError', {
+  enumerable: true,
+  get: function () { return v3.PermissionDeniedError; }
+});
+Object.defineProperty(exports, 'RateLimitError', {
+  enumerable: true,
+  get: function () { return v3.RateLimitError; }
+});
+Object.defineProperty(exports, 'UnprocessableEntityError', {
+  enumerable: true,
+  get: function () { return v3.UnprocessableEntityError; }
+});
 Object.defineProperty(exports, 'logger', {
   enumerable: true,
   get: function () { return v3.logger; }
 });
 exports.InMemoryCache = InMemoryCache;
 exports.createCache = createCache;
+exports.queue = queue;
 exports.retry = retry;
+exports.runs = runs;
+exports.schedules = schedules_exports;
 exports.task = task;
 exports.wait = wait;
 //# sourceMappingURL=out.js.map