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

package/dist/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@pgflow/edge-worker",
+  "version": "0.0.10-prealpha.1",
+  "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:*",
+    "pino": "^9.6.0",
+    "postgres": "3.4.5"
+  },
+  "devDependencies": {
+    "@teidesu/deno-types": "1.42.4",
+    "supabase": "2.21.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/dist/platform/DenoAdapter.d.ts

@@ -0,0 +1,23 @@
+import type { CreateWorkerFn, Logger, PlatformAdapter, PlatformEnvironment } from './types.js';
+import './deno-types.js';
+/**
+ * Adapter for Deno runtime environment
+ */
+export declare class DenoAdapter implements PlatformAdapter {
+    private env;
+    private edgeFunctionName;
+    private worker;
+    constructor();
+    initialize(createWorkerFn: CreateWorkerFn): Promise<void>;
+    terminate(): Promise<void>;
+    getEnv(): PlatformEnvironment;
+    createLogger(module: string): Logger;
+    setWorker(worker: {
+        stop(): void;
+    }): void;
+    spawnNewEdgeFunction(functionName: string): Promise<void>;
+    private detectEnvironment;
+    private extractFunctionName;
+    setupShutdownHandler(): void;
+}
+//# 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":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,MAAM,EACN,eAAe,EACf,mBAAmB,EACpB,MAAM,YAAY,CAAC;AACpB,OAAO,iBAAiB,CAAC;AAEzB;;GAEG;AACH,qBAAa,WAAY,YAAW,eAAe;IACjD,OAAO,CAAC,GAAG,CAAoC;IAC/C,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,MAAM,CAAiC;;IAazC,UAAU,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IA2BzD,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAOhC,MAAM,IAAI,mBAAmB;IAK7B,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IA4CpC,SAAS,CAAC,MAAM,EAAE;QAAE,IAAI,IAAI,IAAI,CAAA;KAAE,GAAG,IAAI;IAInC,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA+B/D,OAAO,CAAC,iBAAiB;IAsBzB,OAAO,CAAC,mBAAmB;IAI3B,oBAAoB,IAAI,IAAI;CAY7B"}

package/dist/platform/DenoAdapter.js

@@ -0,0 +1,132 @@
+import './deno-types.js';
+/**
+ * Adapter for Deno runtime environment
+ */
+export class DenoAdapter {
+    env = null;
+    edgeFunctionName = null;
+    worker = null;
+    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');
+        }
+    }
+    async initialize(createWorkerFn) {
+        // Get environment information
+        this.env = this.detectEnvironment();
+        // Set up HTTP listener for Deno
+        Deno.serve({}, (req) => {
+            if (!this.worker) {
+                this.edgeFunctionName = this.extractFunctionName(req);
+                // Create a logger for the adapter
+                const logger = this.createLogger('DenoAdapter');
+                logger.info(`HTTP Request: ${this.edgeFunctionName}`);
+                // Create the worker using the factory function and the logger
+                this.worker = createWorkerFn(this.createLogger.bind(this));
+            }
+            return new Response('ok', {
+                headers: { 'Content-Type': 'application/json' },
+            });
+        });
+        // Keep function alive for Supabase Edge Functions
+        const promiseThatNeverResolves = new Promise(() => { });
+        EdgeRuntime.waitUntil(promiseThatNeverResolves);
+    }
+    async terminate() {
+        if (this.worker) {
+            this.worker.stop();
+            this.worker = null;
+        }
+    }
+    getEnv() {
+        if (!this.env)
+            throw new Error('Adapter not initialized');
+        return this.env;
+    }
+    createLogger(module) {
+        const workerId = this.env?.executionId || 'unknown';
+        const logLevel = this.env?.logLevel || 'info';
+        // Simple level filtering
+        const levels = { error: 0, warn: 1, info: 2, debug: 3 };
+        const levelValue = levels[logLevel] ?? levels.info;
+        return {
+            debug: (message, ...args) => {
+                if (levelValue >= levels.debug) {
+                    console.debug(`worker_id=${workerId} module=${module} ${message}`, ...args);
+                }
+            },
+            info: (message, ...args) => {
+                if (levelValue >= levels.info) {
+                    console.info(`worker_id=${workerId} module=${module} ${message}`, ...args);
+                }
+            },
+            warn: (message, ...args) => {
+                if (levelValue >= levels.warn) {
+                    console.warn(`worker_id=${workerId} module=${module} ${message}`, ...args);
+                }
+            },
+            error: (message, ...args) => {
+                if (levelValue >= levels.error) {
+                    console.error(`worker_id=${workerId} module=${module} ${message}`, ...args);
+                }
+            },
+        };
+    }
+    setWorker(worker) {
+        this.worker = worker;
+    }
+    async spawnNewEdgeFunction(functionName) {
+        if (!functionName) {
+            throw new Error('functionName cannot be null or empty');
+        }
+        const logger = this.createLogger('spawnNewEdgeFunction');
+        logger.debug('Spawning a new Edge Function...');
+        const SUPABASE_URL = Deno.env.get('SUPABASE_URL');
+        const SUPABASE_ANON_KEY = Deno.env.get('SUPABASE_ANON_KEY');
+        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}`);
+        }
+    }
+    detectEnvironment() {
+        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);
+        }
+        const executionId = Deno.env.get('SB_EXECUTION_ID');
+        if (!executionId) {
+            throw new Error('SB_EXECUTION_ID is not set!');
+        }
+        return {
+            executionId,
+            logLevel: Deno.env.get('EDGE_WORKER_LOG_LEVEL') || 'info',
+            connectionString,
+        };
+    }
+    extractFunctionName(req) {
+        return new URL(req.url).pathname.replace(/^\/+|\/+$/g, '');
+    }
+    setupShutdownHandler() {
+        globalThis.onbeforeunload = async () => {
+            if (this.worker && this.edgeFunctionName) {
+                await this.spawnNewEdgeFunction(this.edgeFunctionName);
+            }
+            if (this.worker) {
+                this.worker.stop();
+                this.worker = null;
+            }
+        };
+    }
+}

package/dist/platform/createAdapter.d.ts

@@ -0,0 +1,7 @@
+import type { PlatformAdapter } from './types.js';
+import './deno-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;AAElD,OAAO,iBAAiB,CAAC;AAEzB;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,eAAe,CAAC,CAS9D"}

package/dist/platform/createAdapter.js

@@ -0,0 +1,17 @@
+import { DenoAdapter } from './DenoAdapter.js';
+import './deno-types.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/deno-types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Minimal type definitions for Deno APIs used in our codebase.
+ * These are used for type checking during build in Node.js environment.
+ * At runtime in Deno, the actual Deno implementations will be used.
+ */
+declare global {
+    interface EdgeRuntimeNamespace {
+        waitUntil(promise: Promise<unknown>): void;
+    }
+    var EdgeRuntime: EdgeRuntimeNamespace;
+}
+export {};
+//# sourceMappingURL=deno-types.d.ts.map

package/dist/platform/deno-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno-types.d.ts","sourceRoot":"","sources":["../../src/platform/deno-types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,CAAC,MAAM,CAAC;IAEb,UAAU,oBAAoB;QAC5B,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;KAC5C;IAID,IAAI,WAAW,EAAE,oBAAoB,CAAC;CACvC;AAGD,OAAO,EAAE,CAAC"}

package/dist/platform/deno-types.js

@@ -0,0 +1,6 @@
+/**
+ * Minimal type definitions for Deno APIs used in our codebase.
+ * These are used for type checking during build in Node.js environment.
+ * At runtime in Deno, the actual Deno implementations will be used.
+ */
+export {};

package/dist/platform/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export { createAdapter } from './createAdapter.js';
+export { DenoAdapter } from './DenoAdapter.js';
+import './deno-types.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;AAC/C,OAAO,iBAAiB,CAAC"}

package/dist/platform/index.js

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

package/dist/platform/types.d.ts

@@ -0,0 +1,45 @@
+import type { Worker } from '../core/Worker.js';
+/**
+ * Basic logger interface used throughout the application
+ */
+export interface Logger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+/**
+ * Logger factory function
+ */
+export type CreateLoggerFn = (module: string) => Logger;
+/**
+ * Logger factory function
+ */
+export type CreateWorkerFn = (createLoggerFn: CreateLoggerFn) => Worker;
+/**
+ * Type for platform-specific environment variables
+ */
+export interface PlatformEnvironment {
+    executionId: string;
+    logLevel: string;
+    connectionString: string;
+}
+/**
+ * Common interface for all platform adapters
+ */
+export interface PlatformAdapter {
+    /**
+     * Initialize the platform adapter with a worker factory function
+     * @param createWorkerFn Function that creates a worker instance when called with a logger
+     */
+    initialize(createWorkerFn: CreateWorkerFn): Promise<void>;
+    /**
+     * Clean up resources when shutting down
+     */
+    terminate(): Promise<void>;
+    /**
+     * Get platform-specific environment variables
+     */
+    getEnv(): PlatformEnvironment;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/platform/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC7C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;AAExD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,cAAc,EAAE,cAAc,KAAK,MAAM,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAE1B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,UAAU,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1D;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3B;;OAEG;IACH,MAAM,IAAI,mBAAmB,CAAC;CAC/B"}

package/dist/platform/types.js

@@ -0,0 +1 @@
+export {};

package/dist/queue/MessageExecutor.d.ts

@@ -0,0 +1,43 @@
+import type { Json } from '../core/types.js';
+import type { PgmqMessageRecord } from './types.js';
+import type { Queue } from './Queue.js';
+import type { Logger } from '../platform/types.js';
+/**
+ * A class that executes a message handler.
+ *
+ * It handles the execution of the message handler and retries or archives the message
+ * based on the retry limit and delay.
+ *
+ * It also handles the abort signal and logs the error.
+ */
+export declare class MessageExecutor<TPayload extends Json> {
+    private readonly queue;
+    private readonly record;
+    private readonly messageHandler;
+    private readonly signal;
+    private readonly retryLimit;
+    private readonly retryDelay;
+    private logger;
+    constructor(queue: Queue<TPayload>, record: PgmqMessageRecord<TPayload>, messageHandler: (message: TPayload) => Promise<void> | void, signal: AbortSignal, retryLimit: number, retryDelay: number, 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 message will reappear after the visibility timeout and be picked up by another worker.
+     *
+     * Otherwise, it proceeds with retry or archiving forever.
+     */
+    private handleExecutionError;
+    /**
+     * Retries the message if it is available.
+     * Otherwise, archives the message forever and stops processing it.
+     */
+    private retryOrArchive;
+    /**
+     * Returns true if the message can be retried.
+     */
+    private get retryAvailable();
+}
+//# sourceMappingURL=MessageExecutor.d.ts.map

package/dist/queue/MessageExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageExecutor.d.ts","sourceRoot":"","sources":["../../src/queue/MessageExecutor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AASnD;;;;;;;GAOG;AACH,qBAAa,eAAe,CAAC,QAAQ,SAAS,IAAI;IAI9C,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAG/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAV7B,OAAO,CAAC,MAAM,CAAS;gBAGJ,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,EACtB,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,EACnC,cAAc,EAAE,CAC/B,OAAO,EAAE,QAAQ,KACd,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EACR,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EACnC,MAAM,EAAE,MAAM;IAKhB,IAAI,KAAK,WAER;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB9B;;;;;;;OAOG;YACW,oBAAoB;IAYlC;;;OAGG;YACW,cAAc;IAY5B;;OAEG;IACH,OAAO,KAAK,cAAc,GAIzB;CACF"}

package/dist/queue/MessageExecutor.js

@@ -0,0 +1,95 @@
+class AbortError extends Error {
+    constructor() {
+        super('Operation aborted');
+        this.name = 'AbortError';
+    }
+}
+/**
+ * A class that executes a message handler.
+ *
+ * It handles the execution of the message handler and retries or archives the message
+ * based on the retry limit and delay.
+ *
+ * It also handles the abort signal and logs the error.
+ */
+export class MessageExecutor {
+    queue;
+    record;
+    messageHandler;
+    signal;
+    retryLimit;
+    retryDelay;
+    logger;
+    constructor(queue, record, messageHandler, signal, retryLimit, retryDelay, logger) {
+        this.queue = queue;
+        this.record = record;
+        this.messageHandler = messageHandler;
+        this.signal = signal;
+        this.retryLimit = retryLimit;
+        this.retryDelay = retryDelay;
+        this.logger = logger;
+    }
+    get msgId() {
+        return this.record.msg_id;
+    }
+    async execute() {
+        try {
+            if (this.signal.aborted) {
+                throw new AbortError();
+            }
+            // Check if already aborted before starting
+            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}`);
+            // Do not throw - the worker was aborted and stopping,
+            // the message will reappear after the visibility timeout
+            // and be picked up by another worker
+        }
+        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) {
+            // adjust visibility timeout for message to appear after retryDelay
+            this.logger.debug(`Retrying ${this.msgId} in ${this.retryDelay} seconds`);
+            await this.queue.setVt(this.msgId, this.retryDelay);
+        }
+        else {
+            // archive message forever and stop processing it
+            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; // initial read also counts
+        return this.record.read_ct < readCountLimit;
+    }
+}

