@kiyasov/platform-hono 1.0.6 → 1.0.8

package/index.ts

@@ -1,3 +1,4 @@
 export * from "./src/adapters";
 export * from "./src/interfaces";
 export * from "./src/drivers";
+export * from "./src/multer";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kiyasov/platform-hono",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Nest adapter for Hono",
   "author": "Islam Kiiasov",
   "license": "MIT",
@@ -29,6 +29,8 @@
     "@nestjs/graphql": "^12.1.1",
     "@swc/cli": "^0.3.12",
     "@swc/core": "^1.5.24",
+    "@types/busboy": "^1.5.4",
+    "graphql-subscriptions": "^2.0.0",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1",
     "tsc": "^2.0.4",

package/src/adapters/hono-adapter.ts

@@ -1,27 +1,27 @@
-import { Server } from "node:net";
-import { HttpBindings, createAdaptorServer } from "@hono/node-server";
-import { RESPONSE_ALREADY_SENT } from "@hono/node-server/utils/response";
-import { RequestMethod } from "@nestjs/common";
-import { HttpStatus, Logger } from "@nestjs/common";
-import { bodyLimit } from "hono/body-limit";
+import { Server } from 'node:net';
+import { HttpBindings, createAdaptorServer } from '@hono/node-server';
+import { RESPONSE_ALREADY_SENT } from '@hono/node-server/utils/response';
+import { RequestMethod } from '@nestjs/common';
+import { HttpStatus, Logger } from '@nestjs/common';
+import { bodyLimit } from 'hono/body-limit';
 import {
   ErrorHandler,
   NestApplicationOptions,
   RequestHandler,
-} from "@nestjs/common/interfaces";
+} from '@nestjs/common/interfaces';
 import {
   ServeStaticOptions,
   serveStatic,
-} from "@hono/node-server/serve-static";
-import { AbstractHttpAdapter } from "@nestjs/core/adapters/http-adapter";
-import { Context, HonoRequest, Next } from "hono";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import { RedirectStatusCode, StatusCode } from "hono/utils/http-status";
-import * as http from "http";
-import { Http2SecureServer, Http2Server } from "http2";
-import * as https from "https";
-import { TypeBodyParser } from "../interfaces";
+} from '@hono/node-server/serve-static';
+import { AbstractHttpAdapter } from '@nestjs/core/adapters/http-adapter';
+import { Context, HonoRequest, Next } from 'hono';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { RedirectStatusCode, StatusCode } from 'hono/utils/http-status';
+import * as http from 'http';
+import { Http2SecureServer, Http2Server } from 'http2';
+import * as https from 'https';
+import { TypeBodyParser } from '../interfaces';
 
 type HonoHandler = RequestHandler<HonoRequest, Context>;
 
@@ -43,10 +43,10 @@ export class HonoAdapter extends AbstractHttpAdapter<
 
   private getRouteAndHandler(
     pathOrHandler: string | HonoHandler,
-    handler?: HonoHandler
+    handler?: HonoHandler,
   ): [string, HonoHandler] {
-    let path = typeof pathOrHandler === "function" ? "" : pathOrHandler;
-    handler = typeof pathOrHandler === "function" ? pathOrHandler : handler;
+    let path = typeof pathOrHandler === 'function' ? '' : pathOrHandler;
+    handler = typeof pathOrHandler === 'function' ? pathOrHandler : handler;
     return [path, handler];
   }
 
@@ -58,14 +58,14 @@ export class HonoAdapter extends AbstractHttpAdapter<
   }
 
   private send(ctx: Context) {
-    const body = ctx.get("body");
-    return typeof body === "string" ? ctx.text(body) : ctx.json(body);
+    const body = ctx.get('body');
+    return typeof body === 'string' ? ctx.text(body) : ctx.json(body);
   }
 
   public get(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
     const [routePath, routeHandler] = this.getRouteAndHandler(
       pathOrHandler,
-      handler
+      handler,
     );
     this.instance.get(routePath, this.createRouteHandler(routeHandler));
   }
@@ -73,7 +73,7 @@ export class HonoAdapter extends AbstractHttpAdapter<
   public post(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
     const [routePath, routeHandler] = this.getRouteAndHandler(
       pathOrHandler,
-      handler
+      handler,
     );
     this.instance.post(routePath, this.createRouteHandler(routeHandler));
   }
