trigger.dev 3.0.0-beta.9 → 3.0.1

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

@@ -1,14 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,187 +0,0 @@
-// src/workers/dev/worker-facade.ts
-import {
-  TaskExecutor,
-  DurableClock,
-  clock,
-  logLevels,
-  getEnvVar,
-  ZodSchemaParsedError
-} from "@trigger.dev/core/v3";
-import {
-  ConsoleInterceptor,
-  DevRuntimeManager,
-  OtelTaskLogger,
-  TaskRunErrorCodes,
-  TriggerTracer,
-  ZodMessageHandler,
-  logger,
-  runtime,
-  workerToChildMessages
-} from "@trigger.dev/core/v3";
-
-// package.json
-var version = "3.0.0-beta.9";
-
-// src/workers/dev/worker-facade.ts
-__WORKER_SETUP__;
-__IMPORTED_PROJECT_CONFIG__;
-var otelTracer = tracingSDK.getTracer("trigger-dev-worker", version);
-var otelLogger = tracingSDK.getLogger("trigger-dev-worker", version);
-var durableClock = new DurableClock();
-clock.setGlobalClock(durableClock);
-var tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
-var consoleInterceptor = new ConsoleInterceptor(otelLogger);
-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 : "log"
-});
-logger.setGlobalTaskLogger(otelTaskLogger);
-var TaskFileImports = {};
-var TaskFiles = {};
-__TASKS__;
-function getTasks() {
-  const result = [];
-  for (const [importName, taskFile] of Object.entries(TaskFiles)) {
-    const fileImports = TaskFileImports[importName];
-    for (const [exportName, task] of Object.entries(fileImports ?? {})) {
-      if (task.__trigger) {
-        result.push({
-          id: task.__trigger.id,
-          exportName,
-          packageVersion: task.__trigger.packageVersion,
-          filePath: taskFile.filePath,
-          queue: task.__trigger.queue,
-          retry: task.__trigger.retry,
-          machine: task.__trigger.machine,
-          fns: task.__trigger.fns
-        });
-      }
-    }
-  }
-  return result;
-}
-function getTaskMetadata() {
-  const result = getTasks();
-  return result.map((task) => {
-    const { fns, ...metadata } = task;
-    return metadata;
-  });
-}
-var tasks = getTasks();
-runtime.registerTasks(tasks);
-var taskExecutors = /* @__PURE__ */ new Map();
-for (const task of tasks) {
-  taskExecutors.set(
-    task.id,
-    new TaskExecutor(task, {
-      tracer,
-      tracingSDK,
-      consoleInterceptor,
-      projectConfig: __PROJECT_CONFIG__,
-      importedConfig,
-      handleErrorFn: handleError
-    })
-  );
-}
-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.attempt.id,
-            error: {
-              type: "INTERNAL_ERROR",
-              code: TaskRunErrorCodes.TASK_ALREADY_RUNNING
-            }
-          }
-        });
-        return;
-      }
-      process.title = `trigger-dev-worker: ${execution.task.id} ${execution.run.id}`;
-      const executor = taskExecutors.get(execution.task.id);
-      if (!executor) {
-        console.error(`Could not find executor for task ${execution.task.id}`);
-        await sender.send("TASK_RUN_COMPLETED", {
-          execution,
-          result: {
-            ok: false,
-            id: execution.attempt.id,
-            error: {
-              type: "INTERNAL_ERROR",
-              code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR
-            }
-          }
-        });
-        return;
-      }
-      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 = getTaskMetadata();
-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

@@ -1,40 +0,0 @@
-// src/workers/dev/worker-setup.ts
-import "source-map-support/register.js";
-import { Resource } from "@opentelemetry/resources";
-import {
-  SemanticInternalAttributes,
-  TracingSDK,
-  ZodMessageSender,
-  childToWorkerMessages
-} from "@trigger.dev/core/v3";
-__SETUP_IMPORTED_PROJECT_CONFIG__;
-var tracingSDK = new TracingSDK({
-  url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
-  resource: new Resource({
-    [SemanticInternalAttributes.CLI_VERSION]: "3.0.0"
-  }),
-  instrumentations: setupImportedConfig?.instrumentations ?? [],
-  diagLogLevel: process.env.OTEL_LOG_LEVEL ?? "none"
-});
-var sender = new ZodMessageSender({
-  schema: childToWorkerMessages,
-  sender: async (message) => {
-    process.send?.(message);
-  }
-});
-process.on("uncaughtException", (error, origin) => {
-  sender.send("UNCAUGHT_EXCEPTION", {
-    error: {
-      name: error.name,
-      message: error.message,
-      stack: error.stack
-    },
-    origin
-  }).catch((err) => {
-    console.error("Failed to send UNCAUGHT_EXCEPTION message", err);
-  });
-});
-export {
-  sender,
-  tracingSDK
-};