@trigger.dev/core 3.0.0-beta.13 → 3.0.0-beta.15

package/dist/v3/index.js

@@ -100,7 +100,8 @@ var TaskRunErrorCodes = {
   TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
   TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
   TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
-  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR"
+  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
+  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT"
 };
 var TaskRunInternalError = zod.z.object({
   type: zod.z.literal("INTERNAL_ERROR"),
@@ -114,7 +115,8 @@ var TaskRunInternalError = zod.z.object({
     "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
     "TASK_RUN_CANCELLED",
     "TASK_OUTPUT_ERROR",
-    "HANDLE_ERROR_ERROR"
+    "HANDLE_ERROR_ERROR",
+    "GRACEFUL_EXIT_TIMEOUT"
   ]),
   message: zod.z.string().optional()
 });
@@ -131,7 +133,8 @@ var TaskRun = zod.z.object({
   context: zod.z.any(),
   tags: zod.z.array(zod.z.string()),
   isTest: zod.z.boolean().default(false),
-  createdAt: zod.z.coerce.date()
+  createdAt: zod.z.coerce.date(),
+  idempotencyKey: zod.z.string().optional()
 });
 var TaskRunExecutionTask = zod.z.object({
   id: zod.z.string(),
@@ -2067,7 +2070,8 @@ var SemanticInternalAttributes = {
   RETRY_AT: "retry.at",
   RETRY_DELAY: "retry.delay",
   RETRY_COUNT: "retry.count",
-  LINK_TITLE: "$link.title"
+  LINK_TITLE: "$link.title",
+  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey"
 };
 
 // src/v3/tasks/taskContextManager.ts
@@ -2126,7 +2130,8 @@ var _TaskContextManager = class _TaskContextManager {
         [SemanticInternalAttributes.RUN_IS_TEST]: this.ctx.run.isTest,
         [SemanticInternalAttributes.ORGANIZATION_SLUG]: this.ctx.organization.slug,
         [SemanticInternalAttributes.ORGANIZATION_NAME]: this.ctx.organization.name,
-        [SemanticInternalAttributes.BATCH_ID]: this.ctx.batch?.id
+        [SemanticInternalAttributes.BATCH_ID]: this.ctx.batch?.id,
+        [SemanticInternalAttributes.IDEMPOTENCY_KEY]: this.ctx.run.idempotencyKey
       };
     }
     return {};
@@ -2217,6 +2222,27 @@ var _ApiClient = class _ApiClient {
     this.accessToken = accessToken;
     this.baseUrl = baseUrl.replace(/\/$/, "");
   }
+  async getRunResult(runId) {
+    try {
+      return await zodfetch(TaskRunExecutionResult, `${this.baseUrl}/api/v1/runs/${runId}/result`, {
+        method: "GET",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+      }, zodFetchOptions);
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.status === 404) {
+          return void 0;
+        }
+      }
+      throw error;
+    }
+  }
+  async getBatchResults(batchId) {
+    return await zodfetch(BatchTaskRunExecutionResult, `${this.baseUrl}/api/v1/batches/${batchId}/results`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
   triggerTask(taskId, body, options) {
     return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
       method: "POST",
@@ -3462,12 +3488,23 @@ __name(_NoopTaskLogger, "NoopTaskLogger");
 var NoopTaskLogger = _NoopTaskLogger;
 function safeJsonProcess(value) {
   try {
-    return JSON.parse(JSON.stringify(value));
+    return JSON.parse(JSON.stringify(value, jsonErrorReplacer));
   } catch {
     return value;
   }
 }
 __name(safeJsonProcess, "safeJsonProcess");
+function jsonErrorReplacer(key, value) {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+  }
+  return value;
+}
+__name(jsonErrorReplacer, "jsonErrorReplacer");
 
 // src/v3/logger/index.ts
 var API_NAME3 = "logger";
@@ -3707,6 +3744,17 @@ function formatDurationInDays(milliseconds) {
   return duration;
 }
 __name(formatDurationInDays, "formatDurationInDays");
+async function unboundedTimeout(delay = 0, value, options) {
+  const maxDelay = 2147483647;
+  const fullTimeouts = Math.floor(delay / maxDelay);
+  const remainingDelay = delay % maxDelay;
+  let lastTimeoutResult = await promises.setTimeout(remainingDelay, value, options);
+  for (let i = 0; i < fullTimeouts; i++) {
+    lastTimeoutResult = await promises.setTimeout(maxDelay, value, options);
+  }
+  return lastTimeoutResult;
+}
+__name(unboundedTimeout, "unboundedTimeout");
 
 // src/v3/runtime/devRuntimeManager.ts
 var _DevRuntimeManager = class _DevRuntimeManager {
@@ -3718,14 +3766,10 @@ var _DevRuntimeManager = class _DevRuntimeManager {
   disable() {
   }
   async waitForDuration(ms) {
-    return new Promise((resolve) => {
-      setTimeout(resolve, ms);
-    });
+    await unboundedTimeout(ms);
   }
   async waitUntil(date) {
-    return new Promise((resolve) => {
-      setTimeout(resolve, date.getTime() - Date.now());
-    });
+    return this.waitForDuration(date.getTime() - Date.now());
   }
   async waitForTask(params) {
     const pendingCompletion = this._pendingCompletionNotifications.get(params.id);
@@ -3733,10 +3777,9 @@ var _DevRuntimeManager = class _DevRuntimeManager {
       this._pendingCompletionNotifications.delete(params.id);
       return pendingCompletion;
     }
-    const promise = new Promise((resolve, reject) => {
+    const promise = new Promise((resolve) => {
       this._taskWaits.set(params.id, {
-        resolve,
-        reject
+        resolve
       });
     });
     return await promise;
@@ -3753,16 +3796,11 @@ var _DevRuntimeManager = class _DevRuntimeManager {
         const pendingCompletion = this._pendingCompletionNotifications.get(runId);
         if (pendingCompletion) {
           this._pendingCompletionNotifications.delete(runId);
-          if (pendingCompletion.ok) {
-            resolve(pendingCompletion);
-          } else {
-            reject(pendingCompletion);
-          }
+          resolve(pendingCompletion);
           return;
         }
         this._taskWaits.set(runId, {
-          resolve,
-          reject
+          resolve
         });
       });
     }));
@@ -3778,16 +3816,14 @@ var _DevRuntimeManager = class _DevRuntimeManager {
       this._pendingCompletionNotifications.set(execution.run.id, completion);
       return;
     }
-    if (completion.ok) {
-      wait.resolve(completion);
-    } else {
-      wait.reject(completion);
-    }
+    wait.resolve(completion);
     this._taskWaits.delete(execution.run.id);
   }
 };
 __name(_DevRuntimeManager, "DevRuntimeManager");
 var DevRuntimeManager = _DevRuntimeManager;
+
+// src/v3/runtime/prodRuntimeManager.ts
 var _ProdRuntimeManager = class _ProdRuntimeManager {
   constructor(ipc, options = {}) {
     this.ipc = ipc;
@@ -3799,7 +3835,7 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
   }
   async waitForDuration(ms) {
     const now = Date.now();
-    const resolveAfterDuration = promises.setTimeout(ms, "duration");
+    const resolveAfterDuration = unboundedTimeout(ms, "duration");
     if (ms <= this.waitThresholdInMs) {
       await resolveAfterDuration;
       return;
@@ -3837,16 +3873,17 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
     return this.waitForDuration(date.getTime() - Date.now());
   }
   async waitForTask(params) {
-    const promise = new Promise((resolve, reject) => {
+    const promise = new Promise((resolve) => {
       this._taskWaits.set(params.id, {
-        resolve,
-        reject
+        resolve
       });
     });
     await this.ipc.send("WAIT_FOR_TASK", {
       friendlyId: params.id
     });
-    return await promise;
+    const result = await promise;
+    clock.reset();
+    return result;
   }
   async waitForBatch(params) {
     if (!params.runs.length) {
@@ -3858,8 +3895,7 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
     const promise = Promise.all(params.runs.map((runId) => {
       return new Promise((resolve, reject) => {
         this._taskWaits.set(runId, {
-          resolve,
-          reject
+          resolve
         });
       });
     }));
@@ -3868,6 +3904,7 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
       runFriendlyIds: params.runs
     });
     const results = await promise;
+    clock.reset();
     return {
       id: params.id,
       items: results
@@ -3878,11 +3915,7 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
     if (!wait) {
       return;
     }
-    if (completion.ok) {
-      wait.resolve(completion);
-    } else {
-      wait.reject(completion);
-    }
+    wait.resolve(completion);
     this._taskWaits.delete(execution.run.id);
   }
   get waitThresholdInMs() {
@@ -4771,7 +4804,7 @@ var _TaskExecutor = class _TaskExecutor {
               }
               return {
                 ok: true,
-                id: execution.attempt.id,
+                id: execution.run.id,
                 output: finalOutput.data,
                 outputType: finalOutput.dataType
               };
@@ -4779,7 +4812,7 @@ var _TaskExecutor = class _TaskExecutor {
               recordSpanException(span, stringifyError);
               return {
                 ok: false,
-                id: execution.attempt.id,
+                id: execution.run.id,
                 error: {
                   type: "INTERNAL_ERROR",
                   code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
@@ -4792,7 +4825,7 @@ var _TaskExecutor = class _TaskExecutor {
               const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
               recordSpanException(span, handleErrorResult.error ?? runError);
               return {
-                id: execution.attempt.id,
+                id: execution.run.id,
                 ok: false,
                 error: handleErrorResult.error ? parseError(handleErrorResult.error) : parseError(runError),
                 retry: handleErrorResult.status === "retry" ? handleErrorResult.retry : void 0,
@@ -4802,7 +4835,7 @@ var _TaskExecutor = class _TaskExecutor {
               recordSpanException(span, handleErrorError);
               return {
                 ok: false,
-                id: execution.attempt.id,
+                id: execution.run.id,
                 error: {
                   type: "INTERNAL_ERROR",
                   code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,