@kiyasov/platform-hono 1.0.6 → 1.0.8

package/src/multer/interceptors/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 { 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);
+
+      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 = await 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 = await 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 = await 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 = await 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,44 @@
+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>();
+
+  if (!req.header("content-type")?.startsWith("multipart/form-data")) {
+    throw new BadRequestException("Not a multipart request");
+  }
+
+  return req;
+};
+
+export const getParts = async (req: THonoRequest, options: UploadOptions) => {
+  const files = await req.parseBody({ all: true });
+
+  for (const [key, file] of Object.entries(files)) {
+    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 files;
+};
+
+export type MultipartsIterator = AsyncIterableIterator<MultipartFile>;

package/src/multer/storage/disk-storage.ts

@@ -0,0 +1,107 @@
+import { tmpdir } from 'os';
+import { createWriteStream } from 'fs';
+import { mkdir, unlink } from 'fs/promises';
+import { join } from 'path';
+
+import { StorageFile, Storage } from './storage';
+import { getUniqueFilename, pathExists } from '../fs';
+import { pump } from '../stream';
+import { HonoRequest } from 'hono';
+import { Readable } from 'node:stream';
+
+export interface DiskStorageFile extends StorageFile {
+  dest: string;
+  filename: string;
+  path: string;
+}
+
+type DiskStorageOptionHandler =
+  | ((file: File, req: HonoRequest) => Promise<string> | string)
+  | string;
+
+export interface DiskStorageOptions {
+  dest?: DiskStorageOptionHandler;
+  filename?: DiskStorageOptionHandler;
+  removeAfter?: boolean;
+}
+
+const excecuteStorageHandler = (
+  file: File,
+  req: HonoRequest,
+  obj?: DiskStorageOptionHandler,
+) => {
+  if (typeof obj === 'function') {
+    return obj(file, req);
+  }
+
+  if (obj != null) return obj;
+
+  return null;
+};
+
+const ENV_TESTS_STORAGE_TMP_PATH = process.env.__TESTS_TMP_PATH__;
+export class DiskStorage
+  implements Storage<DiskStorageFile, DiskStorageOptions>
+{
+  public readonly options?: DiskStorageOptions;
+
+  constructor(options?: DiskStorageOptions) {
+    this.options = options;
+
+    if (ENV_TESTS_STORAGE_TMP_PATH != null) {
+      this.options = { ...this.options, dest: ENV_TESTS_STORAGE_TMP_PATH };
+    }
+  }
+
+  public async handleFile(file: File, req: HonoRequest, fieldName: string) {
+    const filename = await this.getFilename(file, req, this.options?.filename);
+    const dest = await this.getFileDestination(file, req, this.options?.dest);
+
+    if (!(await pathExists(dest))) {
+      await mkdir(dest, { recursive: true });
+    }
+
+    const path = join(dest, filename);
+    const stream = createWriteStream(path);
+
+    const buffer = await file.arrayBuffer();
+    const readableStream = Readable.from(Buffer.from(buffer));
+
+    await pump(readableStream, stream);
+
+    return {
+      size: stream.bytesWritten,
+      dest,
+      filename,
+      originalFilename: file.name,
+      path,
+      mimetype: file.type,
+      encoding: 'utf-8',
+      fieldname: fieldName,
+    };
+  }
+
+  public async removeFile(file: DiskStorageFile, force?: boolean) {
+    if (!this.options?.removeAfter && !force) return;
+
+    await unlink(file.path);
+  }
+
+  protected async getFilename(
+    file: File,
+    req: HonoRequest,
+    obj?: DiskStorageOptionHandler,
+  ): Promise<string> {
+    return (
+      excecuteStorageHandler(file, req, obj) ?? getUniqueFilename(file.name)
+    );
+  }
+
+  protected async getFileDestination(
+    file: File,
+    req: HonoRequest,
+    obj?: DiskStorageOptionHandler,
+  ): Promise<string> {
+    return excecuteStorageHandler(file, req, obj) ?? tmpdir();
+  }
+}

package/src/multer/storage/index.ts

@@ -0,0 +1,3 @@
+export * from "./disk-storage";
+export * from "./memory-storage";
+export * from "./storage";

package/src/multer/storage/memory-storage.ts

@@ -0,0 +1,25 @@
+import { StorageFile, Storage } from './storage';
+import { HonoRequest } from 'hono';
+
+export interface MemoryStorageFile extends StorageFile {
+  buffer: Buffer;
+}
+
+export class MemoryStorage implements Storage<MemoryStorageFile> {
+  public async handleFile(file: File, _req: HonoRequest, fieldName: string) {
+    const buffer = await file.arrayBuffer().then(Buffer.from);
+
+    return {
+      buffer,
+      size: buffer.length,
+      encoding: 'utf-8',
+      mimetype: file.type,
+      fieldname: fieldName,
+      originalFilename: file.name,
+    };
+  }
+
+  public async removeFile(file: MemoryStorageFile) {
+    delete file.buffer;
+  }
+}

package/src/multer/storage/storage.ts

@@ -0,0 +1,15 @@
+import { HonoRequest } from 'hono';
+
+export interface StorageFile {
+  size: number;
+  fieldname: string;
+  encoding: string;
+  mimetype: string;
+  originalFilename: string;
+}
+
+export interface Storage<T extends StorageFile = StorageFile, K = any> {
+  handleFile: (file: File, req: HonoRequest, fieldName: string) => Promise<T>;
+  removeFile: (file: T, force?: boolean) => Promise<void> | void;
+  options?: K;
+}

package/src/multer/stream/index.ts

@@ -0,0 +1,4 @@
+import { promisify } from 'node:util';
+import { pipeline } from 'node:stream';
+
+export const pump = promisify(pipeline);