@tstdl/base 0.92.131 → 0.92.134

package/api/server/api-request-token.provider.d.ts

@@ -5,3 +5,6 @@ export declare abstract class ApiRequestTokenProvider {
 export declare class NoopApiRequestTokenProvider extends ApiRequestTokenProvider {
     getToken<T>(): T;
 }
+export declare class MockApiRequestTokenProvider extends ApiRequestTokenProvider {
+    getToken<T>(): T;
+}

package/api/server/api-request-token.provider.js

@@ -16,3 +16,12 @@ NoopApiRequestTokenProvider = __decorate([
     Singleton({ alias: ApiRequestTokenProvider })
 ], NoopApiRequestTokenProvider);
 export { NoopApiRequestTokenProvider };
+let MockApiRequestTokenProvider = class MockApiRequestTokenProvider extends ApiRequestTokenProvider {
+    getToken() {
+        return {};
+    }
+};
+MockApiRequestTokenProvider = __decorate([
+    Singleton({ alias: ApiRequestTokenProvider })
+], MockApiRequestTokenProvider);
+export { MockApiRequestTokenProvider };

package/api/server/module.js

@@ -4,7 +4,7 @@ import { ensureApiController } from './api-controller.js';
 import { ApiRequestTokenProvider } from './api-request-token.provider.js';
 import { API_CONTROLLER, API_MODULE_OPTIONS } from './tokens.js';
 export const apiModuleOptions = {
-    controllers: []
+    controllers: [],
 };
 export function configureApiServer(options) {
     if (isDefined(options.controllers)) {

package/database/mongo/module.js

@@ -6,7 +6,7 @@ import { Collection, Database, MongoClient } from './classes.js';
 export const mongoModuleConfig = {
     defaultConnection: { url: 'mongodb://localhost:27017/test-db' },
     defaultDatabase: undefined,
-    logPrefix: 'Mongo'
+    logPrefix: 'Mongo',
 };
 export function configureMongo(config) {
     mongoModuleConfig.defaultDatabase = config.defaultDatabase ?? mongoModuleConfig.defaultDatabase;
@@ -31,10 +31,10 @@ Injector.registerSingleton(MongoClient, {
     },
     async afterResolve(client, _argument, { cancellationSignal, data: { url, logger } }) {
         await connect(`mongo at ${url}`, async () => client.connect(), logger, cancellationSignal);
-    }
+    },
 }, {
     defaultArgumentProvider: () => mongoModuleConfig.defaultConnection,
-    argumentIdentityProvider: JSON.stringify
+    argumentIdentityProvider: JSON.stringify,
 });
 Injector.registerSingleton(Database, {
     useFactory: (argument, context) => {
@@ -45,7 +45,7 @@ Injector.registerSingleton(Database, {
     },
     defaultArgumentProvider: () => ({ database: mongoModuleConfig.defaultDatabase, connection: mongoModuleConfig.defaultConnection }),
 }, {
-    argumentIdentityProvider: JSON.stringify
+    argumentIdentityProvider: JSON.stringify,
 });
 Injector.registerSingleton(Collection, {
     useFactory: (config, context) => {
@@ -62,7 +62,7 @@ Injector.registerSingleton(Collection, {
             }
         }
         await database.createCollection(config.collection);
-    }
+    },
 }, {
-    argumentIdentityProvider: JSON.stringify
+    argumentIdentityProvider: JSON.stringify,
 });

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

@@ -71,6 +71,15 @@ export declare const documentManagementApiDefinition: {
             result: typeof DocumentType;
             credentials: true;
         };
+        initiateDocumentUpload: {
+            resource: string;
+            method: "POST";
+            result: import("../../schema/index.js").ObjectSchema<{
+                uploadId: string;
+                uploadUrl: string;
+            }>;
+            credentials: true;
+        };
         createDocument: {
             resource: string;
             method: "POST";
@@ -94,6 +103,7 @@ export declare const documentManagementApiDefinition: {
                         scope: string | string[];
                     };
                 };
+                uploadId: string;
                 properties?: {
                     propertyId: import("../../orm/schemas/uuid.js").Uuid;
                     value: string | number | boolean | null;
@@ -105,8 +115,6 @@ export declare const documentManagementApiDefinition: {
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/schemas/json.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                 }> | undefined;
             }>;
-            body: Uint8ArrayConstructor;
-            maxBytes: number;
             result: typeof Document;
             credentials: true;
         };
@@ -370,6 +378,15 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             result: typeof DocumentType;
             credentials: true;
         };
+        initiateDocumentUpload: {
+            resource: string;
+            method: "POST";
+            result: import("../../schema/index.js").ObjectSchema<{
+                uploadId: string;
+                uploadUrl: string;
+            }>;
+            credentials: true;
+        };
         createDocument: {
             resource: string;
             method: "POST";
@@ -393,6 +410,7 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
                         scope: string | string[];
                     };
                 };
