@pgflow/edge-worker 0.0.5 → 0.0.7-prealpha.1

package/pkgs/edge-worker/dist/pkgs/edge-worker/README.md

@@ -1,46 +0,0 @@
-<div align="center">
-  <h1>Edge Worker</h1>
-  <a href="https://pgflow.dev">
-    <h3>📚 Documentation @ pgflow.dev</h3>
-  </a>
-  
-  <h4>⚠️ <strong>ADVANCED PROOF of CONCEPT - NOT PRODUCTION READY</strong> ⚠️</h4>
-</div>
-
-A task queue worker for Supabase Edge Functions that extends background tasks with useful features.
-
-> [!NOTE]
-> This project is licensed under [AGPL v3](./LICENSE.md) license and is part of **pgflow** stack.
-> See [LICENSING_OVERVIEW.md](../../LICENSING_OVERVIEW.md) in root of this monorepo for more details.
-
-## What is Edge Worker?
-
-Edge Worker processes messages from a queue and executes user-defined functions with their payloads. It builds upon [Supabase Background Tasks](https://supabase.com/docs/guides/functions/background-tasks) to add reliability features like retries, concurrency control and monitoring.
-
-## Key Features
-
-- ⚡ **Reliable Processing**: Retries with configurable delays
-- 🔄 **Concurrency Control**: Limit parallel task execution
-- 📊 **Observability**: Built-in heartbeats and logging
-- 📈 **Horizontal Scaling**: Deploy multiple edge functions for the same queue
-- 🛡️ **Edge-Native**: Designed for Edge Functions' CPU/clock limits
-
-## How It Works
-
-[![Architecture Diagram](https://mermaid.ink/img/pako:eNplkcFugzAMhl8lyrl9AQ47VLBxqdSqlZAGHEziASokyEkmTaXvvoR0o1VziGL_n_9Y9pULLZEnvFItwdSxc1op5o9xTUxU_OQmaMAgy2SL7N0pYXutTMUjGU5WlItYaLog1VFAJSv14paCXdweyw8f-2MZLnZ06LBelXxXRk_DztAM-Gp9KA-kpRP-W7bdvs3Ga4aNaAy0OC_WdzD4B4IQVsLMvvkIZMUiA4mu_8ZHYjW5MxNp4dUnKC9zUHJA-h9R_VQTG-sQyDYINlTs-IaPSCP00q_gGvCK2w5HP53EPyXQJczp5jlwVp9-lOCJJYcbTtq13V_gJgkW0x78lEeefMFgfHYC9an1GqPsraZ9XPiy99svlAqmtA?type=png)](https://mermaid.live/edit#pako:eNplkcFugzAMhl8lyrl9AQ47VLBxqdSqlZAGHEziASokyEkmTaXvvoR0o1VziGL_n_9Y9pULLZEnvFItwdSxc1op5o9xTUxU_OQmaMAgy2SL7N0pYXutTMUjGU5WlItYaLog1VFAJSv14paCXdweyw8f-2MZLnZ06LBelXxXRk_DztAM-Gp9KA-kpRP-W7bdvs3Ga4aNaAy0OC_WdzD4B4IQVsLMvvkIZMUiA4mu_8ZHYjW5MxNp4dUnKC9zUHJA-h9R_VQTG-sQyDYINlTs-IaPSCP00q_gGvCK2w5HP53EPyXQJczp5jlwVp9-lOCJJYcbTtq13V_gJgkW0x78lEeefMFgfHYC9an1GqPsraZ9XPiy99svlAqmtA)
-
-## Edge Function Optimization
-
-Edge Worker is specifically designed to handle Edge Function limitations:
-
-- Stops polling near CPU/clock limits
-- Gracefully aborts pending tasks
-- Uses PGMQ's visibility timeout to prevent message loss
-- Auto-spawns new instances for continuous operation
-- Monitors worker health with database heartbeats
-
-
-## Documentation
-
-For detailed documentation and getting started guide, visit [pgflow.dev](https://pgflow.dev).
-

package/project.json

@@ -1,164 +0,0 @@
-{
-  "name": "edge-worker",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "pkgs/edge-worker",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "pkgs/edge-worker/dist",
-        "main": "pkgs/edge-worker/src/index.ts",
-        "tsConfig": "pkgs/edge-worker/tsconfig.lib.json",
-        "platform": "node",
-        "format": ["esm"],
-        "assets": ["pkgs/edge-worker/*.md"],
-        "external": ["@jsr/*", "postgres"],
-        "bundle": true,
-        "sourcemap": true
-      }
-    },
-    "test:nx-deno": {
-      "executor": "@axhxrx/nx-deno:test",
-      "outputs": ["{workspaceRoot}/coverage/pkgs/edge-worker"],
-      "options": {
-        "coverageDirectory": "coverage/pkgs/edge-worker",
-        "denoConfig": "pkgs/edge-worker/deno.json",
-        "allowNone": false,
-        "check": "local"
-      }
-    },
-    "lint": {
-      "executor": "@axhxrx/nx-deno:lint",
-      "options": {
-        "denoConfig": "pkgs/edge-worker/deno.json",
-        "ignore": "pkgs/edge-worker/supabase/functions/_src/"
-      }
-    },
-    "supabase:start": {
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": ["supabase start"],
-        "parallel": false
-      }
-    },
-    "supabase:stop": {
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": ["supabase stop --no-backup"],
-        "parallel": false
-      }
-    },
-    "supabase:status": {
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": ["supabase status"],
-        "parallel": false
-      }
-    },
-    "supabase:restart": {
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": ["supabase stop --no-backup", "supabase start"],
-        "parallel": false
-      }
-    },
-    "supabase:reset": {
-      "dependsOn": ["supabase:prepare"],
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": [
-          "rm -f supabase/migrations/*.sql",
-          "cp ../core/supabase/migrations/*.sql supabase/migrations/",
-          "cp sql/*_*.sql supabase/migrations/",
-          "supabase db reset"
-        ],
-        "parallel": false
-      }
-    },
-    "supabase:prepare-edge-fn": {
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": [
-          "rm -f supabase/functions/_src/*.ts",
-          "rm -f supabase/functions/_src/deno.*",
-          "cp -r src/* ./supabase/functions/_src/",
-          "cp deno.* ./supabase/functions/_src/",
-          "find supabase/functions -maxdepth 1 -mindepth 1 -type d -not -name '_src' -exec cp deno.* {} \\;"
-        ],
-        "parallel": false
-      }
-    },
-    "supabase:functions-serve": {
-      "dependsOn": ["supabase:start", "supabase:prepare-edge-fn"],
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": [
-          "supabase functions serve --env-file supabase/functions/.env"
-        ],
-        "parallel": false
-      }
-    },
-    "db:ensure": {
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": ["deno task db:ensure"],
-        "parallel": false
-      }
-    },
-    "test:unit": {
-      "dependsOn": ["db:ensure"],
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": [
-          "deno test --allow-all --env=supabase/functions/.env tests/unit/"
-        ],
-        "parallel": false
-      }
-    },
-    "test:integration": {
-      "dependsOn": ["db:ensure"],
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": [
-          "deno test --allow-all --env=supabase/functions/.env tests/integration/"
-        ],
-        "parallel": false
-      }
-    },
-    "test:e2e": {
-      "dependsOn": ["supabase:prepare-edge-fn"],
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": [
-          "deno test --allow-all --env=supabase/functions/.env tests/e2e/"
-        ],
-        "parallel": false
-      }
-    },
-    "test": {
-      "dependsOn": ["test:unit", "test:integration"]
-    },
-    "jsr:publish": {
-      "executor": "nx:run-commands",
-      "options": {
-        "cwd": "pkgs/edge-worker",
-        "commands": ["pnpm dlx jsr publish --allow-slow-types"],
-        "parallel": false
-      }
-    }
-  },
-  "tags": []
-}

