@kiyasov/platform-hono 1.3.7 → 1.3.8

package/src/adapters/hono-adapter.ts

@@ -0,0 +1,333 @@
+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";
+import {
+  ServeStaticOptions,
+  serveStatic,
+} from "@hono/node-server/serve-static";
+import { AbstractHttpAdapter } from "@nestjs/core/adapters/http-adapter";
+import { Context, Next, 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 { HonoRequest, TypeBodyParser } from "../interfaces";
+
+type HonoHandler = RequestHandler<HonoRequest, Context>;
+
+type ServerType = Server | Http2Server | Http2SecureServer;
+
+/**
+ * Adapter for using Hono with NestJS.
+ */
+export class HonoAdapter extends AbstractHttpAdapter<
+  ServerType,
+  HonoRequest,
+  Context
+> {
+  protected readonly instance: Hono<{ Bindings: HttpBindings }>;
+  private _isParserRegistered: boolean;
+
+  constructor() {
+    super(new Hono());
+  }
+
+  get isParserRegistered(): boolean {
+    return !!this._isParserRegistered;
+  }
+
+  private getRouteAndHandler(
+    pathOrHandler: string | HonoHandler,
+    handler?: HonoHandler
+  ): [string, HonoHandler] {
+    let path = typeof pathOrHandler === "function" ? "" : pathOrHandler;
+    handler = typeof pathOrHandler === "function" ? pathOrHandler : handler;
+    return [path, handler];
+  }
+
+  private createRouteHandler(routeHandler: HonoHandler) {
+    return async (ctx: Context, next: Next) => {
+      ctx.req["params"] = ctx.req.param();
+      await routeHandler(ctx.req, ctx, next);
+      return this.send(ctx);
+    };
+  }
+
+  private send(ctx: Context) {
+    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
+    );
+    this.instance.get(routePath, this.createRouteHandler(routeHandler));
+  }
+
+  public post(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
+    const [routePath, routeHandler] = this.getRouteAndHandler(
+      pathOrHandler,
+      handler
+    );
+    this.instance.post(routePath, this.createRouteHandler(routeHandler));
+  }
+
+  public put(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
+    const [routePath, routeHandler] = this.getRouteAndHandler(
+      pathOrHandler,
+      handler
+    );
+    this.instance.put(routePath, this.createRouteHandler(routeHandler));
+  }
+
+  public delete(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
+    const [routePath, routeHandler] = this.getRouteAndHandler(
+      pathOrHandler,
+      handler
+    );
+    this.instance.delete(routePath, this.createRouteHandler(routeHandler));
+  }
+
+  public use(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
+    const [routePath, routeHandler] = this.getRouteAndHandler(
+      pathOrHandler,
+      handler
+    );
+    this.instance.use(routePath, this.createRouteHandler(routeHandler));
+  }
+
+  public patch(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
+    const [routePath, routeHandler] = this.getRouteAndHandler(
+      pathOrHandler,
+      handler
+    );
+    this.instance.patch(routePath, this.createRouteHandler(routeHandler));
+  }
+
+  public options(pathOrHandler: string | HonoHandler, handler?: HonoHandler) {
+    const [routePath, routeHandler] = this.getRouteAndHandler(
+      pathOrHandler,
+      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");
+    if (
+      !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"
+      );
+      this.setHeader(ctx, "Content-Type", "application/json");
+    }
+    ctx.set("body", body);
+  }
+
+  public status(ctx: Context, statusCode: StatusCode) {
+    ctx.status(statusCode);
+  }
+
+  public async end() {
+    return RESPONSE_ALREADY_SENT;
+  }
+
+  public render(response: any, view: string, options: any) {
+    throw new Error("Method not implemented.");
+  }
+
+  public redirect(ctx: Context, statusCode: RedirectStatusCode, url: string) {
+    ctx.redirect(url, statusCode);
+  }
+
+  public setErrorHandler(handler: ErrorHandler) {
+    this.instance.onError(async (err: Error, ctx: Context) => {
+      await handler(err, ctx.req, ctx);
+      return this.send(ctx);
+    });
+  }
+
+  public setNotFoundHandler(handler: RequestHandler) {
+    this.instance.notFound(async (ctx: Context) => {
+      await handler(ctx.req, ctx);
+      return this.send(ctx);
+    });
+  }
+
+  public useStaticAssets(path: string, options: ServeStaticOptions) {
+    Logger.log("Registering static assets middleware");
+    this.instance.use(path, serveStatic(options));
+  }
+
+  public setViewEngine(options: any | string) {
+    throw new Error("Method not implemented.");
+  }
+
+  public isHeadersSent(ctx: Context): boolean {
+    return true;
+  }
+
+  public getHeader?(ctx: Context, name: string) {
+    return ctx.req.header(name);
+  }
+
+  public setHeader(ctx: Context, name: string, value: string) {
+    ctx.header(name, value);
+  }
+
+  public appendHeader?(ctx: Context, name: string, value: string) {
+    ctx.res.headers.append(name, value);
+  }
+
+  public getRequestHostname(ctx: Context): string {
+    return ctx.req.header().host;
+  }
+
+  public getRequestMethod(request: HonoRequest): string {
+    return request.method;
+  }
+
+  public getRequestUrl(request: HonoRequest): string {
+    return request.url;
+  }
+
+  public enableCors(options: any) {
+    this.instance.use(cors(options));
+  }
+
+  public useBodyParser(
+    type: TypeBodyParser,
+    rawBody?: boolean,
+    bodyLimit?: number
+  ) {
+    Logger.log(
+      `Registering body parser middleware for type: ${type} | bodyLimit: ${bodyLimit}`
+    );
+    this.instance.use(this.bodyLimit(bodyLimit));
+
+    // To avoid the Nest application init to override our custom
+    // body parser, we mark the parsers as registered.
+    this._isParserRegistered = true;
+  }
+
+  public close(): Promise<void> {
+    return new Promise((resolve) => this.httpServer.close(() => resolve()));
+  }
+
+  public initHttpServer(options: NestApplicationOptions) {
+    this.instance.use(async (ctx, next) => {
+      ctx.req["ip"] =
+        ctx.req.header("cf-connecting-ip") ??
+        ctx.req.header("x-forwarded-for") ??
+        ctx.req.header("x-real-ip") ??
+        ctx.req.header("forwarded") ??
+        ctx.req.header("true-client-ip") ??
+        ctx.req.header("x-client-ip") ??
+        ctx.req.header("x-cluster-client-ip") ??
+        ctx.req.header("x-forwarded") ??
+        ctx.req.header("forwarded-for") ??
+        ctx.req.header("via");
+      ctx.req["query"] = ctx.req.query() as any;
+      ctx.req["headers"] = Object.fromEntries(ctx.req.raw.headers);
+
+      const contentType = ctx.req.header("content-type");
+
+      if (
+        contentType?.startsWith("multipart/form-data") ||
+        contentType?.startsWith("application/x-www-form-urlencoded")
+      ) {
+        (ctx.req as any).body = await ctx.req.parseBody({
+          all: true,
+        });
+      } else if (
+        contentType?.startsWith("application/json") ||
+        contentType?.startsWith("text/plain")
+      ) {
+        if (options.rawBody) {
+          (ctx.req as any).rawBody = Buffer.from(await ctx.req.text());
+        }
+        (ctx.req as any).body = await ctx.req.json();
+      }
+
+      return next();
+    });
+    const isHttpsEnabled = options?.httpsOptions;
+    const createServer = isHttpsEnabled
+      ? https.createServer
+      : http.createServer;
+    this.httpServer = createAdaptorServer({
+      fetch: this.instance.fetch,
+      createServer,
+      overrideGlobalObjects: false,
+    });
+  }
+
+  public getType(): string {
+    return "hono";
+  }
+
+  public registerParserMiddleware(_prefix?: string, rawBody?: boolean) {
+    if (this._isParserRegistered) {
+      return;
+    }
+
+    Logger.log("Registering parser middleware");
+    this.useBodyParser("application/x-www-form-urlencoded", rawBody);
+    this.useBodyParser("application/json", rawBody);
+    this.useBodyParser("text/plain", rawBody);
+
+    this._isParserRegistered = true;
+  }
+
+  public async createMiddlewareFactory(requestMethod: RequestMethod) {
+    return (path: string, callback: Function) => {
+      const routeMethodsMap = {
+        [RequestMethod.ALL]: this.instance.all,
+        [RequestMethod.DELETE]: this.instance.delete,
+        [RequestMethod.GET]: this.instance.get,
+        [RequestMethod.OPTIONS]: this.instance.options,
+        [RequestMethod.PATCH]: this.instance.patch,
+        [RequestMethod.POST]: this.instance.post,
+        [RequestMethod.PUT]: this.instance.put,
+      };
+      const routeMethod = (
+        routeMethodsMap[requestMethod] || this.instance.get
+      ).bind(this.instance);
+      routeMethod(path, async (ctx: Context, next: Function) => {
+        await callback(ctx.req, ctx, next);
+      });
+    };
+  }
+
+  public applyVersionFilter(): () => () => any {
+    throw new Error("Versioning not yet supported in Hono");
+  }
+
+  public listen(port: string | number, ...args: any[]): ServerType {
+    return this.httpServer.listen(port, ...args);
+  }
+
+  public bodyLimit(maxSize: number) {
+    return bodyLimit({
+      maxSize,
+      onError: () => {
+        throw new Error("Body too large");
+      },
+    });
+  }
+}

