@ventually/memory 0.0.0

package/README.md

@@ -0,0 +1,63 @@
+# `@ventually/memory`
+
+In-memory adapter for Eventually queues.
+
+## Usage
+
+```ts
+import { MemoryAdapter } from "@ventually/memory";
+import { Queue, Worker } from "@ventually/core";
+
+const adapter = new MemoryAdapter();
+```
+
+Works in both browser and server runtimes. State is instance-local and not persistent.
+
+## Dev
+
+Typecheck:
+
+```bash
+bun --filter @ventually/memory check-types
+```
+
+Build:
+
+```bash
+bun --filter @ventually/memory build
+```
+
+Unit tests:
+
+```bash
+bun --filter @ventually/memory test
+```
+
+Stress test:
+
+```bash
+bun --filter @ventually/memory test:stress
+```
+
+Useful stress env vars:
+
+- `EVENTUALLY_MEMORY_STRESS_JOBS`
+- `EVENTUALLY_MEMORY_STRESS_WORKERS`
+- `EVENTUALLY_MEMORY_STRESS_CONCURRENCY`
+- `EVENTUALLY_MEMORY_STRESS_TIMEOUT_MS`
+- `EVENTUALLY_MEMORY_STRESS_POLL_INTERVAL_MS`
+- `EVENTUALLY_MEMORY_STRESS_STAGGER_MS`
+
+Example:
+
+```bash
+EVENTUALLY_MEMORY_STRESS_JOBS=5000 \
+EVENTUALLY_MEMORY_STRESS_WORKERS=8 \
+EVENTUALLY_MEMORY_STRESS_CONCURRENCY=16 \
+bun --filter @ventually/memory test:stress
+```
+
+## Notes
+
+- `close()` is non-destructive and does not clear queue state.
+- Use `reset()` when you want to explicitly clear all in-memory state.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { MemoryAdapter } from "./memory-adapter.js";
+export type { MemoryAdapterOptions, MemoryJobSnapshot, MemoryQueueSnapshot, } from "./memory-adapter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EACV,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { MemoryAdapter } from "./memory-adapter.js";

package/dist/memory-adapter.d.ts

@@ -0,0 +1,53 @@
+import type { AdapterClaimOptions, AdapterEnqueueRequest, AdapterFailureRecord, AdapterJobRecord, IQueueAdapter } from "@ventually/core";
+export interface MemoryAdapterOptions {
+    now?: () => number;
+}
+export interface MemoryJobSnapshot extends AdapterJobRecord {
+    availableAt: number;
+}
+export interface MemoryQueueSnapshot {
+    name: string;
+    counts: Record<AdapterJobRecord["state"], number>;
+    jobs: MemoryJobSnapshot[];
+}
+export declare class MemoryAdapter implements IQueueAdapter {
+    private readonly queues;
+    private readonly baseNow;
+    private offsetMs;
+    private sequence;
+    constructor(options?: MemoryAdapterOptions);
+    now(): number;
+    advanceTime(ms: number): void;
+    reset(): void;
+    getQueueNames(): string[];
+    getQueueSnapshot(queueName: string): MemoryQueueSnapshot;
+    getAllQueuesSnapshot(): MemoryQueueSnapshot[];
+    enqueue(request: AdapterEnqueueRequest): Promise<AdapterJobRecord>;
+    enqueueMany(requests: AdapterEnqueueRequest[]): Promise<AdapterJobRecord[]>;
+    getJob(queueName: string, jobId: string): Promise<AdapterJobRecord | null>;
+    claimNext(queueName: string, options: AdapterClaimOptions): Promise<AdapterJobRecord[]>;
+    complete(queueName: string, jobId: string, lockToken: string, result: unknown, finishedAt: number, keep: {
+        mode: "all" | "none" | "count";
+        count?: number;
+    }): Promise<void>;
+    fail(queueName: string, jobId: string, lockToken: string, failure: AdapterFailureRecord, finishedAt: number, retryAt: number | null, keep: {
+        mode: "all" | "none" | "count";
+        count?: number;
+    }): Promise<void>;
+    updateProgress(queueName: string, jobId: string, lockToken: string, progress: unknown, updatedAt: number): Promise<void>;
+    recoverStalled(queueName: string, now: number, lockTtlMs: number, limit: number): Promise<AdapterJobRecord[]>;
+    close(): Promise<void>;
+    private enqueueInternal;
+    private getStore;
+    private pushWaiting;
+    private pushDelayed;
+    private promoteDueJobs;
+    private requireJob;
+    private assertLock;
+    private pushTerminal;
+    private applyKeepPolicy;
+    private resolveParent;
+    private failParent;
+    private finalizeParentFailure;
+}
+//# sourceMappingURL=memory-adapter.d.ts.map