package/scripts/concatenate-migrations.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-# Create or clear the target file
-target_file="./tests/db/migrations/edge_worker.sql"
-mkdir -p $(dirname "$target_file")
-echo "-- Combined migrations file" > "$target_file"
-echo "-- Generated on $(date)" >> "$target_file"
-echo "" >> "$target_file"
-
-# Also add core migrations
-for f in $(find ../core/supabase/migrations -name '*.sql' | sort); do
-  echo "-- From file: $(basename $f)" >> "$target_file"
-  cat "$f" >> "$target_file"
-  echo "" >> "$target_file"
-  echo "" >> "$target_file"
-done
-
-# And copy the pgflow_tests
-echo "-- From file: seed.sql" >> "$target_file"
-cat "../core/supabase/seed.sql" >> "$target_file"
-echo "" >> "$target_file"
-echo "" >> "$target_file"

package/scripts/wait-for-localhost

@@ -1,17 +0,0 @@
-#!/bin/bash
-port_number=$1
-
-# exit if port is not provided
-if [ -z "$port_number" ]; then
-  echo "Port number is not provided"
-  exit 1
-fi
-
-echo "Waiting for localhost:$port_number..."
-
-until nc -z localhost "$port_number" 2>/dev/null; do
-  echo -n "."
-  sleep 0.1
-done
-
-echo -e "\nPort $port_number is available!"

