@tstdl/base 0.93.86 → 0.93.89

package/queue/postgres/schemas.d.ts

@@ -1,14 +0,0 @@
-import { PostgresTask } from './task.model.js';
-export declare const queueSchema: import("../../orm/server/index.js").DatabaseSchema<"queue">;
-export declare const taskState: import("../../orm/enums.js").PgEnumFromEnumeration<{
-    readonly Pending: "pending";
-    readonly Running: "running";
-    readonly Completed: "completed";
-    readonly Cancelled: "cancelled";
-    readonly Waiting: "waiting";
-    readonly Dead: "dead";
-}>;
-export declare const task: import("../../orm/server/types.js").PgTableFromType<{
-    new (): PostgresTask<any, any, any>;
-    readonly entityName: "Task";
-}, "queue">;

package/queue/postgres/schemas.js

@@ -1,6 +0,0 @@
-import { databaseSchema } from '../../orm/server/index.js';
-import { TaskState } from '../queue.js';
-import { PostgresTask } from './task.model.js';
-export const queueSchema = databaseSchema('queue');
-export const taskState = queueSchema.getEnum(TaskState);
-export const task = queueSchema.getTable((PostgresTask));

package/queue/postgres/task.model.d.ts

@@ -1,24 +0,0 @@
-import { BaseEntity, type Json, type Timestamp } from '../../orm/index.js';
-import type { ObjectLiteral } from '../../types/types.js';
-import { type Task, TaskState } from '../queue.js';
-export declare class PostgresTask<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends BaseEntity implements Task<Data, State, Result> {
-    static readonly entityName = "Task";
-    queue: string;
-    status: TaskState;
-    tag: string | null;
-    priority: number;
-    parentId: string | null;
-    lease: string | null;
-    enqueueTimestamp: Timestamp;
-    scheduleTimestamp: Timestamp;
-    startTimestamp: Timestamp | null;
-    expirationTimestamp: Timestamp | null;
-    lockExpirationTimestamp: Timestamp | null;
-    completeTimestamp: Timestamp | null;
-    tries: number;
-    progress: number;
-    data: Json<Data>;
-    state: Json<State> | null;
-    result: Json<Result> | null;
-    error: Json<ObjectLiteral> | null;
-}

package/queue/postgres/task.model.js

