@tstdl/base 0.92.132 → 0.92.135

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

@@ -1,11 +1,15 @@
 import { type UpdatableDocumentProperties } from '../../../document-management/models/index.js';
 import type { CreateDocumentParameters, SetDocumentPropertyParameters } from '../../../document-management/service-models/index.js';
 import { Transactional } from '../../../orm/server/index.js';
+import type { TypedOmit } from '../../../types.js';
 import { Document } from '../../models/index.js';
 export declare class DocumentService extends Transactional {
     #private;
     readonly repository: import("../../../orm/server/repository.js").EntityRepository<Document>;
-    create({ typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }: CreateDocumentParameters, content: Uint8Array | ReadableStream<Uint8Array>, { createUserId }: {
+    create({ typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }: TypedOmit<CreateDocumentParameters, 'uploadId'>, contentSource: Uint8Array | ReadableStream<Uint8Array> | {
+        uploadId: string;
+        uploadKey: string;
+    }, { createUserId }: {
         createUserId?: string;
     }): Promise<Document>;
     update(id: string, update: Partial<Pick<Document, UpdatableDocumentProperties>> & {

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

@@ -18,7 +18,7 @@ import { toArray } from '../../../utils/array/index.js';
 import { objectKeys } from '../../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../../utils/stream/from-promise.js';
 import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
-import { isDefined, isString, isUndefined } from '../../../utils/type-guards.js';
+import { isDefined, isNotReadableStream, isNotUint8Array, isString, isUndefined } from '../../../utils/type-guards.js';
 import { Document } from '../../models/index.js';
 import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentFileService } from './document-file.service.js';
@@ -29,17 +29,20 @@ import { DocumentManagementSingleton } from './singleton.js';
 let DocumentService = DocumentService_1 = class DocumentService extends Transactional {
     #documentFileService = inject(DocumentFileService);
     #requestService = inject(DocumentRequestService);
-    #workflowService = inject(DocumentWorkflowService, undefined, { forwardRef: true });
+    #workflowService = inject(DocumentWorkflowService);
     #documentPropertyService = inject(DocumentPropertyService);
     #documentCollectionService = inject(DocumentCollectionService);
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #logger = inject(Logger, DocumentService_1.name);
     repository = injectRepository(Document).withSession(this.session);
-    async create({ typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }, content, { createUserId }) {
+    async create({ typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }, contentSource, { createUserId }) {
         const document = await this.transaction(async (tx) => {
-            const documentFile = await this.#documentFileService.withTransaction(tx).create(content, originalFileName);
-            const pages = documentFile.mimeType.includes('pdf') ? await tryIgnoreLogAsync(this.#logger, async () => getPdfPageCount(content), null) : null;
+            const isUpload = isNotUint8Array(contentSource) && isNotReadableStream(contentSource);
+            const [documentFile, content] = isUpload
+                ? await this.#documentFileService.withTransaction(tx).create(contentSource, originalFileName)
+                : [await this.#documentFileService.withTransaction(tx).create(contentSource, originalFileName), contentSource];
+            const pages = documentFile.mimeType.includes('pdf') ? await tryIgnoreLogAsync(this.#logger, async () => await getPdfPageCount(content), null) : null;
             const document = await this.repository.withTransaction(tx).insert({
                 fileId: documentFile.id,
                 typeId: typeId ?? null,
@@ -80,7 +83,7 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     }
     async getContent(documentOrId) {
         const document = isString(documentOrId) ? await this.repository.load(documentOrId) : documentOrId;
-        return this.#documentFileService.getContent(document.fileId);
+        return await this.#documentFileService.getContent(document.fileId);
     }
     getContentStream(documentOrId) {
         return readableStreamFromPromise(async () => {
@@ -90,11 +93,11 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     }
     async getContentUrl(documentOrId, download = false) {
         const document = isString(documentOrId) ? await this.repository.load(documentOrId) : documentOrId;
-        return this.#documentFileService.getContentUrl(document.fileId, document.title, download);
+        return await this.#documentFileService.getContentUrl(document.fileId, document.title, download);
     }
     async getPreview(documentOrId, page = 1) {
         const document = isString(documentOrId) ? await this.repository.load(documentOrId) : documentOrId;
-        return this.#documentFileService.getPreview(document.fileId, page);
+        return await this.#documentFileService.getPreview(document.fileId, page);
     }
     getPreviewStream(documentOrId, page = 1) {
         return readableStreamFromPromise(async () => {
@@ -104,13 +107,13 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     }
     async getPreviewUrl(documentOrId, page = 1) {
         const document = isString(documentOrId) ? await this.repository.load(documentOrId) : documentOrId;
-        return this.#documentFileService.getPreviewUrl(document.fileId, page);
+        return await this.#documentFileService.getPreviewUrl(document.fileId, page);
     }
     /**
      * @returns collectionIds from either direct assignment or automatic assignment scope
      */
     async createAssignment(documentId, assignment, transaction) {
-        return match(assignment)
+        return await match(assignment)
             .with({ collections: P.select() }, async (collectionIds) => {
             const collectionIdsArray = toArray(collectionIds);
             await this.#documentCollectionService.withTransaction(transaction).assignDocument(documentId, collectionIdsArray);

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

@@ -1,4 +1,5 @@
-import { Document, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentPropertyDataType, DocumentRequest, DocumentType, DocumentValidationExecution, DocumentWorkflow } from '../models/index.js';
+import type { TypedOmit } from '../../types.js';
+import { Document, DocumentAssignmentTarget, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentPropertyDataType, DocumentRequest, DocumentType, DocumentValidationExecution, DocumentWorkflow } from '../models/index.js';
 export declare class DocumentCollectionView extends DocumentCollection {
     name: string;
     group: string | null;
@@ -10,8 +11,20 @@ export declare class DocumentPropertyValueView {
     dataType: DocumentPropertyDataType;
     value: string | number | boolean | null;
 }
+export declare class DocumentCollectionAssignmentView implements TypedOmit<DocumentCollectionAssignment, 'id' | 'documentId' | 'metadata'> {
+    collectionId: string;
+    archiveTimestamp: number | null;
+}
+export declare class DocumentAssignmentTaskView implements TypedOmit<DocumentAssignmentTask, 'id' | 'documentId' | 'metadata'> {
+    target: DocumentAssignmentTarget;
+    scope: string[];
+}
+export declare class DocumentAssignmentView {
+    collections: DocumentCollectionAssignmentView[];
+    assignmentTask: DocumentAssignmentTaskView | null;
+}
 export declare class DocumentView extends Document {
-    collectionAssignments: DocumentCollectionAssignment[];
+    assignment: DocumentAssignmentView;
     properties: DocumentPropertyValueView[];
     /** available as long as the document is neither approved nor rejected */
     currentWorkflow: DocumentWorkflow | null;
@@ -19,8 +32,6 @@ export declare class DocumentView extends Document {
 }
 export declare class DocumentRequestView extends DocumentRequest {
     collectionIds: string[];
-    /** current approval-pending or approved document */
-    document: Document | null;
 }
 export declare class DocumentManagementData {
     collections: DocumentCollectionView[];

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

@@ -7,8 +7,8 @@ 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 { Array, Enumeration, Property, StringProperty, Union } from '../../schema/index.js';
-import { Document, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentPropertyDataType, DocumentRequest, DocumentType, DocumentValidationExecution, DocumentWorkflow } from '../models/index.js';
+import { Array, Enumeration, Property, string, StringProperty, Union } from '../../schema/index.js';
+import { Document, DocumentAssignmentTarget, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentPropertyDataType, DocumentRequest, DocumentType, DocumentValidationExecution, DocumentWorkflow } from '../models/index.js';
 export class DocumentCollectionView extends DocumentCollection {
     name;
     group;
@@ -48,17 +48,53 @@ __decorate([
     Union(String, Number, Boolean, { nullable: true }),
     __metadata("design:type", Object)
 ], DocumentPropertyValueView.prototype, "value", void 0);
+export class DocumentCollectionAssignmentView {
+    collectionId;
+    archiveTimestamp;
+}
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], DocumentCollectionAssignmentView.prototype, "collectionId", void 0);
+__decorate([
+    StringProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], DocumentCollectionAssignmentView.prototype, "archiveTimestamp", void 0);
+export class DocumentAssignmentTaskView {
+    target;
+    scope;
+}
+__decorate([
+    Enumeration(DocumentAssignmentTarget),
+    __metadata("design:type", String)
+], DocumentAssignmentTaskView.prototype, "target", void 0);
+__decorate([
+    Array(string()),
+    __metadata("design:type", Array)
+], DocumentAssignmentTaskView.prototype, "scope", void 0);
+export class DocumentAssignmentView {
+    collections;
+    assignmentTask;
+}
+__decorate([
+    Array(DocumentCollectionAssignmentView),
+    __metadata("design:type", Array)
+], DocumentAssignmentView.prototype, "collections", void 0);
+__decorate([
+    Property(DocumentAssignmentTaskView, { nullable: true }),
+    __metadata("design:type", Object)
+], DocumentAssignmentView.prototype, "assignmentTask", void 0);
 export class DocumentView extends Document {
-    collectionAssignments;
+    assignment;
     properties;
     /** available as long as the document is neither approved nor rejected */
     currentWorkflow;
     validations;
 }
 __decorate([
-    Array(DocumentCollectionAssignment),
-    __metadata("design:type", Array)
-], DocumentView.prototype, "collectionAssignments", void 0);
+    Property(DocumentAssignmentView),
+    __metadata("design:type", DocumentAssignmentView)
+], DocumentView.prototype, "assignment", void 0);
 __decorate([
     Array(DocumentPropertyValueView),
     __metadata("design:type", Array)
@@ -73,17 +109,11 @@ __decorate([
 ], DocumentView.prototype, "validations", void 0);
 export class DocumentRequestView extends DocumentRequest {
     collectionIds;
-    /** current approval-pending or approved document */
-    document;
 }
 __decorate([
     Array(String),
     __metadata("design:type", Array)
 ], DocumentRequestView.prototype, "collectionIds", void 0);
-__decorate([
-    Property(Document, { nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestView.prototype, "document", void 0);
 export class DocumentManagementData {
     collections;
     documents;

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

@@ -34,6 +34,7 @@ export declare const createDocumentParametersSchema: import("../../schema/index.
             scope: string | string[];
         };
     };
+    uploadId: string;
     properties?: {
         propertyId: import("../../orm/schemas/uuid.js").Uuid;
         value: string | number | boolean | null;

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

@@ -5,6 +5,7 @@ export const metadataParameterSchema = optional(partial(pick(EntityMetadata, 'at
 export const metadataParameterObjectSchema = object({ metadata: metadataParameterSchema });
 export const setDocumentPropertyParametersSchema = assign(pick(DocumentPropertyValue, ['propertyId']), object({ value: union(string(), number(), boolean(), nullable(never())) }), metadataParameterObjectSchema);
 export const createDocumentParametersSchema = assign(partial(pick(Document, ['typeId', 'title', 'subtitle', 'date', 'summary', 'tags', 'approval', 'comment'])), pick(DocumentFile, ['originalFileName']), object({
+    uploadId: string(),
     assignment: union(object({ collections: oneOrMany(string(), { minimum: 1 }) }), object({ request: string() }), object({
         automatic: object({
             /** collection ids to assign in */

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

@@ -1,11 +1,20 @@
 import type { TypedOmit } from '../../../types.js';
 import type { DocumentCollectionAssignment } from '../../models/index.js';
+import type { DocumentAssignmentTaskView, DocumentAssignmentView, DocumentCollectionAssignmentView } from '../document-management.view-model.js';
 import type { EnrichedDocumentCollection } from './enriched-document-collection.view.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
 import type { EnrichedDocument } from './enriched-document.view.js';
-export declare class EnrichedDocumentAssignment implements TypedOmit<DocumentCollectionAssignment, 'collectionId' | 'documentId' | 'metadata'> {
-    readonly id: string;
-    readonly collection: EnrichedDocumentCollection;
+export declare class EnrichedDocumentCollectionAssignment implements TypedOmit<DocumentCollectionAssignment, 'id' | 'collectionId' | 'documentId' | 'metadata'> {
+    #private;
+    get collection(): EnrichedDocumentCollection;
     readonly document: EnrichedDocument;
     readonly archiveTimestamp: number | null;
-    constructor(id: string, collection: EnrichedDocumentCollection, document: EnrichedDocument, archiveTimestamp: number | null);
+    constructor(data: EnrichedDocumentManagementData, assignment: DocumentCollectionAssignmentView, document: EnrichedDocument);
+}
+export declare class EnrichedDocumentAssignment implements TypedOmit<DocumentAssignmentView, 'collections' | 'assignmentTask'> {
+    #private;
+    get collections(): EnrichedDocumentCollectionAssignment[];
+    get document(): EnrichedDocument;
+    readonly assignmentTask: DocumentAssignmentTaskView | null;
+    constructor(data: EnrichedDocumentManagementData, document: EnrichedDocument, assignment: DocumentAssignmentView);
 }

package/document-management/service-models/enriched/enriched-document-assignment.view.js

@@ -1,12 +1,34 @@
-export class EnrichedDocumentAssignment {
-    id;
-    collection;
+import { assertDefinedPass } from '../../../utils/type-guards.js';
+export class EnrichedDocumentCollectionAssignment {
+    #data;
+    #assignment;
+    get collection() {
+        return assertDefinedPass(this.#data.maps.collections.get(this.#assignment.collectionId));
+    }
     document;
     archiveTimestamp;
-    constructor(id, collection, document, archiveTimestamp) {
-        this.id = id;
-        this.collection = collection;
+    constructor(data, assignment, document) {
+        this.#data = data;
+        this.#assignment = assignment;
         this.document = document;
-        this.archiveTimestamp = archiveTimestamp;
+        this.archiveTimestamp = assignment.archiveTimestamp;
+    }
+}
+export class EnrichedDocumentAssignment {
+    #data;
+    #collections;
+    #document;
+    get collections() {
+        return this.#collections;
+    }
+    get document() {
+        return this.#document;
+    }
+    assignmentTask;
+    constructor(data, document, assignment) {
+        this.#data = data;
+        this.#document = document;
+        this.#collections = assignment.collections.map((assignment) => new EnrichedDocumentCollectionAssignment(data, assignment, document));
+        this.assignmentTask = assignment.assignmentTask;
     }
 }

package/document-management/service-models/enriched/enriched-document-collection.view.js

@@ -22,7 +22,7 @@ export class EnrichedDocumentCollection {
         return this.children.flatMap((child) => [child, ...child.childrenDeep]);
     }
     get documents() {
-        return this.#data.documents.filter((document) => document.assignments.some((assignment) => assignment.collection.id == this.id));
+        return this.#data.documents.filter((document) => document.assignments.collections.some((assignment) => assignment.collection.id == this.id));
     }
     get documentsDeep() {
         return [...this.documents, ...this.children.flatMap((child) => child.documentsDeep)];

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

@@ -5,7 +5,7 @@ import type { EnrichedDocumentCollection } from './enriched-document-collection.
 import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
 import type { EnrichedDocumentType } from './enriched-document-type.view.js';
 import type { EnrichedDocument } from './enriched-document.view.js';
-export declare class EnrichedDocumentRequest implements TypedOmit<DocumentRequestView, 'typeId' | 'documentId' | 'document' | 'collectionIds' | 'metadata'> {
+export declare class EnrichedDocumentRequest implements TypedOmit<DocumentRequestView, 'typeId' | 'documentId' | 'collectionIds' | 'metadata'> {
     #private;
     readonly id: string;
     readonly comment: string | null;

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

@@ -5,7 +5,7 @@ import { EnrichedDocumentAssignment } from './enriched-document-assignment.view.
 import { EnrichedDocumentFile } from './enriched-document-file.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' | 'fileId' | 'collectionAssignments' | 'createUserId' | 'metadata'> {
+export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'fileId' | 'assignment' | 'createUserId' | 'metadata'> {
     #private;
     readonly id: string;
     readonly title: string | null;
@@ -21,6 +21,6 @@ export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId
     readonly validations: DocumentValidationExecution[] | null;
     get type(): EnrichedDocumentType | null;
     get file(): EnrichedDocumentFile;
-    get assignments(): EnrichedDocumentAssignment[];
+    get assignments(): EnrichedDocumentAssignment;
     constructor(data: EnrichedDocumentManagementData, document: DocumentView);
 }

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

@@ -37,11 +37,7 @@ export class EnrichedDocument {
         return new EnrichedDocumentFile(file, this);
     }
     get assignments() {
-        return this.#documentView.collectionAssignments
-            .map((assignment) => {
-            const collection = assertDefinedPass(this.#data.collections.find((collection) => collection.id == assignment.collectionId));
-            return new EnrichedDocumentAssignment(assignment.id, collection, assertDefinedPass(this.#data.documents.find((document) => document.id == this.#documentView.id)), assignment.archiveTimestamp);
-        });
+        return new EnrichedDocumentAssignment(this.#data, this, this.#documentView.assignment);
     }
     constructor(data, document) {
         this.#data = data;
@@ -72,6 +68,6 @@ __decorate([
 ], EnrichedDocument.prototype, "file", null);
 __decorate([
     Memoize(),
-    __metadata("design:type", Array),
+    __metadata("design:type", EnrichedDocumentAssignment),
     __metadata("design:paramtypes", [])
 ], EnrichedDocument.prototype, "assignments", null);

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

@@ -3,7 +3,7 @@ import type { DocumentCollection, DocumentWorkflowStep } from '../../document-ma
 import { DocumentManagementAncillaryService, type DocumentCollectionMetadata } from '../../document-management/server/index.js';
 export declare class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
     _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[];
-    getUserId(_token?: unknown): string;
+    getSubject(_token?: unknown): string;
     canCreateDocuments(_collectionId: string, _token?: unknown): boolean;
     canUpdateDocuments(_collectionId: string, _token?: unknown): boolean;
     canDeleteDocuments(_collectionId: string, _token?: unknown): boolean;

package/examples/document-management/main.js

@@ -6,20 +6,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import '../../polyfills.js';
 import { configureAiService } from '../../ai/index.js';
+import { MockApiRequestTokenProvider } from '../../api/server/api-request-token.provider.js';
 import { configureApiServer } from '../../api/server/module.js';
 import { Application } from '../../application/application.js';
-import { AuthenticationApiRequestTokenProvider } from '../../authentication/server/authentication-api-request-token.provider.js';
 import { DocumentCategoryTypeService, DocumentCollectionService, DocumentManagementAncillaryService, DocumentManagementApiController, DocumentRequestService } from '../../document-management/server/index.js';
 import { configureDocumentManagement, migrateDocumentManagementSchema } from '../../document-management/server/module.js';
 import { DocumentManagementService } from '../../document-management/server/services/document-management.service.js';
+import { configureNodeHttpServer } from '../../http/server/node/module.js';
 import { Injector, Singleton } from '../../injector/index.js';
 import { inject, injectManyAsync, runInInjectionContext } from '../../injector/inject.js';
 import { configureLocalMessageBus } from '../../message-bus/index.js';
+import { WebServerModule } from '../../module/index.js';
 import { configureS3ObjectStorage } from '../../object-storage/index.js';
 import { configureOrm } from '../../orm/server/index.js';
 import { configurePostgresQueue, migratePostgresQueueSchema } from '../../queue/postgres/index.js';
 import { boolean, positiveInteger, string } from '../../utils/config-parser.js';
 import { TstdlCategoryParents, TstdlDocumentCategoryLabels, TstdlDocumentTypeCategories, TstdlDocumentTypeLabels } from './categories-and-types.js';
+import { configureTstdl } from '../../core.js';
 const config = {
     database: {
         host: string('DATABASE_HOST', '127.0.0.1'),
@@ -45,11 +48,12 @@ const config = {
         bucketPerModule: boolean('S3_BUCKET_PER_MODULE', true),
     },
 };
+const userId = crypto.randomUUID();
 let ExampleDocumentManagementAncillaryService = class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
     _resolveMetadata(collections) {
-        return collections.map((collection) => ({ name: collection.id, group: null }));
+        return collections.map((collection) => ({ name: collection.id.split('-')[0], group: null }));
     }
-    getUserId(_token) { return 'user-id'; }
+    getSubject(_token) { return userId; }
     canCreateDocuments(_collectionId, _token) { return true; }
     canUpdateDocuments(_collectionId, _token) { return true; }
     canDeleteDocuments(_collectionId, _token) { return true; }
@@ -70,6 +74,8 @@ ExampleDocumentManagementAncillaryService = __decorate([
 export { ExampleDocumentManagementAncillaryService };
 async function bootstrap() {
     const injector = inject(Injector);
+    configureTstdl();
+    configureNodeHttpServer();
     configurePostgresQueue();
     configureLocalMessageBus();
     configureOrm({
@@ -84,6 +90,7 @@ async function bootstrap() {
     configureDocumentManagement({
         ancillaryService: ExampleDocumentManagementAncillaryService,
         fileObjectStorageModule: 'documents',
+        fileUploadObjectStorageModule: 'document-uploads',
         filePreviewObjectStorageModule: 'document-previews',
     });
     configureS3ObjectStorage({
@@ -95,7 +102,7 @@ async function bootstrap() {
     });
     configureApiServer({
         controllers: [DocumentManagementApiController],
-        requestTokenProvider: AuthenticationApiRequestTokenProvider,
+        requestTokenProvider: MockApiRequestTokenProvider,
         gatewayOptions: {
             prefix: null,
             cors: {
@@ -116,8 +123,13 @@ async function bootstrap() {
 async function main() {
     const [documentManagementService, documentCollectionService] = await injectManyAsync(DocumentManagementService, DocumentCollectionService, DocumentCategoryTypeService, DocumentRequestService);
     const { categories, types } = await documentManagementService.initializeCategoriesAndTypes(TstdlDocumentCategoryLabels, TstdlCategoryParents, TstdlDocumentTypeLabels, TstdlDocumentTypeCategories);
-    const collection = await documentCollectionService.createCollection(null);
-    const data = await documentManagementService.loadData([collection.id]);
-    console.log(data);
+    const collectionCount = await documentCollectionService.repository.count();
+    for (let i = 0; i < (3 - collectionCount); i++) {
+        await documentCollectionService.createCollection(null);
+    }
+    const collections = await documentCollectionService.repository.loadAll();
+    for (const collection of collections) {
+        console.log(`Collection: ${collection.id}`);
+    }
 }
-Application.run({ bootstrap }, main);
+Application.run({ bootstrap }, main, WebServerModule);

package/http/client/adapters/undici.adapter.js

@@ -56,7 +56,7 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
                 body,
                 headersTimeout: httpClientRequest.timeout,
                 bodyTimeout: httpClientRequest.timeout,
-                dispatcher: this.options.dispatcher
+                dispatcher: this.options.dispatcher,
             });
             const httpClientResponse = new HttpClientResponse({
                 request: httpClientRequest,
@@ -64,14 +64,14 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
                 statusMessage: '?',
                 headers: new HttpHeaders(response.headers),
                 body: response.body,
-                closeHandler: () => response.body.destroy()
+                closeHandler: () => response.body.destroy(),
             });
             return httpClientResponse;
         }
         catch (error) {
             if (error instanceof undiciErrors.UndiciError) {
                 const reason = getHttpErrorReason(error);
-                throw new HttpError(reason, httpClientRequest, undefined, undefined, error);
+                throw new HttpError(reason, httpClientRequest, { cause: error });
             }
             throw error;
         }