@pgflow/edge-worker 0.0.8 → 0.0.10-prealpha.1

package/dist/EdgeWorker.d.ts

@@ -0,0 +1,73 @@
+import type { Json } from './core/types.js';
+import { type QueueWorkerConfig } from './queue/createQueueWorker.js';
+import type { PlatformAdapter } from './platform/types.js';
+/**
+ * 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 declare class EdgeWorker {
+    private static adapter;
+    private static wasCalled;
+    /**
+     * 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): Promise<PlatformAdapter>;
+    /**
+     * Stop the EdgeWorker and clean up resources.
+     */
+    static stop(): Promise<void>;
+    private static ensureFirstCall;
+}
+//# sourceMappingURL=EdgeWorker.d.ts.map

package/dist/EdgeWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgeWorker.d.ts","sourceRoot":"","sources":["../src/EdgeWorker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EACV,eAAe,EAGhB,MAAM,qBAAqB,CAAC;AAE7B;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAC,OAAO,CAAgC;IACtD,OAAO,CAAC,MAAM,CAAC,SAAS,CAAS;IAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;WACU,KAAK,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAC7C,OAAO,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EACpD,MAAM,GAAE,gBAAqB;IAmC/B;;OAEG;WACU,IAAI;IAQjB,OAAO,CAAC,MAAM,CAAC,eAAe;CAQ/B"}

package/dist/EdgeWorker.js

@@ -0,0 +1,105 @@
+import { createQueueWorker, } from './queue/createQueueWorker.js';
+import { createAdapter } from './platform/createAdapter.js';
+/**
+ * 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 {
+    static adapter = null;
+    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 async start(handler, config = {}) {
+        this.ensureFirstCall();
+        // First, create the adapter
+        this.adapter = await createAdapter();
+        // Get environment info from adapter
+        const env = this.adapter.getEnv();
+        // Complete the config with default values and environment info
+        const completeConfig = {
+            ...config,
+            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,
+            connectionString: config.connectionString || env.connectionString,
+        };
+        // Create a worker factory function that will be called by the adapter
+        const createWorkerFn = (createLoggerFn) => {
+            return createQueueWorker(handler, completeConfig, createLoggerFn);
+        };
+        // Initialize the adapter with the worker factory function
+        await this.adapter.initialize(createWorkerFn);
+        return this.adapter;
+    }
+    /**
+     * Stop the EdgeWorker and clean up resources.
+     */
+    static async stop() {
+        if (this.adapter) {
+            await this.adapter.terminate();
+        }
+        else {
+            throw new Error('EdgeWorker.start() must be called first');
+        }
+    }
+    static ensureFirstCall() {
+        if (this.wasCalled) {
+            throw new Error('EdgeWorker.start() can only be called once');
+        }
+        this.wasCalled = true;
+    }
+}

package/dist/core/BatchProcessor.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionController } from './ExecutionController.js';
+import type { IMessage, IPoller } from './types.js';
+import type { Logger } from '../platform/types.js';
+export declare class BatchProcessor<TMessage extends IMessage> {
+    private executionController;
+    private poller;
+    private signal;
+    private logger;
+    constructor(executionController: ExecutionController<TMessage>, poller: IPoller<TMessage>, signal: AbortSignal, logger: Logger);
+    processBatch(): Promise<void>;
+    awaitCompletion(): Promise<void>;
+}
+//# sourceMappingURL=BatchProcessor.d.ts.map

package/dist/core/BatchProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchProcessor.d.ts","sourceRoot":"","sources":["../../src/core/BatchProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,qBAAa,cAAc,CAAC,QAAQ,SAAS,QAAQ;IAIjD,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IALhB,OAAO,CAAC,MAAM,CAAS;gBAGb,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAAC,EAClD,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,EACzB,MAAM,EAAE,WAAW,EAC3B,MAAM,EAAE,MAAM;IAQV,YAAY;IAiBZ,eAAe;CAGtB"}

package/dist/core/BatchProcessor.js

@@ -0,0 +1,29 @@
+export class BatchProcessor {
+    executionController;
+    poller;
+    signal;
+    logger;
+    constructor(executionController, poller, signal, logger) {
+        this.executionController = executionController;
+        this.poller = poller;
+        this.signal = signal;
+        this.executionController = executionController;
+        this.signal = signal;
+        this.poller = poller;
+        this.logger = logger;
+    }
+    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();
+    }
+}