package/dist/memory-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-adapter.d.ts","sourceRoot":"","sources":["../src/memory-adapter.ts"],"names":[],"mappings":"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"}

package/dist/memory-adapter.js

@@ -0,0 +1,519 @@
+class BinaryHeap {
+    compare;
+    values = [];
+    constructor(compare) {
+        this.compare = compare;
+    }
+    push(value) {
+        this.values.push(value);
+        this.bubbleUp(this.values.length - 1);
+    }
+    peek() {
+        return this.values[0];
+    }
+    pop() {
+        const first = this.values[0];
+        const last = this.values.pop();
+        if (last === undefined) {
+            return undefined;
+        }
+        if (this.values.length === 0) {
+            return last;
+        }
+        this.values[0] = last;
+        this.bubbleDown(0);
+        return first;
+    }
+    get size() {
+        return this.values.length;
+    }
+    clear() {
+        this.values.length = 0;
+    }
+    bubbleUp(index) {
+        let current = index;
+        while (current > 0) {
+            const parent = Math.floor((current - 1) / 2);
+            if (this.compare(this.values[current], this.values[parent]) >= 0) {
+                break;
+            }
+            this.swap(current, parent);
+            current = parent;
+        }
+    }
+    bubbleDown(index) {
+        let current = index;
+        while (true) {
+            const left = current * 2 + 1;
+            const right = left + 1;
+            let next = current;
+            if (left < this.values.length &&
+                this.compare(this.values[left], this.values[next]) < 0) {
+                next = left;
+            }
+            if (right < this.values.length &&
+                this.compare(this.values[right], this.values[next]) < 0) {
+                next = right;
+            }
+            if (next === current) {
+                return;
+            }
+            this.swap(current, next);
+            current = next;
+        }
+    }
+    swap(left, right) {
+        const current = this.values[left];
+        this.values[left] = this.values[right];
+        this.values[right] = current;
+    }
+}
+function cloneRecord(record) {
+    return {
+        ...record,
+        backoff: record.backoff ? { ...record.backoff } : null,
+        removeOnComplete: { ...record.removeOnComplete },
+        removeOnFail: { ...record.removeOnFail },
+    };
+}
+function computeRetryAt(record, now) {
+    if (!record.backoff) {
+        return now;
+    }
+    if (record.backoff.type === "fixed") {
+        return now + record.backoff.delayMs;
+    }
+    const delay = record.backoff.delayMs * 2 ** Math.max(0, record.attempt - 1);
+    return now + Math.min(delay, record.backoff.maxDelayMs ?? delay);
+}
+function createQueueStore() {
+    return {
+        jobs: new Map(),
+        waiting: new BinaryHeap((left, right) => {
+            if (left.priority !== right.priority) {
+                return right.priority - left.priority;
+            }
+            return left.sequence - right.sequence;
+        }),
+        delayed: new BinaryHeap((left, right) => {
+            if (left.availableAt !== right.availableAt) {
+                return left.availableAt - right.availableAt;
+            }
+            return left.sequence - right.sequence;
+        }),
+        active: new BinaryHeap((left, right) => {
+            if (left.availableAt !== right.availableAt) {
+                return left.availableAt - right.availableAt;
+            }
+            return left.sequence - right.sequence;
+        }),
+        activeExpiries: new Map(),
+        completed: [],
+        completedHead: 0,
+        failed: [],
+        failedHead: 0,
+    };
+}
+export class MemoryAdapter {
+    queues = new Map();
+    baseNow;
+    offsetMs = 0;
+    sequence = 0;
+    constructor(options = {}) {
+        this.baseNow = options.now ?? Date.now;
+    }
+    now() {
+        return this.baseNow() + this.offsetMs;
+    }
+    advanceTime(ms) {
+        this.offsetMs += ms;
+    }
+    reset() {
+        this.queues.clear();
+        this.offsetMs = 0;
+        this.sequence = 0;
+    }
+    getQueueNames() {
+        return [...this.queues.keys()].sort();
+    }
+    getQueueSnapshot(queueName) {
+        const store = this.getStore(queueName);
+        const jobs = [...store.jobs.values()]
+            .map((record) => ({
+            ...cloneRecord(record),
+            availableAt: record.availableAt,
+        }))
+            .sort((left, right) => left.createdAt - right.createdAt);
+        return {
+            name: queueName,
+            counts: {
+                waiting: jobs.filter((job) => job.state === "waiting").length,
+                blocked: jobs.filter((job) => job.state === "blocked").length,
+                active: jobs.filter((job) => job.state === "active").length,
+                delayed: jobs.filter((job) => job.state === "delayed").length,
+                completed: jobs.filter((job) => job.state === "completed").length,
+                failed: jobs.filter((job) => job.state === "failed").length,
+            },
+            jobs,
+        };
+    }
+    getAllQueuesSnapshot() {
+        return this.getQueueNames().map((queueName) => this.getQueueSnapshot(queueName));
+    }
+    async enqueue(request) {
+        return this.enqueueInternal(request);
+    }
+    async enqueueMany(requests) {
+        return requests.map((request) => this.enqueueInternal(request));
+    }
+    async getJob(queueName, jobId) {
+        const store = this.queues.get(queueName);
+        const record = store?.jobs.get(jobId);
+        return record ? cloneRecord(record) : null;
+    }
+    async claimNext(queueName, options) {
+        const store = this.getStore(queueName);
+        this.promoteDueJobs(store, options.now);
+        const claimed = [];
+        while (claimed.length < options.limit) {
+            const entry = store.waiting.pop();
+            if (!entry) {
+                break;
+            }
+            const record = store.jobs.get(entry.id);
+            if (!record ||
+                record.state !== "waiting" ||
+                record.sequence !== entry.sequence ||
+                record.priority !== entry.priority) {
+                continue;
+            }
+            record.state = "active";
+            record.attempt += 1;
+            record.processedAt ??= options.now;
+            record.lockToken = `${record.id}:${record.attempt}:${options.now}`;
+            record.availableAt = options.now + options.lockTtlMs;
+            store.activeExpiries.set(record.id, record.availableAt);
+            store.active.push({
+                id: record.id,
+                availableAt: record.availableAt,
+                sequence: record.sequence,
+            });
+            claimed.push(cloneRecord(record));
+        }
+        return claimed;
+    }
+    async complete(queueName, jobId, lockToken, result, finishedAt, keep) {
+        const record = this.requireJob(queueName, jobId);
+        this.assertLock(record, lockToken);
+        const store = this.getStore(queueName);
+        store.activeExpiries.delete(jobId);
+        record.state = "completed";
+        record.finishedAt = finishedAt;
+        record.result = result;
+        record.lockToken = null;
+        this.pushTerminal(store, "completed", record.id, finishedAt);
+        this.applyKeepPolicy(store, "completed", keep, record.id);
+        this.resolveParent(record, finishedAt);
+    }
+    async fail(queueName, jobId, lockToken, failure, finishedAt, retryAt, keep) {
+        const record = this.requireJob(queueName, jobId);
+        this.assertLock(record, lockToken);
+        const store = this.getStore(queueName);
+        store.activeExpiries.delete(jobId);
+        record.failedReason = failure.message;
+        record.stack = failure.stack;
+        record.result = null;
+        record.finishedAt = retryAt === null ? finishedAt : null;
+        record.lockToken = null;
+        if (retryAt !== null) {
+            record.availableAt = retryAt;
+            if (retryAt <= finishedAt) {
+                record.state = "waiting";
+                this.pushWaiting(store, record);
+            }
+            else {
+                record.state = "delayed";
+                this.pushDelayed(store, record);
+            }
+            return;
+        }
+        record.state = "failed";
+        this.pushTerminal(store, "failed", record.id, finishedAt);
+        this.applyKeepPolicy(store, "failed", keep, record.id);
+        this.failParent(record, failure.message, finishedAt);
+    }
+    async updateProgress(queueName, jobId, lockToken, progress, updatedAt) {
+        const record = this.requireJob(queueName, jobId);
+        this.assertLock(record, lockToken);
+        record.progress = progress;
+        record.availableAt = Math.max(record.availableAt, updatedAt);
+        const store = this.getStore(queueName);
+        store.activeExpiries.set(record.id, record.availableAt);
+        store.active.push({
+            id: record.id,
+            availableAt: record.availableAt,
+            sequence: record.sequence,
+        });
+    }
+    async recoverStalled(queueName, now, lockTtlMs, limit) {
+        void lockTtlMs;
+        const store = this.getStore(queueName);
+        const recovered = [];
+        while (recovered.length < limit) {
+            const entry = store.active.peek();
+            if (!entry || entry.availableAt > now) {
+                break;
+            }
+            store.active.pop();
+            const record = store.jobs.get(entry.id);
+            if (!record ||
+                record.state !== "active" ||
+                record.sequence !== entry.sequence ||
+                store.activeExpiries.get(record.id) !== entry.availableAt) {
+                continue;
+            }
+            store.activeExpiries.delete(record.id);
+            record.lockToken = null;
+            if (record.attempt < record.attempts) {
+                const retryAt = computeRetryAt(record, now);
+                record.availableAt = retryAt;
+                if (retryAt <= now) {
+                    record.state = "waiting";
+                    this.pushWaiting(store, record);
+                }
+                else {
+                    record.state = "delayed";
+                    this.pushDelayed(store, record);
+                }
+            }
+            else {
+                record.state = "failed";
+                record.finishedAt = now;
+                this.pushTerminal(store, "failed", record.id, now);
+                this.applyKeepPolicy(store, "failed", record.removeOnFail, record.id);
+                this.failParent(record, record.failedReason ?? "stalled job failed", now);
+            }
+            recovered.push(cloneRecord(record));
+        }
+        return recovered;
+    }
+    async close() {
+        return;
+    }
+    enqueueInternal(request) {
+        const store = this.getStore(request.queueName);
+        const existing = store.jobs.get(request.id);
+        if (existing) {
+            return cloneRecord(existing);
+        }
+        const record = {
+            id: request.id,
+            queueName: request.queueName,
+            name: request.name,
+            data: request.data,
+            state: (request.pendingChildren ?? 0) > 0
+                ? "blocked"
+                : request.delay > 0
+                    ? "delayed"
+                    : "waiting",
+            attempt: 0,
+            attempts: request.attempts,
+            priority: request.priority,
+            delay: request.delay,
+            createdAt: request.createdAt,
+            processedAt: null,
+            finishedAt: null,
+            result: null,
+            failedReason: null,
+            stack: null,
+            progress: null,
+            lockToken: null,
+            backoff: request.backoff ?? null,
+            removeOnComplete: request.removeOnComplete,
+            removeOnFail: request.removeOnFail,
+            parentKey: request.parentKey ?? null,
+            pendingChildren: request.pendingChildren ?? 0,
+            childFailure: null,
+            sequence: this.sequence++,
+            availableAt: request.createdAt + request.delay,
+        };
+        store.jobs.set(record.id, record);
+        if (record.state === "waiting") {
+            this.pushWaiting(store, record);
+        }
+        else if (record.state === "delayed") {
+            this.pushDelayed(store, record);
+        }
+        return cloneRecord(record);
+    }
+    getStore(queueName) {
+        let store = this.queues.get(queueName);
+        if (!store) {
+            store = createQueueStore();
+            this.queues.set(queueName, store);
+        }
+        return store;
+    }
+    pushWaiting(store, record) {
+        store.waiting.push({
+            id: record.id,
+            priority: record.priority,
+            sequence: record.sequence,
+        });
+    }
+    pushDelayed(store, record) {
+        store.delayed.push({
+            id: record.id,
+            availableAt: record.availableAt,
+            sequence: record.sequence,
+        });
+    }
+    promoteDueJobs(store, now) {
+        while (true) {
+            const entry = store.delayed.peek();
+            if (!entry || entry.availableAt > now) {
+                return;
+            }
+            store.delayed.pop();
+            const record = store.jobs.get(entry.id);
+            if (!record ||
+                record.state !== "delayed" ||
+                record.sequence !== entry.sequence ||
+                record.availableAt !== entry.availableAt) {
+                continue;
+            }
+            record.state = "waiting";
+            this.pushWaiting(store, record);
+        }
+    }
+    requireJob(queueName, jobId) {
+        const store = this.queues.get(queueName);
+        const record = store?.jobs.get(jobId);
+        if (!record) {
+            throw new Error(`Job ${jobId} was not found in queue ${queueName}.`);
+        }
+        return record;
+    }
+    assertLock(record, lockToken) {
+        if (record.lockToken !== lockToken) {
+            throw new Error(`Job ${record.id} lock token mismatch.`);
+        }
+    }
+    pushTerminal(store, kind, jobId, finishedAt) {
+        const record = store.jobs.get(jobId);
+        if (!record) {
+            return;
+        }
+        record.finishedAt = finishedAt;
+        if (kind === "completed") {
+            store.completed.push(jobId);
+        }
+        else {
+            store.failed.push(jobId);
+        }
+    }
+    applyKeepPolicy(store, kind, keep, currentJobId) {
+        if (keep.mode === "all") {
+            return;
+        }
+        const entries = kind === "completed" ? store.completed : store.failed;
+        const headKey = kind === "completed" ? "completedHead" : "failedHead";
+        if (keep.mode === "none") {
+            store.jobs.delete(currentJobId);
+            if (entries.length > 0) {
+                entries[entries.length - 1] = "";
+            }
+            while (entries[store[headKey]] === "") {
+                if (headKey === "completedHead") {
+                    store.completedHead += 1;
+                }
+                else {
+                    store.failedHead += 1;
+                }
+            }
+            return;
+        }
+        const count = keep.count ?? 0;
+        while (entries.length - store[headKey] > count) {
+            const removed = entries[store[headKey]];
+            if (headKey === "completedHead") {
+                store.completedHead += 1;
+            }
+            else {
+                store.failedHead += 1;
+            }
+            if (removed) {
+                store.jobs.delete(removed);
+            }
+        }
+        if (store[headKey] > 256 && store[headKey] > entries.length / 2) {
+            if (kind === "completed") {
+                store.completed = entries.slice(store.completedHead);
+                store.completedHead = 0;
+            }
+            else {
+                store.failed = entries.slice(store.failedHead);
+                store.failedHead = 0;
+            }
+        }
+    }
+    resolveParent(record, finishedAt) {
+        if (!record.parentKey) {
+            return;
+        }
+        const [parentQueueName, parentJobId] = record.parentKey.split(":");
+        if (!parentQueueName || !parentJobId) {
+            return;
+        }
+        const parent = this.queues.get(parentQueueName)?.jobs.get(parentJobId);
+        if (!parent) {
+            return;
+        }
+        parent.pendingChildren = Math.max(0, parent.pendingChildren - 1);
+        if (parent.pendingChildren > 0) {
+            return;
+        }
+        if (parent.childFailure) {
+            this.finalizeParentFailure(parent, parent.childFailure, finishedAt);
+            return;
+        }
+        const store = this.getStore(parent.queueName);
+        if (parent.delay > 0 && parent.createdAt + parent.delay > finishedAt) {
+            parent.state = "delayed";
+            parent.availableAt = parent.createdAt + parent.delay;
+            this.pushDelayed(store, parent);
+            return;
+        }
+        parent.state = "waiting";
+        this.pushWaiting(store, parent);
+    }
+    failParent(record, reason, finishedAt) {
+        if (!record.parentKey) {
+            return;
+        }
+        const [parentQueueName, parentJobId] = record.parentKey.split(":");
+        if (!parentQueueName || !parentJobId) {
+            return;
+        }
+        const parent = this.queues.get(parentQueueName)?.jobs.get(parentJobId);
+        if (!parent) {
+            return;
+        }
+        parent.pendingChildren = Math.max(0, parent.pendingChildren - 1);
+        parent.childFailure = reason;
+        if (parent.pendingChildren === 0) {
+            this.finalizeParentFailure(parent, reason, finishedAt);
+        }
+    }
+    finalizeParentFailure(parent, reason, finishedAt) {
+        const store = this.getStore(parent.queueName);
+        store.activeExpiries.delete(parent.id);
+        parent.state = "failed";
+        parent.finishedAt = finishedAt;
+        parent.failedReason = reason;
+        parent.lockToken = null;
+        this.pushTerminal(store, "failed", parent.id, finishedAt);
+        this.applyKeepPolicy(store, "failed", parent.removeOnFail, parent.id);
+        this.failParent(parent, reason, finishedAt);
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@ventually/memory",
+  "version": "0.0.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run --project unit",
+    "test:stress": "bun run ./test/memory-adapter.stress.ts"
+  },
+  "dependencies": {
+    "@ventually/core": "*"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "*",
+    "@types/node": "^22.15.3",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
+  }
+}