@tstdl/base 0.91.49 → 0.91.51

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

@@ -0,0 +1,376 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { getEntityMap } from '../../database/index.js';
+import { Enumerable } from '../../enumerable/index.js';
+import { BadRequestError } from '../../errors/index.js';
+import { getMimeType, getMimeTypeExtensions } from '../../file/index.js';
+import { Singleton, inject, injectArgument, provide } from '../../injector/index.js';
+import { ObjectStorage } from '../../object-storage/index.js';
+import { DATABASE_CONFIG, EntityRepositoryConfig, injectRepository } from '../../orm/index.js';
+import { toArray } from '../../utils/array/index.js';
+import { assertDefinedPass, compareByValueSelectionToOrder, currentTimestamp, digest, isBoolean, isDefined, isNotNull, isNull, isNumber, isString, isUint8Array, millisecondsPerMinute } from '../../utils/index.js';
+import { groupToMap } from '../../utils/iterable-helpers/index.js';
+import { readBinaryStream } from '../../utils/stream/index.js';
+import { Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, DocumentProperty, DocumentPropertyBooleanValue, DocumentPropertyDataType, DocumentPropertyDecimalValue, DocumentPropertyIntegerValue, DocumentPropertyTextValue, DocumentRequest, DocumentRequestCollection, DocumentRequestFile, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty } from '../models/index.js';
+import { DocumentManagementConfig } from '../module.js';
+let DocumentManagementService = class DocumentManagementService {
+    documentService = injectRepository(Document);
+    documentFileService = injectRepository(DocumentFile);
+    documentCollectionService = injectRepository(DocumentCollection);
+    documentCategoryService = injectRepository(DocumentCategory);
+    documentTypeService = injectRepository(DocumentType);
+    documentRequestService = injectRepository(DocumentRequest);
+    documentRequestsTemplateService = injectRepository(DocumentRequestsTemplate);
+    documentRequestTemplateService = injectRepository(DocumentRequestTemplate);
+    documentRequestCollectionService = injectRepository(DocumentRequestCollection);
+    documentRequestFileService = injectRepository(DocumentRequestFile);
+    documentPropertyService = injectRepository(DocumentProperty);
+    documentTypePropertyService = injectRepository(DocumentTypeProperty);
+    documentPropertyTextValueService = injectRepository(DocumentPropertyTextValue);
+    documentPropertyIntegerValueService = injectRepository(DocumentPropertyIntegerValue);
+    documentPropertyDecimalValueService = injectRepository(DocumentPropertyDecimalValue);
+    documentPropertyBooleanValueService = injectRepository(DocumentPropertyBooleanValue);
+    documentCollectionDocumentService = injectRepository(DocumentCollectionDocument);
+    fileObjectStorage = inject(ObjectStorage, (injectArgument(this, { optional: true }) ?? inject(DocumentManagementConfig)).fileObjectStorageModule);
+    async loadData(collectionIds, collectionsMetadata) {
+        return this.documentCollectionService.transaction(async (_, transaction) => {
+            const [collections, collectionDocuments, requestCollections, categories, types] = await Promise.all([
+                this.documentCollectionService.withTransaction(transaction).loadMany(collectionIds),
+                this.documentCollectionDocumentService.withTransaction(transaction).loadManyByQuery({ collectionId: { $in: collectionIds } }),
+                this.documentRequestCollectionService.withTransaction(transaction).loadManyByQuery({ collectionId: { $in: collectionIds } }),
+                this.documentCategoryService.withTransaction(transaction).loadManyByQuery({}, { order: { label: 1 } }),
+                this.documentTypeService.withTransaction(transaction).loadManyByQuery({}, { order: { label: 1 } })
+            ]);
+            const documentIds = collectionDocuments.map((document) => document.documentId);
+            const requestIds = requestCollections.map((requestCollection) => requestCollection.requestId);
+            const [documents, requests, requestFiles, textValues, integerValues, decimalValues, booleanValues] = 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.documentPropertyTextValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } }),
+                this.documentPropertyIntegerValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } }),
+                this.documentPropertyDecimalValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } }),
+                this.documentPropertyBooleanValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } })
+            ]);
+            const documentFileIds = documents.map((document) => document.fileId);
+            const requestFileIds = requestFiles.map((requestFile) => requestFile.fileId);
+            const files = await this.documentFileService.withTransaction(transaction).loadManyByQuery({ id: { $in: [...documentFileIds, ...requestFileIds] } }, { order: { 'metadata.createTimestamp': 'desc' } });
+            const requestsFilesMap = groupToMap(requestFiles, (requestFile) => requestFile.requestId);
+            const valuesMap = Enumerable.from(textValues).concat(integerValues).concat(decimalValues).concat(booleanValues).groupToMap((value) => value.documentId);
+            const collectionViews = collections.toSorted(compareByValueSelectionToOrder(collectionIds, (collection) => collection.id)).map((collection) => ({
+                ...collection,
+                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 requestViews = requests.map((request) => ({
+                ...request,
+                collectionIds: requestCollections.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId),
+                requestFiles: requestsFilesMap.get(request.id) ?? []
+            }));
+            return {
+                collections: collectionViews,
+                documents: documentViews,
+                requests: requestViews,
+                files,
+                categories,
+                types
+            };
+        });
+    }
+    async loadDocumentRequestsTemplateData() {
+        const [requestsTemplates, requestTemplates] = await Promise.all([
+            this.documentRequestsTemplateService.loadManyByQuery({}, { order: { label: 'asc' } }),
+            this.documentRequestTemplateService.loadManyByQuery({})
+        ]);
+        const templates = requestsTemplates.map((requestsTemplate) => ({
+            ...requestsTemplate,
+            requestTemplates: requestTemplates.filter((requestTemplate) => requestTemplate.requestsTemplateId == requestsTemplate.id)
+        }));
+        return { templates };
+    }
+    async loadCategoriesAndTypes() {
+        const [categories, types] = await Promise.all([
+            this.documentCategoryService.loadManyByQuery({}, { order: { label: 1 } }),
+            this.documentTypeService.loadManyByQuery({}, { order: { label: 1 } })
+        ]);
+        return { categories, types };
+    }
+    async loadDocument(id) {
+        return this.documentService.load(id);
+    }
+    async loadDocumentFile(id) {
+        return this.documentFileService.load(id);
+    }
+    async loadType(id) {
+        return this.documentTypeService.load(id);
+    }
+    async getFileContentUrl(fileId, title, download = false) {
+        const file = await this.documentFileService.load(fileId);
+        return this.getDocumentFileContentObjectUrl(title ?? fileId, file, download);
+    }
+    async createCategory(parameters) {
+        return this.documentCategoryService.insert(parameters);
+    }
+    async createType(parameters) {
+        return this.documentTypeService.insert(parameters);
+    }
+    async createCollection(parameters) {
+        return this.documentCollectionService.insert(parameters ?? {});
+    }
+    async collectionHasDocumentByFilter(collectionId, filter) {
+        const collectionDocuments = await this.documentCollectionDocumentService.loadManyByQuery({ collectionId });
+        const documentIds = collectionDocuments.map((cd) => cd.documentId);
+        return this.documentService.hasByQuery({ $and: [{ id: { $in: documentIds } }, filter] });
+    }
+    async getRequestFilesStats(collectionIds) {
+        const collectionRequests = await this.documentRequestCollectionService.loadManyByQuery({ collectionId: { $in: toArray(collectionIds) } });
+        const requestIds = collectionRequests.map((collectionRequest) => collectionRequest.requestId);
+        const filteredRequests = await this.documentRequestService.loadManyByQuery({ id: { $in: requestIds }, completed: false });
+        const filteredRequestIds = filteredRequests.map((request) => request.id);
+        const requiredFilesCount = filteredRequests.reduce((sum, request) => sum + request.requiredFilesCount, 0);
+        const [pendingFilesCount, approvedFilesCount] = await Promise.all([
+            this.documentRequestFileService.countByQuery({ requestId: { $in: filteredRequestIds }, approval: null }),
+            this.documentRequestFileService.countByQuery({ requestId: { $in: filteredRequestIds }, approval: true })
+        ]);
+        return { requiredFilesCount, requiredFilesLeft: Math.max(0, requiredFilesCount - approvedFilesCount), pendingFilesCount, approvedFilesCount };
+    }
+    async createDocumentRequestsTemplate(parameters) {
+        return this.documentRequestsTemplateService.insert(parameters);
+    }
+    async updateDocumentRequestsTemplate({ id, label, metadata }) {
+        return this.documentRequestsTemplateService.update(id, { label, metadata });
+    }
+    async applyDocumentRequestsTemplate({ id, collectionIds, metadata }) {
+        const requestTemplates = await this.documentRequestTemplateService.loadManyByQuery({ requestsTemplateId: id });
+        await this.documentRequestService.transaction(async (_, transaction) => {
+            for (const { typeId, requiredFilesCount, comment } of requestTemplates) {
+                await this.createDocumentRequest({ typeId, requiredFilesCount, comment, collectionIds, metadata }, transaction);
+            }
+        });
+    }
+    async deleteDocumentRequestsTemplate(parameters) {
+        return this.documentRequestsTemplateService.delete(parameters.id);
+    }
+    async createDocumentRequestTemplate(parameters) {
+        return this.documentRequestTemplateService.insert(parameters);
+    }
+    async updateDocumentRequestTemplate({ id, typeId, requiredFilesCount, comment, metadata }) {
+        return this.documentRequestTemplateService.update(id, { typeId, requiredFilesCount, comment, metadata });
+    }
+    async deleteDocumentRequestTemplate(parameters) {
+        return this.documentRequestTemplateService.delete(parameters.id);
+    }
+    async createDocument({ typeId, addition, date, expiration, originalFileName, collectionIds, properties, metadata }, content) {
+        return 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, addition, date, expiration, metadata });
+            if (isDefined(collectionIds)) {
+                for (const collectionId of toArray(collectionIds)) {
+                    await this.documentCollectionDocumentService.withTransaction(transaction).insert({ collectionId, documentId: document.id, archiveTimestamp: null });
+                }
+            }
+            if (isDefined(properties)) {
+                const mappedProperties = properties.map((property) => ({ ...property, documentId: document.id }));
+                await this.setDocumentProperties(mappedProperties, transaction);
+            }
+            return document;
+        });
+    }
+    async approveDocumentRequestFile({ id, approvalComment, documentMetadata, requestFileMetadata }) {
+        return this.documentRequestFileService.transaction(async (_, transaction) => {
+            const requestFile = await this.documentRequestFileService.withTransaction(transaction).load(id);
+            const requestCollections = await this.documentRequestCollectionService.withTransaction(transaction).loadManyByQuery({ requestId: requestFile.requestId });
+            if (requestFile.approval == true) {
+                throw new BadRequestError('Document request file already accepted.');
+            }
+            const request = await this.documentRequestService.withTransaction(transaction).load(requestFile.requestId);
+            const document = await this.documentService.withTransaction(transaction).insert({
+                fileId: requestFile.fileId,
+                typeId: request.typeId,
+                addition: requestFile.addition,
+                date: null,
+                expiration: null,
+                metadata: documentMetadata
+            });
+            for (const { collectionId } of requestCollections) {
+                await this.addDocumentToCollection({ collectionId, documentId: document.id }, transaction);
+            }
+            await this.documentRequestFileService.withTransaction(transaction).update(id, { approval: true, approvalComment, approvalTimestamp: currentTimestamp(), createdDocumentId: document.id, metadata: requestFileMetadata });
+            return document;
+        });
+    }
+    async rejectDocumentRequestFile({ id, approvalComment, metadata }) {
+        return 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: currentTimestamp(), metadata });
+        });
+    }
+    async updateDocumentRequestFile({ id, addition, approvalComment, metadata }) {
+        return this.documentRequestFileService.update(id, { addition, approvalComment, metadata });
+    }
+    async deleteDocumentRequestFile({ id, metadata }) {
+        const requestFile = await this.documentRequestFileService.load(id);
+        if (isNotNull(requestFile.approval)) {
+            throw new BadRequestError('Only pending request files can be deleted.');
+        }
+        await this.documentRequestFileService.delete(id, metadata);
+    }
+    async createDocumentFile(content, originalFileName, dbTransaction) {
+        return this.documentFileService.useTransaction(dbTransaction, async (_, transaction) => {
+            const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
+            const hash = await digest('SHA-256', contentAsUint8Array).toHex();
+            const mimeType = await getMimeType(contentAsUint8Array);
+            const documentFile = await this.documentFileService.withTransaction(transaction).insert({
+                originalFileName,
+                mimeType,
+                hash,
+                size: contentAsUint8Array.length
+            });
+            const key = getDocumentFileKey(documentFile.id);
+            await this.fileObjectStorage.uploadObject(key, contentAsUint8Array);
+            return documentFile;
+        });
+    }
+    async createDocumentRequestFile({ requestId, addition, originalFileName, metadata }, content) {
+        return this.documentRequestFileService.transaction(async (_, transaction) => {
+            const [request, existingRequestFiles] = await Promise.all([
+                this.documentRequestService.withTransaction(transaction).load(requestId),
+                this.documentRequestFileService.withTransaction(transaction).loadManyByQuery({ requestId })
+            ]);
+            const filesCountLeft = (request.completed ? 0 : request.requiredFilesCount) - existingRequestFiles.reduce((sum, requestFile) => sum + ((requestFile.approval != false) ? 1 : 0), 0);
+            if (filesCountLeft <= 0) {
+                throw new BadRequestError('Maximum amount of allowed files reached.');
+            }
+            const file = await this.createDocumentFile(content, originalFileName, transaction);
+            return this.documentRequestFileService.withTransaction(transaction).insert({ requestId, fileId: file.id, addition, createdDocumentId: null, approval: null, approvalComment: null, approvalTimestamp: null, metadata });
+        });
+    }
+    async createDocumentRequest(parameters, transaction) {
+        if (parameters.collectionIds.length == 0) {
+            throw new BadRequestError('No target collectionId specified.');
+        }
+        return 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;
+        });
+    }
+    async updateDocument(parameters, transaction) {
+        const { id: documentId, properties: propertyUpdates, ...update } = parameters;
+        await this.documentService.useTransaction(transaction, async (repository, tx) => {
+            await repository.update(documentId, update);
+            if (isDefined(propertyUpdates)) {
+                const mappedPropertyUpdates = propertyUpdates.map((property) => ({ documentId, ...property }));
+                await this.setDocumentProperties(mappedPropertyUpdates, tx);
+            }
+        });
+    }
+    async updateDocumentRequest(parameters, transaction) {
+        const { id: documentRequestId, ...update } = parameters;
+        const requestFiles = await this.documentRequestFileService.withOptionalTransaction(transaction).loadManyByQuery({ requestId: parameters.id });
+        if (parameters.completed == true) {
+            const hasCreatedDocument = requestFiles.some((requestFile) => isNotNull(requestFile.createdDocumentId));
+            if (!hasCreatedDocument) {
+                throw new BadRequestError('Cannot complete requests which has no approved files.');
+            }
+        }
+        await this.documentRequestService.withOptionalTransaction(transaction).update(documentRequestId, update);
+    }
+    async deleteDocumentRequest({ id, metadata }, transaction) {
+        const requestFiles = await this.documentRequestFileService.loadManyByQuery({ requestId: id });
+        const hasCreatedDocument = requestFiles.some((requestFile) => isNotNull(requestFile.createdDocumentId));
+        if (hasCreatedDocument) {
+            throw new BadRequestError('Cannot delete requests which has approved files.');
+        }
+        await this.documentRequestService.withOptionalTransaction(transaction).delete(id, metadata);
+    }
+    async setDocumentProperties(setDocumentPropertyItems, transaction) {
+        if ((setDocumentPropertyItems.length == 0)) {
+            return;
+        }
+        await this.documentPropertyService.useTransaction(transaction, async (_, tx) => {
+            const propertyIds = setDocumentPropertyItems.map((property) => property.propertyId);
+            const properties = await this.documentPropertyService.withTransaction(tx).loadManyByQuery({ id: { $in: propertyIds } });
+            const propertiesMap = getEntityMap(properties);
+            for (const { documentId, propertyId, value, metadata } of setDocumentPropertyItems) {
+                const property = assertDefinedPass(propertiesMap.get(propertyId));
+                validatePropertyValue(propertyId, property.dataType, value);
+                const propertyValueService = this.getDocumentPropertyValueService(property.dataType);
+                await propertyValueService.withTransaction(tx).upsert(['documentId', 'propertyId'], { documentId, propertyId, value: value, metadata }, undefined);
+            }
+        });
+    }
+    async addDocumentToCollection(parameters, transaction) {
+        await this.documentCollectionDocumentService.withOptionalTransaction(transaction).upsert(['collectionId', 'documentId'], { ...parameters, archiveTimestamp: null });
+    }
+    async archiveDocument({ collectionId, documentId, metadata }) {
+        await this.documentCollectionDocumentService.updateByQuery({ collectionId, documentId }, { archiveTimestamp: currentTimestamp(), metadata });
+    }
+    async createProperty(parameters) {
+        return this.documentPropertyService.insert(parameters);
+    }
+    async assignPropertyToType(parameters) {
+        await this.documentTypePropertyService.insert(parameters);
+    }
+    getDocumentPropertyValueService(dataType) {
+        switch (dataType) {
+            case DocumentPropertyDataType.Text:
+                return this.documentPropertyTextValueService;
+            case DocumentPropertyDataType.Integer:
+                return this.documentPropertyIntegerValueService;
+            case DocumentPropertyDataType.Decimal:
+                return this.documentPropertyDecimalValueService;
+            case DocumentPropertyDataType.Boolean:
+                return this.documentPropertyBooleanValueService;
+            default:
+                throw new BadRequestError('Unknown property data type.');
+        }
+    }
+    async getDocumentFileContentObjectUrl(title, file, download) {
+        const key = getDocumentFileKey(file.id);
+        const fileExtension = getMimeTypeExtensions(file.mimeType)[0] ?? 'bin';
+        const disposition = download ? 'attachment' : 'inline';
+        const filename = `${title}.${fileExtension}`;
+        return this.fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+            'Response-Content-Type': file.mimeType,
+            'Response-Content-Disposition': `${disposition}; filename="${encodeURIComponent(filename)}"`
+        });
+    }
+};
+DocumentManagementService = __decorate([
+    Singleton({
+        providers: [
+            provide(EntityRepositoryConfig, { useValue: { schema: 'document_management' } }),
+            { provide: DATABASE_CONFIG, useFactory: (_, context) => context.resolve(DocumentManagementConfig).database }
+        ]
+    })
+], DocumentManagementService);
+export { DocumentManagementService };
+function getDocumentFileKey(id) {
+    return `${id.slice(0, 2)}/${id.slice(0, 4)}/${id}`;
+}
+const validators = {
+    [DocumentPropertyDataType.Text]: (value) => isString(value) || isNull(value),
+    [DocumentPropertyDataType.Integer]: (value) => isNumber(value) || isNull(value),
+    [DocumentPropertyDataType.Decimal]: (value) => isNumber(value) || isNull(value),
+    [DocumentPropertyDataType.Boolean]: (value) => isBoolean(value) || isNull(value)
+};
+function validatePropertyValue(propertyId, dataType, value) {
+    const valid = validators[dataType](value);
+    if (!valid) {
+        throw new BadRequestError(`Invalid value for data type ${DocumentPropertyDataType[dataType]} for property ${propertyId}.`);
+    }
+}

