@pgflow/edge-worker 0.0.21 → 0.0.23

package/dist/flow/FlowWorkerLifecycle.js

@@ -0,0 +1,64 @@
+import { Heartbeat } from '../core/Heartbeat.js';
+import { States, WorkerState } from '../core/WorkerState.js';
+/**
+ * A specialized WorkerLifecycle for Flow-based workers that is aware of the Flow's step types
+ */
+export class FlowWorkerLifecycle {
+    workerState;
+    heartbeat;
+    logger;
+    queries;
+    workerRow;
+    flow;
+    constructor(queries, flow, logger) {
+        this.queries = queries;
+        this.flow = flow;
+        this.logger = logger;
+        this.workerState = new WorkerState(logger);
+    }
+    async acknowledgeStart(workerBootstrap) {
+        this.workerState.transitionTo(States.Starting);
+        this.workerRow = await this.queries.onWorkerStarted({
+            queueName: this.queueName,
+            ...workerBootstrap,
+        });
+        this.heartbeat = new Heartbeat(5000, this.queries, this.workerRow, this.logger);
+        this.workerState.transitionTo(States.Running);
+    }
+    acknowledgeStop() {
+        this.workerState.transitionTo(States.Stopping);
+        if (!this.workerRow) {
+            throw new Error('Cannot stop worker: workerRow not set');
+        }
+        try {
+            this.logger.debug('Acknowledging worker stop...');
+            this.workerState.transitionTo(States.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(States.Stopping);
+    }
+}

package/dist/flow/StepTaskExecutor.d.ts

@@ -0,0 +1,28 @@
+import type { AnyFlow } from '@pgflow/dsl';
+import type { StepTaskRecord, IPgflowClient } from './types.js';
+import type { IExecutor } from '../core/types.js';
+import type { Logger } from '../platform/types.js';
+/**
+ * An executor that processes step tasks using an IPgflowClient
+ * with strong typing for the flow's step handlers
+ */
+export declare class StepTaskExecutor<TFlow extends AnyFlow> implements IExecutor {
+    private readonly flow;
+    private readonly task;
+    private readonly adapter;
+    private readonly signal;
+    private logger;
+    constructor(flow: TFlow, task: StepTaskRecord<TFlow>, adapter: IPgflowClient<TFlow>, signal: AbortSignal, logger: Logger);
+    get msgId(): number;
+    execute(): Promise<void>;
+    /**
+     * 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.
+     */
+    private handleExecutionError;
+}
+//# sourceMappingURL=StepTaskExecutor.d.ts.map

package/dist/flow/StepTaskExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepTaskExecutor.d.ts","sourceRoot":"","sources":["../../src/flow/StepTaskExecutor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AASnD;;;GAGG;AACH,qBAAa,gBAAgB,CAAC,KAAK,SAAS,OAAO,CAAE,YAAW,SAAS;IAIrE,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,MAAM,CAAS;gBAGJ,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC,EAC3B,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAC7B,MAAM,EAAE,WAAW,EACpC,MAAM,EAAE,MAAM;IAKhB,IAAI,KAAK,WAER;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC9B;;;;;;;OAOG;YACW,oBAAoB;CAYnC"}

package/dist/flow/StepTaskExecutor.js

@@ -0,0 +1,71 @@
+class AbortError extends Error {
+    constructor() {
+        super('Operation aborted');
+        this.name = 'AbortError';
+    }
+}
+/**
+ * An executor that processes step tasks using an IPgflowClient
+ * with strong typing for the flow's step handlers
+ */
+export class StepTaskExecutor {
+    flow;
+    task;
+    adapter;
+    signal;
+    logger;
+    constructor(flow, task, adapter, signal, logger) {
+        this.flow = flow;
+        this.task = task;
+        this.adapter = adapter;
+        this.signal = signal;
+        this.logger = logger;
+    }
+    get msgId() {
+        return this.task.msg_id;
+    }
+    async execute() {
+        try {
+            if (this.signal.aborted) {
+                throw new AbortError();
+            }
+            // Check if already aborted before starting
+            this.signal.throwIfAborted();
+            const stepSlug = this.task.step_slug;
+            this.logger.debug(`Executing step task ${this.task.msg_id} for step ${stepSlug}`);
+            // Get the step handler from the flow with proper typing
+            const stepDef = this.flow.getStepDefinition(stepSlug);
+            if (!stepDef) {
+                throw new Error(`No step definition found for slug=${stepSlug}`);
+            }
+            // !!! HANDLER EXECUTION !!!
+            const result = await stepDef.handler(this.task.input);
+            // !!! HANDLER EXECUTION !!!
+            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}`);
+            // Do not mark as failed - the worker was aborted and stopping,
+            // the task will be picked up by another worker later
+        }
+        else {
+            this.logger.error(`step task ${this.task.msg_id} failed with error: ${error}`);
+            await this.adapter.failTask(this.task, error);
+        }
+    }
+}

package/dist/flow/StepTaskPoller.d.ts

@@ -0,0 +1,21 @@
+import type { StepTaskRecord, IPgflowClient } from './types.js';
+import type { IPoller } from '../core/types.js';
+import type { Logger } from '../platform/types.js';
+import type { AnyFlow } from '@pgflow/dsl';
+export interface StepTaskPollerConfig {
+    batchSize: number;
+    queueName: string;
+}
+/**
+ * A poller that retrieves flow tasks using an IPgflowClient
+ */
+export declare class StepTaskPoller<TFlow extends AnyFlow> implements IPoller<StepTaskRecord<TFlow>> {
+    private readonly adapter;
+    private readonly signal;
+    private readonly config;
+    private logger;
+    constructor(adapter: IPgflowClient<TFlow>, signal: AbortSignal, config: StepTaskPollerConfig, logger: Logger);
+    poll(): Promise<StepTaskRecord<TFlow>[]>;
+    private isAborted;
+}
+//# sourceMappingURL=StepTaskPoller.d.ts.map

package/dist/flow/StepTaskPoller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepTaskPoller.d.ts","sourceRoot":"","sources":["../../src/flow/StepTaskPoller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,cAAc,CAAC,KAAK,SAAS,OAAO,CAC/C,YAAW,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAKvC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IALzB,OAAO,CAAC,MAAM,CAAS;gBAGJ,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAC7B,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,oBAAoB,EAC7C,MAAM,EAAE,MAAM;IAKV,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;IAuB9C,OAAO,CAAC,SAAS;CAGlB"}

package/dist/flow/StepTaskPoller.js

@@ -0,0 +1,34 @@
+/**
+ * A poller that retrieves flow tasks using an IPgflowClient
+ */
+export class StepTaskPoller {
+    adapter;
+    signal;
+    config;
+    logger;
+    constructor(adapter, signal, config, logger) {
+        this.adapter = adapter;
+        this.signal = signal;
+        this.config = config;
+        this.logger = logger;
+    }
+    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;
+    }
+}

package/dist/flow/createFlowWorker.d.ts

@@ -0,0 +1,24 @@
+import type { AnyFlow } from '@pgflow/dsl';
+import type { EdgeWorkerConfig } from '../EdgeWorker.js';
+import type { Logger } from '../platform/types.js';
+import { Worker } from '../core/Worker.js';
+import postgres from 'postgres';
+/**
+ * Configuration for the flow worker
+ */
+export type FlowWorkerConfig = EdgeWorkerConfig & {
+    maxConcurrent?: number;
+    connectionString?: string;
+    sql?: postgres.Sql;
+    maxPgConnections?: number;
+    batchSize?: number;
+};
+/**
+ * Creates a new Worker instance for processing flow tasks.
+ *
+ * @param flow - The Flow DSL definition
+ * @param config - Configuration options for the worker
+ * @returns A configured Worker instance ready to be started
+ */
+export declare function createFlowWorker<TFlow extends AnyFlow>(flow: TFlow, config: FlowWorkerConfig, createLogger: (module: string) => Logger): Worker;
+//# sourceMappingURL=createFlowWorker.d.ts.map

package/dist/flow/createFlowWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFlowWorker.d.ts","sourceRoot":"","sources":["../../src/flow/createFlowWorker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAQzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,QAAQ,MAAM,UAAU,CAAC;AAIhC;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,SAAS,OAAO,EACpD,IAAI,EAAE,KAAK,EACX,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GACvC,MAAM,CAsFR"}

package/dist/flow/createFlowWorker.js

@@ -0,0 +1,56 @@
+import { ExecutionController } from '../core/ExecutionController.js';
+import { StepTaskPoller } from './StepTaskPoller.js';
+import { StepTaskExecutor } from './StepTaskExecutor.js';
+import { PgflowSqlClient } from '@pgflow/core';
+import { Queries } from '../core/Queries.js';
+import { Worker } from '../core/Worker.js';
+import postgres from 'postgres';
+import { FlowWorkerLifecycle } from './FlowWorkerLifecycle.js';
+import { BatchProcessor } from '../core/BatchProcessor.js';
+/**
+ * Creates a new Worker instance for processing flow tasks.
+ *
+ * @param flow - The Flow DSL definition
+ * @param config - Configuration options for the worker
+ * @returns A configured Worker instance ready to be started
+ */
+export function createFlowWorker(flow, config, createLogger) {
+    const logger = createLogger('createFlowWorker');
+    // Create abort controller for graceful shutdown
+    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 ||
+        postgres(config.connectionString, {
+            max: config.maxPgConnections,
+            prepare: false,
+        });
+    // Create the pgflow adapter
+    const pgflowAdapter = new PgflowSqlClient(sql);
+    // Use flow slug as queue name, or fallback to 'tasks'
+    const queueName = flow.slug || 'tasks';
+    logger.debug(`Using queue name: ${queueName}`);
+    // Create specialized FlowWorkerLifecycle with the proxied queue and flow
+    const queries = new Queries(sql);
+    const lifecycle = new FlowWorkerLifecycle(queries, flow, createLogger('FlowWorkerLifecycle'));
+    // Create StepTaskPoller
+    const pollerConfig = {
+        batchSize: config.batchSize || 10,
+        queueName: flow.slug,
+    };
+    const poller = new StepTaskPoller(pgflowAdapter, abortSignal, pollerConfig, createLogger('StepTaskPoller'));
+    // Create executor factory with proper typing
+    const executorFactory = (record, signal) => {
+        return new StepTaskExecutor(flow, record, pgflowAdapter, signal, createLogger('StepTaskExecutor'));
+    };
+    // Create ExecutionController
+    const executionController = new ExecutionController(executorFactory, abortSignal, {
+        maxConcurrent: config.maxConcurrent || 10,
+    }, createLogger('ExecutionController'));
+    // Create BatchProcessor
+    const batchProcessor = new BatchProcessor(executionController, poller, abortSignal, createLogger('BatchProcessor'));
+    // Return Worker
+    return new Worker(batchProcessor, lifecycle, sql, createLogger('Worker'));
+}

package/dist/flow/types.d.ts

@@ -0,0 +1,2 @@
+export * from '@pgflow/core';
+//# sourceMappingURL=types.d.ts.map

package/dist/flow/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/flow/types.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/flow/types.js

@@ -0,0 +1 @@
+export * from '@pgflow/core';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { createQueueWorker } from './queue/createQueueWorker.js';
+export { EdgeWorker } from './EdgeWorker.js';
+export { createFlowWorker } from './flow/createFlowWorker.js';
+export { FlowWorkerLifecycle } from './flow/FlowWorkerLifecycle.js';
+export * from './platform/index.js';
+export type { StepTaskRecord } from './flow/types.js';
+export type { FlowWorkerConfig } from './flow/createFlowWorker.js';
+export type { StepTaskPollerConfig } from './flow/StepTaskPoller.js';
+export type { Json, IExecutor, IPoller, IMessage, ILifecycle, IBatchProcessor, } from './core/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAGpE,cAAc,qBAAqB,CAAC;AAGpC,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGrE,YAAY,EACV,IAAI,EACJ,SAAS,EACT,OAAO,EACP,QAAQ,EACR,UAAU,EACV,eAAe,GAChB,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+// Export existing queue-based worker
+export { createQueueWorker } from './queue/createQueueWorker.js';
+export { EdgeWorker } from './EdgeWorker.js';
+// Export new flow-based worker
+export { createFlowWorker } from './flow/createFlowWorker.js';
+export { FlowWorkerLifecycle } from './flow/FlowWorkerLifecycle.js';
+// Export platform adapters
+export * from './platform/index.js';

package/dist/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pgflow/edge-worker",
+  "version": "0.0.23",
+  "license": "AGPL-3.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@henrygd/queue": "^1.0.7",
+    "@pgflow/core": "workspace:*",
+    "@pgflow/dsl": "workspace:*",
+    "postgres": "3.4.5"
+  },
+  "devDependencies": {
+    "@types/deno": "npm:@teidesu/deno-types@1.45.2",
+    "@types/node": "~18.16.20",
+    "supabase": "2.21.1"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "."
+  }
+}

package/dist/platform/DenoAdapter.d.ts

@@ -0,0 +1,39 @@
+import type { CreateWorkerFn, Logger, PlatformAdapter } from './types.js';
+/**
+ * Adapter for Deno runtime environment
+ */
+export declare class DenoAdapter implements PlatformAdapter {
+    private edgeFunctionName;
+    private worker;
+    private logger;
+    private loggingFactory;
+    constructor();
+    /**
+     * startWorker the platform adapter with a worker factory function
+     * @param createWorkerFn Function that creates a worker instance when called with a logger
+     */
+    startWorker(createWorkerFn: CreateWorkerFn): Promise<void>;
+    stopWorker(): Promise<void>;
+    createLogger(module: string): Logger;
+    /**
+     * Ensures the config has a connectionString by using the environment value if needed
+     */
+    getConnectionString(): string;
+    /**
+     * Get the Supabase URL for the current environment
+     */
+    private getEnvVarOrThrow;
+    private spawnNewEdgeFunction;
+    private extractFunctionName;
+    private setupShutdownHandler;
+    /**
+     * Supabase EdgeRuntime exposes waitUntil method as a way to extend
+     * the lifetime of the function until the promise resolves.
+     *
+     * We leverage this to extend the lifetime to the absolute maximum,
+     * by passing a promise that never resolves.
+     */
+    private extendLifetimeOfEdgeFunction;
+    private setupStartupHandler;
+}
+//# sourceMappingURL=DenoAdapter.d.ts.map

package/dist/platform/DenoAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DenoAdapter.d.ts","sourceRoot":"","sources":["../../src/platform/DenoAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAI1E;;GAEG;AACH,qBAAa,WAAY,YAAW,eAAe;IACjD,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAAS;IAGvB,OAAO,CAAC,cAAc,CAA0B;;IAoBhD;;;OAGG;IACG,WAAW,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIpC;;OAEG;IACH,mBAAmB,IAAI,MAAM;IAI7B;;OAEG;IACH,OAAO,CAAC,gBAAgB;YAcV,oBAAoB;IA8BlC,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,oBAAoB;IAY5B;;;;;;OAMG;IACH,OAAO,CAAC,4BAA4B;IAMpC,OAAO,CAAC,mBAAmB;CAwB5B"}

package/dist/platform/DenoAdapter.js

@@ -0,0 +1,123 @@
+/// <reference types="./deno-types.d.ts" />
+import { createLoggingFactory } from './logging.js';
+/**
+ * Adapter for Deno runtime environment
+ */
+export class DenoAdapter {
+    edgeFunctionName = null;
+    worker = null;
+    logger;
+    // Logging factory with dynamic workerId support
+    loggingFactory = createLoggingFactory();
+    constructor() {
+        // Guard clause to ensure we're in a Deno environment
+        // This is just for type checking during build
+        // At runtime, this class should only be instantiated in Deno
+        if (typeof Deno === 'undefined' || typeof EdgeRuntime === 'undefined') {
+            throw new Error('DenoAdapter created in non-Deno environment - this is expected during build only');
+        }
+        // Set initial log level
+        const logLevel = this.getEnvVarOrThrow('EDGE_WORKER_LOG_LEVEL') || 'info';
+        this.loggingFactory.setLogLevel(logLevel);
+        // startWorker logger with a default module name
+        this.logger = this.loggingFactory.createLogger('DenoAdapter');
+    }
+    /**
+     * startWorker the platform adapter with a worker factory function
+     * @param createWorkerFn Function that creates a worker instance when called with a logger
+     */
+    async startWorker(createWorkerFn) {
+        this.extendLifetimeOfEdgeFunction();
+        this.setupShutdownHandler();
+        this.setupStartupHandler(createWorkerFn);
+    }
+    async stopWorker() {
+        if (this.worker) {
+            await this.worker.stop();
+        }
+    }
+    createLogger(module) {
+        return this.loggingFactory.createLogger(module);
+    }
+    /**
+     * Ensures the config has a connectionString by using the environment value if needed
+     */
+    getConnectionString() {
+        return this.getEnvVarOrThrow('EDGE_WORKER_DB_URL');
+    }
+    /**
+     * Get the Supabase URL for the current environment
+     */
+    getEnvVarOrThrow(name) {
+        const envVar = Deno.env.get(name);
+        if (!envVar) {
+            const message = `${name} is not set!\n` +
+                'See docs to learn how to prepare the environment:\n' +
+                'https://pgflow.pages.dev/edge-worker/prepare-environment';
+            throw new Error(message);
+        }
+        return envVar;
+    }
+    async spawnNewEdgeFunction() {
+        if (!this.edgeFunctionName) {
+            throw new Error('functionName cannot be null or empty');
+        }
+        const supabaseUrl = this.getEnvVarOrThrow('SUPABASE_URL');
+        const supabaseAnonKey = this.getEnvVarOrThrow('SUPABASE_ANON_KEY');
+        this.logger.debug('Spawning a new Edge Function...');
+        const response = await fetch(`${supabaseUrl}/functions/v1/${this.edgeFunctionName}`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${supabaseAnonKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        this.logger.debug('Edge Function spawned successfully!');
+        if (!response.ok) {
+            throw new Error(`Edge function returned non-OK status: ${response.status} ${response.statusText}`);
+        }
+    }
+    extractFunctionName(req) {
+        return new URL(req.url).pathname.replace(/^\/+|\/+$/g, '');
+    }
+    setupShutdownHandler() {
+        globalThis.onbeforeunload = async () => {
+            this.logger.info('Shutting down...');
+            if (this.worker) {
+                await this.spawnNewEdgeFunction();
+            }
+            await this.stopWorker();
+        };
+    }
+    /**
+     * Supabase EdgeRuntime exposes waitUntil method as a way to extend
+     * the lifetime of the function until the promise resolves.
+     *
+     * We leverage this to extend the lifetime to the absolute maximum,
+     * by passing a promise that never resolves.
+     */
+    extendLifetimeOfEdgeFunction() {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        const promiseThatNeverResolves = new Promise(() => { });
+        EdgeRuntime.waitUntil(promiseThatNeverResolves);
+    }
+    setupStartupHandler(createWorkerFn) {
+        Deno.serve({}, (req) => {
+            this.logger.info(`HTTP Request: ${this.edgeFunctionName}`);
+            if (!this.worker) {
+                this.edgeFunctionName = this.extractFunctionName(req);
+                const workerId = this.getEnvVarOrThrow('SB_EXECUTION_ID');
+                this.loggingFactory.setWorkerId(workerId);
+                // Create the worker using the factory function and the logger
+                this.worker = createWorkerFn(this.loggingFactory.createLogger);
+                this.worker.startOnlyOnce({
+                    edgeFunctionName: this.edgeFunctionName,
+                    workerId,
+                });
+            }
+            return new Response('ok', {
+                headers: { 'Content-Type': 'application/json' },
+            });
+        });
+    }
+}

package/dist/platform/createAdapter.d.ts

@@ -0,0 +1,6 @@
+import type { PlatformAdapter } from './types.js';
+/**
+ * Creates the appropriate platform adapter based on the runtime environment
+ */
+export declare function createAdapter(): Promise<PlatformAdapter>;
+//# sourceMappingURL=createAdapter.d.ts.map

package/dist/platform/createAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAdapter.d.ts","sourceRoot":"","sources":["../../src/platform/createAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,eAAe,CAAC,CAS9D"}

package/dist/platform/createAdapter.js

@@ -0,0 +1,16 @@
+import { DenoAdapter } from './DenoAdapter.js';
+/**
+ * Creates the appropriate platform adapter based on the runtime environment
+ */
+export async function createAdapter() {
+    if (isDenoEnvironment()) {
+        const adapter = new DenoAdapter();
+        return adapter;
+    }
+    // For now, only support Deno
+    // Later add NodeAdapter, BrowserAdapter, etc.
+    throw new Error('Unsupported environment');
+}
+function isDenoEnvironment() {
+    return typeof Deno !== 'undefined';
+}

package/dist/platform/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export { createAdapter } from './createAdapter.js';
+export { DenoAdapter } from './DenoAdapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/platform/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/platform/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export { createAdapter } from './createAdapter.js';
+export { DenoAdapter } from './DenoAdapter.js';

package/dist/platform/logging.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from './types.js';
+/**
+ * Creates a logging factory with dynamic workerId support
+ */
+export declare function createLoggingFactory(): {
+    createLogger: (module: string) => Logger;
+    setWorkerId: (workerId: string) => void;
+    setLogLevel: (newLogLevel: string) => void;
+};
+//# sourceMappingURL=logging.d.ts.map

package/dist/platform/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/platform/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;GAEG;AACH,wBAAgB,oBAAoB;2BAcJ,MAAM,KAAG,MAAM;4BAuDd,MAAM,KAAG,IAAI;+BAOV,MAAM,KAAG,IAAI;EAShD"}