@kiyasov/platform-hono 1.6.1 → 2.0.0

package/src/multer/interceptors/any-files-interceptor.ts

@@ -1,47 +1,16 @@
-import {
-  CallHandler,
-  ExecutionContext,
-  mixin,
-  NestInterceptor,
-  Type,
-} from '@nestjs/common';
-import { finalize } from 'rxjs';
-
 import { handleMultipartAnyFiles } from '../multipart/handlers/any-files';
-import { transformUploadOptions, UploadOptions } from '../multipart/options';
-import { getMultipartRequest } from '../multipart/request';
+import { UploadOptions } from '../multipart/options';
+import { createInterceptor } from './base-interceptor';
 
 export function AnyFilesInterceptor(
-  options?: UploadOptions,
-): Type<NestInterceptor> {
-  class MixinInterceptor implements NestInterceptor {
-    private readonly options: UploadOptions;
-
-    constructor() {
-      this.options = transformUploadOptions(options);
-    }
-
-    async intercept(context: ExecutionContext, next: CallHandler) {
-      const ctx = context.switchToHttp();
-      const req = getMultipartRequest(ctx);
-
-      if (!req.header('content-type')?.startsWith('multipart/form-data')) {
-        return next.handle();
-      }
-
-      const { body, files, remove } = await handleMultipartAnyFiles(
-        req,
-        this.options,
-      );
-
-      req.body = body;
-      req.storageFiles = files;
-
-      return next.handle().pipe(finalize(remove));
-    }
-  }
-
-  const Interceptor = mixin(MixinInterceptor);
-
-  return Interceptor;
+  localOptions?: UploadOptions,
+): ReturnType<typeof createInterceptor> {
+  return createInterceptor(
+    localOptions ?? {},
+    (req, options) => handleMultipartAnyFiles(req, options),
+    (req, result) => {
+      req.body = result.body;
+      req.storageFiles = result.files;
+    },
+  );
 }

package/src/multer/interceptors/base-interceptor.ts

@@ -0,0 +1,54 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  mixin,
+  NestInterceptor,
+  Type,
+} from '@nestjs/common';
+import { finalize } from 'rxjs';
+import { Observable } from 'rxjs/internal/Observable';
+
+import { FileProcessResult } from '../multipart/handlers/base-handler';
+import { transformUploadOptions, UploadOptions } from '../multipart/options';
+import { getMultipartRequest } from '../multipart/request';
+
+export type HandlerFunction<T extends FileProcessResult> = (
+  req: ReturnType<typeof getMultipartRequest>,
+  options: UploadOptions,
+) => Promise<T>;
+
+export function createInterceptor<T extends FileProcessResult>(
+  rawOptions: UploadOptions,
+  handlerFn: HandlerFunction<T>,
+  resultProcessor: (
+    req: ReturnType<typeof getMultipartRequest>,
+    result: T,
+  ) => void,
+): Type<NestInterceptor> {
+  class MixinInterceptor implements NestInterceptor {
+    private readonly options: UploadOptions;
+
+    constructor() {
+      this.options = transformUploadOptions(rawOptions);
+    }
+
+    async intercept(
+      context: ExecutionContext,
+      next: CallHandler,
+    ): Promise<Observable<unknown>> {
+      const ctx = context.switchToHttp();
+      const req = getMultipartRequest(ctx);
+
+      if (!req.header('content-type')?.startsWith('multipart/form-data')) {
+        return next.handle();
+      }
+
+      const result = await handlerFn(req, this.options);
+      resultProcessor(req, result);
+
+      return next.handle().pipe(finalize(result.remove));
+    }
+  }
+
+  return mixin(MixinInterceptor);
+}

package/src/multer/interceptors/file-fields-interceptor.ts

@@ -1,57 +1,23 @@
-import {
-  CallHandler,
-  ExecutionContext,
-  mixin,
-  NestInterceptor,
-  Type,
-} from '@nestjs/common';
-import { finalize } from 'rxjs';
-
 import {
   handleMultipartFileFields,
   UploadField,
-  UploadFieldMapEntry,
   uploadFieldsToMap,
 } from '../multipart/handlers/file-fields';
