@trigger.dev/core 0.0.0-v3-decorators-20240424152300 → 0.0.0-v3-prerelease-20240425102616

package/dist/v3/workers/index.d.mts

@@ -4,8 +4,8 @@ export { TracingDiagnosticLogLevel, recordSpanException } from '../otel/index.mj
 import { p as TaskRunExecution, T as TaskRunExecutionResult } from '../../manager-M9GLDnhJ.mjs';
 export { R as RuntimeManager } from '../../manager-M9GLDnhJ.mjs';
 import { B as BackgroundWorkerProperties, T as TaskFileMetadata, a as TaskMetadataWithFilePath } from '../../messages-AriaDDm0.mjs';
-import { d as TriggerTracer, g as Config, y as ProjectConfig, w as HandleErrorFunction, c as TaskMetadataWithFunctions, C as Clock, a as ClockTime, b as TaskCatalog } from '../../catalog-04wPlpvu.mjs';
-export { O as OtelTaskLogger, z as logLevels } from '../../catalog-04wPlpvu.mjs';
+import { d as TriggerTracer, g as Config, z as ProjectConfig, x as HandleErrorFunction, c as TaskMetadataWithFunctions, C as Clock, a as ClockTime, b as TaskCatalog } from '../../catalog-PA64uhhi.mjs';
+export { O as OtelTaskLogger, A as logLevels } from '../../catalog-PA64uhhi.mjs';
 import { PreciseDate } from '@google-cloud/precise-date';
 import { LogRecordProcessor, LogRecord } from '@opentelemetry/sdk-logs';
 import { SpanProcessor, Span } from '@opentelemetry/sdk-trace-base';

package/dist/v3/workers/index.d.ts

@@ -4,8 +4,8 @@ export { TracingDiagnosticLogLevel, recordSpanException } from '../otel/index.js
 import { p as TaskRunExecution, T as TaskRunExecutionResult } from '../../manager-M9GLDnhJ.js';
 export { R as RuntimeManager } from '../../manager-M9GLDnhJ.js';
 import { B as BackgroundWorkerProperties, T as TaskFileMetadata, a as TaskMetadataWithFilePath } from '../../messages-AriaDDm0.js';
-import { d as TriggerTracer, g as Config, y as ProjectConfig, w as HandleErrorFunction, c as TaskMetadataWithFunctions, C as Clock, a as ClockTime, b as TaskCatalog } from '../../catalog-huF1UvYY.js';
-export { O as OtelTaskLogger, z as logLevels } from '../../catalog-huF1UvYY.js';
+import { d as TriggerTracer, g as Config, z as ProjectConfig, x as HandleErrorFunction, c as TaskMetadataWithFunctions, C as Clock, a as ClockTime, b as TaskCatalog } from '../../catalog-KJXg8k3W.js';
+export { O as OtelTaskLogger, A as logLevels } from '../../catalog-KJXg8k3W.js';
 import { PreciseDate } from '@google-cloud/precise-date';
 import { LogRecordProcessor, LogRecord } from '@opentelemetry/sdk-logs';
 import { SpanProcessor, Span } from '@opentelemetry/sdk-trace-base';

package/dist/v3/workers/index.js

