@tstdl/base 0.93.77 → 0.93.78

package/document-management/server/drizzle/meta/_journal.json

@@ -15,6 +15,13 @@
       "when": 1764857079867,
       "tag": "0001_lyrical_wong",
       "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1767824153882,
+      "tag": "0002_round_warbird",
+      "breakpoints": true
     }
   ]
 }

package/document-management/server/services/document-collection.service.js

@@ -26,13 +26,13 @@ let DocumentCollectionService = class DocumentCollectionService extends Transact
         }
         const loadIds = collectionsOrIds.filter((collection) => isString(collection));
         if (loadIds.length == 0) {
-            return this.#ancillaryService.resolveMetadata(collectionsOrIds);
+            return this.#ancillaryService.resolveMetadata(tenantId, collectionsOrIds);
         }
         const loadedCollections = await this.repository.loadManyByQuery({ tenantId, id: { $in: loadIds } });
         const collections = collectionsOrIds.map((collectionOrId) => isString(collectionOrId)
             ? assertDefinedPass(loadedCollections.find((collection) => collection.id == collectionOrId), `Could not load collection "${collectionOrId}".`)
             : collectionOrId);
-        return this.#ancillaryService.resolveMetadata(collections);
+        return this.#ancillaryService.resolveMetadata(tenantId, collections);
     }
     async resolveMetadataMap(tenantId, collectionsOrIds) {
         const names = await this.resolveMetadata(tenantId, collectionsOrIds);
@@ -63,7 +63,7 @@ let DocumentCollectionService = class DocumentCollectionService extends Transact
     }
     async assignDocument(document, collectionIds) {
         const values = toArray(collectionIds).map((collectionId) => ({ tenantId: document.tenantId, collectionId, documentId: document.id, archiveTimestamp: null }));
-        await this.#documentCollectionAssignmentRepository.withSession(this.session).upsertMany(['collectionId', 'documentId'], values);
+        await this.#documentCollectionAssignmentRepository.withSession(this.session).upsertMany(['tenantId', 'collectionId', 'documentId'], values);
     }
     async archiveDocument(document, collectionIds) {
         await this.#documentCollectionAssignmentRepository.withSession(this.session).updateManyByQuery({ tenantId: document.tenantId, collectionId: { $in: toArray(collectionIds) }, documentId: document.id, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });

package/document-management/server/services/document-management-ancillary.service.d.ts

@@ -6,5 +6,5 @@ export declare abstract class DocumentManagementAncillaryService {
      * @param collections An array of DocumentCollection entities.
      * @returns A promise that resolves to an array of DocumentCollectionMetadata, corresponding to the input collections.
      */
-    abstract resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
+    abstract resolveMetadata(tenantId: string, collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
 }

package/document-management/server/services/document-management.service.js

@@ -56,7 +56,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
      */
     async getRelevantDocumentCollectionIds(tenantId, documentId) {
         const directAssignments = this.#documentCollectionService.session.$with('directAssignments').as((qb) => qb
-            .select({ collectionId: documentCollectionAssignment.id })
+            .select({ collectionId: documentCollectionAssignment.collectionId })
             .from(documentCollectionAssignment)
             .where(and(eq(documentCollectionAssignment.tenantId, tenantId), eq(documentCollectionAssignment.documentId, documentId))));
         const requestAssignments = this.#documentRequestCollectionAssignmentRepository.session.$with('requestAssignments').as((qb) => qb

package/document-management/server/services/document-workflow.service.js

@@ -45,7 +45,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
         if (this.isInTransaction) {
             return;
         }
-        this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => await this.processWorkflowJob(job), this.#logger);
+        this.#queue.process({ concurrency: 5, cancellationSignal }, async (taskContext) => await this.processWorkflowJob(taskContext), this.#logger);
     }
     async loadLatestWorkflow(tenantId, documentId) {
         return await this.repository.loadByQuery({ tenantId, documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
@@ -90,8 +90,8 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
         await this.repository.update(id, { state, completeTimestamp: (state == DocumentWorkflowState.Completed) ? currentTimestamp() : undefined, failReason });
         this.#observationService.workflowChange(id, this.session);
     }
-    async processWorkflowJob(job) {
-        const workflow = await this.repository.load(job.data.workflowId);
+    async processWorkflowJob(task) {
+        const workflow = await this.repository.load(task.data.workflowId);
         this.#logger.verbose(`Processing workflow "${workflow.step}" for document "${workflow.documentId}"`);
         try {
             await this.setWorkflowState(workflow.id, DocumentWorkflowState.Running);
@@ -109,10 +109,10 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
             else {
                 await this.setWorkflowState(workflow.id, DocumentWorkflowState.Review);
             }
+            await task.acknowledge();
         }
         catch (error) {
-            const isLastTry = job.tries >= this.#queue.maxTries;
-            if (isLastTry) {
+            if (task.triesLeft == 0) {
                 await this.repository.update(workflow.id, { state: DocumentWorkflowState.Error });
                 this.#observationService.documentChange(workflow.id, this.session);
             }

package/document-management/server/services/document.service.d.ts

@@ -8,8 +8,6 @@ export declare class DocumentService extends Transactional {
     create(tenantId: string, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }: TypedOmit<CreateDocumentParameters, 'uploadId'>, contentSource: Uint8Array<ArrayBuffer> | ReadableStream<Uint8Array<ArrayBuffer>> | {
         uploadId: string;
         uploadKey: string;
-    }, { createUserId }: {
-        createUserId?: string;
     }): Promise<Document>;
     update(tenantId: string, id: string, update: Partial<Pick<Document, UpdatableDocumentProperties>> & {
         tags?: string[];

package/document-management/server/services/document.service.js

@@ -38,7 +38,7 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     #observationService = inject(DocumentManagementObservationService);
     #logger = inject(Logger, DocumentService_1.name);
     repository = injectRepository(Document);
-    async create(tenantId, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }, contentSource, { createUserId }) {
+    async create(tenantId, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }, contentSource) {
         const document = await this.transaction(async (tx) => {
             const isUpload = isNotUint8Array(contentSource) && isNotReadableStream(contentSource);
             const document = await this.repository.withTransaction(tx).insert({
@@ -51,7 +51,6 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
                 summary: summary ?? null,
                 approval: approval ?? DocumentApproval.Pending,
                 comment: comment ?? null,
-                createUserId: createUserId ?? null,
                 originalFileName: originalFileName ?? null,
                 mimeType: 'pending',
                 hash: 'pending',

package/document-management/service-models/enriched/enriched-document.view.d.ts

@@ -6,7 +6,7 @@ import { EnrichedDocumentAssignment } from './enriched-document-assignment.view.
 import type { EnrichedDocumentCategory } from './enriched-document-category.view.js';
 import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
 import type { EnrichedDocumentType } from './enriched-document-type.view.js';
-export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'assignment' | 'tagIds' | 'createUserId'> {
+export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'assignment' | 'tagIds'> {
     #private;
     readonly id: string;
     readonly tenantId: string;

package/examples/document-management/main.d.ts

@@ -2,7 +2,7 @@ import '../../polyfills.js';
 import { DocumentManagementAuthorizationService, type DocumentCollection, type DocumentCollectionMetadata } from '../../document-management/index.js';
 import { DocumentManagementAncillaryService } from '../../document-management/server/index.js';
 export declare class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
-    resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[];
+    resolveMetadata(_tenantId: string, collections: DocumentCollection[]): DocumentCollectionMetadata[];
 }
 export declare class AllowAllDocumentManagementAuthorizationService extends DocumentManagementAuthorizationService {
     getTenantId(): string;

package/examples/document-management/main.js

@@ -54,7 +54,7 @@ const config = {
     },
 };
 let ExampleDocumentManagementAncillaryService = class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
-    resolveMetadata(collections) {
+    resolveMetadata(_tenantId, collections) {
         return collections.map((collection) => ({ name: collection.metadata.attributes['name'] ?? collection.id.split('-')[0], group: null }));
     }
 };

package/logger/transports/console.d.ts

@@ -1,6 +1,6 @@
 import { type InjectionToken, type Resolvable, type resolveArgumentType } from '../../injector/index.js';
 import type { ProvidersItem } from '../../injector/injector.js';
-import type { LogFormatter, LogPayload } from '../formatter.js';
+import { LogFormatter, type LogPayload } from '../formatter.js';
 import { LogLevel } from '../level.js';
 import { LogTransport, LogTransportOptions } from '../transport.js';
 export declare class ConsoleLogTransportOptions extends LogTransportOptions {

package/logger/transports/console.js

@@ -6,6 +6,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/index.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { LogFormatter } from '../formatter.js';
 import { LogLevel } from '../level.js';
 import { LogTransport, LogTransportOptions, provideLogTransport } from '../transport.js';
 export class ConsoleLogTransportOptions extends LogTransportOptions {
@@ -20,7 +22,8 @@ const consoleLevelFuncMap = {
     [LogLevel.Trace]: 'debug',
 };
 let ConsoleLogTransport = class ConsoleLogTransport extends LogTransport {
-    #formatter = inject(injectArgument(this).formatter);
+    #argument = injectArgument(this, { optional: true });
+    #formatter = isDefined(this.#argument?.formatter) ? inject(this.#argument.formatter) : inject(LogFormatter);
     log(payload) {
         const message = this.#formatter.format(payload);
         const consoleFunc = consoleLevelFuncMap[payload.level];

package/message-bus/message-bus-base.js

@@ -28,7 +28,7 @@ export class MessageBusBase extends MessageBus {
     }
     async [Symbol.asyncDispose]() {
         if (this.disposeToken.isSet) {
-            throw new Error('MessageBus is disposed.');
+            return;
         }
         this.disposeToken.set();
         this.publishSubject.complete();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.77",
+  "version": "0.93.78",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -16,6 +16,7 @@
     "build:docs:watch": "typedoc --watch",
     "lint": "eslint --cache source/",
     "pub": "npm run build:production && npm run cleanup:dist && npm publish dist/",
+    "test": "vitest run",
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
     "cleanup:dist": "rm -vrf dist/tools/",
@@ -161,7 +162,7 @@
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
-    "undici": "^7.16",
+    "undici": "^7.18",
     "urlpattern-polyfill": "^10.1",
     "zod": "^3.25"
   },
@@ -187,7 +188,9 @@
     "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.51"
+    "typescript-eslint": "8.52",
+    "vite-tsconfig-paths": "6.0",
+    "vitest": "4.0"
   },
   "overrides": {
     "drizzle-kit": {

package/queue/enqueue-batch.d.ts

@@ -1,17 +1,17 @@
-import type { EnqueueManyItem, EnqueueOptions, Job, Queue } from './queue.js';
-export interface QueueEnqueueBatchMethods<T> {
-    add(...args: Parameters<Queue<T>['enqueue']>): void;
-    enqueue(): ReturnType<Queue<T>['enqueueMany']>;
+import type { EnqueueManyItem, EnqueueOptions, Task, Queue } from './queue.js';
+export interface QueueEnqueueBatchMethods<Data, State, Result> {
+    add(...args: Parameters<Queue<Data, State, Result>['enqueue']>): void;
+    enqueue(): ReturnType<Queue<Data, State, Result>['enqueueMany']>;
 }
-export declare class QueueEnqueueBatch<T> implements QueueEnqueueBatchMethods<T> {
+export declare class QueueEnqueueBatch<Data, State, Result> implements QueueEnqueueBatchMethods<Data, State, Result> {
     private readonly queue;
     /** added items */
-    items: EnqueueManyItem<T>[];
-    constructor(queue: Queue<T>);
+    items: EnqueueManyItem<Data>[];
+    constructor(queue: Queue<Data, State, Result>);
     /** add data to items */
-    add(data: T, options?: EnqueueOptions): void;
+    add(data: Data, options?: EnqueueOptions): void;
     /** enqueues all added items */
-    enqueue(returnJobs?: false): Promise<void>;
-    enqueue(returnJobs: true): Promise<Job<T>[]>;
-    enqueue(returnJobs?: boolean): Promise<Job<T>[] | undefined>;
+    enqueue(returnTasks?: false): Promise<void>;
+    enqueue(returnTasks: true): Promise<Task<Data, State, Result>[]>;
+    enqueue(returnTasks?: boolean): Promise<Task<Data, State, Result>[] | undefined>;
 }

package/queue/enqueue-batch.js

@@ -10,10 +10,9 @@ export class QueueEnqueueBatch {
     add(data, options) {
         this.items.push({ data, ...options });
     }
-    async enqueue(returnJobs) {
+    async enqueue(returnTasks) {
         const items = this.items;
         this.items = [];
-        const result = await this.queue.enqueueMany(items, { returnJobs });
-        return result;
+        return await this.queue.enqueueMany(items, { returnTasks });
     }
 }

package/queue/index.d.ts

@@ -1,3 +1,4 @@
 export * from './enqueue-batch.js';
 export * from './provider.js';
 export * from './queue.js';
+export * from './task-context.js';

package/queue/index.js

@@ -1,3 +1,4 @@
 export * from './enqueue-batch.js';
 export * from './provider.js';
 export * from './queue.js';
+export * from './task-context.js';

package/queue/postgres/drizzle/0003_tricky_venom.sql

@@ -0,0 +1,30 @@
+CREATE TYPE "queue"."task_state" AS ENUM('pending', 'running', 'completed', 'cancelled', 'waiting', 'dead');--> statement-breakpoint
+CREATE TABLE "queue"."task" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"queue" text NOT NULL,
+	"status" "queue"."task_state" NOT NULL,
+	"tag" text,
+	"priority" integer NOT NULL,
+	"parent_id" uuid,
+	"lease" uuid,
+	"enqueue_timestamp" timestamp with time zone NOT NULL,
+	"schedule_timestamp" timestamp with time zone NOT NULL,
+	"start_timestamp" timestamp with time zone,
+	"expiration_timestamp" timestamp with time zone,
+	"lock_expiration_timestamp" timestamp with time zone,
+	"complete_timestamp" timestamp with time zone,
+	"tries" integer NOT NULL,
+	"progress" double precision NOT NULL,
+	"data" jsonb,
+	"state" jsonb,
+	"result" jsonb,
+	"error" jsonb,
+	CONSTRAINT "task_queue_tag_unique" UNIQUE("queue","tag")
+);
+--> statement-breakpoint
+DROP TABLE "queue"."job" CASCADE;--> statement-breakpoint
+ALTER TABLE "queue"."task" ADD CONSTRAINT "task_parent_id_task_id_fk" FOREIGN KEY ("parent_id") REFERENCES "queue"."task"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "task_parent_id_status_idx" ON "queue"."task" USING btree ("parent_id","status");--> statement-breakpoint
+CREATE INDEX "task_queue_complete_timestamp_idx" ON "queue"."task" USING btree ("queue","complete_timestamp");--> statement-breakpoint
+CREATE INDEX "task_queue_status_lock_expiration_timestamp_idx" ON "queue"."task" USING btree ("queue","status","lock_expiration_timestamp");--> statement-breakpoint
+CREATE INDEX "task_queue_status_priority_schedule_timestamp_idx" ON "queue"."task" USING btree ("queue","status","priority","schedule_timestamp");

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>;