-import { transformUploadOptions, UploadOptions } from '../multipart/options';
-import { getMultipartRequest } from '../multipart/request';
+import { UploadOptions } from '../multipart/options';
+import { createInterceptor } from './base-interceptor';
 
 export function FileFieldsInterceptor(
   uploadFields: UploadField[],
-  options?: UploadOptions,
-): Type<NestInterceptor> {
-  class MixinInterceptor implements NestInterceptor {
-    private readonly options: UploadOptions;
-
-    private readonly fieldsMap: Map<string, UploadFieldMapEntry>;
-
-    constructor() {
-      this.options = transformUploadOptions(options);
-      this.fieldsMap = uploadFieldsToMap(uploadFields);
-    }
-
-    async intercept(context: ExecutionContext, next: CallHandler) {
-      const ctx = context.switchToHttp();
-      const req = getMultipartRequest(ctx);
-
-      if (!req.header('content-type')?.startsWith('multipart/form-data')) {
-        return next.handle();
-      }
-
-      const { body, files, remove } = await handleMultipartFileFields(
-        req,
-        this.fieldsMap,
-        this.options,
-      );
-
-      req.body = body;
-      req.storageFiles = files;
-
-      return next.handle().pipe(finalize(remove));
-    }
-  }
-
-  const Interceptor = mixin(MixinInterceptor);
-
-  return Interceptor;
+  localOptions?: UploadOptions,
+): ReturnType<typeof createInterceptor> {
+  const fieldsMap = uploadFieldsToMap(uploadFields);
+
+  return createInterceptor(
+    localOptions ?? {},
+    (req, options) => handleMultipartFileFields(req, fieldsMap, options),
+    (req, result) => {
+      req.body = result.body;
+      req.storageFiles = result.files;
+    },
+  );
 }

package/src/multer/interceptors/file-interceptor.ts

@@ -1,49 +1,17 @@
-import {
-  CallHandler,
-  ExecutionContext,
-  mixin,
-  NestInterceptor,
-  Type,
-} from '@nestjs/common';
-import { finalize } from 'rxjs';
-
 import { handleMultipartSingleFile } from '../multipart/handlers/single-file';
-import { transformUploadOptions, UploadOptions } from '../multipart/options';
-import { getMultipartRequest } from '../multipart/request';
+import { UploadOptions } from '../multipart/options';
+import { createInterceptor } from './base-interceptor';
 
 export function FileInterceptor(
   fieldname: string,
-  options?: UploadOptions,
-): Type<NestInterceptor> {
-  class MixinInterceptor implements NestInterceptor {
-    private readonly options: UploadOptions;
-
-    constructor() {
-      this.options = transformUploadOptions(options);
-    }
-
-    async intercept(context: ExecutionContext, next: CallHandler) {
-      const ctx = context.switchToHttp();
-      const req = getMultipartRequest(ctx);
-
-      if (!req.header('content-type')?.startsWith('multipart/form-data')) {
-        return next.handle();
-      }
-
-      const { file, body, remove } = await handleMultipartSingleFile(
-        req,
-        fieldname,
-        this.options,
-      );
-
-      req.body = body;
-      req.storageFile = file;
-
-      return next.handle().pipe(finalize(remove));
-    }
-  }
-
-  const Interceptor = mixin(MixinInterceptor);
-
-  return Interceptor;
+  localOptions?: UploadOptions,
+): ReturnType<typeof createInterceptor> {
+  return createInterceptor(
+    localOptions ?? {},
+    (req, options) => handleMultipartSingleFile(req, fieldname, options),
+    (req, result) => {
+      req.body = result.body;
+      req.storageFile = result.file;
+    },
+  );
 }

package/src/multer/interceptors/files-interceptor.ts

@@ -1,51 +1,19 @@
-import {
-  CallHandler,
-  ExecutionContext,
-  mixin,
-  NestInterceptor,
-  Type,
-} from '@nestjs/common';
-import { finalize } from 'rxjs';
-
 import { handleMultipartMultipleFiles } from '../multipart/handlers/multiple-files';