@@ -1975,12 +1975,18 @@ function accessoryAttributes(accessory) {
 __name(accessoryAttributes, "accessoryAttributes");
 
 // src/v3/workers/taskExecutor.ts
-var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callConfigInit, callConfigInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
+var _callRun, callRun_fn, _callInitFunctions, callInitFunctions_fn, _callConfigInit, callConfigInit_fn, _callOnSuccessFunctions, callOnSuccessFunctions_fn, _callOnSuccessFunction, callOnSuccessFunction_fn, _callOnFailureFunctions, callOnFailureFunctions_fn, _callOnFailureFunction, callOnFailureFunction_fn, _callOnStartFunctions, callOnStartFunctions_fn, _callOnStartFunction, callOnStartFunction_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
 var _TaskExecutor = class _TaskExecutor {
   constructor(task, options) {
     __privateAdd(this, _callRun);
-    __privateAdd(this, _callTaskInit);
+    __privateAdd(this, _callInitFunctions);
     __privateAdd(this, _callConfigInit);
+    __privateAdd(this, _callOnSuccessFunctions);
+    __privateAdd(this, _callOnSuccessFunction);
+    __privateAdd(this, _callOnFailureFunctions);
+    __privateAdd(this, _callOnFailureFunction);
+    __privateAdd(this, _callOnStartFunctions);
+    __privateAdd(this, _callOnStartFunction);
     __privateAdd(this, _callTaskCleanup);
     __privateAdd(this, _handleError);
     this.task = task;
@@ -2014,9 +2020,12 @@ var _TaskExecutor = class _TaskExecutor {
         try {
           const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
           parsedPayload = await parsePacket(payloadPacket);
-          await __privateMethod(this, _callConfigInit, callConfigInit_fn).call(this, parsedPayload, ctx);
-          initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
+          if (execution.attempt.number === 1) {
+            await __privateMethod(this, _callOnStartFunctions, callOnStartFunctions_fn).call(this, parsedPayload, ctx);
+          }
+          initOutput = await __privateMethod(this, _callInitFunctions, callInitFunctions_fn).call(this, parsedPayload, ctx);
           const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
+          await __privateMethod(this, _callOnSuccessFunctions, callOnSuccessFunctions_fn).call(this, parsedPayload, output, ctx, initOutput);
           try {
             const stringifiedOutput = await stringifyIO(output);
             const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
@@ -2046,6 +2055,9 @@ var _TaskExecutor = class _TaskExecutor {
           try {
             const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
             recordSpanException(span, handleErrorResult.error ?? runError);
+            if (handleErrorResult.status !== "retry") {
+              await __privateMethod(this, _callOnFailureFunctions, callOnFailureFunctions_fn).call(this, parsedPayload, handleErrorResult.error ?? runError, ctx, initOutput);
+            }
             return {
               id: execution.run.id,
               ok: false,
@@ -2109,8 +2121,9 @@ callRun_fn = /* @__PURE__ */ __name(async function(payload, ctx, init) {
     })
   });
 }, "#callRun");
-_callTaskInit = new WeakSet();
-callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+_callInitFunctions = new WeakSet();
+callInitFunctions_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+  await __privateMethod(this, _callConfigInit, callConfigInit_fn).call(this, payload1, ctx1);
   const initFn = this.task.fns.init;
   if (!initFn) {
     return {};
@@ -2124,7 +2137,7 @@ callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
       [SemanticInternalAttributes.STYLE_ICON]: "function"
     }
   });
-}, "#callTaskInit");
+}, "#callInitFunctions");
 _callConfigInit = new WeakSet();
 callConfigInit_fn = /* @__PURE__ */ __name(async function(payload2, ctx2) {
   const initFn = this._importedConfig?.init;
@@ -2141,21 +2154,92 @@ callConfigInit_fn = /* @__PURE__ */ __name(async function(payload2, ctx2) {
     }
   });
 }, "#callConfigInit");
