@sockethub/data-layer 1.0.0-alpha.12 → 1.0.0-alpha.13

package/src/job-worker.test.ts

@@ -1,142 +0,0 @@
-import { expect } from "chai";
-import * as sinon from "sinon";
-
-import type { Logger } from "@sockethub/schemas";
-
-import { JobWorker } from "./index";
-
-const mockLogger: Logger = {
-    error: () => {},
-    warn: () => {},
-    info: () => {},
-    debug: () => {},
-};
-
-describe("JobWorker", () => {
-    let MockBull, jobWorker, cryptoMocks, sandbox;
-
-    beforeEach(() => {
-        sandbox = sinon.createSandbox();
-        cryptoMocks = {
-            objectHash: sandbox.stub(),
-            decrypt: sandbox.stub(),
-            encrypt: sandbox.stub(),
-            hash: sandbox.stub(),
-        };
-        MockBull = sandbox.stub().returns({
-            add: sandbox.stub(),
-            getJob: sandbox.stub(),
-            removeAllListeners: sandbox.stub(),
-            pause: sandbox.stub(),
-            resume: sandbox.stub(),
-            isPaused: sandbox.stub(),
-            obliterate: sandbox.stub(),
-            isRunning: sandbox.stub(),
-            close: sandbox.stub(),
-            emit: sandbox.stub(),
-            disconnect: sandbox.stub(),
-            on: sandbox.stub().callsArgWith(1, "a job id", "a result string"),
-        });
-
-        class TestJobWorker extends JobWorker {
-            init() {
-                this.redisConnection = MockBull();
-                const queueName = this.queueId.replace(/:/g, "-");
-                this.worker = MockBull(
-                    queueName,
-                    this.jobHandler.bind(this),
-                    this.redisConnection,
-                );
-            }
-            initCrypto() {
-                this.crypto = cryptoMocks;
-            }
-            getQueueId() {
-                return this.queueId;
-            }
-        }
-        jobWorker = new TestJobWorker(
-            "a parent id",
-            "a session id",
-            "secret is 32 char long like this",
-            {
-                url: "redis config",
-            },
-            mockLogger,
-        );
-        jobWorker.emit = sandbox.stub();
-    });
-
-    afterEach(() => {
-        sinon.restore();
-        sandbox.reset();
-    });
-
-    it("returns a valid JobWorker object", () => {
-        expect(typeof jobWorker).to.equal("object");
-        expect(jobWorker.getQueueId()).to.equal(
-            `sockethub:a parent id:data-layer:queue:a session id`,
-        );
-        expect(typeof jobWorker.onJob).to.equal("function");
-        expect(typeof jobWorker.shutdown).to.equal("function");
-    });
-
-    describe("onJob", () => {
-        it("queues the handler", () => {
-            jobWorker.onJob(() => {
-                throw new Error("This handler should never be called");
-            });
-            sinon.assert.notCalled(jobWorker.worker.on);
-        });
-    });
-
-    describe("jobHandler", () => {
-        it("calls handler as expected", async () => {
-            cryptoMocks.decrypt.returns("an unencrypted message");
-            const encryptedJob = {
-                data: {
-                    title: "a title",
-                    msg: "an encrypted message",
-                    sessionId: "a socket id",
-                },
-            };
-            jobWorker.onJob((job) => {
-                const decryptedData = encryptedJob.data;
-                decryptedData.msg = "an unencrypted message";
-                expect(job).to.eql(decryptedData);
-                decryptedData.msg += " handled";
-                return decryptedData;
-            });
-            const result = await jobWorker.jobHandler(encryptedJob);
-            expect(result.msg).to.eql("an unencrypted message handled");
-        });
-    });
-
-    describe("decryptJobData", () => {
-        it("decrypts and returns expected object", () => {
-            cryptoMocks.decrypt.returnsArg(0);
-            const jobData = {
-                data: {
-                    title: "foo",
-                    msg: "encryptedjobdata",
-                    sessionId: "foobar",
-                },
-            };
-            const secret = "secretstring";
-            expect(jobWorker.decryptJobData(jobData, secret)).to.be.eql(
-                jobData.data,
-            );
-        });
-    });
-
-    describe("decryptActivityStream", () => {
-        it("decrypts and returns expected object", () => {
-            cryptoMocks.decrypt.returnsArg(0);
-            const jobData = "encryptedjobdata";
-            const secret = "secretstring";
-            expect(jobWorker.decryptActivityStream(jobData, secret)).to.be.eql(
-                jobData,
-            );
-        });
-    });
-});

package/src/job-worker.ts