package/document-management/services/index.d.ts

@@ -0,0 +1 @@
+export * from './document-management.service.js';

package/document-management/services/index.js

@@ -0,0 +1 @@
+export * from './document-management.service.js';

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

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/examples/document-management/main.js

@@ -0,0 +1,30 @@
+import '../../polyfills.js';
+import { Application } from '../../application/application.js';
+import { configureDocumentManagement, migrateDocumentManagementSchema } from '../../document-management/module.js';
+import { DocumentManagementService } from '../../document-management/services/document-management.service.js';
+import { injectAsync } from '../../injector/inject.js';
+import { configureS3ObjectStorage } from '../../object-storage/index.js';
+async function bootstrap() {
+    configureDocumentManagement({
+        database: {
+            connection: {
+                database: 'xxx',
+                user: 'xxx',
+                password: 'xxx'
+            }
+        },
+        fileObjectStorageModule: 'documents'
+    });
+    configureS3ObjectStorage({ endpoint: 'http://localhost:10000', accessKey: 'tstdl-dev', secretKey: 'tstdl-dev', bucketPerModule: true });
+    await migrateDocumentManagementSchema();
+}
+async function main() {
+    const documentManagementService = await injectAsync(DocumentManagementService);
+    const collection = await documentManagementService.createCollection();
+    const category = await documentManagementService.createCategory({ label: 'Testkategorie' });
+    const type = await documentManagementService.createType({ categoryId: category.id, group: null, label: 'Testtyp' });
+    const request = await documentManagementService.createDocumentRequest({ typeId: type.id, requiredFilesCount: 1, comment: null, collectionIds: [collection.id] });
+    const data = await documentManagementService.loadData([collection.id]);
+    console.log(data);
+}
+Application.run({ bootstrap }, main);