@@ -1,115 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { BaseEntity, Index, JsonProperty, Reference, Table, TimestampProperty, Unique, UuidProperty } from '../../orm/index.js';
-import { Enumeration, Integer, NumberProperty, StringProperty } from '../../schema/index.js';
-import { TaskState } from '../queue.js';
-let PostgresTask = class PostgresTask extends BaseEntity {
-    static entityName = 'Task';
-    queue;
-    status;
-    tag;
-    priority;
-    parentId;
-    lease;
-    enqueueTimestamp;
-    scheduleTimestamp;
-    startTimestamp;
-    expirationTimestamp;
-    lockExpirationTimestamp;
-    completeTimestamp;
-    tries;
-    progress;
-    data;
-    state;
-    result;
-    error;
-};
-__decorate([
-    StringProperty(),
-    __metadata("design:type", String)
-], PostgresTask.prototype, "queue", void 0);
-__decorate([
-    Enumeration(TaskState),
-    __metadata("design:type", String)
-], PostgresTask.prototype, "status", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "tag", void 0);
-__decorate([
-    Integer(),
-    __metadata("design:type", Number)
-], PostgresTask.prototype, "priority", void 0);
-__decorate([
-    Reference(() => PostgresTask),
-    UuidProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "parentId", void 0);
-__decorate([
-    UuidProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "lease", void 0);
-__decorate([
-    TimestampProperty(),
-    __metadata("design:type", Number)
-], PostgresTask.prototype, "enqueueTimestamp", void 0);
-__decorate([
-    TimestampProperty(),
-    __metadata("design:type", Number)
-], PostgresTask.prototype, "scheduleTimestamp", void 0);
-__decorate([
-    TimestampProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "startTimestamp", void 0);
-__decorate([
-    TimestampProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "expirationTimestamp", void 0);
-__decorate([
-    TimestampProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "lockExpirationTimestamp", void 0);
-__decorate([
-    TimestampProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "completeTimestamp", void 0);
-__decorate([
-    Integer(),
-    __metadata("design:type", Number)
-], PostgresTask.prototype, "tries", void 0);
-__decorate([
-    NumberProperty(),
-    __metadata("design:type", Number)
-], PostgresTask.prototype, "progress", void 0);
-__decorate([
-    JsonProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "data", void 0);
-__decorate([
-    JsonProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "state", void 0);
-__decorate([
-    JsonProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "result", void 0);
-__decorate([
-    JsonProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "error", void 0);
-PostgresTask = __decorate([
-    Table('task', { schema: 'queue' }),
-    Unique(['queue', 'tag']),
-    Index(['queue', 'status', 'priority', 'scheduleTimestamp']),
-    Index(['queue', 'status', 'lockExpirationTimestamp']),
-    Index(['queue', 'completeTimestamp']),
-    Index(['parentId', 'status'])
-], PostgresTask);
-export { PostgresTask };

package/queue/provider.js

@@ -1,2 +0,0 @@
-export class QueueProvider {
-}

package/queue/queue.js

@@ -1,131 +0,0 @@
-import { defineEnum } from '../enumeration/enumeration.js';
-import { createArray } from '../utils/array/array.js';
-import { cancelableTimeout } from '../utils/timing.js';
-import { isDefined } from '../utils/type-guards.js';
-import { millisecondsPerDay, millisecondsPerMinute, millisecondsPerSecond } from '../utils/units.js';
-import { QueueEnqueueBatch } from './enqueue-batch.js';
-import { BatchTaskContext } from './task-context.js';
-export const TaskState = defineEnum('TaskState', {
-    /**
-     * The task is waiting to be processed.
-     */
-    Pending: 'pending',
-    /**
-     * The task is currently being processed.
-     */
-    Running: 'running',
-    /**
-     * The task has been completed successfully.
-     */
-    Completed: 'completed',
-    /**
-     * The task has been cancelled and will not be processed.
-     */
-    Cancelled: 'cancelled',
-    /**
-     * The task is scheduled to be processed in the future when all children have completed.
-     */
-    Waiting: 'waiting',
-    /**
-     * The task has failed and will not be retried.
-     */
-    Dead: 'dead',
-});
-export const defaultTaskPriority = 1000;
-export const UniqueTagStrategy = defineEnum('UniqueTagStrategy', {
-    KeepOld: 0,
-    TakeNew: 1,
-});
-export const defaultQueueConfig = {
-    processTimeout: millisecondsPerMinute * 5,
-    executionTimeout: millisecondsPerMinute * 60,
-    maxTries: 3,
-    retentionPeriod: 30 * millisecondsPerDay,
-    globalConcurrency: null,
-    circuitBreakerThreshold: 5,
-    circuitBreakerResetTimeout: 30 * millisecondsPerSecond,
-    retryDelayMinimum: 5 * millisecondsPerSecond,
-    retryDelayMaximum: 5 * millisecondsPerMinute,
-    retryDelayGrowth: 2,
-};
-export class Queue {
-    batch() {
-        return new QueueEnqueueBatch(this);
-    }
-    process({ concurrency = 1, cancellationSignal }, handler, logger) {
-        for (let i = 0; i < concurrency; i++) {
-            void this.processWorker(cancellationSignal, handler, logger);
-        }
-    }
-    processBatch({ batchSize = 10, concurrency = 1, cancellationSignal }, handler, logger) {
-        for (let i = 0; i < concurrency; i++) {
-            void this.processBatchWorker(batchSize, cancellationSignal, handler, logger);
-        }
-    }
-    async processWorker(cancellationSignal, handler, logger) {
-        await this.processBatchWorker(1, cancellationSignal, async (batchContext) => {
-            const task = batchContext.tasks[0];
-            const context = batchContext.for(task);
-            const result = await handler(context);
-            if (isDefined(result)) {
-                return [result];
-            }
-            return undefined;
-        }, logger);
-    }
-    async processBatchWorker(size, cancellationSignal, handler, logger) {
-        for await (const tasks of this.getBatchConsumer(size, cancellationSignal)) {
-            const batchToken = cancellationSignal.createChild();
-            const context = new BatchTaskContext(this, tasks, batchToken, logger);
-            let activeTaskIds = new Set(tasks.map((t) => t.id));
-            context.logger.verbose(`Processing batch of ${tasks.length}`);
-            void (async () => {
-                while (batchToken.isUnset) {
-                    await cancelableTimeout(Math.min(this.processTimeout / 2, 5000), batchToken);
-                    if (batchToken.isSet) {
-                        break;
-                    }
-                    try {
-                        const tasksToTouch = tasks.filter((t) => activeTaskIds.has(t.id));
-                        if (tasksToTouch.length > 0) {
-                            const touchedIds = await this.touchMany(tasksToTouch);
-                            if (touchedIds.length != tasksToTouch.length) {
-                                const lostCount = tasksToTouch.length - touchedIds.length;
-                                context.logger.warn(`Batch integrity compromised: ${lostCount} tasks lost lease. Aborting batch.`);
-                                activeTaskIds = new Set(touchedIds);
-                                batchToken.set();
-                            }
-                            else {
-                                activeTaskIds = new Set(touchedIds);
-                            }
-                        }
-                        if (activeTaskIds.size == 0 && batchToken.isUnset) {
-                            context.logger.warn(`All tasks in batch lost lease. Stopping worker.`);
-                            batchToken.set();
-                        }
-                    }
-                    catch (error) {
-                        context.logger.error(error);
-                    }
-                }
-            })();
-            try {
-                if (batchToken.isSet) {
-                    throw new Error('Tasks cancelled before start');
-                }
-                const results = await handler(context);
-                if (isDefined(results)) {
-                    context.logger.verbose(`Acknowledging batch`);
-                    await this.acknowledgeMany(tasks, results);
-                }
-            }
-            catch (error) {
-                context.logger.error(error);
-                await this.failMany(tasks, createArray(tasks.length, () => error));
-            }
-            finally {
-                batchToken.set();
-            }
-        }
-    }
-}