+_callOnSuccessFunctions = new WeakSet();
+callOnSuccessFunctions_fn = /* @__PURE__ */ __name(async function(payload3, output, ctx3, initOutput) {
+  await __privateMethod(this, _callOnSuccessFunction, callOnSuccessFunction_fn).call(this, this.task.fns.onSuccess, "task.onSuccess", payload3, output, ctx3, initOutput);
+  await __privateMethod(this, _callOnSuccessFunction, callOnSuccessFunction_fn).call(this, this._importedConfig?.onSuccess, "config.onSuccess", payload3, output, ctx3, initOutput);
+}, "#callOnSuccessFunctions");
+_callOnSuccessFunction = new WeakSet();
+callOnSuccessFunction_fn = /* @__PURE__ */ __name(async function(onSuccessFn, name, payload4, output1, ctx4, initOutput1) {
+  if (!onSuccessFn) {
+    return;
+  }
+  try {
+    await this._tracer.startActiveSpan(name, async (span) => {
+      return await onSuccessFn(payload4, output1, {
+        ctx: ctx4,
+        init: initOutput1
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch {
+  }
+}, "#callOnSuccessFunction");
+_callOnFailureFunctions = new WeakSet();
+callOnFailureFunctions_fn = /* @__PURE__ */ __name(async function(payload5, error, ctx5, initOutput2) {
+  await __privateMethod(this, _callOnFailureFunction, callOnFailureFunction_fn).call(this, this.task.fns.onFailure, "task.onFailure", payload5, error, ctx5, initOutput2);
+  await __privateMethod(this, _callOnFailureFunction, callOnFailureFunction_fn).call(this, this._importedConfig?.onFailure, "config.onFailure", payload5, error, ctx5, initOutput2);
+}, "#callOnFailureFunctions");
+_callOnFailureFunction = new WeakSet();
+callOnFailureFunction_fn = /* @__PURE__ */ __name(async function(onFailureFn, name1, payload6, error1, ctx6, initOutput3) {
+  if (!onFailureFn) {
+    return;
+  }
+  try {
+    return await this._tracer.startActiveSpan(name1, async (span) => {
+      return await onFailureFn(payload6, error1, {
+        ctx: ctx6,
+        init: initOutput3
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch (e) {
+  }
+}, "#callOnFailureFunction");
+_callOnStartFunctions = new WeakSet();
+callOnStartFunctions_fn = /* @__PURE__ */ __name(async function(payload7, ctx7) {
+  await __privateMethod(this, _callOnStartFunction, callOnStartFunction_fn).call(this, this._importedConfig?.onStart, "config.onStart", payload7, ctx7, {});
+  await __privateMethod(this, _callOnStartFunction, callOnStartFunction_fn).call(this, this.task.fns.onStart, "task.onStart", payload7, ctx7, {});
+}, "#callOnStartFunctions");
+_callOnStartFunction = new WeakSet();
+callOnStartFunction_fn = /* @__PURE__ */ __name(async function(onStartFn, name2, payload8, ctx8, initOutput4) {
+  if (!onStartFn) {
+    return;
+  }
+  try {
+    await this._tracer.startActiveSpan(name2, async (span) => {
+      return await onStartFn(payload8, {
+        ctx: ctx8
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch {
+  }
+}, "#callOnStartFunction");
 _callTaskCleanup = new WeakSet();
-callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload3, ctx3, init1) {
+callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload9, ctx9, init1) {
   const cleanupFn = this.task.fns.cleanup;
   if (!cleanupFn) {
     return;
   }
   return this._tracer.startActiveSpan("cleanup", async (span) => {
-    return await cleanupFn(payload3, {
-      ctx: ctx3,
+    return await cleanupFn(payload9, {
+      ctx: ctx9,
       init: init1
     });
   });
 }, "#callTaskCleanup");
 _handleError = new WeakSet();
-handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload4, ctx4) {
+handleError_fn = /* @__PURE__ */ __name(async function(execution, error2, payload10, ctx10) {
   const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
   const retry = this.task.retry ?? retriesConfig?.default;
   if (!retry) {
@@ -2170,13 +2254,13 @@ handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload
     };
   }
   return this._tracer.startActiveSpan("handleError()", async (span) => {
-    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload4, error, {
-      ctx: ctx4,
+    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload10, error2, {
+      ctx: ctx10,
       retry,
       retryDelayInMs: delay,
       retryAt: delay ? new Date(Date.now() + delay) : void 0
-    }) : this._importedConfig ? await this._handleErrorFn?.(payload4, error, {
-      ctx: ctx4,
+    }) : this._importedConfig ? await this._handleErrorFn?.(payload10, error2, {
+      ctx: ctx10,
       retry,
       retryDelayInMs: delay,
       retryAt: delay ? new Date(Date.now() + delay) : void 0