@kiyasov/platform-hono 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kiyasov/platform-hono",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Nest adapter for Hono",
   "author": "Islam Kiiasov",
   "license": "MIT",

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

package/src/drivers/graphQLUpload/processRequest.ts

@@ -0,0 +1,50 @@
+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) => capacitor.createReadStream(options),
+      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

@@ -1,20 +1,22 @@
-import { ApolloServer, BaseContext, HeaderMap } from '@apollo/server';
+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';
+} 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 http from "http";
 
-import { PluginsExplorerService } from './services/plugins-explorer.service';
-import { ModulesContainer } from '@nestjs/core';
+import { PluginsExplorerService } from "./services/plugins-explorer.service";
+import { processRequest } from "./graphQLUpload";
 
 export class HonoGraphQLDriver<
-  T extends Record<string, any> = ApolloDriverConfig,
+  T extends Record<string, any> = ApolloDriverConfig
 > extends AbstractGraphQLDriver {
   protected apolloServer: ApolloServer<BaseContext>;
   private _subscriptionService?: GqlSubscriptionService;
@@ -33,15 +35,15 @@ 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");
     }
 
     await this.registerHono(options);
 
     if (options.installSubscriptionHandlers || options.subscriptions) {
       const subscriptionsOptions: SubscriptionConfig =
-        options.subscriptions || { 'subscriptions-transport-ws': {} };
+        options.subscriptions || { "subscriptions-transport-ws": {} };
       this._subscriptionService = new GqlSubscriptionService(
         {
           schema: options.schema,
@@ -49,14 +51,14 @@ export class HonoGraphQLDriver<
           context: options.context,
           ...subscriptionsOptions,
         },
-        this.httpAdapterHost.httpAdapter?.getHttpServer(),
+        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;
@@ -78,7 +80,7 @@ export class HonoGraphQLDriver<
     await server.start();
 
     app.use(path, async (ctx: Context) => {
-      const bodyData = await this.parseBody(ctx.req);
+      const bodyData = await this.parseBody(ctx);
 
       const defaultContext = () => Promise.resolve({} as BaseContext);
 
@@ -108,7 +110,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);
       }
 
@@ -122,7 +124,7 @@ export class HonoGraphQLDriver<
       });
 
       return new Response(readableStream, {
-        headers: { 'Content-Type': 'application/octet-stream' },
+        headers: { "Content-Type": "application/octet-stream" },
       });
     });
 
@@ -140,17 +142,30 @@ export class HonoGraphQLDriver<
     return map;
   }
 
-  private async parseBody(req: HonoRequest): Promise<Record<string, unknown>> {
-    const contentType = req.header('content-type');
-    if (contentType === 'application/graphql')
+  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')
+    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);
+    if (contentType?.startsWith("multipart/form-data")) {
+      return processRequest(ctx);
+    }
     return {};
   }
 
+  headersToRecord(headers: Headers): http.IncomingHttpHeaders {
+    const obj: http.IncomingHttpHeaders = {};
+    headers.forEach((value, key) => {
+      obj[key] = value;
+    });
+    return obj;
+  }
+
   private logError(e: unknown): void {
     if (e instanceof Error) {
       Logger.error(e.stack || e.message);

package/src/drivers/index.ts

@@ -1 +1,2 @@
 export * from "./graphql.driver";
+export * from "./graphQLUpload";