package/examples/orm/drizzle.config.js

@@ -1,5 +1,6 @@
+import { resolve } from 'node:path';
 import { defineConfig } from 'drizzle-kit';
 export default defineConfig({
     dialect: 'postgresql',
-    schema: './schemas.js'
+    schema: resolve(__dirname, './schemas.js')
 });

package/examples/orm/schemas.d.ts

@@ -1,3 +1,3 @@
 import { User } from './user.model.js';
 export declare const mySchema: import("../../orm/database-schema.js").DatabaseSchema<"my_application">;
-export declare const user: import("../../orm/index.js").PgTableFromType<"my_application", typeof User>;
+export declare const user: import("../../orm/drizzle/schema-converter.js").PgTableFromType<"my_application", typeof User>;

package/examples/orm/user.model.d.ts

@@ -1,4 +1,4 @@
-import { Entity, Enum, Integer } from '../../orm/index.js';
+import { Entity, Integer } from '../../orm/index.js';
 export declare enum Foo {
     Bar = 0,
     Baz = 1
@@ -10,5 +10,4 @@ export declare class User extends Entity {
     age: Integer | null;
     hasAge: boolean;
     mail: string;
-    foo: Enum<typeof Foo>;
 }

package/examples/orm/user.model.js

@@ -21,7 +21,6 @@ export class User extends Entity {
     age;
     hasAge;
     mail;
-    foo;
 }
 __decorate([
     StringProperty(),

package/http/server/node/node-http-server.js

@@ -11,6 +11,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import * as Http from 'node:http';
+import { Writable } from 'node:stream';
+import { bindNodeCallback, share } from 'rxjs';
 import { CancellationToken } from '../../../cancellation/index.js';
 import { disposeAsync } from '../../../disposable/index.js';
 import { HttpHeaders } from '../../../http/http-headers.js';
@@ -19,11 +21,9 @@ import { ResolveArg, Singleton } from '../../../injector/index.js';
 import { Logger } from '../../../logger/index.js';
 import { encodeUtf8 } from '../../../utils/encoding.js';
 import { FeedableAsyncIterable } from '../../../utils/feedable-async-iterable.js';
-import { getReadableStreamIterable } from '../../../utils/stream/readable-stream-adapter.js';
 import { Timer } from '../../../utils/timer.js';
 import { cancelableTimeout } from '../../../utils/timing.js';
 import { isDefined, isNullOrUndefined, isString } from '../../../utils/type-guards.js';
-import { bindNodeCallback, share } from 'rxjs';
 import { HttpServerRequest } from '../http-server-request.js';
 import { HttpServer } from '../http-server.js';
 let NodeHttpServer = class NodeHttpServer extends HttpServer {
@@ -167,12 +167,12 @@ async function writeResponseBody(response, httpResponse) {
         if (!httpResponse.hasHeader('Content-Length')) {
             httpResponse.setHeader('Content-Length', bytes.byteLength);
         }
+        null.getWriter().closed;
         await write(httpResponse, bytes);
     }
     else if (isDefined(streamData)) {
-        for await (const chunk of getReadableStreamIterable(streamData)) {
-            await write(httpResponse, chunk);
-        }
+        const responseStream = Writable.toWeb(httpResponse);
+        await streamData.pipeTo(responseStream);
     }
     return new Promise((resolve) => {
         httpResponse.end(resolve);

package/injector/injector.d.ts

@@ -49,7 +49,7 @@ export declare class Injector implements AsyncDisposable {
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static registerSingleton<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
+    static registerSingleton<T, A = ResolveArgument<T, any>, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
     dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
     fork(name: string): Injector;
@@ -108,3 +108,6 @@ export declare class Injector implements AsyncDisposable {
     private getInjectionContext;
     private assertNotDisposed;
 }
+export declare function provide<T = any, A = any, D extends Record = Record>(token: InjectionToken<T, A>, provider: Provider<T, A, D> & {
+    multi?: boolean;
+}): ProvidersItem<T, A, D>;

package/injector/injector.js

@@ -260,7 +260,7 @@ export class Injector {
         const { token, providers } = registration;
         const injector = (providers.length > 0) ? this.fork('LocalProvidersInjector') : this;
         for (const nestedProvider of providers) {
-            injector.register(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
+            injector.registerSingleton(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
         }
         const injectionContext = injector.getInjectionContext(context, argument, chain);
         const previousInjectionContext = setCurrentInjectionContext(injectionContext);
@@ -442,6 +442,9 @@ export class Injector {
         }
     }
 }
+export function provide(token, provider) {
+    return { provide: token, ...provider };
+}
 function addRegistration(registrations, registration) {
     if (isClassProvider(registration.provider)) {
         const injectable = reflectionRegistry.getMetadata(registration.provider.useClass)?.data.has(injectableMetadataSymbol) ?? false;

package/injector/interfaces.d.ts

@@ -4,13 +4,13 @@ import type { AfterResolveContext } from './types.js';
 export declare const resolveArgumentType: unique symbol;
 export declare const afterResolve: unique symbol;
 export type ResolveArgumentType = typeof resolveArgumentType;
-export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? U : T extends Type<Resolvable<infer U>> ? U : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
+export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? (U | undefined) : T extends Type<Resolvable<infer U>> ? (U | undefined) : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
 export interface Resolvable<A = unknown, D extends Record = Record> extends Partial<AfterResolve<A, D>> {
     /**
-     * type of resolve argument
+     * Type of resolve argument
      * @deprecated only used for type inference
      */
-    readonly [resolveArgumentType]: A;
+    readonly [resolveArgumentType]?: A;
 }
 export interface AfterResolve<A = unknown, D extends Record = Record> {
     [afterResolve](argument: A, context: AfterResolveContext<D>): void | Promise<void>;

package/json-path/json-path.d.ts

@@ -14,12 +14,14 @@ export declare class JsonPath<T = any> implements Iterable<JsonPathNode> {
     static from(options?: JsonPathOptions): JsonPath;
     static from(path: JsonPathInput, options?: JsonPathOptions): JsonPath;
     static isJsonPath(path: string): boolean;
+    toString(): string;
     /**
      * Add a property or index to current path
      * @param key
      * @returns new JsonPath instance
      */
     add<K extends keyof T>(key: K): JsonPath<T[K]>;
+    slice(start: number, end?: number): JsonPath;
     /**
      * Updates options
      * @param options

package/json-path/json-path.js

@@ -40,6 +40,7 @@ export class JsonPath {
         }
         else {
             this._options = pathOrNodesOrOptions;
+            this._nodes = [];
         }
     }
     static from(pathOrNodesOrOptions = [], options = {}) {
@@ -48,6 +49,9 @@ export class JsonPath {
     static isJsonPath(path) {
         return isJsonPath(path);
     }
+    toString() {
+        return this.path;
+    }
     /**
      * Add a property or index to current path
      * @param key
@@ -56,6 +60,9 @@ export class JsonPath {
     add(key) {
         return new JsonPath([...this.nodes, key], this._options);
     }
+    slice(start, end) {
+        return new JsonPath(this.nodes.slice(start, end), this._options);
+    }
     /**
      * Updates options
      * @param options

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

@@ -1,14 +1,12 @@
 import type { Observable } from 'rxjs';
-import type { Resolvable } from '../injector/interfaces.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
-import type { AsyncDisposable } from '../disposable/disposable.js';
-import { disposeAsync } from '../disposable/disposable.js';
+import { type Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import { type AsyncDisposable, disposeAsync } from '../disposable/disposable.js';
 export type MessageBusArgument = string;
 export declare abstract class MessageBus<T> implements AsyncDisposable, Resolvable<MessageBusArgument> {
     readonly [resolveArgumentType]: string;
-    /** messages from other instances */
+    /** Messages from other instances */
     abstract readonly messages$: Observable<T>;
-    /** messages from other instances and itself */
+    /** Messages from other instances and itself */
     abstract readonly allMessages$: Observable<T>;
     dispose(): Promise<void>;
     abstract publish(message: T): Promise<void>;

package/orm/database-schema.d.ts

@@ -1,8 +1,11 @@
+import type { PgEnum } from 'drizzle-orm/pg-core';
+import type { Enumeration, EnumerationValue, UnionToTuple } from '../types.js';
 import { type PgTableFromType } from './drizzle/schema-converter.js';
 import type { EntityType } from './entity.js';
 export declare class DatabaseSchema<Name extends string> {
     readonly name: Name;
     constructor(name: Name);
     getTable<T extends EntityType>(type: T): PgTableFromType<Name, T>;
+    getEnum<T extends Enumeration>(enumeration: T, name: string): PgEnum<UnionToTuple<`${EnumerationValue<T>}`> extends [string, ...string[]] ? UnionToTuple<`${EnumerationValue<T>}`> : never>;
 }
 export declare function databaseSchema<Name extends string>(name: Name): DatabaseSchema<Name>;

package/orm/database-schema.js

@@ -1,11 +1,15 @@
-import { getDrizzleTableFromType } from './drizzle/schema-converter.js';
+import { getDrizzleTableFromType, getPgEnum, registerEnum } from './drizzle/schema-converter.js';
 export class DatabaseSchema {
     name;
     constructor(name) {
         this.name = name;
     }
     getTable(type) {
-        return getDrizzleTableFromType(this.name, type);
+        return getDrizzleTableFromType(type, this.name);
+    }
+    getEnum(enumeration, name) {
+        registerEnum(enumeration, name);
+        return getPgEnum(this.name, enumeration); // eslint-disable-line @typescript-eslint/no-unsafe-return
     }
 }
 export function databaseSchema(name) {