package/dist/queue/Queue.d.ts

@@ -0,0 +1,35 @@
+import type postgres from 'postgres';
+import type { PgmqMessageRecord } from './types.js';
+import type { Json } from '../core/types.js';
+import type { Logger } from '../platform/types.js';
+export declare class Queue<TPayload extends Json> {
+    private readonly sql;
+    readonly queueName: string;
+    private logger;
+    constructor(sql: postgres.Sql, queueName: string, logger: Logger);
+    /**
+     * Creates a queue if it doesn't exist.
+     * If the queue already exists, this method does nothing.
+     */
+    safeCreate(): Promise<postgres.RowList<postgres.Row[]>>;
+    /**
+     * Drops a queue if it exists.
+     * If the queue doesn't exist, this method does nothing.
+     */
+    safeDrop(): Promise<postgres.RowList<postgres.Row[]>>;
+    archive(msgId: number): Promise<void>;
+    archiveBatch(msgIds: number[]): Promise<void>;
+    send(message: TPayload): Promise<void>;
+    readWithPoll(batchSize?: number, visibilityTimeout?: number, maxPollSeconds?: number, pollIntervalMs?: number): Promise<postgres.RowList<PgmqMessageRecord<TPayload>[]>>;
+    /**
+     * 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().
+     */
+    setVt(msgId: number, vtOffsetSeconds: number): Promise<PgmqMessageRecord<TPayload>>;
+}
+//# sourceMappingURL=Queue.d.ts.map

