feat: add temporary file upload and download endpoints with root directory support

Author: SevenWaysDP

src/modules/files-storage/api/controller/files-storage.controller.ts

@@ -126,6 +126,49 @@ export class FilesStorageController {
 		return streamableFile;
 	}
 
+	@ApiOperation({ summary: 'Streamable download of a temporary file.' })
+	@ApiProduces('application/octet-stream')
+	@ApiResponse({ status: 200, schema: { type: 'string', format: 'binary' } })
+	@ApiResponse({ status: 206, schema: { type: 'string', format: 'binary' } })
+	@ApiResponse({ status: 400, type: ApiValidationError })
+	@ApiResponse({ status: 403, type: ForbiddenException })
+	@ApiResponse({ status: 404, type: NotFoundException })
+	@ApiResponse({ status: 406, type: NotAcceptableException })
+	@ApiResponse({ status: 500, type: InternalServerErrorException })
+	@ApiHeader({ name: 'Range', required: false })
+	@UseInterceptors(CurrentDownloadMetricsInterceptor)
+	@Get('/temp/download/:fileRecordId/:fileName')
+	public async tempDownload(
+		@Param() params: DownloadFileParams,
+		@Req() req: Request,
+		@Res({ passthrough: true }) response: Response,
+		@Headers('Range') bytesRange?: string
+	): Promise<StreamableFile> {
+		const fileResponse = await this.filesStorageUC.tempDownload(params, bytesRange);
+		const streamableFile = this.streamFileToClient(req, fileResponse, response, bytesRange);
+
+		return streamableFile;
+	}
+
+	@ApiOperation({ summary: 'Temporäres Hochladen einer Datei.' })
+	@ApiResponse({ status: 201, type: FileRecordResponse })
+	@ApiResponse({ status: 400, type: ApiValidationError })
+	@ApiResponse({ status: 400, type: BadRequestException })
+	@ApiResponse({ status: 403, type: ForbiddenException })
+	@ApiResponse({ status: 500, type: InternalServerErrorException })
+	@ApiConsumes('multipart/form-data')
+	@Post('/temp/upload/:storageLocation/:storageLocationId/:parentType/:parentId')
+	public async tempUpload(
+		@Body() _: FileParams,
+		@Param() params: FileRecordParams,
+		@CurrentUser() currentUser: ICurrentUser,
+		@Req() req: Request
+	): Promise<FileRecordResponse> {
+		const response = await this.filesStorageUC.tempUpload(currentUser.userId, params, req);
+
+		return response;
+	}
+
 	@ApiOperation({ summary: 'Streamable download of a preview file.' })
 	@ApiResponse({ status: 200, type: StreamableFile })
 	@ApiResponse({ status: 206, type: StreamableFile })

src/modules/files-storage/api/mapper/file-dto.mapper.ts

@@ -11,8 +11,13 @@ export class FileDtoMapper {
 		return file;
 	}
 