package/sql/990_active_workers.sql

@@ -1,11 +0,0 @@
--- Active workers are workers that have sent a heartbeat in the last 6 seconds
-create or replace view edge_worker.active_workers as
-select
-    worker_id,
-    queue_name,
-    function_name,
-    started_at,
-    stopped_at,
-    last_heartbeat_at
-from edge_worker.workers
-where last_heartbeat_at > now() - make_interval(secs => 6);

package/sql/991_inactive_workers.sql

@@ -1,12 +0,0 @@
--- Inactive workers are workers that have not sent 
--- a heartbeat in the last 6 seconds
-create or replace view edge_worker.inactive_workers as
-select
-    worker_id,
-    queue_name,
-    function_name,
-    started_at,
-    stopped_at,
-    last_heartbeat_at
-from edge_worker.workers
-where last_heartbeat_at < now() - make_interval(secs => 6);

package/sql/992_spawn_worker.sql

@@ -1,68 +0,0 @@
-create extension if not exists pg_net;
-
--- Calls edge function asynchronously, requires Vault secrets to be set:
---   - supabase_anon_key
---   - app_url 
-create or replace function edge_worker.call_edgefn_async(
-    function_name text,
-    body text
-)
-returns bigint
-language plpgsql
-volatile
-set search_path to edge_worker
-as $$
-declare
-    request_id bigint;
-begin
-    IF function_name IS NULL OR function_name = '' THEN
-        raise exception 'function_name cannot be null or empty';
-    END IF;
-
-    WITH secret as (
-        select decrypted_secret AS supabase_anon_key
-        from vault.decrypted_secrets
-        where name = 'supabase_anon_key'
-    ),
-    settings AS (
-        select decrypted_secret AS app_url
-        from vault.decrypted_secrets
-        where name = 'app_url'
-    )
-    select net.http_post(
-        url => (select app_url from settings) || '/functions/v1/' || function_name,
-        body => jsonb_build_object('body', body),
-        headers := jsonb_build_object(
-            'Authorization', 'Bearer ' || (select supabase_anon_key from secret)
-        )
-    ) into request_id;
-
-    return request_id;
-end;
-$$;
-
--- Spawn a new worker asynchronously via edge function
--- 
--- It is intended to be used in a cron job that ensures continuos operation
-create or replace function edge_worker.spawn(
-    function_name text
-) returns integer as $$
-declare
-    p_function_name text := function_name;
-    v_active_count integer;
-begin
-    SELECT COUNT(*)
-    INTO v_active_count
-    FROM edge_worker.active_workers AS aw
-    WHERE aw.function_name = p_function_name;
-
-    IF v_active_count < 1 THEN
-        raise notice 'Spawning new worker: %', p_function_name;
-        PERFORM edge_worker.call_edgefn_async(p_function_name, '');
-        return 1;
-    ELSE
-        raise notice 'Worker Exists for queue: NOT spawning new worker for queue: %', p_function_name;
-        return 0;
-    END IF;
-end;
-$$ language plpgsql;

package/sql/benchmarks/max_concurrency.sql

@@ -1,32 +0,0 @@
--- select * from pgmq.create('max_concurrency');
--- select * from pgmq.drop_queue('max_concurrency');
-WITH 
-params AS (
-  SELECT 
-    2000000 as msg_count,
-    1000 as batch_size
-),
-batch_nums AS (
-  SELECT generate_series(0, msg_count/batch_size - 1) as batch_num
-  FROM params
-),
-batch_ranges AS (
-  SELECT 
-    batch_num,
-    batch_num * batch_size + 1 as start_id,
-    (batch_num + 1) * batch_size as end_id
-  FROM batch_nums
-  CROSS JOIN params
-),
-batches AS (
-  SELECT 
-    batch_num,
-    array_agg(jsonb_build_object('id', i)) as msg_array
-  FROM batch_ranges,
-       generate_series(start_id, end_id) i
-  GROUP BY batch_num
-)
-SELECT pgmq.send_batch('max_concurrency', msg_array)
-FROM batches
-ORDER BY batch_num;
-

package/sql/queries/debug_processing_gaps.sql

