trigger.dev 1.0.6 → 1.0.8

package/dist/templates/examples/simple.ts.template

@@ -0,0 +1,14 @@
+import { logger, task, wait } from "@trigger.dev/sdk/v3";
+
+export const helloWorldTask = task({
+  id: "hello-world",
+  run: async (payload: any, { ctx }) => {
+    logger.log("Hello, world!", { payload, ctx });
+
+    await wait.for({ seconds: 5 });
+
+    return {
+      message: "Hello, world!",
+    }
+  },
+});

package/dist/templates/trigger.config.ts.template

@@ -0,0 +1,16 @@
+import type { TriggerConfig } from "@trigger.dev/sdk/v3";
+
+export const config: TriggerConfig = {
+  project: "${projectRef}",
+  logLevel: "log",
+  retries: {
+    enabledInDev: true,
+    default: {
+      maxAttempts: 3,
+      minTimeoutInMs: 1000,
+      maxTimeoutInMs: 10000,
+      factor: 2,
+      randomize: true,
+    },
+  },${triggerDirectoriesOption}
+};

package/dist/workers/dev/worker-facade.js

@@ -0,0 +1,167 @@
+// src/workers/dev/worker-facade.ts
+import {
+  clock,
+  taskCatalog
+} from "@trigger.dev/core/v3";
+import {
+  TaskExecutor,
+  DurableClock,
+  getEnvVar,
+  logLevels,
+  OtelTaskLogger,
+  ConsoleInterceptor
+} from "@trigger.dev/core/v3/workers";
+import {
+  TaskRunErrorCodes,
+  TriggerTracer,
+  logger,
+  runtime,
+  workerToChildMessages
+} from "@trigger.dev/core/v3";
+import { DevRuntimeManager } from "@trigger.dev/core/v3/dev";
+import {
+  ZodMessageHandler,
+  ZodSchemaParsedError
+} from "@trigger.dev/core/v3/zodMessageHandler";
+__WORKER_SETUP__;
+__IMPORTED_PROJECT_CONFIG__;
+var durableClock = new DurableClock();
+clock.setGlobalClock(durableClock);
+var tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
+var consoleInterceptor = new ConsoleInterceptor(
+  otelLogger,
+  typeof __PROJECT_CONFIG__.enableConsoleLogging === "boolean" ? __PROJECT_CONFIG__.enableConsoleLogging : true
+);
+var devRuntimeManager = new DevRuntimeManager();
+runtime.setGlobalRuntimeManager(devRuntimeManager);
+var triggerLogLevel = getEnvVar("TRIGGER_LOG_LEVEL");
+var configLogLevel = triggerLogLevel ? triggerLogLevel : importedConfig ? importedConfig.logLevel : __PROJECT_CONFIG__.logLevel;
+var otelTaskLogger = new OtelTaskLogger({
+  logger: otelLogger,
+  tracer,
+  level: logLevels.includes(configLogLevel) ? configLogLevel : "info"
+});
+logger.setGlobalTaskLogger(otelTaskLogger);
+var TaskFileImports = {};
+var TaskFiles = {};
+__TASKS__;
+(() => {
+  for (const [importName, taskFile] of Object.entries(TaskFiles)) {
+    const fileImports = TaskFileImports[importName];
+    for (const [exportName, task] of Object.entries(fileImports ?? {})) {
+      if (typeof task === "object" && task !== null && "id" in task && typeof task.id === "string") {
+        if (taskCatalog.taskExists(task.id)) {
+          taskCatalog.registerTaskFileMetadata(task.id, {
+            exportName,
+            filePath: taskFile.filePath
+          });
+        }
+      }
+    }
+  }
+})();
+var _execution;
+var _isRunning = false;
+var handler = new ZodMessageHandler({
+  schema: workerToChildMessages,
+  messages: {
+    EXECUTE_TASK_RUN: async ({ execution, traceContext, metadata }) => {
+      if (_isRunning) {
+        console.error("Worker is already running a task");
+        await sender.send("TASK_RUN_COMPLETED", {
+          execution,
+          result: {
+            ok: false,
+            id: execution.run.id,
+            error: {
+              type: "INTERNAL_ERROR",
+              code: TaskRunErrorCodes.TASK_ALREADY_RUNNING
+            }
+          }
+        });
+        return;
+      }
+      process.title = `trigger-dev-worker: ${execution.task.id} ${execution.run.id}`;
+      const task = taskCatalog.getTask(execution.task.id);
+      if (!task) {
+        console.error(`Could not find task ${execution.task.id}`);
+        await sender.send("TASK_RUN_COMPLETED", {
+          execution,
+          result: {
+            ok: false,
+            id: execution.run.id,
+            error: {
+              type: "INTERNAL_ERROR",
+              code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR
+            }
+          }
+        });
+        return;
+      }
+      const executor = new TaskExecutor(task, {
+        tracer,
+        tracingSDK,
+        consoleInterceptor,
+        projectConfig: __PROJECT_CONFIG__,
+        importedConfig,
+        handleErrorFn: handleError
+      });
+      try {
+        _execution = execution;
+        _isRunning = true;
+        const result = await executor.execute(execution, metadata, traceContext);
+        return sender.send("TASK_RUN_COMPLETED", {
+          execution,
+          result
+        });
+      } finally {
+        _execution = void 0;
+        _isRunning = false;
+      }
+    },
+    TASK_RUN_COMPLETED_NOTIFICATION: async ({ completion, execution }) => {
+      devRuntimeManager.resumeTask(completion, execution);
+    },
+    CLEANUP: async ({ flush, kill }) => {
+      if (kill) {
+        await tracingSDK.flush();
+        await sender.send("READY_TO_DISPOSE", void 0);
+      } else {
+        if (flush) {
+          await tracingSDK.flush();
+        }
+      }
+    }
+  }
+});
+process.on("message", async (msg) => {
+  await handler.handleMessage(msg);
+});
+var TASK_METADATA = taskCatalog.getAllTaskMetadata();
+sender.send("TASKS_READY", { tasks: TASK_METADATA }).catch((err) => {
+  if (err instanceof ZodSchemaParsedError) {
+    sender.send("TASKS_FAILED_TO_PARSE", { zodIssues: err.error.issues, tasks: TASK_METADATA });
+  } else {
+    console.error("Failed to send TASKS_READY message", err);
+  }
+});
+process.title = "trigger-dev-worker";
+async function asyncHeartbeat(initialDelayInSeconds = 30, intervalInSeconds = 5) {
+  async function _doHeartbeat() {
+    while (true) {
+      if (_isRunning && _execution) {
+        try {
+          await sender.send("TASK_HEARTBEAT", { id: _execution.attempt.id });
+        } catch (err) {
+          console.error("Failed to send HEARTBEAT message", err);
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1e3 * intervalInSeconds));
+    }
+  }
+  await new Promise((resolve) => setTimeout(resolve, 1e3 * initialDelayInSeconds));
+  return _doHeartbeat();
+}
+asyncHeartbeat().catch((err) => {
+  console.error("Failed to start asyncHeartbeat", err);
+});

