@kiyasov/platform-hono 1.3.7 → 1.3.8

package/src/drivers/graphQLUpload/processRequest.ts

@@ -0,0 +1,57 @@
+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) => {
+        const stream = capacitor.createReadStream(options);
+        stream.on("close", () => {
+          capacitor.release();
+        });
+        return stream;
+      },
+      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

@@ -0,0 +1,171 @@
+import { ApolloServer, BaseContext, HeaderMap } from "@apollo/server";
+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 { 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;
+  }
+
+  async start(options: T): Promise<void> {
+    const { httpAdapter } = this.httpAdapterHost;
+    const platformName = httpAdapter.getType();
+
+    if (platformName !== "hono") {
+      throw new Error("This driver is only compatible with the Hono platform");
+    }
+
+    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(
+    options: T,
+    { preStartHook }: { preStartHook?: () => void } = {}
+  ) {
+    const { path, typeDefs, resolvers, schema } = options;
+    const { httpAdapter } = this.httpAdapterHost;
+    const app = httpAdapter.getInstance();
+    const drainHttpServerPlugin = ApolloServerPluginDrainHttpServer({
+      httpServer: httpAdapter.getHttpServer(),
+    });
+
+    preStartHook?.();
+
+    const server = new ApolloServer({
+      typeDefs,
+      resolvers,
+      schema,
+      ...options,
+      plugins: (options.plugins || []).concat(drainHttpServerPlugin),
+    });
+
+    await server.start();
+
+    app.use(path, async (ctx: Context) => {
+      const bodyData = await this.parseBody(ctx);
+
+      const defaultContext = () => Promise.resolve({} as BaseContext);
+
+      const contextFunction = options?.context ?? defaultContext;
+
+      const httpGraphQLResponse = await server.executeHTTPGraphQLRequest({
+        httpGraphQLRequest: {
+          body: bodyData,
+          method: ctx.req.method,
+          headers: this.httpHeadersToMap(ctx.req.raw.headers),
+          search: new URL(ctx.req.url).search,
+        },
+        context: () =>
+          contextFunction(ctx, {
+            method: ctx.req.method,
+            url: ctx.req.url,
+            body: ctx.req.raw.body,
+            headers: Object.fromEntries(ctx.req.raw.headers),
+          }),
+      });
+
+      const { headers, body, status } = httpGraphQLResponse;
+
+      for (const [headerKey, headerValue] of headers) {
+        ctx.header(headerKey, headerValue);
+      }
+
+      ctx.status(status === undefined ? 200 : (status as StatusCode));
+
+      if (body.kind === "complete") {
+        return ctx.body(body.string);
+      }
+
+      const readableStream = new ReadableStream({
+        async start(controller) {
+          for await (const chunk of body.asyncIterator) {
+            controller.enqueue(new TextEncoder().encode(chunk));
+          }
+          controller.close();
+        },
+      });
+
+      return new Response(readableStream, {
+        headers: { "Content-Type": "application/octet-stream" },
+      });
+    });
+
+    this.apolloServer = server;
+  }
+
+  public async stop() {
+    await this._subscriptionService?.stop();
+    await this.apolloServer?.stop();
+  }
+
+  private httpHeadersToMap(headers: Headers) {
+    const map = new HeaderMap();
+    headers.forEach((value, key) => map.set(key, value));
+    return map;
+  }
+
+  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 {};
+  }
+
+  private logError(e: unknown): void {
+    if (e instanceof Error) {
+      Logger.error(e.stack || e.message);
+    }
+    throw new Error(`POST body sent invalid JSON: ${e}`);
+  }
+
+  private async parseFormURL(req: HonoRequest) {
+    const searchParams = new URLSearchParams(await req.text());
+    return Object.fromEntries(searchParams.entries());
+  }
+}

package/src/drivers/index.ts

@@ -0,0 +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/interfaces/hono.interface.ts

@@ -0,0 +1,5 @@
+import { HonoRequest as Request } from "hono";
+
+export type HonoRequest = Request & {
+  headers?: Record<string, string>;
+};

package/src/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from "./nest-hono-application.interface";
+export * from "./hono.interface";

package/src/interfaces/nest-hono-application.interface.ts

@@ -0,0 +1,72 @@
+import { ServeStaticOptions } from "@hono/node-server/serve-static";
+import { HttpServer, INestApplication } from "@nestjs/common";
+import { Context, Hono, MiddlewareHandler } from "hono";
+
+export type TypeBodyParser =
+  | "application/json"
+  | "text/plain"
+  | "application/x-www-form-urlencoded";
+
+interface HonoViewOptions {
+  engine: string;
+  templates: string;
+}
+
+/**
+ * @publicApi
+ */
+export interface NestHonoApplication<TServer extends Hono = Hono>
+  extends INestApplication<TServer> {
+  /**
+   * Returns the underlying HTTP adapter bounded to a Hono app.
+   *
+   * @returns {HttpServer}
+   */
+  getHttpAdapter(): HttpServer<Context, MiddlewareHandler, Hono>;
+
+  /**
+   * Register Hono body parsers on the fly.
+   *
+   * @example
+   * // enable the json parser with a parser limit of 50mb
+   * app.useBodyParser('application/json', 50 * 1024 * 1024);
+   *
+   * @returns {this}
+   */
+  useBodyParser(type: TypeBodyParser, bodyLimit?: number): this;
+
+  /**
+   * Sets a base directory for public assets.
+   * Example `app.useStaticAssets('public', { root: '/' })`
+   * @returns {this}
+   */
+  useStaticAssets(path: string, options: ServeStaticOptions): this;
+
+  /**
+   * Sets a view engine for templates (views), for example: `pug`, `handlebars`, or `ejs`.
+   *
+   * Don't pass in a string. The string type in the argument is for compatibility reason and will cause an exception.
+   * @returns {this}
+   */
+  setViewEngine(options: HonoViewOptions | string): this;
+
+  /**
+   * Starts the application.
+   * @returns A Promise that, when resolved, is a reference to the underlying HttpServer.
+   */
+  listen(
+    port: number | string,
+    callback?: (err: Error, address: string) => void
+  ): Promise<TServer>;
+  listen(
+    port: number | string,
+    address: string,
+    callback?: (err: Error, address: string) => void
+  ): Promise<TServer>;
+  listen(
+    port: number | string,
+    address: string,
+    backlog: number,
+    callback?: (err: Error, address: string) => void
+  ): Promise<TServer>;
+}

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