@@ -1,115 +0,0 @@
--- select count(*) from pgmq.a_max_concurrency;
--- select read_ct, count(*) from pgmq.q_max_concurrency group by read_ct;
-select read_ct - 1 as retries_count, count(*) 
-from pgmq.a_max_concurrency group by read_ct order by read_ct;
-
-select * from pgmq.metrics('max_concurrency');
-
-select * from pgmq.a_max_concurrency limit 10;
-select EXTRACT(EPOCH FROM (max(archived_at) - min(enqueued_at))) as total_seconds from pgmq.a_max_concurrency;
-
--- Processing time ranges per read_ct
-SELECT 
-    read_ct - 1 as retry_count,
-    COUNT(*) as messages,
-    round(avg(EXTRACT(EPOCH FROM (vt - make_interval(secs => 3) - enqueued_at))), 2) as avg_s,
-    round(min(EXTRACT(EPOCH FROM (vt - make_interval(secs => 3) - enqueued_at))), 2) as min_s,
-    round(max(EXTRACT(EPOCH FROM (vt - make_interval(secs => 3) - enqueued_at))), 2) as max_s
-FROM pgmq.a_max_concurrency 
-GROUP BY read_ct 
-ORDER BY read_ct;
-
--- Processing time percentiles
-WITH processing_times AS (
-    SELECT archived_at - (vt - make_interval(secs=>3)) as processing_time
-    FROM pgmq.a_max_concurrency
-)
-SELECT 
-    ROUND(EXTRACT(epoch FROM percentile_cont(0.50) WITHIN GROUP (ORDER BY processing_time)) * 1000) as p50_ms,
-    ROUND(EXTRACT(epoch FROM percentile_cont(0.75) WITHIN GROUP (ORDER BY processing_time)) * 1000) as p75_ms,
-    ROUND(EXTRACT(epoch FROM percentile_cont(0.90) WITHIN GROUP (ORDER BY processing_time)) * 1000) as p90_ms,
-    ROUND(EXTRACT(epoch FROM percentile_cont(0.95) WITHIN GROUP (ORDER BY processing_time)) * 1000) as p95_ms,
-    ROUND(EXTRACT(epoch FROM percentile_cont(0.99) WITHIN GROUP (ORDER BY processing_time)) * 1000) as p99_ms,
-    ROUND(EXTRACT(epoch FROM MIN(processing_time)) * 1000) as min_ms,
-    ROUND(EXTRACT(epoch FROM MAX(processing_time)) * 1000) as max_ms
-FROM processing_times;
-
--- Total processing time for messages with read_ct 1 or 2
-SELECT 
-    round(sum(EXTRACT(EPOCH FROM (archived_at - enqueued_at))), 2) as total_processing_seconds
-FROM pgmq.a_max_concurrency 
-WHERE read_ct IN (1, 2);
-
--- Distribution of processing times in configurable intervals
-WITH 
-interval_conf AS (
-    SELECT 1 as interval_seconds
-),
-processing_times AS (
-    SELECT 
-        EXTRACT(EPOCH FROM (archived_at - enqueued_at)) as seconds
-    FROM pgmq.a_max_concurrency
-)
-SELECT 
-    ((floor(seconds / interval_seconds) * interval_seconds) || '-' || 
-     (floor(seconds / interval_seconds) * interval_seconds + interval_seconds) || 's')::text as time_bucket,
-    COUNT(*) as message_count,
-    round((COUNT(*)::numeric / interval_seconds), 1) as messages_per_second,
-    SUM(COUNT(*)) OVER (ORDER BY floor(seconds / interval_seconds)) as total_processed_so_far
-FROM processing_times, interval_conf
-GROUP BY floor(seconds / interval_seconds), interval_seconds
-ORDER BY floor(seconds / interval_seconds);
-
-
--- First let's check the raw distribution
-WITH processing_times AS (
-    SELECT 
-        EXTRACT(EPOCH FROM (archived_at - enqueued_at)) as seconds
-    FROM pgmq.a_max_concurrency
-)
-SELECT 
-    floor(seconds) as seconds,
-    COUNT(*) as message_count
-FROM processing_times
-WHERE seconds BETWEEN 165 AND 381
-GROUP BY floor(seconds)
-ORDER BY floor(seconds);
-
-
--- Examine messages around the gap
-WITH processing_times AS (
-    SELECT 
-        msg_id,
-        enqueued_at,
-        archived_at,
-        EXTRACT(EPOCH FROM (archived_at - enqueued_at)) as processing_time,
-        read_ct
-    FROM pgmq.a_max_concurrency
-)
-SELECT 
-    msg_id,
-    enqueued_at,
-    archived_at,
-    round(processing_time::numeric, 2) as processing_seconds,
-    read_ct
-FROM processing_times
-WHERE 
-    processing_time BETWEEN 164 AND 380
-ORDER BY processing_time;
-
--- Show processing time distribution by retry count
-WITH processing_times AS (
-    SELECT 
-        EXTRACT(EPOCH FROM (archived_at - enqueued_at)) as processing_time,
-        read_ct,
-        width_bucket(EXTRACT(EPOCH FROM (archived_at - enqueued_at)), 0, 400, 20) as time_bucket
-    FROM pgmq.a_max_concurrency
-)
-SELECT 
-    ((time_bucket - 1) * 20) || '-' || (time_bucket * 20) || 's' as time_range,
-    read_ct,
-    COUNT(*) as message_count
-FROM processing_times
-GROUP BY time_bucket, read_ct
-ORDER BY time_bucket, read_ct;
-