+                uploadId: string;
                 properties?: {
                     propertyId: import("../../orm/schemas/uuid.js").Uuid;
                     value: string | number | boolean | null;
@@ -404,8 +422,6 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/schemas/json.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                 }> | undefined;
             }>;
-            body: Uint8ArrayConstructor;
-            maxBytes: number;
             result: typeof Document;
             credentials: true;
         };

package/document-management/api/document-management.api.js

@@ -8,7 +8,6 @@ import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/index.js';
 import { ReplaceClass } from '../../injector/decorators.js';
 import { array, boolean, literal, object, optional, string } from '../../schema/index.js';
-import { megabyte } from '../../utils/units.js';
 import { Document, DocumentCategory, DocumentRequest, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentType } from '../models/index.js';
 import { addOrArchiveDocumentToOrFromCollectionParametersSchema, applyDocumentRequestsTemplateParametersSchema, createDocumentCategoryParametersSchema, createDocumentParametersSchema, createDocumentRequestParametersSchema, createDocumentRequestsTemplateParametersSchema, createDocumentRequestTemplateParametersSchema, createDocumentTypeParametersSchema, deleteDocumentRequestParametersSchema, deleteDocumentRequestsTemplateParametersSchema, deleteDocumentRequestTemplateParametersSchema, DocumentCategoryView, DocumentManagementData, DocumentRequestsTemplateData, loadDataParametersSchema, updateDocumentParametersSchema, updateDocumentRequestParametersSchema, updateDocumentRequestsTemplateParametersSchema, updateDocumentRequestTemplateParametersSchema } from '../service-models/index.js';
 export const documentManagementApiDefinition = defineApi({
@@ -67,12 +66,19 @@ export const documentManagementApiDefinition = defineApi({
             result: DocumentType,
             credentials: true,
         },
+        initiateDocumentUpload: {
+            resource: 'document-uploads',
+            method: 'POST',
+            result: object({
+                uploadId: string(),
+                uploadUrl: string(),
+            }),
+            credentials: true,
+        },
         createDocument: {
             resource: 'documents',
             method: 'POST',
             parameters: createDocumentParametersSchema,
-            body: Uint8Array,
-            maxBytes: 50 * megabyte,
             result: Document,
             credentials: true,
         },

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

@@ -9,6 +9,7 @@ export declare class DocumentManagementApiController implements ApiController<Do
     getContentUrl(context: ApiRequestContext<DocumentManagementApiDefinition, 'getContentUrl'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'getContentUrl'>>;
     createCategory(context: ApiRequestContext<DocumentManagementApiDefinition, 'createCategory'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'createCategory'>>;
     createType(context: ApiRequestContext<DocumentManagementApiDefinition, 'createType'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'createType'>>;
+    initiateDocumentUpload(context: ApiRequestContext<DocumentManagementApiDefinition, 'initiateDocumentUpload'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'initiateDocumentUpload'>>;
     createDocument(context: ApiRequestContext<DocumentManagementApiDefinition, 'createDocument'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'createDocument'>>;
     createDocumentRequestsTemplate(context: ApiRequestContext<DocumentManagementApiDefinition, 'createDocumentRequestsTemplate'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'createDocumentRequestsTemplate'>>;
     updateDocumentRequestsTemplate(_context: ApiRequestContext<DocumentManagementApiDefinition, 'updateDocumentRequestsTemplate'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'updateDocumentRequestsTemplate'>>;

package/document-management/server/api/document-management.api.js

@@ -92,8 +92,15 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
         }
         return await this.#documentCategoryTypeService.createType(context.parameters.label, context.parameters.categoryId);
     }
+    async initiateDocumentUpload(context) {
+        const token = await context.getToken();
+        const subject = await this.#ancillaryService.getSubject(token);
+        return await this.#documentFileService.initiateUpload({ key: subject });
+    }
     async createDocument(context) {
         const token = await context.getToken();
+        const subject = await this.#ancillaryService.getSubject(token);
+        const { uploadId, ...createParameters } = context.parameters;
         const [collectionIds, requiresAssign] = await match(context.parameters.assignment)
             .with({ collections: P.select() }, (collectionIds) => [toArray(collectionIds), true])
             .with({ request: P.select() }, async (requestId) => {
@@ -115,8 +122,8 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
                 }
             }
         }
-        const actionUserId = await this.#ancillaryService.getUserId(token);
-        return await this.#documentService.create(context.parameters, context.body, { createUserId: actionUserId });
+        const actionUserId = await this.#ancillaryService.getSubject(token);
+        return await this.#documentService.create(createParameters, { uploadId, uploadKey: subject }, { createUserId: actionUserId });
     }
     async createDocumentRequestsTemplate(context) {
         const token = await context.getToken();

package/document-management/server/module.d.ts

@@ -5,6 +5,7 @@ import { DocumentManagementAncillaryService } from './services/document-manageme
 export declare class DocumentManagementConfig {
     ancillaryService: InjectionToken<DocumentManagementAncillaryService>;
     fileObjectStorageModule: string;
+    fileUploadObjectStorageModule: string;
     filePreviewObjectStorageModule: string;
     database?: DatabaseConfig;
 }

package/document-management/server/module.js

@@ -5,6 +5,7 @@ import { DocumentManagementAncillaryService } from './services/document-manageme
 export class DocumentManagementConfig {
     ancillaryService;
     fileObjectStorageModule;
+    fileUploadObjectStorageModule;
     filePreviewObjectStorageModule;
     database;
 }

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

@@ -4,7 +4,23 @@ import { DocumentFile } from '../../models/index.js';
 export declare class DocumentFileService extends Transactional {
     #private;
     load(id: string): Promise<DocumentFile>;
+    /**
+     * Initiates a file upload
+     * @param key - key which can be used to authorize the creation of the file. Same key must be provided to {@link create} method, or it will throw an error.
+     * The key could be the user id from the request token. This ensures that the file can only be created by the user who initiated the upload.
+     * @returns upload information
+     */
+    initiateUpload({ key }: {
+        key: string;
+    }): Promise<{
+        uploadId: string;
+        uploadUrl: string;
+    }>;
     create(content: Uint8Array | ReadableStream<Uint8Array>, originalFileName: string | null): Promise<DocumentFile>;
+    create(content: {
+        uploadId: string;
+        uploadKey: string;
+    }, originalFileName: string | null): Promise<[DocumentFile, Uint8Array]>;
     getContent(fileId: string): Promise<Uint8Array>;
     getContentStream(fileId: string): ReadableStream<Uint8Array>;
     getContentUrl(fileId: string, title: string | null, download?: boolean): Promise<string>;

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

@@ -61,6 +61,7 @@ var DocumentFileService_1;
 import sharp, {} from 'sharp';
 import { match } from 'ts-pattern';
 import { AiService } from '../../../ai/ai.service.js';
+import { ForbiddenError } from '../../../errors/forbidden.error.js';
 import { NotImplementedError } from '../../../errors/not-implemented.error.js';
 import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
 import { TemporaryFile } from '../../../file/server/index.js';
@@ -70,30 +71,55 @@ import { ObjectStorage } from '../../../object-storage/index.js';
 import { Transactional } from '../../../orm/server/index.js';
 import { injectRepository } from '../../../orm/server/repository.js';
 import { pdfToImage } from '../../../pdf/index.js';
+import { Alphabet } from '../../../utils/alphabet.js';
 import { digest } from '../../../utils/cryptography.js';
 import { currentTimestamp } from '../../../utils/date-time.js';
+import { getRandomString } from '../../../utils/random.js';
 import { readableStreamFromPromise, readBinaryStream } from '../../../utils/stream/index.js';
-import { isDefined, isUint8Array } from '../../../utils/type-guards.js';
-import { millisecondsPerMinute } from '../../../utils/units.js';
+import { isDefined, isNotReadableStream, isNotUint8Array, isUint8Array } from '../../../utils/type-guards.js';
+import { millisecondsPerMinute, secondsPerMinute } from '../../../utils/units.js';
 import { Document, DocumentFile } from '../../models/index.js';
 import { DocumentManagementConfig } from '../module.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentFileService = DocumentFileService_1 = class DocumentFileService extends Transactional {
+    #config = inject(DocumentManagementConfig);
     #documentFileRepository = injectRepository(DocumentFile);
     #documentRepository = injectRepository(Document);
     #aiService = inject(AiService);
-    #fileObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).fileObjectStorageModule);
-    #filePreviewObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).filePreviewObjectStorageModule);
+    #fileObjectStorage = inject(ObjectStorage, this.#config.fileObjectStorageModule);
+    #filePreviewObjectStorage = inject(ObjectStorage, this.#config.filePreviewObjectStorageModule);
+    #fileUploadObjectStorage = inject(ObjectStorage, { module: this.#config.fileUploadObjectStorageModule, configuration: { lifecycle: { expiration: { after: 5 * secondsPerMinute } } } });
     #logger = inject(Logger, DocumentFileService_1.name);
     #aiFilePartCache = new Map();
     async load(id) {
-        return this.#documentFileRepository.load(id);
+        return await this.#documentFileRepository.load(id);
+    }
+    /**
+     * Initiates a file upload
+     * @param key - key which can be used to authorize the creation of the file. Same key must be provided to {@link create} method, or it will throw an error.
+     * The key could be the user id from the request token. This ensures that the file can only be created by the user who initiated the upload.
+     * @returns upload information
+     */
+    async initiateUpload({ key }) {
+        const id = getRandomString(64, Alphabet.LowerUpperCaseNumbers);
+        const url = await this.#fileUploadObjectStorage.getUploadUrl(id, currentTimestamp() + (5 * millisecondsPerMinute), { metadata: { uploadKey: key } });
+        return { uploadId: id, uploadUrl: url };
     }
     async create(content, originalFileName) {
-        const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
+        const isUpload = isNotUint8Array(content) && isNotReadableStream(content);
+        if (isUpload) {
+            const object = await this.#fileUploadObjectStorage.getObject(content.uploadId);
+            const objectMetadata = await object.getMetadata();
+            if (content.uploadKey != objectMetadata['uploadKey']) {
+                throw new ForbiddenError(`Invalid upload key`);
+            }
+        }
+        const contentAsUint8Array = isUpload
+            ? await this.#fileUploadObjectStorage.getContent(content.uploadId)
+            : (isUint8Array(content) ? content : await readBinaryStream(content));
         const hash = await digest('SHA-256', contentAsUint8Array).toHex();
         const mimeType = await getMimeType(contentAsUint8Array);
-        return this.transaction(async (tx) => {
+        return await this.transaction(async (tx) => {
             const documentFile = await this.#documentFileRepository
                 .withTransaction(tx)
                 .insert({
@@ -102,39 +128,43 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
                 hash,
                 size: contentAsUint8Array.length,
             });
-            const key = getDocumentFileKey(documentFile.id);
-            await this.#fileObjectStorage.uploadObject(key, contentAsUint8Array);
+            const objectKey = getDocumentFileKey(documentFile.id);
+            if (isUpload) {
+                await this.#fileUploadObjectStorage.moveObject(content.uploadId, [this.#fileObjectStorage, objectKey]);
+                return [documentFile, contentAsUint8Array];
+            }
+            await this.#fileObjectStorage.uploadObject(objectKey, contentAsUint8Array);
             return documentFile;
         });
     }
     async getContent(fileId) {
-        const key = getDocumentFileKey(fileId);
-        return this.#fileObjectStorage.getContent(key);
+        const objectKey = getDocumentFileKey(fileId);
+        return await this.#fileObjectStorage.getContent(objectKey);
     }
     getContentStream(fileId) {
-        const key = getDocumentFileKey(fileId);
-        return this.#fileObjectStorage.getContentStream(key);
+        const objectKey = getDocumentFileKey(fileId);
+        return this.#fileObjectStorage.getContentStream(objectKey);
     }
     async getContentUrl(fileId, title, download = false) {
         const file = await this.#documentFileRepository.load(fileId);
-        return this.getDocumentFileContentObjectUrl(title ?? fileId, file, download);
+        return await this.getDocumentFileContentObjectUrl(title ?? fileId, file, download);
     }
     async getPreview(fileId, page = 1) {
-        const key = getDocumentFileKey(fileId);
+        const objectKey = getDocumentFileKey(fileId);
         await this.createPreviewIfNotExists(fileId, page);
-        return this.#filePreviewObjectStorage.getContent(key);
+        return await this.#filePreviewObjectStorage.getContent(objectKey);
     }
     getPreviewStream(fileId, page = 1) {
         return readableStreamFromPromise(async () => {
-            const key = getDocumentFileKey(fileId);
+            const objectKey = getDocumentFileKey(fileId);
             await this.createPreviewIfNotExists(fileId, page);
-            return this.#filePreviewObjectStorage.getContentStream(key);
+            return this.#filePreviewObjectStorage.getContentStream(objectKey);
         });
     }
     async getPreviewUrl(fileId, page = 1) {
-        const key = getDocumentFileKey(fileId);
+        const objectKey = getDocumentFileKey(fileId);
         await this.createPreviewIfNotExists(fileId, page);
-        return this.#filePreviewObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+        return await this.#filePreviewObjectStorage.getDownloadUrl(objectKey, currentTimestamp() + (5 * millisecondsPerMinute), {
             'Response-Content-Type': 'image/jpeg',
         });
     }
@@ -175,9 +205,9 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
             const image = await match(file.mimeType)
                 .with('application/pdf', async () => {
                 const imageBytes = await pdfToImage(content, page, 768, 'jpeg');
-                return imageToPreview(imageBytes);
+                return await imageToPreview(imageBytes);
             })
-                .with('image/*', async () => imageToPreview(content))
+                .with('image/*', async () => await imageToPreview(content))
                 .otherwise(() => { throw new NotImplementedError('Preview generation is not implemented for this file type.'); });
             await this.#filePreviewObjectStorage.uploadObject(key, image, { contentLength: image.length, metadata: { 'Content-Type': 'image/jpeg' } });
         }
@@ -187,7 +217,7 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
         const fileExtension = getMimeTypeExtensions(file.mimeType)[0] ?? 'bin';
         const disposition = download ? 'attachment' : 'inline';
         const filename = `${title}.${fileExtension}`;
-        return this.#fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+        return await this.#fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
             'Response-Content-Type': file.mimeType,
             'Response-Content-Disposition': `${disposition}; filename = "${encodeURIComponent(filename)}"`,
         });
@@ -201,7 +231,7 @@ function getDocumentFileKey(id) {
     return `${id.slice(0, 2)}/${id.slice(0, 4)}/${id}`;
 }
 async function imageToPreview(input) {
-    return sharp(input)
+    return await sharp(input)
         .resize({
         width: 768,
         height: 768,

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

@@ -28,10 +28,10 @@ export declare abstract class DocumentManagementAncillaryService<Token = unknown
      */
     abstract _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
     /**
-     * Gets the user ID from the request token.
+     * Gets the subject from the request token.
      * @param token The token of the request
      */
-    abstract getUserId(token?: Token): string | Promise<string>;
+    abstract getSubject(token?: Token): string | Promise<string>;
     /**
      * Checks if a user can read/view a specific document collection and its documents.
      * @param collectionId The ID of the document collection.

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';
@@ -36,10 +36,13 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     #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.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-management-data.view.d.ts

@@ -28,9 +28,10 @@ export declare class EnrichedDocumentManagementData {
         categories: Map<string, EnrichedDocumentCategory>;
         types: Map<string, EnrichedDocumentType>;
     };
+    get collectionIds(): string[];
     get rootCollections(): EnrichedDocumentCollection[];
     get collections(): EnrichedDocumentCollection[];
-    get groupedCollections(): EnrichedCollectionsGroup[];
+    get collectionGroups(): EnrichedCollectionsGroup[];
     get documents(): EnrichedDocument[];
     get requests(): EnrichedDocumentRequest[];
     get rootCategories(): EnrichedDocumentCategory[];

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

@@ -51,13 +51,16 @@ export class EnrichedDocumentManagementData {
         categories: () => getEntityMap(this.categories),
         types: () => getEntityMap(this.types),
     });
+    get collectionIds() {
+        return this.rawData.collections.map((collection) => collection.id);
+    }
     get rootCollections() {
         return this.rawData.collections.filter((collection) => isNull(collection.parentId)).map((collection) => new EnrichedDocumentCollection(this, collection, null));
     }
     get collections() {
         return this.rootCollections.flatMap((collection) => [collection, ...collection.childrenDeep]);
     }
-    get groupedCollections() {
+    get collectionGroups() {
         const groups = [...group(this.collections, (collection) => collection.group)];
         return groups.map(([group, collections]) => new EnrichedCollectionsGroup(group, collections));
     }
@@ -83,6 +86,11 @@ export class EnrichedDocumentManagementData {
         this.rawData = data;
     }
 }
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "collectionIds", null);
 __decorate([
     Memoize(),
     __metadata("design:type", Array),
@@ -97,7 +105,7 @@ __decorate([
     Memoize(),
     __metadata("design:type", Array),
     __metadata("design:paramtypes", [])
-], EnrichedDocumentManagementData.prototype, "groupedCollections", null);
+], EnrichedDocumentManagementData.prototype, "collectionGroups", null);
 __decorate([
     Memoize(),
     __metadata("design:type", Array),

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;