@kiyasov/platform-hono 1.0.7 → 1.0.9

package/src/drivers/graphQLUpload/processRequest.ts

@@ -0,0 +1,50 @@
+import { Context } from "hono";
+import { WriteStream, Upload } from ".";
+import { Readable } from "stream";
+
+export async function processRequest(
+  ctx: Context
+): Promise<Record<string, any>> {
+  const body = await ctx.req.parseBody();
+  const operations = JSON.parse(body.operations as string);
+  const map = new Map(Object.entries(JSON.parse(body.map as string)));
+
+  for (const [fieldName, file] of Object.entries(body)) {
+    if (
+      fieldName === "operations" ||
+      fieldName === "map" ||
+      !(file instanceof File)
+    )
+      continue;
+
+    const fileKeys = map.get(fieldName);
+    if (!Array.isArray(fileKeys) || !fileKeys.length) continue;
+
+    const buffer = Buffer.from(await file.arrayBuffer());
+    const capacitor = new WriteStream();
+    Readable.from(buffer).pipe(capacitor);
+
+    const upload = new Upload();
+    upload.file = {
+      filename: file.name,
+      mimetype: file.type,
+      fieldName,
+      encoding: "7bit",
+      createReadStream: (options) => capacitor.createReadStream(options),
+      capacitor,
+    };
+    upload.resolve(upload.file);
+
+    for (const fileKey of fileKeys) {
+      const pathSegments = fileKey.split(".");
+      let current = operations;
+      for (let i = 0; i < pathSegments.length - 1; i++) {
+        if (!current[pathSegments[i]]) current[pathSegments[i]] = {};
+        current = current[pathSegments[i]];
+      }
+      current[pathSegments[pathSegments.length - 1]] = upload;
+    }
+  }
+
+  return operations;
+}

package/src/drivers/graphql.driver.ts

@@ -1,15 +1,31 @@
 import { ApolloServer, BaseContext, HeaderMap } from "@apollo/server";
-import { AbstractGraphQLDriver } from "@nestjs/graphql";
+import { ModulesContainer } from "@nestjs/core";
+import {
+  AbstractGraphQLDriver,
+  GqlSubscriptionService,
+  SubscriptionConfig,
+} from "@nestjs/graphql";
 import { ApolloServerPluginDrainHttpServer } from "@apollo/server/plugin/drainHttpServer";
 import { ApolloDriverConfig } from "@nestjs/apollo";
 import { Context, HonoRequest } from "hono";
 import { StatusCode } from "hono/utils/http-status";
 import { Logger } from "@nestjs/common";