package/dist/core/ExecutionController.d.ts

@@ -0,0 +1,15 @@
+import type { IExecutor, IMessage } from './types.js';
+import type { Logger } from '../platform/types.js';
+export interface ExecutionConfig {
+    maxConcurrent: number;
+}
+export declare class ExecutionController<TMessage extends IMessage> {
+    private logger;
+    private promiseQueue;
+    private signal;
+    private createExecutor;
+    constructor(executorFactory: (record: TMessage, signal: AbortSignal) => IExecutor, abortSignal: AbortSignal, config: ExecutionConfig, logger: Logger);
+    start(record: TMessage): Promise<void>;
+    awaitCompletion(): Promise<void>;
+}
+//# sourceMappingURL=ExecutionController.d.ts.map

package/dist/core/ExecutionController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionController.d.ts","sourceRoot":"","sources":["../../src/core/ExecutionController.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,mBAAmB,CAAC,QAAQ,SAAS,QAAQ;IACxD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,cAAc,CAAuD;gBAG3E,eAAe,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,KAAK,SAAS,EACrE,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,MAAM;IAQV,KAAK,CAAC,MAAM,EAAE,QAAQ;IAiBtB,eAAe;CAStB"}

package/dist/core/ExecutionController.js

@@ -0,0 +1,34 @@
+import { newQueue } from '@henrygd/queue';
+export class ExecutionController {
+    logger;
+    promiseQueue;
+    signal;
+    createExecutor;
+    constructor(executorFactory, abortSignal, config, logger) {
+        this.signal = abortSignal;
+        this.createExecutor = executorFactory;
+        this.promiseQueue = newQueue(config.maxConcurrent);
+        this.logger = logger;
+    }
+    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();
+    }
+}

package/dist/core/Heartbeat.d.ts

@@ -0,0 +1,13 @@
+import type { Queries } from './Queries.js';
+import type { WorkerRow } from './types.js';
+import type { Logger } from '../platform/types.js';
+export declare class Heartbeat {
+    private interval;
+    private queries;
+    private workerRow;
+    private logger;
+    private lastHeartbeat;
+    constructor(interval: number, queries: Queries, workerRow: WorkerRow, logger: Logger);
+    send(): Promise<void>;
+}
+//# sourceMappingURL=Heartbeat.d.ts.map

package/dist/core/Heartbeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Heartbeat.d.ts","sourceRoot":"","sources":["../../src/core/Heartbeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,qBAAa,SAAS;IAKlB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,SAAS;IANnB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAK;gBAGhB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,SAAS,EAC5B,MAAM,EAAE,MAAM;IAKV,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ5B"}

package/dist/core/Heartbeat.js

@@ -0,0 +1,21 @@
+export class Heartbeat {
+    interval;
+    queries;
+    workerRow;
+    logger;
+    lastHeartbeat = 0;
+    constructor(interval, queries, workerRow, logger) {
+        this.interval = interval;
+        this.queries = queries;
+        this.workerRow = workerRow;
+        this.logger = logger;
+    }
+    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;
+        }
+    }
+}

package/dist/core/Queries.d.ts

@@ -0,0 +1,14 @@
+import type postgres from 'postgres';
+import type { WorkerRow } from './types.js';
+export declare class Queries {
+    private readonly sql;
+    constructor(sql: postgres.Sql);
+    onWorkerStarted({ queueName, workerId, edgeFunctionName, }: {
+        queueName: string;
+        workerId: string;
+        edgeFunctionName: string;
+    }): Promise<WorkerRow>;
+    onWorkerStopped(workerRow: WorkerRow): Promise<WorkerRow>;
+    sendHeartbeat(workerRow: WorkerRow): Promise<void>;
+}
+//# sourceMappingURL=Queries.d.ts.map

package/dist/core/Queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Queries.d.ts","sourceRoot":"","sources":["../../src/core/Queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,qBAAa,OAAO;IACN,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,QAAQ,CAAC,GAAG;IAExC,eAAe,CAAC,EACpB,SAAS,EACT,QAAQ,EACR,gBAAgB,GACjB,EAAE;QACD,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,gBAAgB,EAAE,MAAM,CAAC;KAC1B,GAAG,OAAO,CAAC,SAAS,CAAC;IAUhB,eAAe,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IAWzD,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAQzD"}