package/src/adapters/index.ts

@@ -0,0 +1 @@
+export * from "./hono-adapter";

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/graphQLUpload/GraphQLUpload.ts

@@ -0,0 +1,17 @@
+import { Upload } from "./Upload";
+import { ASTNode, GraphQLError, GraphQLScalarType } from "graphql";
+
+export const GraphQLUpload = new GraphQLScalarType({
+  name: "Upload",
+  description: "The `Upload` scalar type represents a file upload.",
+  parseValue(value: { promise: Promise<Upload> }) {
+    if (value instanceof Upload) return value.promise;
+    throw new GraphQLError("Upload value invalid.");
+  },
+  parseLiteral(node: ASTNode | ASTNode[]) {
+    throw new GraphQLError("Upload literal unsupported.", { nodes: node });
+  },
+  serialize() {
+    throw new GraphQLError("Upload serialization unsupported.");
+  },
+});

package/src/drivers/graphQLUpload/Upload.ts

@@ -0,0 +1,35 @@
+import { ReadStream, ReadStreamOptions, WriteStream } from "./fs-capacitor";
+
+export interface FileUpload {
+  filename: string;
+  fieldName: string;
+  mimetype: string;
+  encoding: string;
+
+  createReadStream(options?: ReadStreamOptions): ReadStream;
+
+  capacitor: WriteStream;
+}
+
+export class Upload {
+  promise: Promise<FileUpload>;
+  resolve: (file?: FileUpload) => void;
+  reject: (error?: Error | string) => void;
+  file?: FileUpload;
+
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = (file) => {
+        this.file = file;
+
+        resolve(file);
+      };
+
+      this.reject = reject;
+    });
+
+    // Prevent errors crashing Node.js, see:
+    // https://github.com/nodejs/node/issues/20392
+    this.promise.catch(() => {});
+  }
+}