package/dist/queue/Queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Queue.d.ts","sourceRoot":"","sources":["../../src/queue/Queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,qBAAa,KAAK,CAAC,QAAQ,SAAS,IAAI;IAIpC,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM;IAJ5B,OAAO,CAAC,MAAM,CAAS;gBAGJ,GAAG,EAAE,QAAQ,CAAC,GAAG,EACzB,SAAS,EAAE,MAAM,EAC1B,MAAM,EAAE,MAAM;IAKhB;;;OAGG;IACG,UAAU;IAUhB;;;OAGG;IACG,QAAQ;IAUR,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOrC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7C,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtC,YAAY,CAChB,SAAS,SAAK,EACd,iBAAiB,SAAI,EACrB,cAAc,SAAI,EAClB,cAAc,SAAM;IAetB;;;;;;;;OAQG;IACG,KAAK,CACT,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;CAUxC"}

package/dist/queue/Queue.js

@@ -0,0 +1,87 @@
+export class Queue {
+    sql;
+    queueName;
+    logger;
+    constructor(sql, queueName, logger) {
+        this.sql = sql;
+        this.queueName = queueName;
+        this.logger = logger;
+    }
+    /**
+     * Creates a queue if it doesn't exist.
+     * If the queue already exists, this method does nothing.
+     */
+    async safeCreate() {
+        this.logger.debug(`Creating queue '${this.queueName}' if it doesn't exist`);
+        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() {
+        this.logger.debug(`Dropping queue '${this.queueName}' if it exists`);
+        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) {
+        this.logger.debug(`Archiving message ${msgId} from queue '${this.queueName}'`);
+        await this.sql `
+      SELECT pgmq.archive(queue_name => ${this.queueName}, msg_id => ${msgId}::bigint);
+    `;
+    }
+    async archiveBatch(msgIds) {
+        this.logger.debug(`Archiving ${msgIds.length} messages from queue '${this.queueName}'`);
+        await this.sql `
+      SELECT pgmq.archive(queue_name => ${this.queueName}, msg_ids => ${msgIds}::bigint[]);
+    `;
+    }
+    async send(message) {
+        this.logger.debug(`Sending message to queue '${this.queueName}'`);
+        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) {
+        this.logger.debug(`Reading messages from queue '${this.queueName}' with poll`);
+        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) {
+        this.logger.debug(`Setting visibility timeout for message ${msgId} to ${vtOffsetSeconds} seconds`);
+        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];
+    }
+}