+import http from "http";
+
+import { PluginsExplorerService } from "./services/plugins-explorer.service";
+import { processRequest } from "./graphQLUpload";
 
 export class HonoGraphQLDriver<
   T extends Record<string, any> = ApolloDriverConfig
 > extends AbstractGraphQLDriver {
   protected apolloServer: ApolloServer<BaseContext>;
+  private _subscriptionService?: GqlSubscriptionService;
+  private readonly pluginsExplorerService: PluginsExplorerService;
+
+  constructor(modulesContainer: ModulesContainer) {
+    super();
+    this.pluginsExplorerService = new PluginsExplorerService(modulesContainer);
+  }
 
   get instance(): ApolloServer<BaseContext> {
     return this.apolloServer;
@@ -23,7 +39,21 @@ export class HonoGraphQLDriver<
       throw new Error("This driver is only compatible with the Hono platform");
     }
 
-    return this.registerHono(options);
+    await this.registerHono(options);
+
+    if (options.installSubscriptionHandlers || options.subscriptions) {
+      const subscriptionsOptions: SubscriptionConfig =
+        options.subscriptions || { "subscriptions-transport-ws": {} };
+      this._subscriptionService = new GqlSubscriptionService(
+        {
+          schema: options.schema,
+          path: options.path,
+          context: options.context,
+          ...subscriptionsOptions,
+        },
+        this.httpAdapterHost.httpAdapter?.getHttpServer()
+      );
+    }
   }
 
   protected async registerHono(
@@ -50,7 +80,7 @@ export class HonoGraphQLDriver<
     await server.start();
 
     app.use(path, async (ctx: Context) => {
-      const bodyData = await this.parseBody(ctx.req);
+      const bodyData = await this.parseBody(ctx);
 
       const defaultContext = () => Promise.resolve({} as BaseContext);
 
@@ -101,8 +131,9 @@ export class HonoGraphQLDriver<
     this.apolloServer = server;
   }
 
-  public stop() {
-    return this.apolloServer?.stop();
+  public async stop() {
+    await this._subscriptionService?.stop();
+    await this.apolloServer?.stop();
   }
 
   private httpHeadersToMap(headers: Headers) {
@@ -111,17 +142,30 @@ export class HonoGraphQLDriver<
     return map;
   }
 
-  private async parseBody(req: HonoRequest): Promise<Record<string, unknown>> {
+  private async parseBody(ctx: Context): Promise<Record<string, unknown>> {
+    const req = ctx.req;
     const contentType = req.header("content-type");
+
     if (contentType === "application/graphql")
       return { query: await req.text() };
     if (contentType === "application/json")
       return req.json().catch(this.logError);
     if (contentType === "application/x-www-form-urlencoded")
       return this.parseFormURL(req);
+    if (contentType?.startsWith("multipart/form-data")) {
+      return processRequest(ctx);
+    }
     return {};
   }
 
+  headersToRecord(headers: Headers): http.IncomingHttpHeaders {
+    const obj: http.IncomingHttpHeaders = {};
+    headers.forEach((value, key) => {
+      obj[key] = value;
+    });
+    return obj;
+  }
+
   private logError(e: unknown): void {
     if (e instanceof Error) {
       Logger.error(e.stack || e.message);

package/src/drivers/index.ts

@@ -1 +1,2 @@
 export * from "./graphql.driver";
+export * from "./graphQLUpload";

package/src/drivers/services/plugins-explorer.service.ts

@@ -0,0 +1,27 @@
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { ModulesContainer } from '@nestjs/core/injector/modules-container';
+import { BaseExplorerService, GqlModuleOptions } from '@nestjs/graphql';
+import { PLUGIN_METADATA } from '../constants';
+
+export class PluginsExplorerService extends BaseExplorerService {
+  constructor(private readonly modulesContainer: ModulesContainer) {
+    super();
+  }
+
+  explore(options: GqlModuleOptions) {
+    const modules = this.getModules(
+      this.modulesContainer,
+      options.include || [],
+    );
+    return this.flatMap(modules, (instance) => this.filterPlugins(instance));
+  }
+
+  filterPlugins<T = any>(wrapper: InstanceWrapper<T>) {
+    const { instance } = wrapper;
+    if (!instance) {
+      return undefined;
+    }
+    const metadata = Reflect.getMetadata(PLUGIN_METADATA, instance.constructor);
+    return metadata ? instance : undefined;
+  }
+}

package/src/multer/crypto/index.ts

@@ -0,0 +1,4 @@
+import { promisify } from 'node:util';
+import { randomBytes as cryptoRandomBytes } from 'node:crypto';
+
+export const randomBytes = promisify(cryptoRandomBytes);

package/src/multer/decorators/index.ts

@@ -0,0 +1,2 @@
+export * from "./uploaded-files-decorator";
+export * from "./uploaded-file-decorator";

package/src/multer/decorators/uploaded-file-decorator.ts

@@ -0,0 +1,12 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+import { getMultipartRequest } from '../multipart/request';
+import { StorageFile } from '../storage/storage';
+
+export const UploadedFile = createParamDecorator(
+  async (_data, ctx: ExecutionContext): Promise<StorageFile | undefined> => {
+    const req = getMultipartRequest(ctx.switchToHttp());
+
+    return req?.storageFile;
+  },
+);

package/src/multer/decorators/uploaded-files-decorator.ts

@@ -0,0 +1,15 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+import { getMultipartRequest } from '../multipart/request';
+import { StorageFile } from '../storage/storage';
+
+export const UploadedFiles = createParamDecorator(
+  async (
+    _data: any,
+    ctx: ExecutionContext,
+  ): Promise<Record<string, StorageFile[]> | StorageFile[] | undefined> => {
+    const req = getMultipartRequest(ctx.switchToHttp());
+
+    return req?.storageFiles;
+  },
+);

package/src/multer/fs/index.ts

@@ -0,0 +1,22 @@
+import fs from 'node:fs/promises';
+import { extname } from 'node:path';
+
+import { randomBytes } from '../crypto';
+
+export const pathExists = async (path: string) => {
+  try {
+    await fs.stat(path);
+  } catch (err) {
+    return false;
+  }
+
+  return true;
+};
+
+export const getUniqueFilename = async (filename: string) => {
+  const buffer = await randomBytes(16);
+
+  const ext = extname(filename);
+
+  return buffer.toString('hex') + ext;
+};

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,46 @@
+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);
+
+      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,56 @@
+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);
+
+      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,48 @@
+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);
+
+      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,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";