package/src/drivers/graphQLUpload/fs-capacitor.ts

@@ -0,0 +1,285 @@
+import { randomBytes } from "crypto";
+import { read, open, closeSync, unlinkSync, write, close, unlink } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { Readable, ReadableOptions, Writable, WritableOptions } from "stream";
+import { EventEmitter } from "events";
+
+export class ReadAfterDestroyedError extends Error {}
+export class ReadAfterReleasedError extends Error {}
+
+export interface ReadStreamOptions {
+  highWaterMark?: ReadableOptions["highWaterMark"];
+  encoding?: ReadableOptions["encoding"];
+}
+
+// Use a “proxy” event emitter configured to have an infinite maximum number of
+// listeners to prevent Node.js max listeners exceeded warnings if many
+// `fs-capacitor` `ReadStream` instances are created at the same time. See:
+// https://github.com/mike-marcacci/fs-capacitor/issues/30
+const processExitProxy = new EventEmitter();
+processExitProxy.setMaxListeners(Infinity);
+process.once("exit", () => processExitProxy.emit("exit"));
+
+export class ReadStream extends Readable {
+  private _pos: number = 0;
+  private _writeStream: WriteStream;
+
+  constructor(writeStream: WriteStream, options?: ReadStreamOptions) {
+    super({
+      highWaterMark: options?.highWaterMark,
+      encoding: options?.encoding,
+      autoDestroy: true,
+    });
+    this._writeStream = writeStream;
+  }
+
+  _read(n: number): void {
+    if (this.destroyed) return;
+
+    if (typeof this._writeStream["_fd"] !== "number") {
+      this._writeStream.once("ready", () => this._read(n));
+      return;
+    }
+
+    // Using `allocUnsafe` here is OK because we return a slice the length of
+    // `bytesRead`, and discard the rest. This prevents node from having to zero
+    // out the entire allocation first.
+    const buf = Buffer.allocUnsafe(n);
+    read(this._writeStream["_fd"], buf, 0, n, this._pos, (error, bytesRead) => {
+      if (error) this.destroy(error);
+
+      // Push any read bytes into the local stream buffer.
+      if (bytesRead) {
+        this._pos += bytesRead;
+        this.push(buf.slice(0, bytesRead));
+        return;
+      }
+
+      // If there were no more bytes to read and the write stream is finished,
+      // then this stream has reached the end.
+      if (
+        (
+          this._writeStream as any as {
+            _writableState: { finished: boolean };
+          }
+        )._writableState.finished
+      ) {
+        // Check if we have consumed the whole file up to where
+        // the write stream has written before ending the stream
+        if (this._pos < (this._writeStream as any as { _pos: number })._pos)
+          this._read(n);
+        else this.push(null);
+        return;
+      }
+
+      // Otherwise, wait for the write stream to add more data or finish.
+      const retry = (): void => {
+        this._writeStream.off("finish", retry);
+        this._writeStream.off("write", retry);
+        this._read(n);
+      };
+
+      this._writeStream.on("finish", retry);
+      this._writeStream.on("write", retry);
+    });
+  }
+}
+
+export interface WriteStreamOptions {
+  highWaterMark?: WritableOptions["highWaterMark"];
+  defaultEncoding?: WritableOptions["defaultEncoding"];
+  tmpdir?: () => string;
+}
+
+export class WriteStream extends Writable {
+  private _fd: null | number = null;
+  private _path: null | string = null;
+  private _pos: number = 0;
+  private _readStreams: Set<ReadStream> = new Set();
+  private _released: boolean = false;
+
+  constructor(options?: WriteStreamOptions) {
+    super({
+      highWaterMark: options?.highWaterMark,
+      defaultEncoding: options?.defaultEncoding,
+      autoDestroy: false,
+    });
+
+    // Generate a random filename.
+    randomBytes(16, (error, buffer) => {
+      if (error) {
+        this.destroy(error);
+        return;
+      }
+
+      this._path = join(
+        (options?.tmpdir ?? tmpdir)(),
+        `capacitor-${buffer.toString("hex")}.tmp`
+      );
+
+      // Create a file in the OS's temporary files directory.
+      open(this._path, "wx+", 0o600, (error, fd) => {
+        if (error) {
+          this.destroy(error);
+          return;
+        }
+
+        // Cleanup when the process exits or is killed.
+        processExitProxy.once("exit", this._cleanupSync);
+
+        this._fd = fd;
+        this.emit("ready");
+      });
+    });
+  }
+
+  _cleanup = (callback: (error: null | Error) => void): void => {
+    const fd = this._fd;
+    const path = this._path;
+
+    if (typeof fd !== "number" || typeof path !== "string") {
+      callback(null);
+      return;
+    }
+
+    // Close the file descriptor.
+    close(fd, (closeError) => {
+      // An error here probably means the fd was already closed, but we can
+      // still try to unlink the file.
+      unlink(path, (unlinkError) => {
+        // If we are unable to unlink the file, the operating system will
+        // clean up on next restart, since we use store thes in `os.tmpdir()`
+        this._fd = null;
+
+        // We avoid removing this until now in case an exit occurs while
+        // asyncronously cleaning up.
+        processExitProxy.off("exit", this._cleanupSync);
+        callback(unlinkError ?? closeError);
+      });
+    });
+  };
+
+  _cleanupSync = (): void => {
+    processExitProxy.off("exit", this._cleanupSync);
+
+    if (typeof this._fd === "number")
+      try {
+        closeSync(this._fd);
+      } catch (error) {
+        // An error here probably means the fd was already closed, but we can
+        // still try to unlink the file.
+      }
+
+    try {
+      if (this._path !== null) {
+        unlinkSync(this._path);
+      }
+    } catch (error) {
+      // If we are unable to unlink the file, the operating system will clean
+      // up on next restart, since we use store thes in `os.tmpdir()`
+    }
+  };
+
+  _final(callback: (error?: null | Error) => any): void {
+    if (typeof this._fd !== "number") {
+      this.once("ready", () => this._final(callback));
+      return;
+    }
+    callback();
+  }
+
+  _write(
+    chunk: Buffer,
+    encoding: string,
+    callback: (error?: null | Error) => any
+  ): void {
+    if (typeof this._fd !== "number") {
+      this.once("ready", () => this._write(chunk, encoding, callback));
+      return;
+    }
+
+    write(this._fd, chunk, 0, chunk.length, this._pos, (error) => {
+      if (error) {
+        callback(error);
+        return;
+      }
+
+      // It's safe to increment `this._pos` after flushing to the filesystem
+      // because node streams ensure that only one `_write()` is active at a
+      // time. If this assumption is broken, the behavior of this library is
+      // undefined, regardless of where this is incremented. Relocating this
+      // to increment syncronously would result in correct file contents, but
+      // the out-of-order writes would still open the potential for read streams
+      // to scan positions that have not yet been written.
+      this._pos += chunk.length;
+      this.emit("write");
+      callback();
+    });
+  }
+
+  release(): void {
+    this._released = true;
+    if (this._readStreams.size === 0) this.destroy();
+  }
+
+  _destroy(
+    error: undefined | null | Error,
+    callback: (error?: null | Error) => any
+  ): void {
+    // Destroy all attached read streams.
+    for (const readStream of this._readStreams) {
+      readStream.destroy(error || undefined);
+    }
+
+    // This capacitor is fully initialized.
+    if (typeof this._fd === "number" && typeof this._path === "string") {
+      this._cleanup((cleanupError) => callback(cleanupError ?? error));
+      return;
+    }
+
+    // This capacitor has not yet finished initialization; if initialization
+    // does complete, immediately clean up after.
+    this.once("ready", () => {
+      this._cleanup((cleanupError) => {
+        if (cleanupError) {
+          this.emit("error", cleanupError);
+        }
+      });
+    });
+
+    callback(error);
+  }
+
+  createReadStream(options?: ReadStreamOptions): ReadStream {
+    if (this.destroyed)
+      throw new ReadAfterDestroyedError(
+        "A ReadStream cannot be created from a destroyed WriteStream."
+      );
+
+    if (this._released)
+      throw new ReadAfterReleasedError(
+        "A ReadStream cannot be created from a released WriteStream."
+      );
+
+    const readStream = new ReadStream(this, options);
+    this._readStreams.add(readStream);
+
+    readStream.once("close", (): void => {
+      this._readStreams.delete(readStream);
+
+      if (this._released && this._readStreams.size === 0) {
+        this.destroy();
+      }
+    });
+
+    return readStream;
+  }
+}
+
+export default {
+  WriteStream,
+  ReadStream,
+  ReadAfterDestroyedError,
+  ReadAfterReleasedError,
+};

package/src/drivers/graphQLUpload/index.ts

@@ -0,0 +1,4 @@
+export * from "./fs-capacitor";
+export * from "./Upload";
+export * from "./GraphQLUpload";
+export * from "./processRequest";