@@ -1,116 +0,0 @@
-import {
-    createLogger,
-    getLoggerNamespace,
-    type Logger,
-} from "@sockethub/logger";
-import { Worker } from "bullmq";
-
-import { JobBase } from "./job-base.js";
-import { buildQueueId } from "./queue-id.js";
-import type { JobEncrypted, JobHandler, RedisConfig } from "./types.js";
-
-/**
- * Worker for processing jobs from a Redis queue within platform child processes.
- *
- * Connects to the same queue as its corresponding JobQueue instance and processes
- * jobs using a platform-specific handler function. Provides automatic decryption
- * of job data and error handling.
- *
- * @example
- * ```typescript
- * const worker = new JobWorker('irc-platform', 'session123', secret, redisConfig);
- * worker.onJob(async (job) => {
- *   // Process the decrypted ActivityStreams message
- *   return await processMessage(job.msg);
- * });
- * ```
- */
-export class JobWorker extends JobBase {
-    private readonly connectionName: string;
-    protected worker: Worker;
-    protected handler: JobHandler;
-    private readonly log: Logger;
-    private readonly redisConfig: RedisConfig;
-    protected readonly queueId: string;
-    private initialized = false;
-
-    /**
-     * Creates a new JobWorker instance.
-     *
-     * @param parentId - Must match the parentId of the corresponding JobQueue
-     * @param instanceId - Must match the instanceId of the corresponding JobQueue
-     * @param secret - 32-character encryption secret, must match JobQueue secret
-     * @param redisConfig - Redis connection configuration
-     */
-    constructor(
-        parentId: string,
-        instanceId: string,
-        secret: string,
-        redisConfig: RedisConfig,
-    ) {
-        super(secret);
-        // Create logger with full namespace (context will be prepended automatically)
-        this.log = createLogger(`data-layer:worker:${parentId}:${instanceId}`);
-
-        // Use logger's full namespace (includes context) for Redis connection name
-        this.connectionName = getLoggerNamespace(this.log);
-        redisConfig.connectionName = this.connectionName;
-
-        // Queue ID must match JobQueue's namespace (context-free) for cross-process connection
-        this.queueId = buildQueueId(parentId, instanceId);
-        this.redisConfig = redisConfig;
-    }
-
-    protected init() {
-        if (this.initialized) {
-            throw new Error(
-                `JobWorker already initialized for ${this.queueId}`,
-            );
-        }
-        this.initialized = true;
-        // BullMQ v5+ prohibits colons in queue names; derive the queue name
-        // from the canonical queue id by replacing ':' with '-'.
-        const queueName = this.queueId.replace(/:/g, "-");
-        // Let BullMQ create its own connection (it duplicates them internally anyway)
-        this.worker = new Worker(queueName, this.jobHandler.bind(this), {
-            connection: this.redisConfig,
-            // Prevent infinite retry loops when platform child process crashes mid-job.
-            // If worker disappears (crash/disconnect), job becomes "stalled" and retries
-            // up to maxStalledCount times (with default 30s interval) before failing permanently.
-            maxStalledCount: 3,
-        });
-
-        // Handle Redis contention errors (e.g., BUSY from Lua scripts)
-        this.worker.on("error", (err) => {
-            this.log.warn(`worker error: ${err.message}`);
-        });
-
-        this.log.info("initialized");
-    }
-
-    /**
-     * Registers a job handler function and starts processing jobs from the queue.
-     *
-     * @param handler - Function that processes decrypted job data and returns results
-     */
-    onJob(handler: JobHandler): void {
-        this.handler = handler;
-        this.init();
-    }
-
-    /**
-     * Gracefully shuts down the worker, stopping job processing and cleaning up connections.
-     */
-    async shutdown() {
-        await this.worker.pause();
-        this.removeAllListeners();
-        this.worker.removeAllListeners();
-        await this.worker.close();
-    }
-
-    protected async jobHandler(encryptedJob: JobEncrypted) {
-        const job = this.decryptJobData(encryptedJob);
-        this.log.debug(`handling ${job.title} ${job.msg.type}`);
-        return await this.handler(job);
-    }
-}

package/src/queue-id.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { buildCredentialsStoreId, buildQueueId } from "./queue-id";
-
-describe("queue-id helpers", () => {
-    it("buildQueueId uses canonical namespace", () => {
-        expect(buildQueueId("parent", "platform")).toBe(
-            "sockethub:parent:data-layer:queue:platform",
-        );
-    });
-
-    it("buildCredentialsStoreId uses canonical namespace", () => {
-        expect(buildCredentialsStoreId("parent", "session")).toBe(
-            "sockethub:parent:data-layer:credentials-store:session",
-        );
-    });
-});

package/src/queue-id.ts

@@ -1,14 +0,0 @@
-const REDIS_QUEUE_PREFIX = "sockethub";
-
-// Canonical ids use ':' separators; BullMQ queue names are derived by replacing
-// ':' with '-' when constructing the queue name.
-export function buildQueueId(parentId: string, instanceId: string): string {
-    return `${REDIS_QUEUE_PREFIX}:${parentId}:data-layer:queue:${instanceId}`;
-}
-
-export function buildCredentialsStoreId(
-    parentId: string,
-    sessionId: string,
-): string {
-    return `${REDIS_QUEUE_PREFIX}:${parentId}:data-layer:credentials-store:${sessionId}`;
-}