package/dist/queue/ReadWithPollPoller.d.ts

@@ -0,0 +1,20 @@
+import type { Queue } from './Queue.js';
+import type { PgmqMessageRecord } from './types.js';
+import type { Json } from '../core/types.js';
+import type { Logger } from '../platform/types.js';
+export interface PollerConfig {
+    batchSize: number;
+    maxPollSeconds: number;
+    pollIntervalMs: number;
+    visibilityTimeout: number;
+}
+export declare class ReadWithPollPoller<TPayload extends Json> {
+    protected readonly queue: Queue<TPayload>;
+    protected readonly signal: AbortSignal;
+    protected readonly config: PollerConfig;
+    private logger;
+    constructor(queue: Queue<TPayload>, signal: AbortSignal, config: PollerConfig, logger: Logger);
+    poll(): Promise<PgmqMessageRecord<TPayload>[]>;
+    private isAborted;
+}
+//# sourceMappingURL=ReadWithPollPoller.d.ts.map

package/dist/queue/ReadWithPollPoller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadWithPollPoller.d.ts","sourceRoot":"","sources":["../../src/queue/ReadWithPollPoller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,qBAAa,kBAAkB,CAAC,QAAQ,SAAS,IAAI;IAIjD,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC;IACzC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,WAAW;IACtC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY;IALzC,OAAO,CAAC,MAAM,CAAS;gBAGF,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,EACtB,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,YAAY,EACvC,MAAM,EAAE,MAAM;IAKV,IAAI,IAAI,OAAO,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC;IAkBpD,OAAO,CAAC,SAAS;CAGlB"}

package/dist/queue/ReadWithPollPoller.js

@@ -0,0 +1,25 @@
+export class ReadWithPollPoller {
+    queue;
+    signal;
+    config;
+    logger;
+    constructor(queue, signal, config, logger) {
+        this.queue = queue;
+        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 queue '${this.queue.queueName}' with batch size ${this.config.batchSize}`);
+        const messages = await this.queue.readWithPoll(this.config.batchSize, this.config.visibilityTimeout, this.config.maxPollSeconds, this.config.pollIntervalMs);
+        this.logger.debug(`Received ${messages.length} messages from queue '${this.queue.queueName}'`);
+        return messages;
+    }
+    isAborted() {
+        return this.signal.aborted;
+    }
+}