@kiyasov/platform-hono 1.6.0 → 2.0.0

package/src/drivers/graphQLUpload/utils/validators.ts

@@ -0,0 +1,219 @@
+import { isAllowedFileType } from './file';
+
+/**
+ * Common file type groups for validation
+ */
+export const FileTypes = {
+  // Images
+  IMAGES: [
+    'image/jpeg',
+    'image/png',
+    'image/gif',
+    'image/webp',
+    'image/svg+xml',
+    'image/avif',
+    'image/heic',
+    'image/heif',
+    'image/tiff',
+    'image/bmp',
+    'image/x-icon',
+    '.jpg',
+    '.jpeg',
+    '.png',
+    '.gif',
+    '.webp',
+    '.svg',
+    '.avif',
+    '.heic',
+    '.heif',
+    '.tiff',
+    '.bmp',
+    '.ico',
+  ] as const,
+
+  // Documents
+  DOCUMENTS: [
+    // PDF
+    'application/pdf',
+    '.pdf',
+    // Microsoft Word
+    'application/msword',
+    '.doc',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.docx',
+    // Microsoft Excel
+    'application/vnd.ms-excel',
+    '.xls',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.xlsx',
+    // Microsoft PowerPoint
+    'application/vnd.ms-powerpoint',
+    '.ppt',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.pptx',
+    // OpenDocument formats
+    'application/vnd.oasis.opendocument.text',
+    '.odt',
+    'application/vnd.oasis.opendocument.spreadsheet',
+    '.ods',
+    'application/vnd.oasis.opendocument.presentation',
+    '.odp',
+    // Apple iWork
+    'application/vnd.apple.pages',
+    '.pages',
+    'application/vnd.apple.numbers',
+    '.numbers',
+    'application/vnd.apple.keynote',
+    '.key',
+    // Rich text
+    'application/rtf',
+    '.rtf',
+    'text/plain',
+    '.txt',
+    // CSV
+    'text/csv',
+    '.csv',
+  ] as const,
+
+  // Videos
+  VIDEOS: [
+    'video/mp4',
+    'video/mpeg',
+    'video/quicktime',
+    'video/webm',
+    'video/x-msvideo',
+    'video/x-matroska',
+    'video/quicktime',
+    'video/x-flv',
+    '.mp4',
+    '.mpeg',
+    '.mov',
+    '.webm',
+    '.avi',
+    '.mkv',
+    '.flv',
+  ] as const,
+
+  // Audio
+  AUDIO: [
+    'audio/mpeg',
+    'audio/mp4',
+    'audio/wav',
+    'audio/ogg',
+    'audio/webm',
+    'audio/flac',
+    'audio/aac',
+    'audio/x-m4a',
+    'audio/x-wav',
+    '.mp3',
+    '.m4a',
+    '.wav',
+    '.ogg',
+    '.flac',
+    '.aac',
+  ] as const,
+
+  // Archives
+  ARCHIVES: [
+    'application/zip',
+    'application/x-zip-compressed',
+    '.zip',
+    'application/x-rar-compressed',
+    '.rar',
+    'application/x-7z-compressed',
+    '.7z',
+    'application/x-tar',
+    '.tar',
+    'application/gzip',
+    '.gz',
+    'application/x-gzip',
+    'application/x-bzip2',
+    '.bz2',
+    'application/x-compress',
+    '.Z',
+    'application/x-apple-diskimage',
+    '.dmg',
+    'application/x-iso9660-image',
+    '.iso',
+  ] as const,
+
+  // 3D Models
+  MODELS_3D: [
+    'model/stl',
+    '.stl',
+    'model/obj',
+    '.obj',
+    'model/gltf-binary',
+    '.glb',
+    'model/gltf+json',
+    '.gltf',
+    'model/fbx',
+    '.fbx',
+    'model/dae',
+    '.dae',
+    'model/vnd.collada+xml',
+  ] as const,
+
+  // Fonts
+  FONTS: [
+    'font/ttf',
+    '.ttf',
+    'font/otf',
+    '.otf',
+    'font/woff',
+    '.woff',
+    'font/woff2',
+    '.woff2',
+    'application/x-font-ttf',
+    'application/x-font-opentype',
+  ] as const,
+} as const;
+
+/**
+ * Validator configuration for file uploads
+ */
+export interface FileValidatorOptions {
+  /** Maximum file size in bytes */
+  maxSize?: number;
+  /** Allowed MIME types or extensions */
+  allowedTypes?: string[];
+  /** Denied MIME types or extensions */
+  deniedTypes?: string[];
+}
+
+/**
+ * Validates a file against the given options
+ * @param file - File to validate
+ * @param options - Validation options
+ * @returns Object with isValid flag and error message
+ */
+export function validateFile(
+  file: File,
+  options: FileValidatorOptions,
+): { isValid: boolean; error?: string } {
+  // Check file size
+  if (options.maxSize && file.size > options.maxSize) {
+    return {
+      isValid: false,
+      error: `File "${file.name}" exceeds maximum size of ${options.maxSize} bytes`,
+    };
+  }
+
+  // Check denied types
+  if (options.deniedTypes && isAllowedFileType(file, options.deniedTypes)) {
+    return {
+      isValid: false,
+      error: `File type "${file.type}" is not allowed`,
+    };
+  }
+
+  // Check allowed types
+  if (options.allowedTypes && !isAllowedFileType(file, options.allowedTypes)) {
+    return {
+      isValid: false,
+      error: `File type "${file.type}" is not allowed. Allowed types: ${options.allowedTypes.join(', ')}`,
+    };
+  }
+
+  return { isValid: true };
+}

package/src/multer/index.ts

@@ -2,3 +2,4 @@ export * from './interceptors';
 export * from './decorators';
 export * from './storage';
 export * from './multipart';
+export * from './utils';

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(),
+  };
 };