@kiyasov/platform-hono 1.3.7 → 1.3.9

package/src/multer/index.ts

@@ -0,0 +1,4 @@
+export * from "./interceptors";
+export * from "./decorators";
+export * from "./storage";
+export * from "./multipart";

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

@@ -0,0 +1,50 @@
+import { Observable, tap } from "rxjs";
+import {
+  CallHandler,
+  ExecutionContext,
+  mixin,
+  NestInterceptor,
+  Type,
+} from "@nestjs/common";
+
+import { getMultipartRequest } from "../multipart/request";
+import { transformUploadOptions, UploadOptions } from "../multipart/options";
+import { handleMultipartAnyFiles } from "../multipart/handlers/any-files";
+
+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
+    ): Promise<Observable<any>> {
+      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(tap(remove));
+    }
+  }
+
+  const Interceptor = mixin(MixinInterceptor);
+
+  return Interceptor;
+}

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

@@ -0,0 +1,60 @@
+import { Observable, tap } from "rxjs";
+import {
+  CallHandler,
+  ExecutionContext,
+  mixin,
+  NestInterceptor,
+  Type,
+} from "@nestjs/common";
+
+import { getMultipartRequest } from "../multipart/request";
+import { transformUploadOptions, UploadOptions } from "../multipart/options";
+import {
+  handleMultipartFileFields,
+  UploadField,
+  UploadFieldMapEntry,
+  uploadFieldsToMap,
+} from "../multipart/handlers/file-fields";
+
+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
+    ): Promise<Observable<any>> {
+      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(tap(remove));
+    }
+  }
+
+  const Interceptor = mixin(MixinInterceptor);
+
+  return Interceptor;
+}

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

@@ -0,0 +1,52 @@
+import { Observable, tap } from "rxjs";
+import {
+  CallHandler,
+  ExecutionContext,
+  mixin,
+  NestInterceptor,
+  Type,
+} from "@nestjs/common";
+
+import { getMultipartRequest } from "../multipart/request";
+import { transformUploadOptions, UploadOptions } from "../multipart/options";
+import { handleMultipartSingleFile } from "../multipart/handlers/single-file";
+
+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
+    ): Promise<Observable<any>> {
+      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(tap(remove));
+    }
+  }
+
+  const Interceptor = mixin(MixinInterceptor);
+
+  return Interceptor;
+}

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

@@ -0,0 +1,54 @@
+import { Observable, tap } from "rxjs";
+import {
+  CallHandler,
+  ExecutionContext,
+  mixin,
+  NestInterceptor,
+  Type,
+} from "@nestjs/common";
+
+import { getMultipartRequest } from "../multipart/request";
+import { transformUploadOptions, UploadOptions } from "../multipart/options";
+import { handleMultipartMultipleFiles } from "../multipart/handlers/multiple-files";
+
+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
+    ): Promise<Observable<any>> {
+      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(tap(remove));
+    }
+  }
+
+  const Interceptor = mixin(MixinInterceptor);
+
+  return Interceptor;
+}

package/src/multer/interceptors/index.ts

@@ -0,0 +1,4 @@
+export * from "./file-fields-interceptor";
+export * from "./file-interceptor";
+export * from "./any-files-interceptor";
+export * from "./files-interceptor";

package/src/multer/multipart/exceptions.ts

@@ -0,0 +1,25 @@
+import {
+  BadRequestException,
+  HttpException,
+  PayloadTooLargeException,
+} from '@nestjs/common';
+
+export const transformException = (err: Error | undefined) => {
+  if (!err || err instanceof HttpException) {
+    return err;
+  }
+
+  const code: string = (err as any).code;
+
+  switch (code) {
+    case 'REQ_FILE_TOO_LARGE':
+      return new PayloadTooLargeException();
+    case 'PARTS_LIMIT':
+    case 'FILES_LIMIT':
+    case 'PROTO_VIOLATION':
+    case 'INVALID_MULTIPART_CONTENT_TYPE':
+      return new BadRequestException(err.message);
+  }
+
+  return err;
+};

package/src/multer/multipart/file.ts

@@ -0,0 +1,18 @@
+import { Readable } from 'stream';
+import { Storage, StorageFile } from '../storage';
+
+export type MultipartFile = Omit<File[], 'file'> & {
+  value?: any;
+  file: Readable & { truncated?: boolean };
+};
+
+export const removeStorageFiles = async (
+  storage: Storage,
+  files?: (StorageFile | undefined)[],
+  force?: boolean,
+) => {
+  if (files == null) return;
+  await Promise.all(
+    files.map((file) => file && storage.removeFile(file, force)),
+  );
+};

package/src/multer/multipart/filter.ts

