@pgflow/core 0.0.5 → 0.0.7

package/pkgs/edge-worker/dist/index.js

@@ -1,953 +0,0 @@
-// ../edge-worker/src/core/ExecutionController.ts
-import { newQueue } from "@henrygd/queue";
-
-// ../edge-worker/src/core/Logger.ts
-import pino from "pino";
-function getLogLevelFromEnv() {
-  const validLevels = [
-    "DEBUG",
-    "INFO",
-    "ERROR"
-  ];
-  const logLevel = Deno.env.get("EDGE_WORKER_LOG_LEVEL")?.toUpperCase();
-  if (logLevel && !validLevels.includes(logLevel)) {
-    console.warn(`Invalid log level "${logLevel}". Using "INFO" instead.`);
-    return "info";
-  }
-  return logLevel?.toLowerCase() || "info";
-}
-function setupLogger(workerId) {
-  const level = getLogLevelFromEnv();
-  const loggerOptions = {
-    level,
-    formatters: {
-      bindings: () => ({ worker_id: workerId })
-    },
-    serializers: pino.stdSerializers,
-    transport: {
-      target: "pino-pretty",
-      options: {
-        colorize: true,
-        messageFormat: "[{module}] {msg}"
-      }
-    }
-  };
-  pino(loggerOptions);
-}
-function getLogger(module) {
-  return pino().child({ module });
-}
-
-// ../edge-worker/src/core/ExecutionController.ts
-var ExecutionController = class {
-  constructor(executorFactory, abortSignal, config) {
-    this.logger = getLogger("ExecutionController");
-    this.signal = abortSignal;
-    this.createExecutor = executorFactory;
-    this.promiseQueue = newQueue(config.maxConcurrent);
-  }
-  async start(record) {
-    const executor = this.createExecutor(record, this.signal);
-    this.logger.info(`Scheduling execution of task ${executor.msgId}`);
-    return await this.promiseQueue.add(async () => {
-      try {
-        this.logger.debug(`Executing task ${executor.msgId}...`);
-        await executor.execute();
-        this.logger.debug(`Execution successful for ${executor.msgId}`);
-      } catch (error) {
-        this.logger.error(`Execution failed for ${executor.msgId}:`, error);
-        throw error;
-      }
-    });
-  }
-  async awaitCompletion() {
-    const active = this.promiseQueue.active();
-    const all = this.promiseQueue.size();
-    this.logger.debug(
-      `Awaiting completion of all tasks... (active/all: ${active}}/${all})`
-    );
-    await this.promiseQueue.done();
-  }
-};
-
-// ../edge-worker/src/queue/MessageExecutor.ts
-var AbortError = class extends Error {
-  constructor() {
-    super("Operation aborted");
-    this.name = "AbortError";
-  }
-};
-var MessageExecutor = class {
-  constructor(queue, record, messageHandler, signal, retryLimit, retryDelay) {
-    this.queue = queue;
-    this.record = record;
-    this.messageHandler = messageHandler;
-    this.signal = signal;
-    this.retryLimit = retryLimit;
-    this.retryDelay = retryDelay;
-    this.logger = getLogger("MessageExecutor");
-  }
-  get msgId() {
-    return this.record.msg_id;
-  }
-  async execute() {
-    try {
-      if (this.signal.aborted) {
-        throw new AbortError();
-      }
-      this.signal.throwIfAborted();
-      this.logger.debug(`Executing task ${this.msgId}...`);
-      await this.messageHandler(this.record.message);
-      this.logger.debug(
-        `Task ${this.msgId} completed successfully, archiving...`
-      );
-      await this.queue.archive(this.msgId);
-      this.logger.debug(`Archived task ${this.msgId} successfully`);
-    } catch (error) {
-      await this.handleExecutionError(error);
-    }
-  }
-  /**
-   * Handles the error that occurred during execution.
-   *
-   * If the error is an AbortError, it means that the worker was aborted and stopping,
-   * the message will reappear after the visibility timeout and be picked up by another worker.
-   *
-   * Otherwise, it proceeds with retry or archiving forever.
-   */
-  async handleExecutionError(error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      this.logger.debug(`Aborted execution for ${this.msgId}`);
-    } else {
-      this.logger.debug(`Task ${this.msgId} failed with error: ${error}`);
-      await this.retryOrArchive();
-    }
-  }
-  /**
-   * Retries the message if it is available.
-   * Otherwise, archives the message forever and stops processing it.
-   */
-  async retryOrArchive() {
-    if (this.retryAvailable) {
-      this.logger.debug(`Retrying ${this.msgId} in ${this.retryDelay} seconds`);
-      await this.queue.setVt(this.msgId, this.retryDelay);
-    } else {
-      this.logger.debug(`Archiving ${this.msgId} forever`);
-      await this.queue.archive(this.msgId);
-    }
-  }
-  /**
-   * Returns true if the message can be retried.
-   */
-  get retryAvailable() {
-    const readCountLimit = this.retryLimit + 1;
-    return this.record.read_ct < readCountLimit;
-  }
-};
-
-// ../edge-worker/src/core/Queries.ts
-var Queries = class {
-  constructor(sql) {
-    this.sql = sql;
-  }
-  async onWorkerStarted({
-    queueName,
-    workerId,
-    edgeFunctionName
-  }) {
-    const [worker] = await this.sql`
-      INSERT INTO edge_worker.workers (queue_name, worker_id, function_name)
-      VALUES (${queueName}, ${workerId}, ${edgeFunctionName})
-      RETURNING *;
-    `;
-    return worker;
-  }
-  async onWorkerStopped(workerRow) {
-    const [worker] = await this.sql`
-      UPDATE edge_worker.workers AS w
-      SET stopped_at = clock_timestamp(), last_heartbeat_at = clock_timestamp()
-      WHERE w.worker_id = ${workerRow.worker_id}
-      RETURNING *;
-    `;
-    return worker;
-  }
-  async sendHeartbeat(workerRow) {
-    await this.sql`
-      UPDATE edge_worker.workers AS w
-      SET last_heartbeat_at = clock_timestamp()
-      WHERE w.worker_id = ${workerRow.worker_id}
-      RETURNING *;
-    `;
-  }
-};
-
-// ../edge-worker/src/queue/Queue.ts
-var Queue = class {
-  constructor(sql, queueName) {
-    this.sql = sql;
-    this.queueName = queueName;
-  }
-  /**
-   * Creates a queue if it doesn't exist.
-   * If the queue already exists, this method does nothing.
-   */
-  async safeCreate() {
-    return await this.sql`
-        select * from pgmq.create(${this.queueName})
-        where not exists (
-          select 1 from pgmq.list_queues() where queue_name = ${this.queueName}
-        );
-    `;
-  }
-  /**
-   * Drops a queue if it exists.
-   * If the queue doesn't exist, this method does nothing.
-   */
-  async safeDrop() {
-    return await this.sql`
-        select * from pgmq.drop_queue(${this.queueName})
-        where exists (
-          select 1 from pgmq.list_queues() where queue_name = ${this.queueName}
-        );
-    `;
-  }
-  async archive(msgId) {
-    await this.sql`
-      SELECT pgmq.archive(queue_name => ${this.queueName}, msg_id => ${msgId}::bigint);
-    `;
-  }
-  async archiveBatch(msgIds) {
-    await this.sql`
-      SELECT pgmq.archive(queue_name => ${this.queueName}, msg_ids => ${msgIds}::bigint[]);
-    `;
-  }
-  async send(message) {
-    const msgJson = JSON.stringify(message);
-    await this.sql`
-      SELECT pgmq.send(queue_name => ${this.queueName}, msg => ${msgJson}::jsonb)
-    `;
-  }
-  async readWithPoll(batchSize = 20, visibilityTimeout = 2, maxPollSeconds = 5, pollIntervalMs = 200) {
-    return await this.sql`
-      SELECT *
-      FROM edge_worker.read_with_poll(
-        queue_name => ${this.queueName},
-        vt => ${visibilityTimeout},
-        qty => ${batchSize},
-        max_poll_seconds => ${maxPollSeconds},
-        poll_interval_ms => ${pollIntervalMs}
-      );
-    `;
-  }
-  /**
-   * Sets the visibility timeout of a message to the current time plus the given offset.
-   *
-   * This is an inlined version of the pgmq.set_vt in order to fix the bug.
-   * The original uses now() instead of clock_timestamp() which is problematic in transactions.
-   * See more details here: https://github.com/tembo-io/pgmq/issues/367
-   *
-   * The only change made is now() replaced with clock_timestamp().
-   */
-  async setVt(msgId, vtOffsetSeconds) {
-    const records = await this.sql`
-      UPDATE ${this.sql("pgmq.q_" + this.queueName)}
-      SET vt = (clock_timestamp() + make_interval(secs => ${vtOffsetSeconds}))
-      WHERE msg_id = ${msgId}::bigint
-      RETURNING *;
-    `;
-    return records[0];
-  }
-};
-
-// ../edge-worker/src/queue/ReadWithPollPoller.ts
-var ReadWithPollPoller = class {
-  constructor(queue, signal, config) {
-    this.queue = queue;
-    this.signal = signal;
-    this.config = config;
-  }
-  async poll() {
-    if (this.isAborted()) {
-      return [];
-    }
-    return await this.queue.readWithPoll(
-      this.config.batchSize,
-      this.config.visibilityTimeout,
-      this.config.maxPollSeconds,
-      this.config.pollIntervalMs
-    );
-  }
-  isAborted() {
-    return this.signal.aborted;
-  }
-};
-
-// ../edge-worker/src/core/Worker.ts
-var Worker = class {
-  constructor(batchProcessor, lifecycle, sql) {
-    this.logger = getLogger("Worker");
-    this.abortController = new AbortController();
-    this.sql = sql;
-    this.lifecycle = lifecycle;
-    this.batchProcessor = batchProcessor;
-  }
-  async startOnlyOnce(workerBootstrap) {
-    if (this.lifecycle.isRunning) {
-      this.logger.debug("Worker already running, ignoring start request");
-      return;
-    }
-    await this.start(workerBootstrap);
-  }
-  async start(workerBootstrap) {
-    setupLogger(workerBootstrap.workerId);
-    try {
-      await this.lifecycle.acknowledgeStart(workerBootstrap);
-      while (this.isMainLoopActive) {
-        try {
-          await this.lifecycle.sendHeartbeat();
-        } catch (error) {
-          this.logger.error(`Error sending heartbeat: ${error}`);
-        }
-        try {
-          await this.batchProcessor.processBatch();
-        } catch (error) {
-          this.logger.error(`Error processing batch: ${error}`);
-        }
-      }
-    } catch (error) {
-      this.logger.error(`Error in worker main loop: ${error}`);
-      throw error;
-    }
-  }
-  async stop() {
-    if (this.lifecycle.isStopping || this.lifecycle.isStopped) {
-      return;
-    }
-    this.lifecycle.transitionToStopping();
-    try {
-      this.logger.info("-> Stopped accepting new messages");
-      this.abortController.abort();
-      this.logger.info("-> Waiting for pending tasks to complete...");
-      await this.batchProcessor.awaitCompletion();
-      this.logger.info("-> Pending tasks completed!");
-      this.lifecycle.acknowledgeStop();
-      this.logger.info("-> Closing SQL connection...");
-      await this.sql.end();
-      this.logger.info("-> SQL connection closed!");
-    } catch (error) {
-      this.logger.info(`Error during worker stop: ${error}`);
-      throw error;
-    }
-  }
-  get edgeFunctionName() {
-    return this.lifecycle.edgeFunctionName;
-  }
-  /**
-   * Returns true if worker state is Running and worker was not stopped
-   */
-  get isMainLoopActive() {
-    return this.lifecycle.isRunning && !this.isAborted;
-  }
-  get isAborted() {
-    return this.abortController.signal.aborted;
-  }
-};
-
-// ../edge-worker/src/queue/createQueueWorker.ts
-import postgres from "postgres";
-
-// ../edge-worker/src/core/Heartbeat.ts
-var Heartbeat = class {
-  constructor(interval, queries, workerRow) {
-    this.interval = interval;
-    this.queries = queries;
-    this.workerRow = workerRow;
-    this.logger = getLogger("Heartbeat");
-    this.lastHeartbeat = 0;
-  }
-  async send() {
-    const now = Date.now();
-    if (now - this.lastHeartbeat >= this.interval) {
-      await this.queries.sendHeartbeat(this.workerRow);
-      this.logger.debug("OK");
-      this.lastHeartbeat = now;
-    }
-  }
-};
-
-// ../edge-worker/src/core/WorkerState.ts
-var Transitions = {
-  ["created" /* Created */]: ["starting" /* Starting */],
-  ["starting" /* Starting */]: ["running" /* Running */],
-  ["running" /* Running */]: ["stopping" /* Stopping */],
-  ["stopping" /* Stopping */]: ["stopped" /* Stopped */],
-  ["stopped" /* Stopped */]: []
-  // Terminal state - no valid transitions from here
-};
-var TransitionError = class extends Error {
-  constructor(options) {
-    super(`Cannot transition from ${options.from} to ${options.to}`);
-  }
-};
-var WorkerState = class {
-  constructor() {
-    this.logger = getLogger("WorkerState");
-    this.state = "created" /* Created */;
-  }
-  get current() {
-    return this.state;
-  }
-  get isCreated() {
-    return this.state === "created" /* Created */;
-  }
-  get isStarting() {
-    return this.state === "starting" /* Starting */;
-  }
-  get isRunning() {
-    return this.state === "running" /* Running */;
-  }
-  get isStopping() {
-    return this.state === "stopping" /* Stopping */;
-  }
-  get isStopped() {
-    return this.state === "stopped" /* Stopped */;
-  }
-  transitionTo(state) {
-    this.logger.debug(
-      `[WorkerState] Starting transition to '${state}' (current state: ${this.state})`
-    );
-    if (this.state === state) {
-      return;
-    }
-    if (Transitions[this.state].includes(state)) {
-      this.state = state;
-      this.logger.debug(`[WorkerState] Transitioned to '${state}'`);
-    } else {
-      throw new TransitionError({
-        from: this.state,
-        to: state
-      });
-    }
-  }
-};
-
-// ../edge-worker/src/core/WorkerLifecycle.ts
-var WorkerLifecycle = class {
-  constructor(queries, queue) {
-    this.workerState = new WorkerState();
-    this.logger = getLogger("WorkerLifecycle");
-    this.queries = queries;
-    this.queue = queue;
-  }
-  async acknowledgeStart(workerBootstrap) {
-    this.workerState.transitionTo("starting" /* Starting */);
-    this.logger.info(`Ensuring queue '${this.queue.queueName}' exists...`);
-    await this.queue.safeCreate();
-    this.workerRow = await this.queries.onWorkerStarted({
-      queueName: this.queueName,
-      ...workerBootstrap
-    });
-    this.heartbeat = new Heartbeat(5e3, this.queries, this.workerRow);
-    this.workerState.transitionTo("running" /* Running */);
-  }
-  acknowledgeStop() {
-    this.workerState.transitionTo("stopping" /* Stopping */);
-    if (!this.workerRow) {
-      throw new Error("Cannot stop worker: workerRow not set");
-    }
-    try {
-      this.logger.debug("Acknowledging worker stop...");
-      this.workerState.transitionTo("stopped" /* Stopped */);
-      this.logger.debug("Worker stop acknowledged");
-    } catch (error) {
-      this.logger.debug(`Error acknowledging worker stop: ${error}`);
-      throw error;
-    }
-  }
-  get edgeFunctionName() {
-    return this.workerRow?.function_name;
-  }
-  get queueName() {
-    return this.queue.queueName;
-  }
-  async sendHeartbeat() {
-    await this.heartbeat?.send();
-  }
-  get isRunning() {
-    return this.workerState.isRunning;
-  }
-  get isStopping() {
-    return this.workerState.isStopping;
-  }
-  get isStopped() {
-    return this.workerState.isStopped;
-  }
-  transitionToStopping() {
-    this.workerState.transitionTo("stopping" /* Stopping */);
-  }
-};
-
-// ../edge-worker/src/core/BatchProcessor.ts
-var BatchProcessor = class {
-  constructor(executionController, poller, signal) {
-    this.executionController = executionController;
-    this.poller = poller;
-    this.signal = signal;
-    this.logger = getLogger("BatchProcessor");
-    this.executionController = executionController;
-    this.signal = signal;
-    this.poller = poller;
-  }
-  async processBatch() {
-    this.logger.debug("Polling for new batch of messages...");
-    const messageRecords = await this.poller.poll();
-    if (this.signal.aborted) {
-      this.logger.info("Discarding messageRecords because worker is stopping");
-      return;
-    }
-    this.logger.debug(`Starting ${messageRecords.length} messages`);
-    const startPromises = messageRecords.map(
-      (message) => this.executionController.start(message)
-    );
-    await Promise.all(startPromises);
-  }
-  async awaitCompletion() {
-    return await this.executionController.awaitCompletion();
-  }
-};
-
-// ../edge-worker/src/queue/createQueueWorker.ts
-function createQueueWorker(handler, config) {
-  const abortController = new AbortController();
-  const abortSignal = abortController.signal;
-  const sql = config.sql || postgres(config.connectionString || "", {
-    max: config.maxPgConnections,
-    prepare: false
-  });
-  const queue = new Queue(sql, config.queueName || "tasks");
-  const queries = new Queries(sql);
-  const lifecycle = new WorkerLifecycle(queries, queue);
-  const executorFactory = (record, signal) => {
-    return new MessageExecutor(
-      queue,
-      record,
-      handler,
-      signal,
-      config.retryLimit || 5,
-      config.retryDelay || 3
-    );
-  };
-  const poller = new ReadWithPollPoller(queue, abortSignal, {
-    batchSize: config.batchSize || config.maxConcurrent || 10,
-    maxPollSeconds: config.maxPollSeconds || 5,
-    pollIntervalMs: config.pollIntervalMs || 200,
-    visibilityTimeout: config.visibilityTimeout || 3
-  });
-  const executionController = new ExecutionController(
-    executorFactory,
-    abortSignal,
-    {
-      maxConcurrent: config.maxConcurrent || 10
-    }
-  );
-  const batchProcessor = new BatchProcessor(
-    executionController,
-    poller,
-    abortSignal
-  );
-  return new Worker(batchProcessor, lifecycle, sql);
-}
-
-// ../edge-worker/src/spawnNewEdgeFunction.ts
-var SUPABASE_URL = Deno.env.get("SUPABASE_URL");
-var SUPABASE_ANON_KEY = Deno.env.get("SUPABASE_ANON_KEY");
-var logger = getLogger("spawnNewEdgeFunction");
-async function spawnNewEdgeFunction(functionName = "edge-worker") {
-  if (!functionName) {
-    throw new Error("functionName cannot be null or empty");
-  }
-  logger.debug("Spawning a new Edge Function...");
-  const response = await fetch(`${SUPABASE_URL}/functions/v1/${functionName}`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${SUPABASE_ANON_KEY}`,
-      "Content-Type": "application/json"
-    }
-  });
-  logger.debug("Edge Function spawned successfully!");
-  if (!response.ok) {
-    throw new Error(
-      `Edge function returned non-OK status: ${response.status} ${response.statusText}`
-    );
-  }
-}
-
-// ../edge-worker/src/EdgeWorker.ts
-var EdgeWorker = class {
-  static {
-    this.logger = getLogger("EdgeWorker");
-  }
-  static {
-    this.wasCalled = false;
-  }
-  /**
-   * Start the EdgeWorker with the given message handler and configuration.
-   *
-   * @param handler - Function that processes each message from the queue
-   * @param config - Configuration options for the worker
-   *
-   * @example
-   * ```typescript
-   * EdgeWorker.start(handler, {
-   *   // name of the queue to poll for messages
-   *   queueName: 'tasks',
-   *
-   *   // how many tasks are processed at the same time
-   *   maxConcurrent: 10,
-   *
-   *   // how many connections to the database are opened
-   *   maxPgConnections: 4,
-   *
-   *   // in-worker polling interval
-   *   maxPollSeconds: 5,
-   *
-   *   // in-database polling interval
-   *   pollIntervalMs: 200,
-   *
-   *   // how long to wait before retrying a failed job
-   *   retryDelay: 5,
-   *
-   *   // how many times to retry a failed job
-   *   retryLimit: 5,
-   *
-   *   // how long a job is invisible after reading
-   *   // if not successful, will reappear after this time
-   *   visibilityTimeout: 3,
-   * });
-   * ```
-   */
-  static start(handler, config = {}) {
-    this.ensureFirstCall();
-    const connectionString = config.connectionString || this.getConnectionString();
-    const completeConfig = {
-      // Pass through any config options first
-      ...config,
-      // Then override with defaults for missing values
-      queueName: config.queueName || "tasks",
-      maxConcurrent: config.maxConcurrent ?? 10,
-      maxPgConnections: config.maxPgConnections ?? 4,
-      maxPollSeconds: config.maxPollSeconds ?? 5,
-      pollIntervalMs: config.pollIntervalMs ?? 200,
-      retryDelay: config.retryDelay ?? 5,
-      retryLimit: config.retryLimit ?? 5,
-      visibilityTimeout: config.visibilityTimeout ?? 3,
-      // Ensure connectionString is always set
-      connectionString
-    };
-    this.setupRequestHandler(handler, completeConfig);
-  }
-  static ensureFirstCall() {
-    if (this.wasCalled) {
-      throw new Error("EdgeWorker.start() can only be called once");
-    }
-    this.wasCalled = true;
-  }
-  static getConnectionString() {
-    const connectionString = Deno.env.get("EDGE_WORKER_DB_URL");
-    if (!connectionString) {
-      const message = "EDGE_WORKER_DB_URL is not set!\nSee https://pgflow.pages.dev/edge-worker/prepare-environment/#prepare-connection-string";
-      throw new Error(message);
-    }
-    return connectionString;
-  }
-  static setupShutdownHandler(worker) {
-    globalThis.onbeforeunload = async () => {
-      if (worker.edgeFunctionName) {
-        await spawnNewEdgeFunction(worker.edgeFunctionName);
-      }
-      worker.stop();
-    };
-    EdgeRuntime.waitUntil(new Promise(() => {
-    }));
-  }
-  static setupRequestHandler(handler, workerConfig) {
-    let worker = null;
-    Deno.serve({}, (req) => {
-      if (!worker) {
-        const edgeFunctionName = this.extractFunctionName(req);
-        const sbExecutionId = Deno.env.get("SB_EXECUTION_ID");
-        setupLogger(sbExecutionId);
-        this.logger.info(`HTTP Request: ${edgeFunctionName}`);
-        worker = createQueueWorker(handler, workerConfig);
-        worker.startOnlyOnce({
-          edgeFunctionName,
-          workerId: sbExecutionId
-        });
-        this.setupShutdownHandler(worker);
-      }
-      return new Response("ok", {
-        headers: { "Content-Type": "application/json" }
-      });
-    });
-  }
-  static extractFunctionName(req) {
-    return new URL(req.url).pathname.replace(/^\/+|\/+$/g, "");
-  }
-};
-
-// ../edge-worker/src/flow/StepTaskPoller.ts
-var StepTaskPoller = class {
-  constructor(adapter, signal, config) {
-    this.adapter = adapter;
-    this.signal = signal;
-    this.config = config;
-    this.logger = getLogger("StepTaskPoller");
-  }
-  async poll() {
-    if (this.isAborted()) {
-      this.logger.debug("Polling aborted, returning empty array");
-      return [];
-    }
-    this.logger.debug(
-      `Polling for flow tasks with batch size ${this.config.batchSize}`
-    );
-    try {
-      const tasks = await this.adapter.pollForTasks(
-        this.config.queueName,
-        this.config.batchSize
-      );
-      this.logger.debug(`Retrieved ${tasks.length} flow tasks`);
-      return tasks;
-    } catch (err) {
-      this.logger.error(`Error polling for flow tasks: ${err}`);
-      return [];
-    }
-  }
-  isAborted() {
-    return this.signal.aborted;
-  }
-};
-
-// ../edge-worker/src/flow/StepTaskExecutor.ts
-var AbortError2 = class extends Error {
-  constructor() {
-    super("Operation aborted");
-    this.name = "AbortError";
-  }
-};
-var StepTaskExecutor = class {
-  constructor(flow, task, adapter, signal) {
-    this.flow = flow;
-    this.task = task;
-    this.adapter = adapter;
-    this.signal = signal;
-    this.logger = getLogger("StepTaskExecutor");
-  }
-  get msgId() {
-    return this.task.msg_id;
-  }
-  async execute() {
-    try {
-      if (this.signal.aborted) {
-        throw new AbortError2();
-      }
-      this.signal.throwIfAborted();
-      const stepSlug = this.task.step_slug;
-      this.logger.debug(
-        `Executing step task ${this.task.msg_id} for step ${stepSlug}`
-      );
-      const stepDef = this.flow.getStepDefinition(stepSlug);
-      if (!stepDef) {
-        throw new Error(`No step definition found for slug=${stepSlug}`);
-      }
-      const result = await stepDef.handler(this.task.input);
-      this.logger.debug(
-        `step task ${this.task.msg_id} completed successfully, marking as complete`
-      );
-      await this.adapter.completeTask(this.task, result);
-      this.logger.debug(`step task ${this.task.msg_id} marked as complete`);
-    } catch (error) {
-      await this.handleExecutionError(error);
-    }
-  }
-  /**
-   * Handles the error that occurred during execution.
-   *
-   * If the error is an AbortError, it means that the worker was aborted and stopping,
-   * the task will be picked up by another worker later.
-   *
-   * Otherwise, it marks the task as failed.
-   */
-  async handleExecutionError(error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      this.logger.debug(`Aborted execution for step task ${this.task.msg_id}`);
-    } else {
-      this.logger.error(
-        `step task ${this.task.msg_id} failed with error: ${error}`
-      );
-      await this.adapter.failTask(this.task, error);
-    }
-  }
-};
-
-// src/PgflowSqlClient.ts
-var PgflowSqlClient = class {
-  constructor(sql) {
-    this.sql = sql;
-  }
-  async pollForTasks(queueName, batchSize = 20, visibilityTimeout = 2, maxPollSeconds = 5, pollIntervalMs = 200) {
-    return await this.sql`
-      SELECT *
-      FROM pgflow.poll_for_tasks(
-        queue_name => ${queueName},
-        vt => ${visibilityTimeout},
-        qty => ${batchSize},
-        max_poll_seconds => ${maxPollSeconds},
-        poll_interval_ms => ${pollIntervalMs}
-      );
-    `;
-  }
-  async completeTask(stepTask, output) {
-    await this.sql`
-      SELECT pgflow.complete_task(
-        run_id => ${stepTask.run_id}::uuid,
-        step_slug => ${stepTask.step_slug}::text,
-        task_index => ${0}::int,
-        output => ${this.sql.json(output || null)}::jsonb
-      );
-    `;
-  }
-  async failTask(stepTask, error) {
-    const errorString = typeof error === "string" ? error : error instanceof Error ? error.message : JSON.stringify(error);
-    await this.sql`
-      SELECT pgflow.fail_task(
-        run_id => ${stepTask.run_id}::uuid,
-        step_slug => ${stepTask.step_slug}::text,
-        task_index => ${0}::int,
-        error_message => ${errorString}::text
-      );
-    `;
-  }
-  async startFlow(flow, input) {
-    const results = await this.sql`
-      SELECT * FROM pgflow.start_flow(${flow.slug}::text, ${this.sql.json(
-      input
-    )}::jsonb);
-    `;
-    if (results.length === 0) {
-      throw new Error(`Failed to start flow ${flow.slug}`);
-    }
-    const [flowRun] = results;
-    return flowRun;
-  }
-};
-
-// ../edge-worker/src/flow/createFlowWorker.ts
-import postgres2 from "postgres";
-
-// ../edge-worker/src/flow/FlowWorkerLifecycle.ts
-var FlowWorkerLifecycle = class {
-  constructor(queries, flow) {
-    this.workerState = new WorkerState();
-    this.logger = getLogger("FlowWorkerLifecycle");
-    this.queries = queries;
-    this.flow = flow;
-  }
-  async acknowledgeStart(workerBootstrap) {
-    this.workerState.transitionTo("starting" /* Starting */);
-    this.workerRow = await this.queries.onWorkerStarted({
-      queueName: this.queueName,
-      ...workerBootstrap
-    });
-    this.heartbeat = new Heartbeat(5e3, this.queries, this.workerRow);
-    this.workerState.transitionTo("running" /* Running */);
-  }
-  acknowledgeStop() {
-    this.workerState.transitionTo("stopping" /* Stopping */);
-    if (!this.workerRow) {
-      throw new Error("Cannot stop worker: workerRow not set");
-    }
-    try {
-      this.logger.debug("Acknowledging worker stop...");
-      this.workerState.transitionTo("stopped" /* Stopped */);
-      this.logger.debug("Worker stop acknowledged");
-    } catch (error) {
-      this.logger.debug(`Error acknowledging worker stop: ${error}`);
-      throw error;
-    }
-  }
-  get edgeFunctionName() {
-    return this.workerRow?.function_name;
-  }
-  get queueName() {
-    return this.flow.slug;
-  }
-  async sendHeartbeat() {
-    await this.heartbeat?.send();
-  }
-  get isRunning() {
-    return this.workerState.isRunning;
-  }
-  get isStopping() {
-    return this.workerState.isStopping;
-  }
-  get isStopped() {
-    return this.workerState.isStopped;
-  }
-  transitionToStopping() {
-    this.workerState.transitionTo("stopping" /* Stopping */);
-  }
-};
-
-// ../edge-worker/src/flow/createFlowWorker.ts
-function createFlowWorker(flow, config) {
-  const logger2 = getLogger("createFlowWorker");
-  const abortController = new AbortController();
-  const abortSignal = abortController.signal;
-  if (!config.sql && !config.connectionString) {
-    throw new Error(
-      "Either 'sql' or 'connectionString' must be provided in FlowWorkerConfig."
-    );
-  }
-  const sql = config.sql || postgres2(config.connectionString, {
-    max: config.maxPgConnections,
-    prepare: false
-  });
-  const pgflowAdapter = new PgflowSqlClient(sql);
-  const queueName = flow.slug || "tasks";
-  logger2.debug(`Using queue name: ${queueName}`);
-  const queries = new Queries(sql);
-  const lifecycle = new FlowWorkerLifecycle(queries, flow);
-  const pollerConfig = {
-    batchSize: config.batchSize || 10,
-    queueName: flow.slug
-  };
-  const poller = new StepTaskPoller(
-    pgflowAdapter,
-    abortSignal,
-    pollerConfig
-  );
-  const executorFactory = (record, signal) => {
-    return new StepTaskExecutor(flow, record, pgflowAdapter, signal);
-  };
-  const executionController = new ExecutionController(
-    executorFactory,
-    abortSignal,
-    {
-      maxConcurrent: config.maxConcurrent || 10
-    }
-  );
-  const batchProcessor = new BatchProcessor(
-    executionController,
-    poller,
-    abortSignal
-  );
-  return new Worker(batchProcessor, lifecycle, sql);
-}
-export {
-  EdgeWorker,
-  FlowWorkerLifecycle,
-  createFlowWorker,
-  createQueueWorker
-};
-//# sourceMappingURL=index.js.map