@pgflow/edge-worker 0.0.19 → 0.0.20

package/dist/CHANGELOG.md

@@ -0,0 +1,102 @@
+# @pgflow/edge-worker
+
+## 0.0.17
+
+### Patch Changes
+
+- @pgflow/core@0.0.17
+- @pgflow/dsl@0.0.17
+
+## 0.0.16
+
+### Patch Changes
+
+- @pgflow/core@0.0.16
+- @pgflow/dsl@0.0.16
+
+## 0.0.15
+
+### Patch Changes
+
+- @pgflow/core@0.0.15
+- @pgflow/dsl@0.0.15
+
+## 0.0.14
+
+### Patch Changes
+
+- @pgflow/core@0.0.14
+- @pgflow/dsl@0.0.14
+
+## 0.0.13
+
+### Patch Changes
+
+- @pgflow/core@0.0.13
+- @pgflow/dsl@0.0.13
+
+## 0.0.12
+
+### Patch Changes
+
+- @pgflow/core@0.0.12
+- @pgflow/dsl@0.0.12
+
+## 0.0.11
+
+### Patch Changes
+
+- Updated dependencies [17937e3]
+  - @pgflow/dsl@0.0.11
+  - @pgflow/core@0.0.11
+
+## 0.0.10
+
+### Patch Changes
+
+- Release again on NPM
+  - @pgflow/core@0.0.10
+  - @pgflow/dsl@0.0.10
+
+## 0.0.9
+
+### Patch Changes
+
+- 8786acf: Test jsr publish again
+- Updated dependencies [70d3f2d]
+  - @pgflow/dsl@0.0.9
+  - @pgflow/core@0.0.9
+
+## 0.0.8
+
+### Patch Changes
+
+- Test jsr version writing
+  - @pgflow/core@0.0.8
+  - @pgflow/dsl@0.0.8
+
+## 0.0.7
+
+### Patch Changes
+
+- 7c83db9: Add release-related options to package.json files
+- Updated dependencies [7c83db9]
+  - @pgflow/core@0.0.7
+  - @pgflow/dsl@0.0.7
+
+## 0.0.6
+
+### Patch Changes
+
+- 9dd4676: Update package.json configuration
+  - @pgflow/core@0.0.6
+  - @pgflow/dsl@0.0.6
+
+## 0.0.5
+
+### Patch Changes
+
+- Updated dependencies [196f7d8]
+- Updated dependencies [b4b0809]
+  - @pgflow/core@0.0.5
+  - @pgflow/dsl@0.0.5

package/dist/EdgeWorker.d.ts

@@ -0,0 +1,74 @@
+import type { Json } from './core/types.js';
+import { type QueueWorkerConfig } from './queue/createQueueWorker.js';
+import type { PlatformAdapter } from './platform/types.js';
+import { MessageHandlerFn } from './queue/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 platform;
+    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: MessageHandlerFn<TPayload>, 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,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAgC;IACvD,OAAO,CAAC,MAAM,CAAC,SAAS,CAAS;IAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;WACU,KAAK,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAC7C,OAAO,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EACnC,MAAM,GAAE,gBAAqB;IA6B/B;;OAEG;WACU,IAAI;IAQjB,OAAO,CAAC,MAAM,CAAC,eAAe;CAM/B"}

package/dist/EdgeWorker.js

@@ -0,0 +1,98 @@
+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 platform = 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.platform = await createAdapter();
+        // Apply default values to the config
+        const workerConfig = {
+            ...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 || this.platform.getConnectionString(),
+        };
+        await this.platform.startWorker((createLoggerFn) => createQueueWorker(handler, workerConfig, createLoggerFn));
+        return this.platform;
+    }
+    /**
+     * Stop the EdgeWorker and clean up resources.
+     */
+    static async stop() {
+        if (this.platform) {
+            await this.platform.stopWorker();
+        }
+        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;
+    }
+}