package/dist/core/Queries.js

@@ -0,0 +1,31 @@
+export class Queries {
+    sql;
+    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 *;
+    `;
+    }
+}

package/dist/core/Worker.d.ts

@@ -0,0 +1,21 @@
+import type postgres from 'postgres';
+import type { IBatchProcessor, ILifecycle, WorkerBootstrap } from './types.js';
+import type { Logger } from '../platform/types.js';
+export declare class Worker {
+    private lifecycle;
+    private logger;
+    private abortController;
+    private batchProcessor;
+    private sql;
+    constructor(batchProcessor: IBatchProcessor, lifecycle: ILifecycle, sql: postgres.Sql, logger: Logger);
+    startOnlyOnce(workerBootstrap: WorkerBootstrap): Promise<void>;
+    private start;
+    stop(): Promise<void>;
+    get edgeFunctionName(): string | undefined;
+    /**
+     * Returns true if worker state is Running and worker was not stopped
+     */
+    private get isMainLoopActive();
+    private get isAborted();
+}
+//# sourceMappingURL=Worker.d.ts.map

package/dist/core/Worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/core/Worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,qBAAa,MAAM;IACjB,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,eAAe,CAAyB;IAEhD,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,GAAG,CAAe;gBAGxB,cAAc,EAAE,eAAe,EAC/B,SAAS,EAAE,UAAU,EACrB,GAAG,EAAE,QAAQ,CAAC,GAAG,EACjB,MAAM,EAAE,MAAM;IAQV,aAAa,CAAC,eAAe,EAAE,eAAe;YAStC,KAAK;IAyBb,IAAI;IA2BV,IAAI,gBAAgB,uBAEnB;IAED;;OAEG;IACH,OAAO,KAAK,gBAAgB,GAE3B;IAED,OAAO,KAAK,SAAS,GAEpB;CACF"}

package/dist/core/Worker.js

@@ -0,0 +1,79 @@
+export class Worker {
+    lifecycle;
+    logger;
+    abortController = new AbortController();
+    batchProcessor;
+    sql;
+    constructor(batchProcessor, lifecycle, sql, logger) {
+        this.sql = sql;
+        this.lifecycle = lifecycle;
+        this.batchProcessor = batchProcessor;
+        this.logger = logger;
+    }
+    async startOnlyOnce(workerBootstrap) {
+        if (this.lifecycle.isRunning) {
+            this.logger.debug('Worker already running, ignoring start request');
+            return;
+        }
+        await this.start(workerBootstrap);
+    }
+    async start(workerBootstrap) {
+        try {
+            await this.lifecycle.acknowledgeStart(workerBootstrap);
+            while (this.isMainLoopActive) {
+                try {
+                    await this.lifecycle.sendHeartbeat();
+                }
+                catch (error) {
+                    this.logger.error(`Error sending heartbeat: ${error}`);
+                    // Continue execution - a failed heartbeat shouldn't stop processing
+                }
+                try {
+                    await this.batchProcessor.processBatch();
+                }
+                catch (error) {
+                    this.logger.error(`Error processing batch: ${error}`);
+                    // Continue to next iteration - failed batch shouldn't stop the worker
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error in worker main loop: ${error}`);
+            throw error;
+        }
+    }
+    async stop() {
+        // If the worker is already stopping or stopped, do nothing
+        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;
+    }
+}

package/dist/core/WorkerLifecycle.d.ts

@@ -0,0 +1,26 @@
+import type { Queries } from './Queries.js';
+import type { Queue } from '../queue/Queue.js';
+import type { ILifecycle, Json, WorkerBootstrap } from './types.js';
+import type { Logger } from '../platform/types.js';
+export interface LifecycleConfig {
+    queueName: string;
+}
+export declare class WorkerLifecycle<IMessage extends Json> implements ILifecycle {
+    private workerState;
+    private heartbeat?;
+    private logger;
+    private queries;
+    private queue;
+    private workerRow?;
+    constructor(queries: Queries, queue: Queue<IMessage>, logger: Logger);
+    acknowledgeStart(workerBootstrap: WorkerBootstrap): Promise<void>;
+    acknowledgeStop(): void;
+    get edgeFunctionName(): string | undefined;
+    get queueName(): string;
+    sendHeartbeat(): Promise<void>;
+    get isRunning(): boolean;
+    get isStopping(): boolean;
+    get isStopped(): boolean;
+    transitionToStopping(): void;
+}
+//# sourceMappingURL=WorkerLifecycle.d.ts.map

