@tstdl/base 0.92.99 → 0.92.100

package/api/server/middlewares/cors.middleware.js

@@ -2,7 +2,6 @@ import { resolveApiEndpointDataProvider } from '../../../api/types.js';
 import { toArray } from '../../../utils/array/array.js';
 import { isDefined } from '../../../utils/type-guards.js';
 export function corsMiddleware(options = {}) {
-    // eslint-disable-next-line max-statements, @typescript-eslint/no-shadow
     async function corsMiddleware(context, next) {
         try {
             await next();
@@ -15,18 +14,18 @@ export function corsMiddleware(options = {}) {
             const cors = { ...options.default, ...endpointDefinition?.cors };
             if (isOptions) {
                 const allowMethods = (await resolveApiEndpointDataProvider(request, context, cors.accessControlAllowMethods)) ?? [...context.api.endpoints.keys()].join(', ');
-                response.headers.setIfMissing('Access-Control-Allow-Methods', allowMethods);
+                response.headers.set('Access-Control-Allow-Methods', allowMethods);
                 if (isDefined(cors.accessControlAllowHeaders) && !request.headers.has('Access-Control-Allow-Headers')) {
                     const value = await resolveApiEndpointDataProvider(request, context, cors.accessControlAllowHeaders);
-                    response.headers.setIfMissing('Access-Control-Allow-Headers', value);
+                    response.headers.set('Access-Control-Allow-Headers', value);
                 }
                 if (isDefined(cors.accessControlExposeHeaders) && !request.headers.has('Access-Control-Expose-Headers')) {
                     const value = await resolveApiEndpointDataProvider(request, context, cors.accessControlExposeHeaders);
-                    response.headers.setIfMissing('Access-Control-Expose-Headers', value);
+                    response.headers.set('Access-Control-Expose-Headers', value);
                 }
                 if (isDefined(cors.accessControlMaxAge) && !request.headers.has('Access-Control-Max-Age')) {
                     const value = await resolveApiEndpointDataProvider(request, context, cors.accessControlMaxAge);
-                    response.headers.setIfMissing('Access-Control-Max-Age', value);
+                    response.headers.set('Access-Control-Max-Age', value);
                 }
             }
             if (!request.headers.has('Access-Control-Allow-Credentials')) {
@@ -34,19 +33,19 @@ export function corsMiddleware(options = {}) {
                     ? await resolveApiEndpointDataProvider(request, context, cors.accessControlAllowCredentials)
                     : endpointDefinition?.credentials;
                 if (allowCredentials == true) {
-                    response.headers.setIfMissing('Access-Control-Allow-Credentials', 'true');
+                    response.headers.set('Access-Control-Allow-Credentials', 'true');
                 }
             }
             if (isDefined(cors.accessControlAllowOrigin) && !response.headers.has('Access-Control-Allow-Origin')) {
                 const value = await resolveApiEndpointDataProvider(request, context, cors.accessControlAllowOrigin);
-                response.headers.setIfMissing('Access-Control-Allow-Origin', value);
+                response.headers.set('Access-Control-Allow-Origin', value);
             }
             if (isDefined(cors.autoAccessControlAllowOrigin) && !response.headers.has('Access-Control-Allow-Origin')) {
                 const value = await resolveApiEndpointDataProvider(request, context, cors.autoAccessControlAllowOrigin);
                 const origin = request.headers.tryGetSingle('Origin');
                 const allowed = isDefined(value) && toArray(value).includes(origin);
                 if (allowed) {
-                    response.headers.setIfMissing('Access-Control-Allow-Origin', origin);
+                    response.headers.set('Access-Control-Allow-Origin', origin);
                 }
             }
         }

package/document-management/api/document-management.api.d.ts

@@ -98,6 +98,7 @@ export declare const documentManagementApiDefinition: {
                 typeId: import("../../orm/schemas/uuid.js").Uuid | null;
                 subtitle: string | null;
                 pages: number | null;
+                validated: boolean;
                 originalFileName: string | null;
                 collectionIds: string | string[];
                 properties?: {
@@ -374,6 +375,7 @@ export declare const documentManagementApiDefinition: {
                 typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 subtitle?: string | null | undefined;
                 pages?: number | null | undefined;
+                validated?: boolean | undefined;
                 properties?: {
                     propertyId: import("../../orm/schemas/uuid.js").Uuid;
                     value: unknown;
@@ -488,6 +490,7 @@ declare const _DocumentManagementApi: import("../../api/index.js").ApiClient<{
                 typeId: import("../../orm/schemas/uuid.js").Uuid | null;
                 subtitle: string | null;
                 pages: number | null;
+                validated: boolean;
                 originalFileName: string | null;
                 collectionIds: string | string[];
                 properties?: {
@@ -764,6 +767,7 @@ declare const _DocumentManagementApi: import("../../api/index.js").ApiClient<{
                 typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 subtitle?: string | null | undefined;
                 pages?: number | null | undefined;
+                validated?: boolean | undefined;
                 properties?: {
                     propertyId: import("../../orm/schemas/uuid.js").Uuid;
                     value: unknown;

package/document-management/models/document.model.d.ts

@@ -9,4 +9,5 @@ export declare class Document extends Entity {
     date: NumericDate | null;
     summary: string | null;
     tags: string[] | null;
+    validated: boolean;
 }

package/document-management/models/document.model.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { References } from '../../orm/decorators.js';
 import { Entity } from '../../orm/entity.js';
 import { NumericDate, Uuid } from '../../orm/types.js';
-import { Array, Integer, string, StringProperty } from '../../schema/index.js';
+import { Array, BooleanProperty, Integer, string, StringProperty } from '../../schema/index.js';
 import { DocumentFile } from './document-file.model.js';
 import { DocumentManagementTable } from './document-management-table.js';
 import { DocumentType } from './document-type.model.js';
@@ -23,6 +23,7 @@ let Document = class Document extends Entity {
     date;
     summary;
     tags;
+    validated;
 };
 __decorate([
     Uuid(),
@@ -58,6 +59,10 @@ __decorate([
     Array(string(), { nullable: true }),
     __metadata("design:type", Object)
 ], Document.prototype, "tags", void 0);
+__decorate([
+    BooleanProperty(),
+    __metadata("design:type", Boolean)
+], Document.prototype, "validated", void 0);
 Document = __decorate([
     DocumentManagementTable()
 ], Document);

package/document-management/models/service-models/document.service-model.d.ts

@@ -22,6 +22,7 @@ export declare const createDocumentParametersSchema: import("../../../schema/ind
     typeId: import("../../../orm/schemas/uuid.js").Uuid | null;
     subtitle: string | null;
     pages: number | null;
+    validated: boolean;
     originalFileName: string | null;
     collectionIds: string | string[];
     properties?: {
@@ -45,6 +46,7 @@ export declare const updateDocumentParametersSchema: import("../../../schema/ind
     typeId?: import("../../../orm/types.js").Uuid | null | undefined;
     subtitle?: string | null | undefined;
     pages?: number | null | undefined;
+    validated?: boolean | undefined;
     properties?: {
         propertyId: import("../../../orm/schemas/uuid.js").Uuid;
         value: unknown;

package/document-management/models/service-models/document.service-model.js

@@ -15,7 +15,7 @@ import { Document } from '../document.model.js';
 export const metadataParameterSchema = optional(partial(pick(EntityMetadata, 'attributes')));
 export const metadataParameterObjectSchema = object({ metadata: metadataParameterSchema });
 export const setDocumentPropertyParametersSchema = assign(pick(DocumentPropertyValueBase, ['propertyId']), object({ value: unknown() }), metadataParameterObjectSchema);
-export const createDocumentParametersSchema = assign(pick(Document, ['typeId', 'title', 'subtitle', 'pages', 'date', 'summary', 'tags']), pick(DocumentFile, ['originalFileName']), object({
+export const createDocumentParametersSchema = assign(pick(Document, ['typeId', 'title', 'subtitle', 'pages', 'date', 'summary', 'tags', 'validated']), pick(DocumentFile, ['originalFileName']), object({
     collectionIds: oneOrMany(string()),
     properties: optional(array(setDocumentPropertyParametersSchema))
 }), metadataParameterObjectSchema);

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

@@ -1,3 +1,4 @@
+import { type EnumType } from '../../../enumeration/enumeration.js';
 import { Timestamp } from '../../../orm/types.js';
 import { DocumentCategory } from '../document-category.model.js';
 import { DocumentCollection } from '../document-collection.model.js';
@@ -7,6 +8,12 @@ import { DocumentRequestFile } from '../document-request-file.model.js';
 import { DocumentRequest } from '../document-request.model.js';
 import { DocumentType } from '../document-type.model.js';
 import { Document } from '../document.model.js';
+export declare const ExtractionStatus: {
+    readonly Pending: "pending";
+    readonly Extracting: "extracting";
+    readonly Error: "error";
+};
+export type ExtractionStatus = EnumType<typeof ExtractionStatus>;
 export declare class DocumentCollectionView extends DocumentCollection {
     name: string | null;
     group: string | null;
@@ -18,6 +25,7 @@ export declare class DocumentViewCollectionAssignment {
 export declare class DocumentView extends Document {
     collectionAssignments: DocumentViewCollectionAssignment[];
     properties: DocumentPropertyValue[];
+    extractionStatus: ExtractionStatus | null;
 }
 export declare class DocumentRequestView extends DocumentRequest {
     collectionIds: string[];

package/document-management/models/service-models/document.view-model.js

@@ -7,8 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+import { defineEnum } from '../../../enumeration/enumeration.js';
 import { Timestamp } from '../../../orm/types.js';
-import { Array, StringProperty } from '../../../schema/index.js';
+import { Array, Enumeration, StringProperty } from '../../../schema/index.js';
 import { DocumentCategory } from '../document-category.model.js';
 import { DocumentCollection } from '../document-collection.model.js';
 import { DocumentFile } from '../document-file.model.js';
@@ -17,6 +18,11 @@ import { DocumentRequestFile } from '../document-request-file.model.js';
 import { DocumentRequest } from '../document-request.model.js';
 import { DocumentType } from '../document-type.model.js';
 import { Document } from '../document.model.js';
+export const ExtractionStatus = defineEnum('ExtractionStatus', {
+    Pending: 'pending',
+    Extracting: 'extracting',
+    Error: 'error'
+});
 export class DocumentCollectionView extends DocumentCollection {
     name;
     group;
@@ -44,6 +50,7 @@ __decorate([
 export class DocumentView extends Document {
     collectionAssignments;
     properties;
+    extractionStatus;
 }
 __decorate([
     Array(DocumentViewCollectionAssignment),
@@ -53,6 +60,10 @@ __decorate([
     Array(DocumentPropertyValue),
     __metadata("design:type", Array)
 ], DocumentView.prototype, "properties", void 0);
+__decorate([
+    Enumeration(ExtractionStatus, { nullable: true }),
+    __metadata("design:type", Object)
+], DocumentView.prototype, "extractionStatus", void 0);
 export class DocumentRequestView extends DocumentRequest {
     collectionIds;
     requestFiles;

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

@@ -2,11 +2,13 @@ import type { RequireExactlyOne, Stringified } from 'type-fest';
 import type { CancellationSignal } from '../../../cancellation/token.js';
 import { type AfterResolveContext, afterResolve } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
+import { MessageBus } from '../../../message-bus/message-bus.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
 import type { Query } from '../../../orm/index.js';
 import { type Transaction } from '../../../orm/server/index.js';
 import { Queue } from '../../../queue/queue.js';
 import type { OneOrMany, Record } from '../../../types.js';
+import { type Observable } from 'rxjs';
 import { type AddOrArchiveDocumentToOrFromCollectionParameters, type ApplyDocumentRequestsTemplateParameters, type ApproveDocumentRequestFileParameters, type AssignPropertyToTypeParameters, type CategoryAndTypesView, type CreateCollectionParameters, type CreateDocumentCategoryParameters, type CreateDocumentParameters, type CreateDocumentPropertyParameters, type CreateDocumentRequestFileParameters, type CreateDocumentRequestParameters, type CreateDocumentRequestTemplateParameters, type CreateDocumentRequestsTemplateParameters, type CreateDocumentTypeParameters, type DeleteDocumentRequestFileParameters, type DeleteDocumentRequestParameters, type DeleteDocumentRequestTemplateParameters, type DeleteDocumentRequestsTemplateParameters, Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, type DocumentManagementData, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestAssignmentTask, DocumentRequestAssignmentTaskCollection, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestCollection, DocumentRequestFile, DocumentRequestFilePropertyValue, DocumentRequestTemplate, DocumentRequestsTemplate, type DocumentRequestsTemplateData, DocumentType, DocumentTypeProperty, type LoadDataCollectionsMetadataParameters, type RejectDocumentRequestFileParameters, type RequestFilesStats, type SetDocumentPropertiesParameters, type UpdateDocumentParameters, type UpdateDocumentRequestFileParameters, type UpdateDocumentRequestParameters, type UpdateDocumentRequestTemplateParameters, type UpdateDocumentRequestsTemplateParameters } from '../../models/index.js';
 import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
 type DocumentInformationExtractionPropertyResult = {
@@ -56,8 +58,10 @@ export declare class DocumentManagementService extends DocumentManagementService
     protected readonly fileObjectStorage: ObjectStorage;
     protected readonly extractionQueue: Queue<ExtractionJobData>;
     protected readonly assignmentQueue: Queue<AssignmentJobData>;
+    protected readonly collectionChangeMessageBus: MessageBus<string[] | undefined>;
     protected readonly logger: Logger;
     [afterResolve](_: unknown, { cancellationSignal }: AfterResolveContext<any>): void;
+    changes$(collectionIds: OneOrMany<string>): Observable<void>;
     processQueues(cancellationSignal: CancellationSignal): void;
     resolveNames<const T extends (DocumentCollection | string)[]>(...collectionsOrIds: T): Promise<Stringified<T>>;
     resolveNamesMap(...collectionsOrIds: (DocumentCollection | string)[]): Promise<Record<string, string>>;
@@ -80,7 +84,7 @@ export declare class DocumentManagementService extends DocumentManagementService
     createDocumentRequestTemplate(parameters: CreateDocumentRequestTemplateParameters): Promise<DocumentRequestTemplate>;
     updateDocumentRequestTemplate({ id, typeId, requiredFilesCount, comment, metadata }: UpdateDocumentRequestTemplateParameters): Promise<DocumentRequestTemplate>;
     deleteDocumentRequestTemplate(parameters: DeleteDocumentRequestTemplateParameters): Promise<DocumentRequestTemplate>;
-    createDocument({ typeId, title, subtitle, pages, date, summary, tags, originalFileName, collectionIds, properties, metadata }: CreateDocumentParameters, content: Uint8Array | ReadableStream<Uint8Array>): Promise<Document>;
+    createDocument({ typeId, title, subtitle, pages, date, summary, tags, validated, originalFileName, collectionIds, properties, metadata }: CreateDocumentParameters, content: Uint8Array | ReadableStream<Uint8Array>): Promise<Document>;
     approveDocumentRequestFile({ id, approvalComment, documentMetadata, requestFileMetadata }: ApproveDocumentRequestFileParameters): Promise<Document>;
     rejectDocumentRequestFile({ id, approvalComment, metadata }: RejectDocumentRequestFileParameters): Promise<void>;
     updateDocumentRequestFile({ id, title, approvalComment, metadata }: UpdateDocumentRequestFileParameters): Promise<DocumentRequestFile>;
@@ -108,5 +112,12 @@ export declare class DocumentManagementService extends DocumentManagementService
     protected getDocumentFileContent(fileId: string): Promise<Uint8Array>;
     protected getDocumentFileContentStream(fileId: string): ReadableStream<Uint8Array>;
     protected getDocumentFileContentObjectUrl(title: string, file: DocumentFile, download: boolean): Promise<string>;
+    protected publishChange({ collectionIds, documentIds, requestIds, requestFileIds, requestAssignmentTaskIds: requestAssignmentTasksIds }: {
+        collectionIds?: string[];
+        documentIds?: string[];
+        requestIds?: string[];
+        requestFileIds?: string[];
+        requestAssignmentTaskIds?: string[];
+    }): void;
 }
 export {};

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

@@ -63,11 +63,12 @@ import { AiService } from '../../../ai/index.js';
 import { Enumerable } from '../../../enumerable/index.js';
 import { BadRequestError } from '../../../errors/index.js';
 import { TemporaryFile, getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
-import { Singleton, afterResolve, inject, provide } from '../../../injector/index.js';
+import { Singleton, afterResolve, inject } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
+import { MessageBus } from '../../../message-bus/message-bus.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
 import { TRANSACTION_TIMESTAMP, arrayAgg, coalesce, getEntityMap, jsonAgg, toJsonb } from '../../../orm/index.js';
-import { DatabaseConfig, EntityRepositoryConfig, getRepository, injectRepository } from '../../../orm/server/index.js';
+import { DatabaseConfig, getRepository, injectRepository } from '../../../orm/server/index.js';
 import { getPdfPageCount } from '../../../pdf/index.js';
 import { Queue } from '../../../queue/queue.js';
 import { array, boolean, enumeration, integer, nullable, number, object, string } from '../../../schema/index.js';
@@ -81,9 +82,11 @@ import { readBinaryStream } from '../../../utils/stream/index.js';
 import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
 import { assertBooleanPass, assertDefined, assertDefinedPass, assertNotNullPass, assertNumberPass, assertStringPass, isBoolean, isDefined, isNotNull, isNull, isNumber, isString, isUint8Array, isUndefined } from '../../../utils/type-guards.js';
 import { millisecondsPerMinute } from '../../../utils/units.js';
+import { union } from 'drizzle-orm/pg-core';
+import { debounceTime, filter, map } from 'rxjs';
 import { Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestAssignmentTask, DocumentRequestAssignmentTaskCollection, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestCollection, DocumentRequestFile, DocumentRequestFilePropertyValue, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty } from '../../models/index.js';
 import { DocumentManagementConfig } from '../module.js';
-import { documentCategory, documentProperty, documentRequest, documentRequestAssignmentTask, documentRequestAssignmentTaskCollection, documentRequestAssignmentTaskPropertyValue, documentRequestCollection, documentRequestFile, documentType } from '../schemas.js';
+import { documentCategory, documentCollectionDocument, documentProperty, documentRequest, documentRequestAssignmentTask, documentRequestAssignmentTaskCollection, documentRequestAssignmentTaskPropertyValue, documentRequestCollection, documentRequestFile, documentType } from '../schemas.js';
 import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
 const defaultGenerationOptions = {
     model: 'gemini-2.0-flash',
@@ -116,6 +119,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
     fileObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).fileObjectStorageModule);
     extractionQueue = inject((Queue), { name: 'DocumentManagement:extraction', processTimeout: 15 * millisecondsPerMinute });
     assignmentQueue = inject((Queue), { name: 'DocumentManagement:assignment', processTimeout: 15 * millisecondsPerMinute });
+    collectionChangeMessageBus = inject((MessageBus), 'DocumentManagement:collectionChange');
     logger = inject(Logger, DocumentManagementService_1.name);
     [afterResolve](_, { cancellationSignal }) {
         if (this.isFork) {
@@ -123,6 +127,10 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         }
         this.processQueues(cancellationSignal);
     }
+    changes$(collectionIds) {
+        const collectionIdsArray = toArray(collectionIds);
+        return this.collectionChangeMessageBus.allMessages$.pipe(filter((message) => isUndefined(message) || collectionIdsArray.some((id) => message.includes(id))), debounceTime(250), map(() => undefined));
+    }
     processQueues(cancellationSignal) {
         this.extractionQueue.process({ concurrency: 1, cancellationSignal }, async (job) => {
             const [entry] = objectEntries(job.data);
@@ -168,11 +176,12 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             ]);
             const documentIds = collectionDocuments.map((document) => document.documentId);
             const requestIds = requestCollections.map((requestCollection) => requestCollection.requestId);
-            const [documents, requests, requestFiles, propertyValues] = await Promise.all([
+            const [documents, requests, requestFiles, propertyValues, extractionJobs] = await Promise.all([
                 this.documentService.withTransaction(transaction).loadManyByQuery({ id: { $in: documentIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
                 this.documentRequestService.withTransaction(transaction).loadManyByQuery({ id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
                 this.documentRequestFileService.withTransaction(transaction).loadManyByQuery({ requestId: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
-                this.documentPropertyValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } })
+                this.documentPropertyValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } }),
+                this.extractionQueue.getByTags(documentIds)
             ]);
             const documentFileIds = documents.map((document) => document.fileId);
             const requestFileIds = requestFiles.map((requestFile) => requestFile.fileId);
@@ -184,11 +193,21 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 name: collectionsMetadata?.[collection.id]?.name ?? null,
                 group: collectionsMetadata?.[collection.id]?.group ?? null
             }));
-            const documentViews = documents.map((document) => ({
-                ...document,
-                collectionAssignments: collectionDocuments.filter((collectionDocument) => collectionDocument.documentId == document.id).map(({ collectionId, archiveTimestamp }) => ({ collectionId, archiveTimestamp })),
-                properties: valuesMap.get(document.id) ?? []
-            }));
+            const documentViews = documents.map((document) => {
+                const job = extractionJobs.find((job) => job.tag == document.id);
+                return {
+                    ...document,
+                    collectionAssignments: collectionDocuments.filter((collectionDocument) => collectionDocument.documentId == document.id).map(({ collectionId, archiveTimestamp }) => ({ collectionId, archiveTimestamp })),
+                    properties: valuesMap.get(document.id) ?? [],
+                    extractionStatus: isUndefined(job)
+                        ? null
+                        : isNull(job.lastDequeueTimestamp)
+                            ? 'pending'
+                            : (job.tries >= this.extractionQueue.maxTries) && (job.lastDequeueTimestamp >= (currentTimestamp() + this.extractionQueue.processTimeout))
+                                ? 'error'
+                                : 'extracting'
+                };
+            });
             const requestViews = requests.map((request) => ({
                 ...request,
                 collectionIds: requestCollections.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId),
@@ -287,11 +306,12 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
     async deleteDocumentRequestTemplate(parameters) {
         return this.documentRequestTemplateService.delete(parameters.id);
     }
-    async createDocument({ typeId, title, subtitle, pages, date, summary, tags, originalFileName, collectionIds, properties, metadata }, content) {
+    async createDocument({ typeId, title, subtitle, pages, date, summary, tags, validated, originalFileName, collectionIds, properties, metadata }, content) {
+        const collectionIdsArray = toArray(collectionIds);
         const document = await this.documentService.transaction(async (_, transaction) => {
             const documentFile = await this.createDocumentFile(content, originalFileName, transaction);
-            const document = await this.documentService.withTransaction(transaction).insert({ fileId: documentFile.id, typeId, title, subtitle, pages, date, summary, tags, metadata });
-            for (const collectionId of toArray(collectionIds)) {
+            const document = await this.documentService.withTransaction(transaction).insert({ fileId: documentFile.id, typeId, title, subtitle, pages, date, summary, tags, metadata, validated });
+            for (const collectionId of collectionIdsArray) {
                 await this.documentCollectionDocumentService.withTransaction(transaction).insert({ collectionId, documentId: document.id, archiveTimestamp: null });
             }
             if (isDefined(properties)) {
@@ -299,7 +319,8 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             }
             return document;
         });
-        void tryIgnoreLogAsync(async () => this.extractionQueue.enqueue({ documentId: document.id }), this.logger);
+        void tryIgnoreLogAsync(this.logger, async () => this.extractionQueue.enqueue({ documentId: document.id }, { tag: document.id }));
+        this.publishChange({ collectionIds: collectionIdsArray });
         return document;
     }
     async approveDocumentRequestFile({ id, approvalComment, documentMetadata, requestFileMetadata }) {
@@ -319,6 +340,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 date: requestFile.date,
                 summary: requestFile.summary,
                 tags: requestFile.tags,
+                validated: true,
                 metadata: documentMetadata
             });
             for (const { collectionId } of requestCollections) {
@@ -329,16 +351,19 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         });
     }
     async rejectDocumentRequestFile({ id, approvalComment, metadata }) {
-        return this.documentRequestFileService.transaction(async (_, transaction) => {
+        const requestFile = await this.documentRequestFileService.transaction(async (_, transaction) => {
             const requestFile = await this.documentRequestFileService.withTransaction(transaction).load(id);
             if (requestFile.approval == true) {
                 throw new BadRequestError('Document request file already accepted.');
             }
-            await this.documentRequestFileService.withTransaction(transaction).update(id, { approval: false, approvalComment, approvalTimestamp: TRANSACTION_TIMESTAMP, metadata });
+            return this.documentRequestFileService.withTransaction(transaction).update(id, { approval: false, approvalComment, approvalTimestamp: TRANSACTION_TIMESTAMP, metadata });
         });
+        this.publishChange({ requestIds: [requestFile.requestId] });
     }
     async updateDocumentRequestFile({ id, title, approvalComment, metadata }) {
-        return this.documentRequestFileService.update(id, { title, approvalComment, metadata });
+        const result = await this.documentRequestFileService.update(id, { title, approvalComment, metadata });
+        this.publishChange({ requestIds: [result.requestId] });
+        return result;
     }
     async deleteDocumentRequestFile({ id, metadata }) {
         const requestFile = await this.documentRequestFileService.load(id);
@@ -346,6 +371,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             throw new BadRequestError('Only pending request files can be deleted.');
         }
         await this.documentRequestFileService.delete(id, metadata);
+        this.publishChange({ requestIds: [requestFile.requestId] });
     }
     async createDocumentFile(content, originalFileName, transaction) {
         const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
@@ -376,7 +402,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 throw new BadRequestError('Maximum amount of allowed files reached.');
             }
             const file = await this.createDocumentFile(content, originalFileName, transaction);
-            return await this.documentRequestFileService
+            const result = await this.documentRequestFileService
                 .withTransaction(transaction)
                 .insert({
                 requestId,
@@ -393,20 +419,24 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 approvalTimestamp: null,
                 metadata
             });
+            return result;
         });
-        void tryIgnoreLogAsync(async () => this.extractionQueue.enqueue({ requestFileId: documentRequestFile.id }), this.logger);
+        void tryIgnoreLogAsync(this.logger, async () => this.extractionQueue.enqueue({ requestFileId: documentRequestFile.id }));
+        this.publishChange({ requestIds: [documentRequestFile.requestId] });
         return documentRequestFile;
     }
     async createDocumentRequest(parameters, transaction) {
         if (parameters.collectionIds.length == 0) {
             throw new BadRequestError('No target collectionId specified.');
         }
-        return this.documentRequestService.useTransaction(transaction, async (_, tx) => {
+        const result = await this.documentRequestService.useTransaction(transaction, async (_, tx) => {
             const request = await this.documentRequestService.withTransaction(tx).insert({ ...parameters, completed: false });
             const newDocumentRequestCollections = parameters.collectionIds.map((collectionId) => ({ requestId: request.id, collectionId }));
             await this.documentRequestCollectionService.withTransaction(tx).insertMany(newDocumentRequestCollections);
             return request;
         });
+        this.publishChange({ collectionIds: parameters.collectionIds });
+        return result;
     }
     async createDocumentRequestAssignmentTask({ originalFileName, collectionIds }, content) {
         if (collectionIds.length == 0) {
@@ -428,7 +458,8 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             });
             const newTaksCollections = collectionIds.map((collectionId) => ({ requestAssignmentTaskId: task.id, collectionId }));
             await this.documentRequestAssignmentTaskCollectionService.withTransaction(transaction).insertMany(newTaksCollections);
-            void tryIgnoreLogAsync(async () => this.extractionQueue.enqueue({ requestAssignmentTaskId: task.id }), this.logger);
+            void tryIgnoreLogAsync(this.logger, async () => this.extractionQueue.enqueue({ requestAssignmentTaskId: task.id }));
+            this.publishChange({ collectionIds });
             return task;
         });
     }
@@ -440,6 +471,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 await this.setPropertyValues({ documentId, properties: propertyUpdates }, tx);
             }
         });
+        this.publishChange({ documentIds: [documentId] });
     }
     async updateDocumentRequest(parameters, transaction) {
         const { id: documentRequestId, ...update } = parameters;
@@ -451,6 +483,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             }
         }
         await this.documentRequestService.withOptionalTransaction(transaction).update(documentRequestId, update);
+        this.publishChange({ requestIds: [documentRequestId] });
     }
     async deleteDocumentRequest({ id, metadata }, transaction) {
         const requestFiles = await this.documentRequestFileService.loadManyByQuery({ requestId: id });
@@ -459,6 +492,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             throw new BadRequestError('Cannot delete requests which has approved files.');
         }
         await this.documentRequestService.withOptionalTransaction(transaction).delete(id, metadata);
+        this.publishChange({ requestIds: [id] });
     }
     async setPropertyValues({ documentId, requestFileId, requestAssignmentTaskId, properties: items }, transaction) {
         if ((items.length == 0)) {
@@ -497,12 +531,19 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                     .upsertMany(['requestAssignmentTaskId', 'propertyId'], propertyItems.map((propertyItem) => ({ ...propertyItem, requestAssignmentTaskId })));
             }
         });
+        this.publishChange({
+            documentIds: isDefined(documentId) ? [documentId] : undefined,
+            requestFileIds: isDefined(requestFileId) ? [requestFileId] : undefined,
+            requestAssignmentTaskIds: isDefined(requestAssignmentTaskId) ? [requestAssignmentTaskId] : undefined
+        });
     }
     async addDocumentToCollection(parameters, transaction) {
         await this.documentCollectionDocumentService.withOptionalTransaction(transaction).upsert(['collectionId', 'documentId'], { ...parameters, archiveTimestamp: null });
+        this.publishChange({ documentIds: [parameters.documentId] });
     }
     async archiveDocument({ collectionId, documentId, metadata }) {
         await this.documentCollectionDocumentService.updateByQuery({ collectionId, documentId }, { archiveTimestamp: TRANSACTION_TIMESTAMP, metadata });
+        this.publishChange({ documentIds: [documentId] });
     }
     async createProperty(parameters) {
         return this.documentPropertyService.insert(parameters);
@@ -514,9 +555,10 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         const document = await this.documentService.load(documentId);
         const { properties, ...extractionResult } = await this.extractFileInformation(document.fileId, document.typeId);
         await this.documentService.transaction(async (documentService, transaction) => {
-            await documentService.update(document.id, extractionResult);
+            await documentService.update(document.id, { ...extractionResult, validated: false });
             await this.setPropertyValues({ documentId, properties: properties }, transaction);
         });
+        this.publishChange({ documentIds: [documentId] });
     }
     async enrichDocumentRequestFile(requestFileId) {
         const requestFile = await this.documentRequestFileService.load(requestFileId);
@@ -526,6 +568,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             await documentRequestFileService.update(requestFile.id, extractionResult);
             await this.setPropertyValues({ requestFileId, properties: properties }, transaction);
         });
+        this.publishChange({ requestIds: [request.id] });
     }
     async enrichDocumentRequestAssignmentTask(requestAssignmentTaskId) {
         const task = await this.documentRequestAssignmentTaskService.load(requestAssignmentTaskId);
@@ -534,7 +577,8 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             await documentRequestAssignmentTaskService.update(task.id, extractionResult);
             await this.setPropertyValues({ requestAssignmentTaskId, properties: properties }, transaction);
         });
-        void tryIgnoreLogAsync(async () => this.assignmentQueue.enqueue({ requestAssignmentTaskId }), this.logger);
+        void tryIgnoreLogAsync(this.logger, async () => this.assignmentQueue.enqueue({ requestAssignmentTaskId }));
+        this.publishChange({ requestAssignmentTaskIds: [requestAssignmentTaskId] });
     }
     async assignDocumentRequest(requestAssignmentTaskId) {
         const session = this.documentRequestAssignmentTaskCollectionService.session;
@@ -656,6 +700,7 @@ Ordne die Datei unter "file" der passenden Anforderungen unter "requests" zu. Gi
             });
             await this.setPropertyValues({ requestFileId: requestFile.id, properties: task.properties }, transaction);
         });
+        this.publishChange({ collectionIds: requestsCollectionIds });
     }
     async extractFileInformation(fileId, assumeTypeId) {
         const env_1 = { stack: [], error: void 0, hasError: false };
@@ -665,7 +710,7 @@ Ordne die Datei unter "file" der passenden Anforderungen unter "requests" zu. Gi
             const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
             const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: file.mimeType });
             const pages = file.mimeType.includes('pdf')
-                ? await tryIgnoreLogAsync(async () => getPdfPageCount(tmpFile.path), this.logger, null)
+                ? await tryIgnoreLogAsync(this.logger, async () => getPdfPageCount(tmpFile.path), null)
                 : null;
             const types = await this.documentTypeService.session
                 .select({
@@ -797,6 +842,51 @@ Antworte auf deutsch.`
             'Response-Content-Disposition': `${disposition}; filename = "${encodeURIComponent(filename)}"`
         });
     }
+    publishChange({ collectionIds, documentIds, requestIds, requestFileIds, requestAssignmentTaskIds: requestAssignmentTasksIds }) {
+        void tryIgnoreLogAsync(this.logger, async () => {
+            const queries = [
+                isUndefined(documentIds)
+                    ? undefined
+                    : this.session
+                        .selectDistinct({ collectionId: documentCollectionDocument.collectionId })
+                        .from(documentCollectionDocument)
+                        .where(inArray(documentCollectionDocument.documentId, documentIds)),
+                isUndefined(requestIds)
+                    ? undefined
+                    : this.session
+                        .selectDistinct({ collectionId: documentRequestCollection.collectionId })
+                        .from(documentRequestCollection)
+                        .where(inArray(documentRequestCollection.requestId, requestIds)),
+                isUndefined(requestFileIds)
+                    ? undefined
+                    : this.session
+                        .selectDistinct({ collectionId: documentRequestCollection.collectionId })
+                        .from(documentRequestFile)
+                        .innerJoin(documentRequestCollection, eq(documentRequestCollection.requestId, documentRequestFile.requestId))
+                        .where(inArray(documentRequestFile.requestId, requestFileIds)),
+                isUndefined(requestAssignmentTasksIds)
+                    ? undefined
+                    : this.session
+                        .selectDistinct({ collectionId: documentRequestAssignmentTaskCollection.collectionId })
+                        .from(documentRequestAssignmentTaskCollection)
+                        .where(inArray(documentRequestAssignmentTaskCollection.requestAssignmentTaskId, requestAssignmentTasksIds))
+            ];
+            const filteredQueries = queries.filter(isDefined);
+            const mappings = (filteredQueries.length == 1)
+                ? await filteredQueries[0]
+                : (filteredQueries.length > 1)
+                    ? await union(filteredQueries[0], filteredQueries[1], ...filteredQueries.slice(2))
+                    : [];
+            const allCollectionIds = distinct([
+                ...(collectionIds ?? []),
+                ...mappings.map((mapping) => mapping.collectionId)
+            ]);
+            if (allCollectionIds.length == 0) {
+                return;
+            }
+            this.collectionChangeMessageBus.publishAndForget(allCollectionIds);
+        });
+    }
 };
 DocumentManagementService = DocumentManagementService_1 = __decorate([
     Singleton({

package/message-bus/message-bus-base.d.ts

@@ -17,7 +17,6 @@ export declare abstract class MessageBusBase<T> extends MessageBus<T> {
     publishAndForget(message: T): void;
     publish(message: T): Promise<void>;
     [disposeAsync](): Promise<void>;
-    private _publishAndForget;
     /**
      * publish messages to other instances
      * @param message message to send to other instances

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

@@ -1,4 +1,5 @@
 import { defer, merge, share, Subject, takeUntil } from 'rxjs';
+import { tryIgnoreLogAsync } from '../utils/try-ignore.js';
 import { CancellationToken } from '../cancellation/token.js';
 import { disposeAsync } from '../disposable/disposable.js';
 import { MessageBus } from './message-bus.js';
@@ -17,7 +18,7 @@ export class MessageBusBase extends MessageBus {
         this.allMessages$ = merge(this.messages$, this.publishSubject);
     }
     publishAndForget(message) {
-        void this._publishAndForget(message);
+        void tryIgnoreLogAsync(this.logger, async () => this.publish(message));
     }
     async publish(message) {
         if (this.disposeToken.isSet) {
@@ -34,12 +35,4 @@ export class MessageBusBase extends MessageBus {
         this.publishSubject.complete();
         return this._dispose();
     }
-    async _publishAndForget(message) {
-        try {
-            await this.publish(message);
-        }
-        catch (error) {
-            this.logger.error(error);
-        }
-    }
 }

package/orm/decorators.d.ts

@@ -5,6 +5,7 @@ import type { Entity, EntityType } from './entity.js';
 import type { PgTableFromType } from './server/types.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
 type NamingStrategy = 'abbreviated-table';
+type Columns<T> = [Extract<keyof T, string>, ...Extract<keyof T, string>[]];
 export type CheckBuilder<T extends Entity = any> = (table: PgTableFromType<EntityType<T>>) => SQL;
 export type OrmTableReflectionData = {
     name?: string;
@@ -69,9 +70,9 @@ type TableOptions = Partial<Pick<OrmTableReflectionData, 'name' | 'schema'>>;
 export declare function Table(name?: string, options?: TypedOmit<TableOptions, 'schema'>): ClassDecorator;
 export declare function Table(options?: TableOptions): ClassDecorator;
 export declare function Unique(name?: string, options?: UniqueReflectionData['options']): PropertyDecorator;
-export declare function Unique<T>(name: string | undefined, columns: [Extract<keyof T, string>, ...Extract<keyof T, string>[]], options?: UniqueReflectionData['options']): ClassDecorator;
-export declare function Unique<T>(columns: [Extract<keyof T, string>, ...Extract<keyof T, string>[]], options?: UniqueReflectionData['options']): ClassDecorator;
+export declare function Unique<T>(name: string | undefined, columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
+export declare function Unique<T>(columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
 export declare function Index(name?: string, options?: IndexReflectionData['options']): PropertyDecorator;
-export declare function Index(name: string, columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
-export declare function Index(columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
+export declare function Index<T>(name: string, columns: Columns<T>, options?: IndexReflectionData['options']): ClassDecorator;
+export declare function Index<T>(columns: Columns<T>, options?: IndexReflectionData['options']): ClassDecorator;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.99",
+  "version": "0.92.100",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/queue/mongo/queue.d.ts

@@ -8,9 +8,9 @@ export declare class MongoQueue<T = unknown> extends Queue<T> {
     private readonly repository;
     private readonly lock;
     private readonly queueKey;
-    private readonly processTimeout;
-    private readonly maxTries;
     private readonly messageBus;
+    readonly processTimeout: number;
+    readonly maxTries: number;
     constructor(repository: MongoJobRepository<T>, lock: Lock, messageBusProvider: MessageBusProvider, key: string, config?: QueueConfig);
     enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
     enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
@@ -24,6 +24,7 @@ export declare class MongoQueue<T = unknown> extends Queue<T> {
     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>;

package/queue/mongo/queue.js

@@ -36,9 +36,9 @@ let MongoQueue = class MongoQueue extends Queue {
     repository;
     lock;
     queueKey;
+    messageBus;
     processTimeout;
     maxTries;
-    messageBus;
     constructor(repository, lock, messageBusProvider, key, config) {
         super();
         this.repository = repository;
@@ -122,6 +122,9 @@ let MongoQueue = class MongoQueue extends Queue {
     async getByTag(tag) {
         return this.repository.loadManyByFilter({ queue: this.queueKey, tag });
     }
+    async getByTags(tags) {
+        return this.repository.loadManyByFilter({ queue: this.queueKey, tag: { $in: tags } });
+    }
     async cancel(id) {
         await this.repository.deleteByFilter({ queue: this.queueKey, jobId: id });
     }
@@ -237,7 +240,10 @@ function toModelJob(mongoJob) {
         id: mongoJob.jobId,
         priority: mongoJob.priority,
         tag: mongoJob.tag,
-        data: mongoJob.data
+        data: mongoJob.data,
+        enqueueTimestamp: mongoJob.enqueueTimestamp,
+        lastDequeueTimestamp: mongoJob.lastDequeueTimestamp,
+        tries: mongoJob.tries
     };
     return job;
 }

package/queue/postgres/job.model.js

@@ -7,9 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Table } from '../../orm/decorators.js';
+import { Index, Table } from '../../orm/decorators.js';
 import { EntityWithoutMetadata } from '../../orm/entity.js';
-import { Integer, Json, Timestamp, Unique } from '../../orm/index.js';
+import { Integer, Json, Timestamp } from '../../orm/index.js';
 import { StringProperty } from '../../schema/index.js';
 let PostgresJob = class PostgresJob extends EntityWithoutMetadata {
     queue;
@@ -50,6 +50,6 @@ __decorate([
 ], PostgresJob.prototype, "data", void 0);
 PostgresJob = __decorate([
     Table('job'),
-    Unique(['queue', 'tag'])
+    Index(['queue', 'tag'])
 ], PostgresJob);
 export { PostgresJob };

package/queue/postgres/queue.d.ts

@@ -3,6 +3,8 @@ import type { ObjectLiteral } from '../../types.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> {
     #private;
+    readonly processTimeout: number;
+    readonly maxTries: number;
     enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
     enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
         returnJobs?: false;
@@ -15,6 +17,7 @@ export declare class PostgresQueue<T extends ObjectLiteral> extends Queue<T> {
     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>;

package/queue/postgres/queue.js

@@ -12,7 +12,7 @@ import { MessageBus } from '../../message-bus/index.js';
 import { interval, RANDOM_UUID, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
 import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../orm/server/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
-import { isDefined, isString } from '../../utils/type-guards.js';
+import { isDefined, isString, isUndefined } from '../../utils/type-guards.js';
 import { millisecondsPerSecond } from '../../utils/units.js';
 import { defaultQueueConfig, Queue, UniqueTagStrategy } from '../queue.js';
 import { PostgresJob } from './job.model.js';
@@ -21,11 +21,11 @@ import { job } from './schemas.js';
 let PostgresQueue = class PostgresQueue extends Queue {
     #repository = injectRepository(PostgresJob);
     #config = injectArgument(this);
-    #processTimeout = (isString(this.#config) ? undefined : this.#config.processTimeout) ?? defaultQueueConfig.processTimeout;
-    #maxTries = (isString(this.#config) ? undefined : this.#config.maxTries) ?? defaultQueueConfig.maxTries;
     #queueName = isString(this.#config) ? this.#config : this.#config.name;
     #messageBus = inject((MessageBus), `PostgresQueue:${this.#queueName}`);
     #keepOldUpdate = { id: sql `${job.id}` };
+    processTimeout = (isString(this.#config) ? undefined : this.#config.processTimeout) ?? defaultQueueConfig.processTimeout;
+    maxTries = (isString(this.#config) ? undefined : this.#config.maxTries) ?? defaultQueueConfig.maxTries;
     #takeNewUpdate = {
         id: RANDOM_UUID,
         queue: this.#queueName,
@@ -36,7 +36,7 @@ let PostgresQueue = class PostgresQueue extends Queue {
         lastDequeueTimestamp: null,
         data: sql `excluded.data`
     };
-    #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.#maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(sql `${job.lastDequeueTimestamp} + ${interval(this.#processTimeout, 'milliseconds')}`, TRANSACTION_TIMESTAMP)));
+    #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(sql `${job.lastDequeueTimestamp} + ${interval(this.processTimeout, 'milliseconds')}`, TRANSACTION_TIMESTAMP)));
     #dequeueUpdate = {
         tries: sql `${job.tries} + 1`,
         lastDequeueTimestamp: TRANSACTION_TIMESTAMP
@@ -57,8 +57,12 @@ let PostgresQueue = class PostgresQueue extends Queue {
         }));
         const update = (options?.uniqueTag == UniqueTagStrategy.TakeNew)
             ? this.#takeNewUpdate
-            : this.#keepOldUpdate;
-        const jobs = await this.#repository.upsertMany(['queue', 'tag'], newEntities, update);
+            : (options?.uniqueTag == UniqueTagStrategy.KeepOld)
+                ? this.#keepOldUpdate
+                : undefined;
+        const jobs = isUndefined(update)
+            ? await this.#repository.insertMany(newEntities)
+            : await this.#repository.upsertMany(['queue', 'tag'], newEntities, update);
         this.#messageBus.publishAndForget();
         return jobs;
     }
@@ -74,6 +78,9 @@ let PostgresQueue = class PostgresQueue extends Queue {
     async getByTag(tag) {
         return this.#repository.loadManyByQuery({ queue: this.#queueName, tag });
     }
+    async getByTags(tags) {
+        return this.#repository.loadManyByQuery({ queue: this.#queueName, tag: { $in: tags } });
+    }
     async cancel(id) {
         await this.#repository.hardDeleteByQuery({ queue: this.#queueName, id });
     }

package/queue/queue.d.ts

@@ -14,6 +14,9 @@ export type Job<T> = {
     priority: number;
     tag: JobTag;
     data: T;
+    enqueueTimestamp: number;
+    lastDequeueTimestamp: number | null;
+    tries: number;
 };
 export declare const defaultJobPriority = 1000;
 export declare enum UniqueTagStrategy {
@@ -46,6 +49,8 @@ export type QueueArgument = string | (QueueConfig & {
 export declare const defaultQueueConfig: Required<QueueConfig>;
 export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
     readonly [resolveArgumentType]: QueueArgument;
+    abstract readonly processTimeout: number;
+    abstract readonly maxTries: number;
     batch(): QueueEnqueueBatch<T>;
     abstract enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
     abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
@@ -59,6 +64,7 @@ export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
     abstract countByTag(tag: JobTag): Promise<number>;
     abstract get(id: string): Promise<Job<T> | undefined>;
     abstract getByTag(tag: JobTag): Promise<Job<T>[]>;
+    abstract getByTags(tags: JobTag[]): Promise<Job<T>[]>;
     abstract cancel(id: string): Promise<void>;
     abstract cancelMany(ids: string[]): Promise<void>;
     abstract cancelByTag(tag: JobTag): Promise<void>;

package/utils/try-ignore.d.ts

@@ -3,7 +3,7 @@ export declare function tryIgnore<R>(fn: () => R): R;
 export declare function tryIgnore<R, F>(fn: () => R, fallback: F): R | F;
 export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R>;
 export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<F>;
-export declare function tryIgnoreLog<R>(fn: () => R, logger: Logger): R;
-export declare function tryIgnoreLog<R, F>(fn: () => R, logger: Logger, fallback: F): R | F;
-export declare function tryIgnoreLogAsync<R>(fn: () => Promise<R>, logger: Logger): Promise<R>;
-export declare function tryIgnoreLogAsync<R, F>(fn: () => Promise<R>, logger: Logger, fallback: F): Promise<F>;
+export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R;
+export declare function tryIgnoreLog<R, F>(logger: Logger, fn: () => R, fallback: F): R | F;
+export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreLogAsync<R, F>(logger: Logger, fn: () => Promise<R>, fallback: F): Promise<F>;

package/utils/try-ignore.js

@@ -15,7 +15,7 @@ export async function tryIgnoreAsync(fn, fallback) {
         return fallback;
     }
 }
-export function tryIgnoreLog(fn, logger, fallback) {
+export function tryIgnoreLog(logger, fn, fallback) {
     try {
         return fn();
     }
@@ -24,7 +24,7 @@ export function tryIgnoreLog(fn, logger, fallback) {
         return fallback;
     }
 }
-export async function tryIgnoreLogAsync(fn, logger, fallback) {
+export async function tryIgnoreLogAsync(logger, fn, fallback) {
     try {
         const value = await fn();
         return value;