@@ -0,0 +1,38 @@
+import { BadRequestException } from '@nestjs/common';
+import { UploadOptions } from '.';
+
+import { DiskStorageFile, MemoryStorageFile, StorageFile } from '../storage';
+import { HonoRequest } from 'hono';
+
+export type UploadFilterFile =
+  | DiskStorageFile
+  | MemoryStorageFile
+  | StorageFile;
+
+export type UploadFilterHandler = (
+  req: HonoRequest,
+  file: UploadFilterFile,
+) => Promise<boolean | string> | boolean | string;
+
+export const filterUpload = async (
+  uploadOptions: UploadOptions,
+  req: HonoRequest,
+  file: UploadFilterFile,
+): Promise<boolean> => {
+  if (uploadOptions.filter == null) {
+    return true;
+  }
+
+  try {
+    const res = await uploadOptions.filter(req, file);
+
+    if (typeof res === 'string') {
+      throw new BadRequestException(res);
+    }
+
+    return res;
+  } catch (error) {
+    await uploadOptions.storage!.removeFile(file, true);
+    throw error;
+  }
+};

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

@@ -0,0 +1,39 @@
+import { UploadOptions } from "../options";
+import { StorageFile } from "../../storage";
+import { THonoRequest, getParts } from "../request";
+import { removeStorageFiles } from "../file";
+import { filterUpload } from "../filter";
+
+export const handleMultipartAnyFiles = async (
+  req: THonoRequest,
+  options: UploadOptions
+) => {
+  const parts = getParts(req, options);
+
+  const body: Record<string, any> = {};
+
+  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);
+      }
+    }
+  } catch (error) {
+    await removeFiles(true);
+    throw error;
+  }
+
+  return { body, files, remove: () => removeFiles() };
+};

package/src/multer/multipart/handlers/file-fields.ts

@@ -0,0 +1,89 @@
+import { BadRequestException } from "@nestjs/common";
+
+import { UploadOptions } from "../options";
+import { StorageFile } from "../../storage/storage";
+import { THonoRequest, getParts } from "../request";
+import { removeStorageFiles } from "../file";
+import { filterUpload } from "../filter";
+import { HonoRequest } from "hono";
+
+export interface UploadField {
+  /**
+   * Field name
+   */
+  name: string;
+  /**
+   * Max number of files in this field
+   */
+  maxCount?: number;
+}
+
+export type UploadFieldMapEntry = Required<Pick<UploadField, "maxCount">>;
+
+export const uploadFieldsToMap = (uploadFields: UploadField[]) => {
+  const map = new Map<string, UploadFieldMapEntry>();
+
+  uploadFields.forEach(({ name, ...opts }) => {
+    map.set(name, { maxCount: 1, ...opts });
+  });
+
+  return map;
+};
+
+export const handleMultipartFileFields = async (
+  req: THonoRequest,
+  fieldsMap: Map<string, UploadFieldMapEntry>,
+  options: UploadOptions
+) => {
+  const parts = getParts(req, options);
+  const body: Record<string, any> = {};
+
+  const files: Record<string, StorageFile[]> = {};
+
+  const removeFiles = async (error?: boolean) => {
+    const allFiles = ([] as StorageFile[]).concat(...Object.values(files));
+    return await removeStorageFiles(options.storage!, allFiles, error);
+  };
+
+  try {
+    for await (const [fieldName, part] of Object.entries(parts)) {
+      if (!(part instanceof File)) {
+        body[fieldName] = part;
+        continue;
+      }
+
+      const fieldOptions = fieldsMap.get(fieldName);
+
+      if (fieldOptions == null) {
+        throw new BadRequestException(
+          `Field ${fieldName} doesn't accept files`
+        );
+      }
+
+      if (files[fieldName] == null) {
+        files[fieldName] = [];
+      }
+
+      if (files[fieldName].length + 1 > fieldOptions.maxCount) {
+        throw new BadRequestException(
+          `Field ${fieldName} accepts max ${fieldOptions.maxCount} files`
+        );
+      }
+
+      const file = await options.storage!.handleFile(part, req, fieldName);
+
+      if (await filterUpload(options, req, file)) {
+        files[fieldName].push(file);
+      }
+    }
+  } catch (error) {
+    await removeFiles(true);
+    throw error;
+  }
+
+  return {
+    body,
+    files,
+    remove: () => removeFiles(),
+  };
+};

package/src/multer/multipart/handlers/index.ts

@@ -0,0 +1 @@
+export { UploadField } from "./file-fields";

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