package/src/EdgeWorker.ts

@@ -1,172 +0,0 @@
-import type { Worker } from './core/Worker.ts';
-import spawnNewEdgeFunction from './spawnNewEdgeFunction.ts';
-import type { Json } from './core/types.ts';
-import { getLogger, setupLogger } from './core/Logger.ts';
-import {
-  createQueueWorker,
-  type QueueWorkerConfig,
-} from './queue/createQueueWorker.ts';
-
-/**
- * Configuration options for the EdgeWorker.
- */
-export type EdgeWorkerConfig = QueueWorkerConfig;
-
-/**
- * EdgeWorker is the main entry point for creating and starting edge workers.
- *
- * It provides a simple interface for starting a worker that processes messages from a queue.
- *
- * @example
- * ```typescript
- * import { EdgeWorker } from '@pgflow/edge-worker';
- *
- * EdgeWorker.start(async (message) => {
- *   // Process the message
- *   console.log('Processing message:', message);
- * }, {
- *   queueName: 'my-queue',
- *   maxConcurrent: 5,
- *   retryLimit: 3
- * });
- * ```
- */
-export class EdgeWorker {
-  private static logger = getLogger('EdgeWorker');
-  private static 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<TPayload extends Json = Json>(
-    handler: (message: TPayload) => Promise<void> | void,
-    config: EdgeWorkerConfig = {}
-  ) {
-    this.ensureFirstCall();
-
-    // Get connection string from config or environment
-    const connectionString =
-      config.connectionString || this.getConnectionString();
-
-    // Create a complete configuration object with defaults
-    const completeConfig: EdgeWorkerConfig = {
-      // 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);
-  }
-
-  private static ensureFirstCall() {
-    if (this.wasCalled) {
-      throw new Error('EdgeWorker.start() can only be called once');
-    }
-    this.wasCalled = true;
-  }
-
-  private static getConnectionString(): string {
-    // @ts-ignore - TODO: fix the types
-    const connectionString = Deno.env.get('EDGE_WORKER_DB_URL');
-    if (!connectionString) {
-      const message =
-        'EDGE_WORKER_DB_URL is not set!\n' +
-        'See https://pgflow.pages.dev/edge-worker/prepare-environment/#prepare-connection-string';
-      throw new Error(message);
-    }
-    return connectionString;
-  }
-
-  private static setupShutdownHandler(worker: Worker) {
-    globalThis.onbeforeunload = async () => {
-      if (worker.edgeFunctionName) {
-        await spawnNewEdgeFunction(worker.edgeFunctionName);
-      }
-
-      worker.stop();
-    };
-
-    // use waitUntil to prevent the function from exiting
-    // @ts-ignore: TODO: fix the types
-    EdgeRuntime.waitUntil(new Promise(() => {}));
-  }
-
-  private static setupRequestHandler<TPayload extends Json>(
-    handler: (message: TPayload) => Promise<void> | void,
-    workerConfig: EdgeWorkerConfig
-  ) {
-    let worker: Worker | null = 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}`);
-        // Create the worker with all configuration options
-
-        worker = createQueueWorker(handler, workerConfig);
-        worker.startOnlyOnce({
-          edgeFunctionName,
-          workerId: sbExecutionId,
-        });
-
-        this.setupShutdownHandler(worker);
-      }
-
-      return new Response('ok', {
-        headers: { 'Content-Type': 'application/json' },
-      });
-    });
-  }
-
-  private static extractFunctionName(req: Request): string {
-    return new URL(req.url).pathname.replace(/^\/+|\/+$/g, '');
-  }
-}