@@ -81,7 +81,7 @@ export class HonoAdapter extends AbstractHttpAdapter<
   public put(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
     const [routePath, routeHandler] = this.getRouteAndHandler(
       pathOrHandler,
-      handler
+      handler,
     );
     this.instance.put(routePath, this.createRouteHandler(routeHandler));
   }
@@ -89,7 +89,7 @@ export class HonoAdapter extends AbstractHttpAdapter<
   public delete(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
     const [routePath, routeHandler] = this.getRouteAndHandler(
       pathOrHandler,
-      handler
+      handler,
     );
     this.instance.delete(routePath, this.createRouteHandler(routeHandler));
   }
@@ -97,7 +97,7 @@ export class HonoAdapter extends AbstractHttpAdapter<
   public use(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
     const [routePath, routeHandler] = this.getRouteAndHandler(
       pathOrHandler,
-      handler
+      handler,
     );
     this.instance.use(routePath, this.createRouteHandler(routeHandler));
   }
@@ -105,7 +105,7 @@ export class HonoAdapter extends AbstractHttpAdapter<
   public patch(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
     const [routePath, routeHandler] = this.getRouteAndHandler(
       pathOrHandler,
-      handler
+      handler,
     );
     this.instance.patch(routePath, this.createRouteHandler(routeHandler));
   }
