@kiyasov/platform-hono 1.3.7 → 1.3.9

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";

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