package/dist/workers/dev/worker-setup.js

@@ -0,0 +1,34 @@
+// src/workers/dev/worker-setup.ts
+import { childToWorkerMessages, taskCatalog } from "@trigger.dev/core/v3";
+import {
+  StandardTaskCatalog,
+  TracingSDK
+} from "@trigger.dev/core/v3/workers";
+import { ZodMessageSender } from "@trigger.dev/core/v3/zodMessageHandler";
+import "source-map-support/register.js";
+
+// package.json
+var version = "3.0.0-beta.33";
+
+// src/workers/dev/worker-setup.ts
+__SETUP_IMPORTED_PROJECT_CONFIG__;
+var tracingSDK = new TracingSDK({
+  url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
+  instrumentations: setupImportedConfig?.instrumentations ?? [],
+  diagLogLevel: process.env.OTEL_LOG_LEVEL ?? "none"
+});
+var otelTracer = tracingSDK.getTracer("trigger-dev-worker", version);
+var otelLogger = tracingSDK.getLogger("trigger-dev-worker", version);
+var sender = new ZodMessageSender({
+  schema: childToWorkerMessages,
+  sender: async (message) => {
+    process.send?.(message);
+  }
+});
+taskCatalog.setGlobalTaskCatalog(new StandardTaskCatalog());
+export {
+  otelLogger,
+  otelTracer,
+  sender,
+  tracingSDK
+};