@tstdl/base 0.93.77 → 0.93.80

package/queue/postgres/drizzle/meta/0003_snapshot.json

@@ -0,0 +1,288 @@
+{
+  "id": "705393d9-616b-4a01-9553-3b5408f64180",
+  "prevId": "74e8909c-3a81-46a3-9fe7-176e263da2df",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "queue.task": {
+      "name": "task",
+      "schema": "queue",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "queue": {
+          "name": "queue",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "task_state",
+          "typeSchema": "queue",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tag": {
+          "name": "tag",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "lease": {
+          "name": "lease",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enqueue_timestamp": {
+          "name": "enqueue_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "schedule_timestamp": {
+          "name": "schedule_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "start_timestamp": {
+          "name": "start_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expiration_timestamp": {
+          "name": "expiration_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "lock_expiration_timestamp": {
+          "name": "lock_expiration_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "complete_timestamp": {
+          "name": "complete_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tries": {
+          "name": "tries",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "progress": {
+          "name": "progress",
+          "type": "double precision",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "data": {
+          "name": "data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "state": {
+          "name": "state",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "result": {
+          "name": "result",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error": {
+          "name": "error",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "task_parent_id_status_idx": {
+          "name": "task_parent_id_status_idx",
+          "columns": [
+            {
+              "expression": "parent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "task_queue_complete_timestamp_idx": {
+          "name": "task_queue_complete_timestamp_idx",
+          "columns": [
+            {
+              "expression": "queue",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "complete_timestamp",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "task_queue_status_lock_expiration_timestamp_idx": {
+          "name": "task_queue_status_lock_expiration_timestamp_idx",
+          "columns": [
+            {
+              "expression": "queue",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "lock_expiration_timestamp",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "task_queue_status_priority_schedule_timestamp_idx": {
+          "name": "task_queue_status_priority_schedule_timestamp_idx",
+          "columns": [
+            {
+              "expression": "queue",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "priority",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "schedule_timestamp",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "task_parent_id_task_id_fk": {
+          "name": "task_parent_id_task_id_fk",
+          "tableFrom": "task",
+          "tableTo": "task",
+          "schemaTo": "queue",
+          "columnsFrom": [
+            "parent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "task_queue_tag_unique": {
+          "name": "task_queue_tag_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "queue",
+            "tag"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "queue.task_state": {
+      "name": "task_state",
+      "schema": "queue",
+      "values": [
+        "pending",
+        "running",
+        "completed",
+        "cancelled",
+        "waiting",
+        "dead"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/queue/postgres/drizzle/meta/_journal.json

@@ -22,6 +22,13 @@
       "when": 1760974453539,
       "tag": "0002_dear_meggan",
       "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1767731213291,
+      "tag": "0003_tricky_venom",
+      "breakpoints": true
     }
   ]
 }

package/queue/postgres/drizzle.config.js

@@ -6,6 +6,6 @@ export default defineConfig({
     schema: resolve(__dirname, './schemas.js'),
     migrations: {
         schema: 'queue',
-        table: '_migrations'
-    }
+        table: '_migrations',
+    },
 });

package/queue/postgres/index.d.ts

@@ -1,4 +1,4 @@
-export * from './job.model.js';
+export * from './task.model.js';
 export * from './module.js';
 export * from './queue.js';
 export * from './queue.provider.js';

package/queue/postgres/index.js

@@ -1,4 +1,4 @@
-export * from './job.model.js';
+export * from './task.model.js';
 export * from './module.js';
 export * from './queue.js';
 export * from './queue.provider.js';

package/queue/postgres/module.d.ts

@@ -3,7 +3,7 @@ export declare class PostgresQueueModuleConfig {
     database?: DatabaseConfig;
 }
 /**
- * configure mail module
+ * configure queue module
  */
 export declare function configurePostgresQueue(config?: PostgresQueueModuleConfig, register?: boolean): void;
 export declare function migratePostgresQueueSchema(): Promise<void>;

package/queue/postgres/module.js

@@ -9,7 +9,7 @@ export class PostgresQueueModuleConfig {
     database;
 }
 /**
- * configure mail module
+ * configure queue module
  */
 export function configurePostgresQueue(config, register = true) {
     Injector.register(PostgresQueueModuleConfig, { useValue: config });

package/queue/postgres/queue.d.ts

@@ -1,31 +1,60 @@
 import { CancellationSignal } from '../../cancellation/index.js';
+import type { Query } from '../../orm/index.js';
+import { type Transaction } from '../../orm/server/index.js';
 import type { ObjectLiteral } from '../../types/index.js';
-import { Queue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Job, type JobTag } from '../queue.js';
-export declare class PostgresQueue<T extends ObjectLiteral> extends Queue<T> {
+import { Queue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Task, type TaskTag } from '../queue.js';
+export declare class PostgresQueue<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral> extends Queue<Data, State, Result> {
     #private;
     readonly processTimeout: number;
+    readonly executionTimeout: number;
     readonly maxTries: number;
-    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
-        returnJobs?: false;
+    readonly retryDelayMinimum: number;
+    readonly retryDelayMaximum: number;
+    readonly retryDelayGrowth: number;
+    readonly retentionPeriod: number;
+    readonly globalConcurrency: number | null;
+    enqueue(data: Data, options?: EnqueueOneOptions): Promise<Task<Data, State, Result>>;
+    enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions & {
+        returnTasks?: false;
     }): Promise<void>;
-    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
-        returnJobs: true;
-    }): Promise<Job<T>[]>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
+    enqueueMany(items: EnqueueManyItem<Data>[], options: EnqueueManyOptions & {
+        returnTasks: true;
+    }): Promise<Task<Data, State, Result>[]>;
+    enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions): Promise<Task<Data, State, Result>[] | undefined>;
     has(id: string): Promise<boolean>;
-    countByTag(tag: JobTag): Promise<number>;
-    get(id: string): Promise<Job<T> | undefined>;
-    getByTag(tag: JobTag): Promise<Job<T>[]>;
-    getByTags(tags: JobTag[]): Promise<Job<T>[]>;
-    cancel(id: string): Promise<void>;
-    cancelMany(ids: string[]): Promise<void>;
-    cancelByTag(tag: JobTag): Promise<void>;
-    cancelByTags(tags: JobTag[]): Promise<void>;
-    dequeue(): Promise<Job<T> | undefined>;
-    dequeueMany(count: number): Promise<Job<T>[]>;
-    acknowledge(job: Job<T>): Promise<void>;
-    acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
-    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
+    countByTag(tag: TaskTag): Promise<number>;
+    get(id: string): Promise<Task<Data, State, Result> | undefined>;
+    getByTag(tag: TaskTag): Promise<Task<Data, State, Result>[]>;
+    getByTags(tags: TaskTag[]): Promise<Task<Data, State, Result>[]>;
+    getTree(idOrIds: string | string[], transaction?: Transaction): Promise<Task<unknown, unknown, unknown>[]>;
+    getTreeByQuery(query: Query<Task>, transaction?: Transaction): Promise<Task<unknown, unknown, unknown>[]>;
+    cancel(id: string, transaction?: Transaction): Promise<void>;
+    cancelMany(ids: string[], transaction?: Transaction): Promise<void>;
+    cancelByTag(tag: TaskTag): Promise<void>;
+    cancelManyByTag(tags: TaskTag[]): Promise<void>;
+    clear(): Promise<void>;
+    dequeue(): Promise<Task<Data, State, Result> | undefined>;
+    dequeueMany(count: number): Promise<Task<Data, State, Result>[]>;
+    reschedule(id: string, timestamp: number, transaction?: Transaction): Promise<void>;
+    rescheduleMany(ids: string[], timestamp: number, transaction?: Transaction): Promise<void>;
+    rescheduleByTag(tag: TaskTag, timestamp: number, transaction?: Transaction): Promise<void>;
+    rescheduleManyByTag(tags: TaskTag[], timestamp: number, transaction?: Transaction): Promise<void>;
+    touch(task: Task, options?: {
+        progress?: number;
+        state?: State;
+        transaction?: Transaction;
+    }): Promise<Task<Data, State, Result> | undefined>;
+    touchMany(tasks: Task[], progresses?: number[], states?: State[], transaction?: Transaction): Promise<string[]>;
+    acknowledge<R>(task: Task<any, any, R>, result?: R, transaction?: Transaction, { skipFanIn }?: {
+        skipFanIn?: boolean;
+    }): Promise<void>;
+    acknowledgeMany<R>(tasks: Task<any, any, R>[], results?: R[], transaction?: Transaction): Promise<void>;
+    fail(task: Task, error: any, fatal?: boolean, transaction?: Transaction, { skipFanIn }?: {
+        skipFanIn?: boolean;
+    }): Promise<void>;
+    failMany(tasks: Task[], errors: any[], transaction?: Transaction): Promise<void>;
+    prune(): Promise<void>;
+    restart(id: string, transaction?: Transaction): Promise<void>;
+    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Task<Data, State, Result>>;
+    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Task<Data, State, Result>[]>;
 }