-	public static mapFromBusboyFileInfo(fileInfo: BusboyFileInfo, stream: Readable, abortSignal?: AbortSignal): FileDto {
-		const file = FileDtoFactory.create(fileInfo.filename, stream, fileInfo.mimeType, abortSignal);
+	public static mapFromBusboyFileInfo(
+		fileInfo: BusboyFileInfo,
+		stream: Readable,
+		abortSignal?: AbortSignal,
+		rootDirectory?: string
+	): FileDto {
+		const file = FileDtoFactory.create(fileInfo.filename, stream, fileInfo.mimeType, abortSignal, rootDirectory);
 
 		return file;
 	}

src/modules/files-storage/api/uc/files-storage.uc.ts

@@ -61,6 +61,8 @@ export const FileStorageAuthorizationContext = {
 
 @Injectable()
 export class FilesStorageUC {
+	private readonly tempFolderName = 'temp';
+
 	constructor(
 		private readonly logger: Logger,
 		private readonly authorizationClientAdapter: AuthorizationClientAdapter,
@@ -104,6 +106,28 @@ export class FilesStorageUC {
 		return fileRecordResponse;
 	}
 
+	public async tempDownload(params: DownloadFileParams, bytesRange: string | undefined): Promise<GetFileResponse> {
+		const fileRecord = await this.filesStorageService.getFileRecord(params.fileRecordId);
+		const parentInfo = fileRecord.getParentInfo();
+
+		await this.checkPermission(parentInfo, FileStorageAuthorizationContext.read);
+
+		return this.filesStorageService.downloadFile(fileRecord, bytesRange, this.tempFolderName);
+	}
+
+	public async tempUpload(userId: string, params: FileRecordParams, req: Request): Promise<FileRecordResponse> {
+		await Promise.all([
+			this.checkPermission(params, FileStorageAuthorizationContext.create),
+			this.checkStorageLocationCanRead(params.storageLocation, params.storageLocationId),
+		]);
+
+		const fileRecord = await this.uploadFileWithBusboy(userId, params, req, this.tempFolderName);
+		const status = this.filesStorageService.getFileRecordStatus(fileRecord);
+		const fileRecordResponse = FileRecordMapper.mapToFileRecordResponse(fileRecord, status);
+
+		return fileRecordResponse;
+	}
+
 	// download
 	public async download(params: DownloadFileParams, bytesRange?: string): Promise<GetFileResponse> {
 		const fileRecord = await this.filesStorageService.getFileRecord(params.fileRecordId);
@@ -341,7 +365,12 @@ export class FilesStorageUC {
 	}
 
 	// private: stream helper
-	private uploadFileWithBusboy(userId: EntityId, params: FileRecordParams, req: AbortableRequest): Promise<FileRecord> {
+	private uploadFileWithBusboy(
+		userId: EntityId,
+		params: FileRecordParams,
+		req: AbortableRequest,
+		rootDirectory?: string
+	): Promise<FileRecord> {
 		return new Promise<FileRecord>((resolve, reject) => {
 			const bb = busboy({ headers: req.headers, defParamCharset: 'utf8' });
 			const abortController = new AbortController();
@@ -397,7 +426,7 @@ export class FilesStorageUC {
 			bb.on('file', (_name, file, info) => {
 				if (isResolved) return; // Already resolved/rejected
 
-				const fileDto = FileDtoMapper.mapFromBusboyFileInfo(info, file, abortController.signal);
+				const fileDto = FileDtoMapper.mapFromBusboyFileInfo(info, file, abortController.signal, rootDirectory);
 
 				fileRecordPromise = RequestContext.create(this.em, () => {
 					return this.filesStorageService.uploadFile(userId, params, fileDto);

src/modules/files-storage/domain/dto/file.dto.ts

@@ -7,6 +7,7 @@ export class FileDto implements File {
 		this.data = file.data;
 		this.mimeType = file.mimeType;
 		this.abortSignal = file.abortSignal;
+		this.rootDirectory = file.rootDirectory;
 	}
 
 	name: string;
@@ -16,4 +17,6 @@ export class FileDto implements File {
 	mimeType: string;
 
 	abortSignal?: AbortSignal;
+
+	rootDirectory: string | undefined = undefined;
 }

src/modules/files-storage/domain/dto/pass-through-file.dto.ts

@@ -9,6 +9,7 @@ export class PassThroughFileDto implements FileDto {
 		this.abortSignal = file.abortSignal;
 		this.streamCompletion = file.streamCompletion;
 		this.fileSize = file.fileSize;
+		this.rootDirectory = file.rootDirectory;
 	}
 
 	name: string;
@@ -22,4 +23,6 @@ export class PassThroughFileDto implements FileDto {
 	streamCompletion?: Promise<void>;
 
 	fileSize: number;
+
+	rootDirectory: string | undefined;
 }

src/modules/files-storage/domain/factory/file-dto.factory.ts

@@ -2,12 +2,19 @@ import { Readable } from 'node:stream';
 import { FileDto } from '../dto';
 
 export class FileDtoFactory {
-	public static create(name: string, stream: Readable, mimeType: string, abortSignal?: AbortSignal): FileDto {
+	public static create(
+		name: string,
+		stream: Readable,
+		mimeType: string,
+		abortSignal?: AbortSignal,
+		rootDirectory?: string
+	): FileDto {
 		const file = new FileDto({
 			name,
 			data: stream,
 			mimeType,
 			abortSignal,
+			rootDirectory,
 		});
 
 		return file;

src/modules/files-storage/domain/factory/pass-through-file-dto.factory.ts

@@ -7,7 +7,8 @@ export class PassThroughFileDtoFactory {
 		sourceFile: FileDto,
 		passThrough: PassThrough,
 		mimeType: string,
-		newFileName?: string
+		newFileName?: string,
+		rootDirectory?: string
 	): PassThroughFileDto {
 		const streamCompletion = awaitStreamCompletion(passThrough, sourceFile.abortSignal);
 		const file = new PassThroughFileDto({
@@ -17,6 +18,7 @@ export class PassThroughFileDtoFactory {
 			abortSignal: sourceFile.abortSignal,
 			streamCompletion,
 			fileSize: 0,
+			rootDirectory: rootDirectory ?? sourceFile.rootDirectory,
 		});
 
 		return file;

src/modules/files-storage/domain/file-record.do.ts

@@ -338,8 +338,8 @@ export class FileRecord extends DomainObject<FileRecordProps> {
 		}
 	}
 
-	public createPath(): string {
-		const path = [this.props.storageLocationId, this.id].join('/');
+	public createPath(rootDirectory?: string): string {
+		const path = [rootDirectory, this.props.storageLocationId, this.id].filter(Boolean).join('/');
 
 		return path;
 	}

src/modules/files-storage/domain/service/files-storage.service.ts

@@ -207,7 +207,7 @@ export class FilesStorageService {
 	}
 
 	private async uploadAndScan(fileRecord: FileRecord, file: PassThroughFileDto): Promise<void> {
-		const filePath = fileRecord.createPath();
+		const filePath = fileRecord.createPath(file.rootDirectory);
 
 		if (this.shouldStreamToAntivirus(fileRecord)) {
 			const pipedStream = file.data.pipe(new PassThrough());
@@ -299,8 +299,12 @@ export class FilesStorageService {
 		}
 	}
 
-	public async downloadFile(fileRecord: FileRecord, bytesRange?: string): Promise<GetFileResponse> {
-		const pathToFile = fileRecord.createPath();
+	public async downloadFile(
+		fileRecord: FileRecord,
+		bytesRange?: string,
+		rootDirectory?: string
+	): Promise<GetFileResponse> {
+		const pathToFile = fileRecord.createPath(rootDirectory);
 		const file = await this.storageClient.get(pathToFile, bytesRange);
 		const fileResponse = FileResponseFactory.create(file, fileRecord.getName());
 

src/modules/files-storage/testing/file-dto.test.factory.ts

@@ -16,6 +16,7 @@ class FileDtoTestFactory {
 		data: Readable.from('abc'),
 		mimeType: 'application/octet-stream',
 		abortSignal: new AbortController().signal,
+		rootDirectory: undefined,
 	};
 
 	private static readonly mimeTypeMap = new Map<string, () => Readable>([