@blokjs/trigger-worker 0.2.0

package/dist/index.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * @blok/trigger-worker
+ *
+ * Worker-based trigger for Blok workflows.
+ * Supports background job processing with:
+ * - Configurable concurrency per queue
+ * - Automatic retries with exponential backoff
+ * - Job timeouts
+ * - Priority-based job ordering
+ * - Delayed job scheduling
+ * - Queue statistics and monitoring
+ *
+ * Adapters:
+ * - BullMQ (Redis-backed, production)
+ * - InMemory (development/testing)
+ *
+ * @example BullMQ
+ * ```typescript
+ * import { WorkerTrigger, BullMQAdapter } from "@blok/trigger-worker";
+ *
+ * class MyWorkerTrigger extends WorkerTrigger {
+ *   protected adapter = new BullMQAdapter({
+ *     host: "localhost",
+ *     port: 6379,
+ *   });
+ *
+ *   protected nodes = myNodes;
+ *   protected workflows = myWorkflows;
+ * }
+ *
+ * const trigger = new MyWorkerTrigger();
+ * await trigger.listen();
+ *
+ * // Dispatch a job
+ * await trigger.dispatch("background-jobs", { userId: "123" }, {
+ *   priority: 10,
+ *   retries: 3,
+ *   delay: 5000, // delay 5 seconds
+ * });
+ * ```
+ *
+ * @example InMemory (development)
+ * ```typescript
+ * import { WorkerTrigger, InMemoryAdapter } from "@blok/trigger-worker";
+ *
+ * class DevWorkerTrigger extends WorkerTrigger {
+ *   protected adapter = new InMemoryAdapter();
+ *   protected nodes = myNodes;
+ *   protected workflows = myWorkflows;
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryAdapter = exports.BullMQAdapter = exports.WorkerTrigger = void 0;
+// Core exports
+var WorkerTrigger_1 = require("./WorkerTrigger");
+Object.defineProperty(exports, "WorkerTrigger", { enumerable: true, get: function () { return WorkerTrigger_1.WorkerTrigger; } });
+// Adapters
+var BullMQAdapter_1 = require("./adapters/BullMQAdapter");
+Object.defineProperty(exports, "BullMQAdapter", { enumerable: true, get: function () { return BullMQAdapter_1.BullMQAdapter; } });
+var InMemoryAdapter_1 = require("./adapters/InMemoryAdapter");
+Object.defineProperty(exports, "InMemoryAdapter", { enumerable: true, get: function () { return InMemoryAdapter_1.InMemoryAdapter; } });
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@blokjs/trigger-worker",
+	"version": "0.2.0",
+	"description": "Worker-based trigger for Blok workflows - supports background job processing with concurrency, retries, and scheduling",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"build": "rm -rf dist && bun run tsc",
+		"build:dev": "tsc --watch",
+		"test": "vitest run",
+		"test:dev": "vitest"
+	},
+	"author": "Deskree Technologies Inc.",
+	"license": "Apache-2.0",
+	"dependencies": {
+		"@blokjs/helper": "workspace:*",
+		"@blokjs/runner": "workspace:*",
+		"@blokjs/shared": "workspace:*",
+		"@opentelemetry/api": "^1.9.0",
+		"uuid": "^11.1.0"
+	},
+	"devDependencies": {
+		"@types/node": "^22.15.21",
+		"@types/uuid": "^11.0.0",
+		"typescript": "^5.8.3",
+		"vitest": "^4.0.18"
+	},
+	"peerDependencies": {
+		"bullmq": "^5.67.2",
+		"ioredis": "^5.9.2"
+	},
+	"peerDependenciesMeta": {
+		"bullmq": {
+			"optional": true
+		},
+		"ioredis": {
+			"optional": true
+		}
+	},
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/WorkerTrigger.test.ts

@@ -0,0 +1,510 @@
+/**
+ * WorkerTrigger Tests
+ *
+ * Tests the WorkerTrigger base class, WorkerAdapter interface,
+ * InMemoryAdapter, and BullMQAdapter configuration.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "./WorkerTrigger";
+import { InMemoryAdapter } from "./adapters/InMemoryAdapter";
+
+// ============================================================================
+// WorkerJob Interface Tests
+// ============================================================================
+
+describe("WorkerTrigger", () => {
+	describe("WorkerJob Interface", () => {
+		it("should accept valid worker job structure", () => {
+			const job: WorkerJob = {
+				id: "job-123",
+				data: { userId: "user-1", action: "send-email" },
+				headers: { "content-type": "application/json" },
+				queue: "background-jobs",
+				priority: 5,
+				attempts: 0,
+				maxRetries: 3,
+				createdAt: new Date(),
+				delay: 0,
+				timeout: 30000,
+				raw: {},
+				complete: async () => {},
+				fail: async () => {},
+			};
+
+			expect(job.id).toBe("job-123");
+			expect(job.data).toEqual({ userId: "user-1", action: "send-email" });
+			expect(job.queue).toBe("background-jobs");
+			expect(job.priority).toBe(5);
+			expect(job.maxRetries).toBe(3);
+		});
+
+		it("should handle minimal required fields", () => {
+			const job: WorkerJob = {
+				id: "job-min",
+				data: null,
+				headers: {},
+				queue: "default",
+				priority: 0,
+				attempts: 0,
+				maxRetries: 0,
+				createdAt: new Date(),
+				raw: null,
+				complete: async () => {},
+				fail: async () => {},
+			};
+
+			expect(job.id).toBeDefined();
+			expect(job.queue).toBeDefined();
+			expect(job.complete).toBeDefined();
+			expect(job.fail).toBeDefined();
+		});
+
+		it("should support optional delay and timeout", () => {
+			const job: WorkerJob = {
+				id: "job-delayed",
+				data: { type: "scheduled-report" },
+				headers: {},
+				queue: "reports",
+				priority: 1,
+				attempts: 0,
+				maxRetries: 2,
+				createdAt: new Date(),
+				delay: 60000,
+				timeout: 120000,
+				raw: {},
+				complete: async () => {},
+				fail: async () => {},
+			};
+
+			expect(job.delay).toBe(60000);
+			expect(job.timeout).toBe(120000);
+		});
+	});
+
+	describe("WorkerAdapter Interface", () => {
+		it("should validate adapter interface methods", () => {
+			const mockAdapter: WorkerAdapter = {
+				provider: "mock",
+				connect: vi.fn().mockResolvedValue(undefined),
+				disconnect: vi.fn().mockResolvedValue(undefined),
+				process: vi.fn().mockResolvedValue(undefined),
+				addJob: vi.fn().mockResolvedValue("job-1"),
+				stopProcessing: vi.fn().mockResolvedValue(undefined),
+				isConnected: vi.fn().mockReturnValue(true),
+				healthCheck: vi.fn().mockResolvedValue(true),
+				getQueueStats: vi.fn().mockResolvedValue({
+					waiting: 5,
+					active: 2,
+					completed: 100,
+					failed: 3,
+					delayed: 1,
+				}),
+			};
+
+			expect(mockAdapter.provider).toBe("mock");
+			expect(typeof mockAdapter.connect).toBe("function");
+			expect(typeof mockAdapter.disconnect).toBe("function");
+			expect(typeof mockAdapter.process).toBe("function");
+			expect(typeof mockAdapter.addJob).toBe("function");
+			expect(typeof mockAdapter.stopProcessing).toBe("function");
+			expect(typeof mockAdapter.isConnected).toBe("function");
+			expect(typeof mockAdapter.healthCheck).toBe("function");
+			expect(typeof mockAdapter.getQueueStats).toBe("function");
+		});
+
+		it("should return correct queue stats structure", async () => {
+			const stats: WorkerQueueStats = {
+				waiting: 10,
+				active: 3,
+				completed: 500,
+				failed: 12,
+				delayed: 5,
+			};
+
+			expect(stats.waiting).toBe(10);
+			expect(stats.active).toBe(3);
+			expect(stats.completed).toBe(500);
+			expect(stats.failed).toBe(12);
+			expect(stats.delayed).toBe(5);
+		});
+	});
+});
+
+// ============================================================================
+// InMemoryAdapter Tests
+// ============================================================================
+
+describe("InMemoryAdapter", () => {
+	let adapter: InMemoryAdapter;
+
+	beforeEach(() => {
+		adapter = new InMemoryAdapter();
+	});
+
+	afterEach(async () => {
+		await adapter.disconnect();
+	});
+
+	describe("Connection Lifecycle", () => {
+		it("should connect successfully", async () => {
+			expect(adapter.isConnected()).toBe(false);
+			await adapter.connect();
+			expect(adapter.isConnected()).toBe(true);
+		});
+
+		it("should disconnect successfully", async () => {
+			await adapter.connect();
+			expect(adapter.isConnected()).toBe(true);
+			await adapter.disconnect();
+			expect(adapter.isConnected()).toBe(false);
+		});
+
+		it("should report healthy when connected", async () => {
+			await adapter.connect();
+			expect(await adapter.healthCheck()).toBe(true);
+		});
+
+		it("should report unhealthy when disconnected", async () => {
+			expect(await adapter.healthCheck()).toBe(false);
+		});
+
+		it("should have provider name 'in-memory'", () => {
+			expect(adapter.provider).toBe("in-memory");
+		});
+	});
+
+	describe("Job Dispatching", () => {
+		it("should add a job and return its ID", async () => {
+			await adapter.connect();
+			const jobId = await adapter.addJob("test-queue", { action: "test" });
+			expect(jobId).toBeDefined();
+			expect(typeof jobId).toBe("string");
+		});
+
+		it("should accept custom job ID", async () => {
+			await adapter.connect();
+			const jobId = await adapter.addJob(
+				"test-queue",
+				{ data: 1 },
+				{
+					jobId: "custom-id-123",
+				},
+			);
+			expect(jobId).toBe("custom-id-123");
+		});
+
+		it("should add jobs with priority ordering", async () => {
+			await adapter.connect();
+			await adapter.addJob("priority-queue", { order: "low" }, { priority: 1 });
+			await adapter.addJob("priority-queue", { order: "high" }, { priority: 10 });
+			await adapter.addJob("priority-queue", { order: "medium" }, { priority: 5 });
+
+			const stats = await adapter.getQueueStats("priority-queue");
+			expect(stats.waiting).toBe(3);
+		});
+
+		it("should add delayed jobs", async () => {
+			await adapter.connect();
+			await adapter.addJob(
+				"delayed-queue",
+				{ data: 1 },
+				{
+					delay: 5000,
+				},
+			);
+
+			const stats = await adapter.getQueueStats("delayed-queue");
+			expect(stats.delayed).toBe(1);
+			expect(stats.waiting).toBe(0);
+		});
+
+		it("should throw when not connected", async () => {
+			await expect(adapter.addJob("test-queue", { data: 1 })).rejects.toThrow("Not connected");
+		});
+	});
+
+	describe("Job Processing", () => {
+		it("should process jobs from a queue", async () => {
+			await adapter.connect();
+
+			const processedJobs: WorkerJob[] = [];
+
+			await adapter.process({ queue: "process-queue", concurrency: 1, retries: 3, priority: 0 }, async (job) => {
+				processedJobs.push(job);
+				await job.complete();
+			});
+
+			await adapter.addJob("process-queue", { item: "test-1" });
+
+			// Wait for processing
+			await new Promise((resolve) => setTimeout(resolve, 200));
+
+			expect(processedJobs).toHaveLength(1);
+			expect(processedJobs[0].data).toEqual({ item: "test-1" });
+		});
+
+		it("should process multiple jobs sequentially", async () => {
+			await adapter.connect();
+
+			const processedOrder: number[] = [];
+
+			await adapter.process({ queue: "seq-queue", concurrency: 1, retries: 3, priority: 0 }, async (job) => {
+				processedOrder.push(job.data as number);
+				await job.complete();
+			});
+
+			await adapter.addJob("seq-queue", 1);
+			await adapter.addJob("seq-queue", 2);
+			await adapter.addJob("seq-queue", 3);
+
+			await new Promise((resolve) => setTimeout(resolve, 500));
+
+			expect(processedOrder).toEqual([1, 2, 3]);
+		});
+
+		it("should track queue stats correctly", async () => {
+			await adapter.connect();
+
+			await adapter.process({ queue: "stats-queue", concurrency: 1, retries: 3, priority: 0 }, async (job) => {
+				await job.complete();
+			});
+
+			await adapter.addJob("stats-queue", { a: 1 });
+			await adapter.addJob("stats-queue", { a: 2 });
+
+			await new Promise((resolve) => setTimeout(resolve, 300));
+
+			const stats = await adapter.getQueueStats("stats-queue");
+			expect(stats.completed).toBe(2);
+			expect(stats.waiting).toBe(0);
+		});
+
+		it("should handle job failures", async () => {
+			await adapter.connect();
+
+			await adapter.process({ queue: "fail-queue", concurrency: 1, retries: 0, priority: 0 }, async (job) => {
+				await job.fail(new Error("test failure"), false);
+			});
+
+			await adapter.addJob("fail-queue", { data: "will-fail" }, { retries: 0 });
+
+			await new Promise((resolve) => setTimeout(resolve, 200));
+
+			const stats = await adapter.getQueueStats("fail-queue");
+			expect(stats.failed).toBe(1);
+		});
+
+		it("should requeue failed jobs for retry", async () => {
+			await adapter.connect();
+
+			let attemptCount = 0;
+
+			await adapter.process({ queue: "retry-queue", concurrency: 1, retries: 3, priority: 0 }, async (job) => {
+				attemptCount++;
+				if (attemptCount < 2) {
+					await job.fail(new Error("temporary failure"), true);
+				} else {
+					await job.complete();
+				}
+			});
+
+			await adapter.addJob("retry-queue", { data: "retry-me" }, { retries: 3 });
+
+			// Wait long enough for retry backoff + processing
+			await new Promise((resolve) => setTimeout(resolve, 3000));
+
+			expect(attemptCount).toBeGreaterThanOrEqual(2);
+		}, 5000);
+
+		it("should stop processing a queue", async () => {
+			await adapter.connect();
+
+			const processed: string[] = [];
+
+			await adapter.process({ queue: "stop-queue", concurrency: 1, retries: 3, priority: 0 }, async (job) => {
+				processed.push(job.id);
+				await job.complete();
+			});
+
+			await adapter.addJob("stop-queue", { first: true });
+			await new Promise((resolve) => setTimeout(resolve, 200));
+
+			await adapter.stopProcessing("stop-queue");
+
+			await adapter.addJob("stop-queue", { second: true });
+			await new Promise((resolve) => setTimeout(resolve, 200));
+
+			// Only first job should have been processed
+			expect(processed).toHaveLength(1);
+		});
+
+		it("should throw when processing without connection", async () => {
+			await expect(
+				adapter.process({ queue: "q", concurrency: 1, retries: 0, priority: 0 }, async () => {}),
+			).rejects.toThrow("Not connected");
+		});
+	});
+
+	describe("Queue Stats", () => {
+		it("should return zeros for unknown queue", async () => {
+			await adapter.connect();
+			const stats = await adapter.getQueueStats("nonexistent");
+			expect(stats).toEqual({
+				waiting: 0,
+				active: 0,
+				completed: 0,
+				failed: 0,
+				delayed: 0,
+			});
+		});
+
+		it("should track waiting count", async () => {
+			await adapter.connect();
+			await adapter.addJob("count-queue", { a: 1 });
+			await adapter.addJob("count-queue", { a: 2 });
+			await adapter.addJob("count-queue", { a: 3 });
+
+			const stats = await adapter.getQueueStats("count-queue");
+			expect(stats.waiting).toBe(3);
+		});
+	});
+});
+
+// ============================================================================
+// BullMQAdapter Config Tests
+// ============================================================================
+
+describe("BullMQAdapter", () => {
+	it("should read config from environment variables", () => {
+		const originalHost = process.env.REDIS_HOST;
+		const originalPort = process.env.REDIS_PORT;
+		const originalPassword = process.env.REDIS_PASSWORD;
+		const originalDb = process.env.REDIS_DB;
+
+		process.env.REDIS_HOST = "redis.example.com";
+		process.env.REDIS_PORT = "6380";
+		process.env.REDIS_PASSWORD = "secret123";
+		process.env.REDIS_DB = "2";
+
+		const config = {
+			host: process.env.REDIS_HOST || "localhost",
+			port: Number.parseInt(process.env.REDIS_PORT || "6379", 10),
+			password: process.env.REDIS_PASSWORD,
+			db: Number.parseInt(process.env.REDIS_DB || "0", 10),
+		};
+
+		expect(config.host).toBe("redis.example.com");
+		expect(config.port).toBe(6380);
+		expect(config.password).toBe("secret123");
+		expect(config.db).toBe(2);
+
+		// Restore
+		process.env.REDIS_HOST = originalHost;
+		process.env.REDIS_PORT = originalPort;
+		process.env.REDIS_PASSWORD = originalPassword;
+		process.env.REDIS_DB = originalDb;
+	});
+
+	it("should use default values when env vars not set", () => {
+		const originalHost = process.env.REDIS_HOST;
+		const originalPort = process.env.REDIS_PORT;
+
+		delete process.env.REDIS_HOST;
+		delete process.env.REDIS_PORT;
+
+		const config = {
+			host: process.env.REDIS_HOST || "localhost",
+			port: Number.parseInt(process.env.REDIS_PORT || "6379", 10),
+		};
+
+		expect(config.host).toBe("localhost");
+		expect(config.port).toBe(6379);
+
+		// Restore
+		process.env.REDIS_HOST = originalHost;
+		process.env.REDIS_PORT = originalPort;
+	});
+});
+
+// ============================================================================
+// WorkerTriggerOpts Schema Tests
+// ============================================================================
+
+describe("WorkerTriggerOpts Schema", () => {
+	it("should validate worker trigger configuration", () => {
+		const validConfig = {
+			queue: "background-jobs",
+			concurrency: 5,
+			timeout: 30000,
+			retries: 3,
+			priority: 10,
+			delay: 1000,
+		};
+
+		expect(validConfig.queue).toBe("background-jobs");
+		expect(validConfig.concurrency).toBe(5);
+		expect(validConfig.timeout).toBe(30000);
+		expect(validConfig.retries).toBe(3);
+		expect(validConfig.priority).toBe(10);
+		expect(validConfig.delay).toBe(1000);
+	});
+
+	it("should support minimal configuration", () => {
+		const minConfig = {
+			queue: "default",
+		};
+
+		expect(minConfig.queue).toBe("default");
+	});
+
+	it("should support high-concurrency configuration", () => {
+		const config = {
+			queue: "high-throughput",
+			concurrency: 50,
+			retries: 5,
+			timeout: 60000,
+			priority: 0,
+		};
+
+		expect(config.concurrency).toBe(50);
+		expect(config.retries).toBe(5);
+	});
+});
+
+// ============================================================================
+// Exponential Backoff Tests
+// ============================================================================
+
+describe("Exponential Backoff", () => {
+	it("should calculate increasing delays", () => {
+		const base = 1000;
+		const maxDelay = 30000;
+
+		const delays = [0, 1, 2, 3, 4, 5].map((attempt) => {
+			const exponential = Math.min(base * Math.pow(2, attempt), maxDelay);
+			return exponential;
+		});
+
+		expect(delays[0]).toBe(1000); // 1s
+		expect(delays[1]).toBe(2000); // 2s
+		expect(delays[2]).toBe(4000); // 4s
+		expect(delays[3]).toBe(8000); // 8s
+		expect(delays[4]).toBe(16000); // 16s
+		expect(delays[5]).toBe(30000); // capped at 30s
+	});
+
+	it("should cap at maximum delay", () => {
+		const base = 1000;
+		const maxDelay = 30000;
+
+		const delay = Math.min(base * Math.pow(2, 10), maxDelay);
+		expect(delay).toBe(30000);
+	});
+
+	it("should support custom base delay", () => {
+		const base = 500;
+		const exponential = base * Math.pow(2, 2);
+		expect(exponential).toBe(2000);
+	});
+});