-import { transformUploadOptions, UploadOptions } from '../multipart/options';
-import { getMultipartRequest } from '../multipart/request';
+import { UploadOptions } from '../multipart/options';
+import { createInterceptor } from './base-interceptor';
 
 export function FilesInterceptor(
   fieldname: string,
   maxCount = 1,
-  options?: UploadOptions,
-): Type<NestInterceptor> {
-  class MixinInterceptor implements NestInterceptor {
-    private readonly options: UploadOptions;
-
-    constructor() {
-      this.options = transformUploadOptions(options);
-    }
-
-    async intercept(context: ExecutionContext, next: CallHandler) {
-      const ctx = context.switchToHttp();
-      const req = getMultipartRequest(ctx);
-
-      if (!req.header('content-type')?.startsWith('multipart/form-data')) {
-        return next.handle();
-      }
-
-      const { body, files, remove } = await handleMultipartMultipleFiles(
-        req,
-        fieldname,
-        maxCount,
-        this.options,
-      );
-
-      req.body = body;
-      req.storageFiles = files;
-
-      return next.handle().pipe(finalize(remove));
-    }
-  }
-
-  const Interceptor = mixin(MixinInterceptor);
-
-  return Interceptor;
+  localOptions?: UploadOptions,
+): ReturnType<typeof createInterceptor> {
+  return createInterceptor(
+    localOptions ?? {},
+    (req, options) =>
+      handleMultipartMultipleFiles(req, fieldname, maxCount, options),
+    (req, result) => {
+      req.body = result.body;
+      req.storageFiles = result.files;
+    },
+  );
 }

package/src/multer/interceptors/index.ts

@@ -2,3 +2,4 @@ export * from './file-fields-interceptor';
 export * from './file-interceptor';
 export * from './any-files-interceptor';
 export * from './files-interceptor';
+export * from './base-interceptor';

package/src/multer/multipart/handlers/any-files.ts

@@ -1,41 +1,23 @@
-import { BodyData } from 'hono/utils/body';
-
-import { StorageFile } from '../../storage';
-import { removeStorageFiles } from '../file';
-import { filterUpload } from '../filter';
 import { UploadOptions } from '../options';
