@kiyasov/platform-hono 1.0.7 → 1.0.9

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);