@@ -113,24 +113,25 @@ export class HonoAdapter extends AbstractHttpAdapter<
   public options(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
     const [routePath, routeHandler] = this.getRouteAndHandler(
       pathOrHandler,
-      handler
+      handler,
     );
     this.instance.options(routePath, this.createRouteHandler(routeHandler));
   }
 
   public async reply(ctx: Context, body: any, statusCode?: StatusCode) {
     if (statusCode) ctx.status(statusCode);
-    const responseContentType = this.getHeader(ctx, "Content-Type");
+
+    const responseContentType = this.getHeader(ctx, 'Content-Type');
     if (
-      !responseContentType?.startsWith("application/json") &&
+      !responseContentType?.startsWith('application/json') &&
       body?.statusCode >= HttpStatus.BAD_REQUEST
     ) {
       Logger.warn(
-        "Content-Type doesn't match Reply body, you might need a custom ExceptionFilter for non-JSON responses"
+        "Content-Type doesn't match Reply body, you might need a custom ExceptionFilter for non-JSON responses",
       );
-      this.setHeader(ctx, "Content-Type", "application/json");
+      this.setHeader(ctx, 'Content-Type', 'application/json');
     }
-    ctx.set("body", body);
+    ctx.set('body', body);
   }
 
   public status(ctx: Context, statusCode: StatusCode) {
@@ -142,7 +143,7 @@ export class HonoAdapter extends AbstractHttpAdapter<
   }
 
   public render(response: any, view: string, options: any) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
 
   public redirect(ctx: Context, statusCode: RedirectStatusCode, url: string) {
@@ -164,12 +165,12 @@ export class HonoAdapter extends AbstractHttpAdapter<
   }
 
   public useStaticAssets(path: string, options: ServeStaticOptions) {
-    Logger.log("Registering static assets middleware");
+    Logger.log('Registering static assets middleware');
     this.instance.use(path, serveStatic(options));
   }
 
   public setViewEngine(options: any | string) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
 
   public isHeadersSent(ctx: Context): boolean {
@@ -205,16 +206,16 @@ export class HonoAdapter extends AbstractHttpAdapter<
   }
 
   public useBodyParser(type: TypeBodyParser, bodyLimit: number = 1e6) {
-    Logger.log("Registering body parser middleware");
+    Logger.log('Registering body parser middleware');
     this.instance.use(this.bodyLimit(bodyLimit), async (ctx, next) => {
-      const contentType = ctx.req.header("content-type");
+      const contentType = ctx.req.header('content-type');
       switch (type) {
-        case "application/json":
-          if (contentType === "application/json")
+        case 'application/json':
+          if (contentType === 'application/json')
             (ctx.req as any).body = await ctx.req.json();
           break;
-        case "text/plain":
-          if (contentType === "text/plain") {
+        case 'text/plain':
+          if (contentType === 'text/plain') {
             (ctx.req as any).rawBody = Buffer.from(await ctx.req.text());
             (ctx.req as any).body = await ctx.req.json();
           }
@@ -244,14 +245,14 @@ export class HonoAdapter extends AbstractHttpAdapter<
   }
 
   public getType(): string {
-    return "hono";
+    return 'hono';
   }
 
   public registerParserMiddleware(prefix?: string, rawBody?: boolean) {
-    Logger.log("Registering parser middleware");
-    this.useBodyParser("application/x-www-form-urlencoded");
-    this.useBodyParser("application/json");
-    this.useBodyParser("text/plain");
+    Logger.log('Registering parser middleware');
+    this.useBodyParser('application/x-www-form-urlencoded');
+    this.useBodyParser('application/json');
+    this.useBodyParser('text/plain');
   }
 
   public async createMiddlewareFactory(requestMethod: RequestMethod) {
@@ -275,7 +276,7 @@ export class HonoAdapter extends AbstractHttpAdapter<
   }
 
   public applyVersionFilter(): () => () => any {
-    throw new Error("Versioning not yet supported in Hono");
+    throw new Error('Versioning not yet supported in Hono');
   }
 
   public listen(port: string | number, ...args: any[]): ServerType {
@@ -286,7 +287,7 @@ export class HonoAdapter extends AbstractHttpAdapter<
     return bodyLimit({
       maxSize,
       onError: () => {
-        throw new Error("Body too large");
+        throw new Error('Body too large');
       },
     });
   }

package/src/drivers/constants/apollo.constants.ts

@@ -0,0 +1 @@
+export const PLUGIN_METADATA = 'graphql:plugin';

package/src/drivers/constants/index.ts

@@ -0,0 +1 @@
+export * from './apollo.constants';

package/src/drivers/graphql.driver.ts

@@ -1,15 +1,29 @@
-import { ApolloServer, BaseContext, HeaderMap } from "@apollo/server";
-import { AbstractGraphQLDriver } 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 { ApolloServer, BaseContext, HeaderMap } from '@apollo/server';
+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 { ModulesContainer } from '@nestjs/core';
 
 export class HonoGraphQLDriver<
-  T extends Record<string, any> = ApolloDriverConfig
+  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;
@@ -19,16 +33,30 @@ export class HonoGraphQLDriver<
     const { httpAdapter } = this.httpAdapterHost;
     const platformName = httpAdapter.getType();
 
-    if (platformName !== "hono") {
-      throw new Error("This driver is only compatible with the Hono platform");
+    if (platformName !== 'hono') {
+      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(
     options: T,
-    { preStartHook }: { preStartHook?: () => void } = {}
+    { preStartHook }: { preStartHook?: () => void } = {},
   ) {
     const { path, typeDefs, resolvers, schema } = options;
     const { httpAdapter } = this.httpAdapterHost;
@@ -65,7 +93,9 @@ export class HonoGraphQLDriver<
         },
         context: () =>
           contextFunction(ctx, {
-            ...ctx.req.raw,
+            method: ctx.req.method,
+            url: ctx.req.url,
+            body: ctx.req.raw.body,
             headers: Object.fromEntries(ctx.req.raw.headers),
           }),
       });
@@ -78,7 +108,7 @@ export class HonoGraphQLDriver<
 
       ctx.status(status === undefined ? 200 : (status as StatusCode));
 
-      if (body.kind === "complete") {
+      if (body.kind === 'complete') {
         return ctx.body(body.string);
       }
 
@@ -92,15 +122,16 @@ export class HonoGraphQLDriver<
       });
 
       return new Response(readableStream, {
-        headers: { "Content-Type": "application/octet-stream" },
+        headers: { 'Content-Type': 'application/octet-stream' },
       });
     });
 
     this.apolloServer = server;
   }
 
-  public stop() {
-    return this.apolloServer?.stop();
+  public async stop() {
+    await this._subscriptionService?.stop();
+    await this.apolloServer?.stop();
   }
 
   private httpHeadersToMap(headers: Headers) {
@@ -110,12 +141,12 @@ export class HonoGraphQLDriver<
   }
 
   private async parseBody(req: HonoRequest): Promise<Record<string, unknown>> {
-    const contentType = req.header("content-type");
-    if (contentType === "application/graphql")
+    const contentType = req.header('content-type');
+    if (contentType === 'application/graphql')
       return { query: await req.text() };
-    if (contentType === "application/json")
+    if (contentType === 'application/json')
       return req.json().catch(this.logError);
-    if (contentType === "application/x-www-form-urlencoded")
+    if (contentType === 'application/x-www-form-urlencoded')
       return this.parseFormURL(req);
     return {};
   }

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