@kiyasov/platform-hono 1.0.7 → 1.0.9

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.7",
+  "version": "1.0.9",
   "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/graphQLUpload/GraphQLUpload.ts

@@ -0,0 +1,86 @@
+import { Upload } from "./Upload";
+import { ASTNode, GraphQLError, GraphQLScalarType } from "graphql";
+
+/**
+ * A GraphQL `Upload` scalar that can be used in a
+ * [`GraphQLSchema`](https://graphql.org/graphql-js/type/#graphqlschema).
+ * It's value in resolvers is a promise that resolves
+ * [file upload details]{@link FileUpload} for processing and storage.
+ * @example <caption>Ways to `import`.</caption>
+ * ```js
+ * import { GraphQLUpload } from 'graphql-upload-ts';
+ * ```
+ *
+ * ```js
+ * import GraphQLUpload from 'graphql-upload-ts/dist/GraphQLUpload.js';
+ * ```
+ * @example <caption>Ways to `require`.</caption>
+ * ```js
+ * const { GraphQLUpload } = require('graphql-upload-ts');
+ * ```
+ *
+ * ```js
+ * const GraphQLUpload = require('graphql-upload-ts/dist/GraphQLUpload');
+ * ```
+ * @example <caption>Setup for a schema built with [`makeExecutableSchema`](https://apollographql.com/docs/graphql-tools/generate-schema#makeExecutableSchema).</caption>
+ * ```js
+ * const { makeExecutableSchema } = require('graphql-tools');
+ * const { GraphQLUpload } = require('graphql-upload-ts');
+ *
+ * const schema = makeExecutableSchema({
+ *   typeDefs: /* GraphQL *\/ `
+ *     scalar Upload
+ *   `,
+ *   resolvers: {
+ *     Upload: GraphQLUpload,
+ *   },
+ * });
+ * ```
+ * @example <caption>A manually constructed schema with an image upload mutation.</caption>
+ * ```js
+ * const {
+ *   GraphQLSchema,
+ *   GraphQLObjectType,
+ *   GraphQLBoolean,
+ * } = require('graphql');
+ * const { GraphQLUpload } = require('graphql-upload-ts');
+ *
+ * const schema = new GraphQLSchema({
+ *   mutation: new GraphQLObjectType({
+ *     name: 'Mutation',
+ *     fields: {
+ *       uploadImage: {
+ *         description: 'Uploads an image.',
+ *         type: GraphQLBoolean,
+ *         args: {
+ *           image: {
+ *             description: 'Image file.',
+ *             type: GraphQLUpload,
+ *           },
+ *         },
+ *         async resolve(parent, { image }) {
+ *           const { filename, fieldName, mimetype, createReadStream } = await image;
+ *           const stream = createReadStream();
+ *           // Promisify the stream and store the file, then…
+ *           return true;
+ *         },
+ *       },
+ *     },
+ *   }),
+ * });
+ * ```
+ */
+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";