package/dist/core/WorkerLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerLifecycle.d.ts","sourceRoot":"","sources":["../../src/core/WorkerLifecycle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,EAAa,MAAM,YAAY,CAAC;AAE/E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,eAAe,CAAC,QAAQ,SAAS,IAAI,CAAE,YAAW,UAAU;IACvE,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,SAAS,CAAC,CAAY;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,SAAS,CAAC,CAAY;gBAElB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM;IAO9D,gBAAgB,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvE,eAAe;IAyBf,IAAI,gBAAgB,uBAEnB;IAED,IAAI,SAAS,WAEZ;IAEK,aAAa;IAInB,IAAI,SAAS,YAEZ;IAED,IAAI,UAAU,YAEb;IAED,IAAI,SAAS,YAEZ;IAED,oBAAoB;CAGrB"}

package/dist/core/WorkerLifecycle.js

@@ -0,0 +1,69 @@
+import { Heartbeat } from './Heartbeat.js';
+import { States, WorkerState } from './WorkerState.js';
+export class WorkerLifecycle {
+    workerState;
+    heartbeat;
+    logger;
+    queries;
+    queue;
+    workerRow;
+    constructor(queries, queue, logger) {
+        this.queries = queries;
+        this.queue = queue;
+        this.logger = logger;
+        this.workerState = new WorkerState(logger);
+    }
+    async acknowledgeStart(workerBootstrap) {
+        this.workerState.transitionTo(States.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(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...');
+            // TODO: commented out because we can live without this
+            //       but it is causing problems with DbHandler - workes does not have
+            //       enough time to fire this query before hard-terimnated
+            //       We can always check the heartbeat to see if it is still running
+            //
+            // await this.queries.onWorkerStopped(this.workerRow);
+            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.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(States.Stopping);
+    }
+}

package/dist/core/WorkerState.d.ts

@@ -0,0 +1,37 @@
+import type { Logger } from '../platform/types.js';
+export declare enum States {
+    /** The worker has been created but has not yet started. */
+    Created = "created",
+    /** The worker is starting but has not yet started processing messages. */
+    Starting = "starting",
+    /** The worker is processing messages. */
+    Running = "running",
+    /** The worker stopped processing messages but is still releasing resources. */
+    Stopping = "stopping",
+    /** The worker has stopped processing messages and released resources
+     * and can be discarded. */
+    Stopped = "stopped"
+}
+export declare const Transitions: Record<States, States[]>;
+export declare class TransitionError extends Error {
+    constructor(options: {
+        from: States;
+        to: States;
+    });
+}
+/**
+ * Represents the state of a worker and exposes method for doing allowed transitions
+ */
+export declare class WorkerState {
+    private logger;
+    private state;
+    constructor(logger: Logger);
+    get current(): States;
+    get isCreated(): boolean;
+    get isStarting(): boolean;
+    get isRunning(): boolean;
+    get isStopping(): boolean;
+    get isStopped(): boolean;
+    transitionTo(state: States): void;
+}
+//# sourceMappingURL=WorkerState.d.ts.map

package/dist/core/WorkerState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerState.d.ts","sourceRoot":"","sources":["../../src/core/WorkerState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,oBAAY,MAAM;IAChB,2DAA2D;IAC3D,OAAO,YAAY;IAEnB,0EAA0E;IAC1E,QAAQ,aAAa;IAErB,yCAAyC;IACzC,OAAO,YAAY;IAEnB,+EAA+E;IAC/E,QAAQ,aAAa;IAErB;+BAC2B;IAC3B,OAAO,YAAY;CACpB;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAMhD,CAAC;AAEF,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE;CAGlD;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAA0B;gBAE3B,MAAM,EAAE,MAAM;IAI1B,IAAI,OAAO,WAEV;IAED,IAAI,SAAS,YAEZ;IAED,IAAI,UAAU,YAEb;IAED,IAAI,SAAS,YAEZ;IAED,IAAI,UAAU,YAEb;IAED,IAAI,SAAS,YAEZ;IAED,YAAY,CAAC,KAAK,EAAE,MAAM;CAmB3B"}