@@ -0,0 +1,55 @@
+import { BadRequestException } from "@nestjs/common";
+
+import { UploadOptions } from "../options";
+import { StorageFile } from "../../storage";
+import { removeStorageFiles } from "../file";
+import { THonoRequest, getParts } from "../request";
+import { filterUpload } from "../filter";
+
+export const handleMultipartMultipleFiles = async (
+  req: THonoRequest,
+  fieldname: string,
+  maxCount: number,
+  options: UploadOptions
+) => {
+  const parts = getParts(req, options);
+  const body: Record<string, any> = {};
+
+  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;
+      }
+
+      if (partFieldName !== fieldname) {
+        throw new BadRequestException(
+          `Field ${partFieldName} doesn't accept files`
+        );
+      }
+
+      if (files.length + 1 > maxCount) {
+        throw new BadRequestException(
+          `Field ${partFieldName} accepts max ${maxCount} files`
+        );
+      }
+
+      const file = await options.storage!.handleFile(part, req, partFieldName);
+
+      if (await filterUpload(options, req, file)) {
+        files.push(file);
+      }
+    }
+  } catch (error) {
+    await removeFiles(error);
+    throw error;
+  }
+
+  return { body, files, remove: () => removeFiles() };
+};

package/src/multer/multipart/handlers/single-file.ts

@@ -0,0 +1,56 @@
+import { BadRequestException } from "@nestjs/common";
+
+import { UploadOptions } from "../options";
+import { StorageFile } from "../../storage";
+import { THonoRequest, getParts } from "../request";
+import { filterUpload } from "../filter";
+
+export const handleMultipartSingleFile = async (
+  req: THonoRequest,
+  fieldname: string,
+  options: UploadOptions
+) => {
+  const parts = getParts(req, options);
+  const body: Record<string, any> = {};
+
+  let file: StorageFile | undefined = undefined;
+
+  const removeFiles = async (error?: boolean) => {
+    if (file == null) return;
+    await options.storage!.removeFile(file, error);
+  };
+
+  try {
+    for await (const [partFieldName, part] of Object.entries(parts)) {
+      if (!(part instanceof File)) {
+        body[partFieldName] = part;
+        continue;
+      }
+
+      if (partFieldName !== fieldname) {
+        throw new BadRequestException(
+          `Field ${partFieldName} doesn't accept file`
+        );
+      } else if (file != null) {
+        throw new BadRequestException(
+          `Field ${fieldname} accepts only one file`
+        );
+      }
+
+      const _file = await options.storage!.handleFile(part, req, partFieldName);
+
+      if (await filterUpload(options, req, _file)) {
+        file = _file;
+      }
+    }
+  } catch (error) {
+    await removeFiles(true);
+    throw error;
+  }
+
+  return {
+    body,
+    file,
+    remove: () => removeFiles(),
+  };
+};

package/src/multer/multipart/index.ts

@@ -0,0 +1,3 @@
+export * from "./options";
+export * from "./filter";
+export { UploadFilterFile, UploadFilterHandler } from "./filter";

package/src/multer/multipart/options.ts

@@ -0,0 +1,29 @@
+import busboy from 'busboy';
+import { DiskStorage, MemoryStorage, Storage } from '../storage';
+import { UploadFilterHandler } from './filter';
+
+export type UploadOptions = busboy.BusboyConfig & {
+  dest?: string;
+  storage?: Storage;
+  filter?: UploadFilterHandler;
+};
+
+export const DEFAULT_UPLOAD_OPTIONS: Partial<UploadOptions> = {
+  storage: new MemoryStorage(),
+};
+
+export const transformUploadOptions = (opts?: UploadOptions) => {
+  if (opts == null) return DEFAULT_UPLOAD_OPTIONS;
+
+  if (opts.dest != null) {
+    return {
+      ...opts,
+      storage: new DiskStorage({
+        dest: opts.dest,
+        ...opts.storage?.options,
+      }),
+    };
+  }
+
+  return { ...DEFAULT_UPLOAD_OPTIONS, ...opts };
+};

package/src/multer/multipart/request.ts

@@ -0,0 +1,40 @@
+import { BadRequestException } from "@nestjs/common";
+import { HttpArgumentsHost } from "@nestjs/common/interfaces";
+
+import { UploadOptions } from "./options";
+import { StorageFile } from "../storage";
+import { MultipartFile } from "./file";
+import { HonoRequest } from "hono";
+
+export type THonoRequest = HonoRequest & {
+  files: Record<string, File[]>;
+  body: Record<string, any>;
+  storageFile?: StorageFile;
+  storageFiles?: StorageFile[] | Record<string, StorageFile[]>;
+};
+
+export const getMultipartRequest = (ctx: HttpArgumentsHost) => {
+  const req = ctx.getRequest<THonoRequest>();
+
+  return req;
+};
+
+export const getParts = (req: THonoRequest, options: UploadOptions) => {
+  const parts = req.body;
+
+  for (const [key, file] of Object.entries(parts)) {
+    if (
+      file instanceof File &&
+      options?.limits?.fileSize &&
+      file.size > options.limits.fileSize
+    ) {
+      throw new BadRequestException(
+        `File ${key} is too large. Maximum size is ${options.limits.fileSize} bytes`
+      );
+    }
+  }
+
+  return parts;
+};
+
+export type MultipartsIterator = AsyncIterableIterator<MultipartFile>;