@tstdl/base 0.93.77 → 0.93.80

package/queue/task-context.js

@@ -0,0 +1,102 @@
+import { currentTimestamp } from '../utils/date-time.js';
+import { isInstanceOf, isNumber, isUndefined } from '../utils/type-guards.js';
+import { Queue } from './queue.js';
+export class TaskContext {
+    #queue;
+    #logger;
+    #signal;
+    #task;
+    constructor(queue, task, signal, logger) {
+        this.#queue = queue;
+        this.#task = task;
+        this.#signal = signal;
+        this.#logger = logger.with({ taskId: task.id });
+    }
+    get id() {
+        return this.#task.id;
+    }
+    get data() {
+        return this.#task.data;
+    }
+    get attempt() {
+        return this.#task.tries;
+    }
+    get triesLeft() {
+        return this.#queue.maxTries - this.#task.tries;
+    }
+    get signal() {
+        return this.#signal.signal;
+    }
+    get logger() {
+        return this.#logger;
+    }
+    async acknowledge(result, transaction) {
+        await this.#queue.acknowledge(this.#task, result, transaction);
+    }
+    async checkpoint(options) {
+        const updatedTask = await this.#queue.touch(this.#task, options);
+        if (isUndefined(updatedTask)) {
+            this.#logger.warn('Lease lost during checkpoint');
+            this.#signal.set();
+        }
+        else {
+            this.#task = updatedTask;
+        }
+    }
+    async spawn(queueOrData, dataOrOptionsOrNothing, optionsOrNothing) {
+        if (isInstanceOf(queueOrData, Queue)) {
+            return await queueOrData.enqueue(dataOrOptionsOrNothing, { ...optionsOrNothing, parentId: this.#task.id });
+        }
+        return await this.#queue.enqueue(queueOrData, { ...dataOrOptionsOrNothing, parentId: this.#task.id });
+    }
+    async spawnMany(queueOrItems, itemsOrNothing) {
+        const isForOtherQueue = isInstanceOf(queueOrItems, Queue);
+        const items = (isForOtherQueue ? itemsOrNothing : queueOrItems).map((item) => ({ ...item, parentId: this.#task.id }));
+        if (isForOtherQueue) {
+            return await queueOrItems.enqueueMany(items, { returnTasks: true });
+        }
+        return await this.#queue.enqueueMany(items, { returnTasks: true });
+    }
+    async reschedule(timestampOrDelay) {
+        const timestamp = isNumber(timestampOrDelay)
+            ? timestampOrDelay
+            : currentTimestamp() + timestampOrDelay.delay;
+        this.#logger.debug(`Rescheduling task for ${new Date(timestamp).toISOString()}.`);
+        await this.#queue.reschedule(this.#task.id, timestamp);
+        this.#signal.set();
+    }
+    async fail(error, fatal, transaction) {
+        await this.#queue.fail(this.#task, error, fatal, transaction);
+        this.#signal.set();
+    }
+}
+export class BatchTaskContext {
+    #queue;
+    #tasks;
+    #logger;
+    #signal;
+    constructor(queue, tasks, signal, logger) {
+        this.#queue = queue;
+        this.#tasks = tasks;
+        this.#signal = signal;
+        this.#logger = logger.fork('Batch');
+    }
+    get tasks() {
+        return this.#tasks;
+    }
+    get signal() {
+        return this.#signal.signal;
+    }
+    get logger() {
+        return this.#logger;
+    }
+    for(task) {
+        return new TaskContext(this.#queue, task, this.#signal, this.#logger);
+    }
+    async checkpointAll(progresses, states) {
+        const validIds = await this.#queue.touchMany(this.#tasks, progresses, states);
+        if (validIds.length < this.#tasks.length) {
+            this.#logger.warn(`${this.#tasks.length - validIds.length} tasks in batch lost their lease during checkpoint`);
+        }
+    }
+}

package/queue/tests/queue.test.d.ts

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