-import { THonoRequest, getParts } from '../request';
+import { THonoRequest } from '../request';
+import { FileHandler, MultipleFilesResult } from './base-handler';
 
 export const handleMultipartAnyFiles = async (
   req: THonoRequest,
   options: UploadOptions,
-) => {
-  const parts = getParts(req, options);
-
-  const body: BodyData = {};
+): Promise<MultipleFilesResult> => {
+  const handler = new FileHandler(req, options);
 
-  const files: StorageFile[] = [];
-
-  const removeFiles = async (error?: boolean) => {
-    return await removeStorageFiles(options.storage!, files, error);
-  };
-
-  try {
-    for await (const [partFieldName, part] of Object.entries(parts)) {
-      if (!(part instanceof File)) {
-        body[partFieldName] = part;
-        continue;
-      }
-      const file = await options.storage!.handleFile(part, req, partFieldName);
-
-      if (await filterUpload(options, req, file)) {
-        files.push(file);
-      }
+  await handler.process(async (fieldName, part) => {
+    const storageFile = await handler.handleSingleFile(fieldName, part);
+    if (storageFile) {
+      handler.addFile(fieldName, storageFile);
     }
-  } catch (error) {
-    await removeFiles(true);
-    throw error;
-  }
+  });
 
-  return { body, files, remove: () => removeFiles() };
+  return {
+    body: handler.getBody(),
+    files: handler.getFiles(),
+    remove: handler.createRemoveFunction(),
+  };
 };

package/src/multer/multipart/handlers/base-handler.ts

@@ -0,0 +1,204 @@
+import { BadRequestException } from '@nestjs/common';
+import { BodyData } from 'hono/utils/body';
+
+import { StorageFile } from '../../storage/storage';
+import { removeStorageFiles } from '../file';
+import { filterUpload } from '../filter';
+import { UploadOptions } from '../options';
+import { THonoRequest, getParts } from '../request';
+
+export interface ProcessedFile {
+  file: StorageFile;
+  fieldName: string;
+}
+
+export interface FileProcessResult {
+  body: BodyData;
+  remove: () => Promise<void>;
+}
+
+export interface SingleFileResult extends FileProcessResult {
+  file?: StorageFile;
+}
+
+export interface MultipleFilesResult extends FileProcessResult {
+  files: StorageFile[];
+}
+
+export interface FileFieldsResult extends FileProcessResult {
+  files: Record<string, StorageFile[]>;
+}
+
+export class FileHandler {
+  private readonly body: BodyData = {};
+  private readonly files: StorageFile[] = [];
+  private readonly filesByField: Record<string, StorageFile[]> = {};
+  private processed = false;
+  private cleanedUp = false;
+
+  constructor(
+    private readonly req: THonoRequest,
+    private readonly options: UploadOptions,
+  ) {}
+
+  /**
+   * Processes all parts in the multipart request.
+   */
+  async process(
+    processor: (fieldName: string, file: File) => Promise<void>,
+  ): Promise<void> {
+    if (this.processed) {
+      throw new Error('Request already processed');
+    }
+
+    this.processed = true;
+    const parts = getParts(this.req, this.options);
+
+    try {
+      for await (const [fieldName, part] of Object.entries(parts)) {
+        // Handle array of files (for multiple file uploads with same field name)
+        if (Array.isArray(part) && part.every((item) => item instanceof File)) {
+          for (const file of part) {
+            await processor(fieldName, file);
+          }
+          continue;
+        }
+
+        if (!(part instanceof File)) {
+          this.body[fieldName] = part;
+          continue;
+        }
+
+        await processor(fieldName, part);
+      }
+    } catch (error) {
+      await this.cleanup(true);
+      throw error;
+    }
+  }
+
+  /**
+   * Handles a single file upload for a specific field.
+   */
+  async handleSingleFile(
+    fieldName: string,
+    file: File,
+  ): Promise<StorageFile | undefined> {
+    const storageFile = await this.options.storage!.handleFile(
+      file,
+      this.req,
+      fieldName,
+    );
+
+    if (await filterUpload(this.options, this.req, storageFile)) {
+      return storageFile;
+    }
+
+    // If file was filtered out, remove it from storage
+    await this.options.storage!.removeFile(storageFile, true);
+    return undefined;
+  }
+
+  /**
+   * Validates that the field name matches the expected field name.
+   */
+  validateFieldName(fieldName: string, expectedFieldName: string): void {
+    if (fieldName !== expectedFieldName) {
+      throw new BadRequestException(
+        `Field "${fieldName}" doesn't accept file.`,
+      );
+    }
+  }
+
+  /**
+   * Validates that only one file is uploaded for a field.
+   */
+  validateSingleFile(currentFile: StorageFile | undefined): void {
+    if (currentFile) {
+      throw new BadRequestException('Field accepts only one file.');
+    }
+  }
+
+  /**
+   * Validates the maximum number of files for a field.
+   */
+  validateMaxCount(
+    fieldName: string,
+    currentCount: number,
+    maxCount: number,
+  ): void {
+    if (currentCount >= maxCount) {
+      throw new BadRequestException(
+        `Field "${fieldName}" accepts max ${maxCount} files.`,
+      );
+    }
+  }
+
+  /**
+   * Adds a file to the files collection.
+   */
+  addFile(fieldName: string, file: StorageFile): void {
+    this.files.push(file);
+
+    if (!this.filesByField[fieldName]) {
+      this.filesByField[fieldName] = [];
+    }
+    this.filesByField[fieldName].push(file);
+  }
+
+  /**
+   * Returns all processed files.
+   */
+  getFiles(): StorageFile[] {
+    return [...this.files];
+  }
+
+  /**
+   * Returns files grouped by field name.
+   */
+  getFilesByField(): Record<string, StorageFile[]> {
+    return { ...this.filesByField };
+  }
+
+  /**
+   * Returns the request body.
+   */
+  getBody(): BodyData {
+    return { ...this.body };
+  }
+
+  /**
+   * Cleans up all uploaded files.
+   * Prevents multiple cleanups and clears references to avoid memory leaks.
+   */
+  async cleanup(error?: boolean): Promise<void> {
+    if (this.cleanedUp) {
+      return;
+    }
+
+    this.cleanedUp = true;
+
+    await removeStorageFiles(this.options.storage!, this.files, error);
+
+    // Clear references to allow garbage collection
+    this.files.length = 0;
+    for (const key of Object.keys(this.filesByField)) {
+      delete this.filesByField[key];
+    }
+  }
+
+  /**
+   * Creates a remove function for cleanup that prevents multiple calls.
+   */
+  createRemoveFunction(): () => Promise<void> {
+    let called = false;
+
+    return async () => {
+      if (called) {
+        return;
+      }
+      called = true;
+      await this.cleanup();
+    };
+  }
+}