@kiyasov/platform-hono 1.4.0 → 1.4.2

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

@@ -1,16 +1,16 @@
-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";
+import { randomBytes } from 'crypto';
+import { EventEmitter } from 'events';
+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';
 
 export class ReadAfterDestroyedError extends Error {}
 export class ReadAfterReleasedError extends Error {}
 
 export interface ReadStreamOptions {
-  highWaterMark?: ReadableOptions["highWaterMark"];
-  encoding?: ReadableOptions["encoding"];
+  highWaterMark?: ReadableOptions['highWaterMark'];
+  encoding?: ReadableOptions['encoding'];
 }
 
 // Use a “proxy” event emitter configured to have an infinite maximum number of
@@ -19,7 +19,7 @@ export interface ReadStreamOptions {
 // https://github.com/mike-marcacci/fs-capacitor/issues/30
 const processExitProxy = new EventEmitter();
 processExitProxy.setMaxListeners(Infinity);
-process.once("exit", () => processExitProxy.emit("exit"));
+process.once('exit', () => processExitProxy.emit('exit'));
 
 export class ReadStream extends Readable {
   private _pos: number = 0;
@@ -37,8 +37,8 @@ export class ReadStream extends Readable {
   _read(n: number): void {
     if (this.destroyed) return;
 
-    if (typeof this._writeStream["_fd"] !== "number") {
-      this._writeStream.once("ready", () => this._read(n));
+    if (typeof this._writeStream['_fd'] !== 'number') {
+      this._writeStream.once('ready', () => this._read(n));
       return;
     }
 
@@ -46,7 +46,7 @@ export class ReadStream extends Readable {
     // `bytesRead`, and discard the rest. This prevents node from having to zero
     // out the entire allocation first.
     const buf = new Uint8Array(Buffer.allocUnsafe(n).buffer);
-    read(this._writeStream["_fd"], buf, 0, n, this._pos, (error, bytesRead) => {
+    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.
@@ -60,14 +60,14 @@ export class ReadStream extends Readable {
       // then this stream has reached the end.
       if (
         (
-          this._writeStream as any as {
+          this._writeStream as unknown 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)
+        if (this._pos < (this._writeStream as unknown as { _pos: number })._pos)
           this._read(n);
         else this.push(null);
         return;
@@ -75,20 +75,20 @@ export class ReadStream extends Readable {
 
       // 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._writeStream.off('finish', retry);
+        this._writeStream.off('write', retry);
         this._read(n);
       };
 
-      this._writeStream.on("finish", retry);
-      this._writeStream.on("write", retry);
+      this._writeStream.on('finish', retry);
+      this._writeStream.on('write', retry);
     });
   }
 }
 
 export interface WriteStreamOptions {
-  highWaterMark?: WritableOptions["highWaterMark"];
-  defaultEncoding?: WritableOptions["defaultEncoding"];
+  highWaterMark?: WritableOptions['highWaterMark'];
+  defaultEncoding?: WritableOptions['defaultEncoding'];
   tmpdir?: () => string;
 }
 
@@ -115,21 +115,21 @@ export class WriteStream extends Writable {
 
       this._path = join(
         (options?.tmpdir ?? tmpdir)(),
-        `capacitor-${buffer.toString("hex")}.tmp`
+        `capacitor-${buffer.toString('hex')}.tmp`,
       );
 
       // Create a file in the OS's temporary files directory.
-      open(this._path, "wx+", 0o600, (error, fd) => {
+      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);
+        processExitProxy.once('exit', this._cleanupSync);
 
         this._fd = fd;
-        this.emit("ready");
+        this.emit('ready');
       });
     });
   }
@@ -138,7 +138,7 @@ export class WriteStream extends Writable {
     const fd = this._fd;
     const path = this._path;
 
-    if (typeof fd !== "number" || typeof path !== "string") {
+    if (typeof fd !== 'number' || typeof path !== 'string') {
       callback(null);
       return;
     }
@@ -154,19 +154,19 @@ export class WriteStream extends Writable {
 
         // We avoid removing this until now in case an exit occurs while
         // asyncronously cleaning up.
-        processExitProxy.off("exit", this._cleanupSync);
+        processExitProxy.off('exit', this._cleanupSync);
         callback(unlinkError ?? closeError);
       });
     });
   };
 
   _cleanupSync = (): void => {
-    processExitProxy.off("exit", this._cleanupSync);
+    processExitProxy.off('exit', this._cleanupSync);
 
-    if (typeof this._fd === "number")
+    if (typeof this._fd === 'number')
       try {
         closeSync(this._fd);
-      } catch (error) {
+      } catch {
         // An error here probably means the fd was already closed, but we can
         // still try to unlink the file.
       }
@@ -175,15 +175,15 @@ export class WriteStream extends Writable {
       if (this._path !== null) {
         unlinkSync(this._path);
       }
-    } catch (error) {
+    } catch {
       // 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));
+  _final(callback: (error?: null | Error) => unknown): void {
+    if (typeof this._fd !== 'number') {
+      this.once('ready', () => this._final(callback));
       return;
     }
     callback();
@@ -192,17 +192,17 @@ export class WriteStream extends Writable {
   _write(
     chunk: Buffer,
     encoding: string,
-    callback: (error?: null | Error) => any
+    callback: (error?: null | Error) => unknown,
   ): void {
-    if (typeof this._fd !== "number") {
-      this.once("ready", () => this._write(chunk, encoding, callback));
+    if (typeof this._fd !== 'number') {
+      this.once('ready', () => this._write(chunk, encoding, callback));
       return;
     }
 
     const uint8Array = new Uint8Array(
       chunk.buffer,
       chunk.byteOffset,
-      chunk.byteLength
+      chunk.byteLength,
     );
 
     write(this._fd, uint8Array, 0, chunk.length, this._pos, (error) => {
@@ -219,7 +219,7 @@ export class WriteStream extends Writable {
       // 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");
+      this.emit('write');
       callback();
     });
   }
@@ -231,7 +231,7 @@ export class WriteStream extends Writable {
 
   _destroy(
     error: undefined | null | Error,
-    callback: (error?: null | Error) => any
+    callback: (error?: null | Error) => unknown,
   ): void {
     // Destroy all attached read streams.
     for (const readStream of this._readStreams) {
@@ -239,17 +239,17 @@ export class WriteStream extends Writable {
     }
 
     // This capacitor is fully initialized.
-    if (typeof this._fd === "number" && typeof this._path === "string") {
+    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.once('ready', () => {
       this._cleanup((cleanupError) => {
         if (cleanupError) {
-          this.emit("error", cleanupError);
+          this.emit('error', cleanupError);
         }
       });
     });
@@ -260,18 +260,18 @@ export class WriteStream extends Writable {
   createReadStream(options?: ReadStreamOptions): ReadStream {
     if (this.destroyed)
       throw new ReadAfterDestroyedError(
-        "A ReadStream cannot be created from a destroyed WriteStream."
+        'A ReadStream cannot be created from a destroyed WriteStream.',
       );
 
     if (this._released)
       throw new ReadAfterReleasedError(
-        "A ReadStream cannot be created from a released WriteStream."
+        'A ReadStream cannot be created from a released WriteStream.',
       );
 
     const readStream = new ReadStream(this, options);
     this._readStreams.add(readStream);
 
-    readStream.once("close", (): void => {
+    readStream.once('close', (): void => {
       this._readStreams.delete(readStream);
 
       if (this._released && this._readStreams.size === 0) {

package/src/drivers/graphQLUpload/index.ts

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

package/src/drivers/graphQLUpload/processRequest.ts

@@ -1,18 +1,19 @@
-import { Context } from "hono";
-import { WriteStream, Upload } from ".";
-import { Readable } from "stream";
+import { Context } from 'hono';
+import { Readable } from 'stream';
+
+import { WriteStream, Upload } from '.';
 
 export async function processRequest(
-  ctx: Context
-): Promise<Record<string, any>> {
+  ctx: Context,
+): Promise<Record<string, unknown>> {
   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" ||
+      fieldName === 'operations' ||
+      fieldName === 'map' ||
       !(file instanceof File)
     )
       continue;
@@ -30,10 +31,10 @@ export async function processRequest(
       filename: file.name,
       mimetype: file.type,
       fieldName,
-      encoding: "7bit",
+      encoding: '7bit',
       createReadStream: (options) => {
         const stream = capacitor.createReadStream(options);
-        stream.on("close", () => {
+        stream.on('close', () => {
           capacitor.release();
         });
         return stream;
@@ -43,7 +44,7 @@ export async function processRequest(
     upload.resolve(upload.file);
 
     for (const fileKey of fileKeys) {
-      const pathSegments = fileKey.split(".");
+      const pathSegments = fileKey.split('.');
       let current = operations;
       for (let i = 0; i < pathSegments.length - 1; i++) {
         if (!current[pathSegments[i]]) current[pathSegments[i]] = {};

package/src/drivers/graphql.driver.ts

@@ -1,21 +1,22 @@
-import { ApolloServer, BaseContext, HeaderMap } from "@apollo/server";
-import { ModulesContainer } from "@nestjs/core";
+import { ApolloServer, BaseContext, HeaderMap } from '@apollo/server';
+import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer';
+import { ApolloDriverConfig } from '@nestjs/apollo';
+import { Logger } from '@nestjs/common';
+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 { Context, HonoRequest } from 'hono';
+import { StatusCode } from 'hono/utils/http-status';
 
-import { PluginsExplorerService } from "./services/plugins-explorer.service";
-import { processRequest } from "./graphQLUpload";
+import { processRequest } from './graphQLUpload';
+import { PluginsExplorerService } from './services/plugins-explorer.service';
 
 export class HonoGraphQLDriver<
-  T extends Record<string, any> = ApolloDriverConfig
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  T extends Record<string, any> = ApolloDriverConfig,
 > extends AbstractGraphQLDriver {
   protected apolloServer: ApolloServer<BaseContext>;
   private _subscriptionService?: GqlSubscriptionService;
@@ -34,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,
@@ -50,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;
@@ -109,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);
       }
 
@@ -123,7 +124,7 @@ export class HonoGraphQLDriver<
       });
 
       return new Response(readableStream, {
-        headers: { "Content-Type": "application/octet-stream" },
+        headers: { 'Content-Type': 'application/octet-stream' },
       });
     });
 
@@ -143,15 +144,15 @@ export class HonoGraphQLDriver<
 
   private async parseBody(ctx: Context): Promise<Record<string, unknown>> {
     const req = ctx.req;
-    const contentType = req.header("content-type");
+    const contentType = req.header('content-type');
 
-    if (contentType === "application/graphql")
+    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")) {
+    if (contentType?.startsWith('multipart/form-data')) {
       return processRequest(ctx);
     }
     return {};

package/src/drivers/index.ts

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

package/src/drivers/services/plugins-explorer.service.ts

@@ -1,6 +1,7 @@
 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 {
@@ -16,7 +17,7 @@ export class PluginsExplorerService extends BaseExplorerService {
     return this.flatMap(modules, (instance) => this.filterPlugins(instance));
   }
 
-  filterPlugins<T = any>(wrapper: InstanceWrapper<T>) {
+  filterPlugins<T = unknown>(wrapper: InstanceWrapper<T>) {
     const { instance } = wrapper;
     if (!instance) {
       return undefined;

package/src/interfaces/hono.interface.ts

@@ -1,4 +1,4 @@
-import { HonoRequest as Request } from "hono";
+import { HonoRequest as Request } from 'hono';
 
 export type HonoRequest = Request & {
   headers?: Record<string, string>;

package/src/interfaces/index.ts

@@ -1,2 +1,2 @@
-export * from "./nest-hono-application.interface";
-export * from "./hono.interface";
+export * from './nest-hono-application.interface';
+export * from './hono.interface';

package/src/interfaces/nest-hono-application.interface.ts

@@ -1,11 +1,11 @@
-import { ServeStaticOptions } from "@hono/node-server/serve-static";
-import { HttpServer, INestApplication } from "@nestjs/common";
-import { Context, Hono, MiddlewareHandler } from "hono";
+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";
+  | 'application/json'
+  | 'text/plain'
+  | 'application/x-www-form-urlencoded';
 
 interface HonoViewOptions {
   engine: string;
@@ -56,17 +56,17 @@ export interface NestHonoApplication<TServer extends Hono = Hono>
    */
   listen(
     port: number | string,
-    callback?: (err: Error, address: string) => void
+    callback?: (err: Error, address: string) => void,
   ): Promise<TServer>;
   listen(
     port: number | string,
     address: string,
-    callback?: (err: Error, address: string) => void
+    callback?: (err: Error, address: string) => void,
   ): Promise<TServer>;
   listen(
     port: number | string,
     address: string,
     backlog: number,
-    callback?: (err: Error, address: string) => void
+    callback?: (err: Error, address: string) => void,
   ): Promise<TServer>;
 }

package/src/multer/decorators/index.ts

@@ -1,2 +1,2 @@
-export * from "./uploaded-files-decorator";
-export * from "./uploaded-file-decorator";
+export * from './uploaded-files-decorator';
+export * from './uploaded-file-decorator';

package/src/multer/decorators/uploaded-files-decorator.ts

@@ -5,7 +5,7 @@ import { StorageFile } from '../storage/storage';
 
 export const UploadedFiles = createParamDecorator(
   async (
-    _data: any,
+    _data: unknown,
     ctx: ExecutionContext,
   ): Promise<Record<string, StorageFile[]> | StorageFile[] | undefined> => {
     const req = getMultipartRequest(ctx.switchToHttp());

package/src/multer/fs/index.ts

@@ -1,22 +1,18 @@
-import fs from 'node:fs/promises';
-import { extname } from 'node:path';
-
-import { randomBytes } from '../crypto';
+import { randomBytes } from 'crypto';
+import { stat } from 'fs/promises';
+import { extname } from 'path';
 
 export const pathExists = async (path: string) => {
   try {
-    await fs.stat(path);
-  } catch (err) {
+    await stat(path);
+    return true;
+  } catch {
     return false;
   }
-
-  return true;
 };
 
 export const getUniqueFilename = async (filename: string) => {
-  const buffer = await randomBytes(16);
-
+  const buffer = randomBytes(16);
   const ext = extname(filename);
-
   return buffer.toString('hex') + ext;
 };

package/src/multer/index.ts

@@ -1,4 +1,4 @@
-export * from "./interceptors";
-export * from "./decorators";
-export * from "./storage";
-export * from "./multipart";
+export * from './interceptors';
+export * from './decorators';
+export * from './storage';
+export * from './multipart';

package/src/multer/interceptors/any-files-interceptor.ts

@@ -1,18 +1,18 @@
-import { Observable, tap } from "rxjs";
 import {
   CallHandler,
   ExecutionContext,
   mixin,
   NestInterceptor,
   Type,
-} from "@nestjs/common";
+} from '@nestjs/common';
+import { finalize } from 'rxjs';
 
-import { getMultipartRequest } from "../multipart/request";
-import { transformUploadOptions, UploadOptions } from "../multipart/options";
-import { handleMultipartAnyFiles } from "../multipart/handlers/any-files";
+import { handleMultipartAnyFiles } from '../multipart/handlers/any-files';
+import { transformUploadOptions, UploadOptions } from '../multipart/options';
+import { getMultipartRequest } from '../multipart/request';
 
 export function AnyFilesInterceptor(
-  options?: UploadOptions
+  options?: UploadOptions,
 ): Type<NestInterceptor> {
   class MixinInterceptor implements NestInterceptor {
     private readonly options: UploadOptions;
@@ -21,26 +21,23 @@ export function AnyFilesInterceptor(
       this.options = transformUploadOptions(options);
     }
 
-    async intercept(
-      context: ExecutionContext,
-      next: CallHandler
-    ): Promise<Observable<any>> {
+    async intercept(context: ExecutionContext, next: CallHandler) {
       const ctx = context.switchToHttp();
       const req = getMultipartRequest(ctx);
 
-      if (!req.header("content-type")?.startsWith("multipart/form-data")) {
+      if (!req.header('content-type')?.startsWith('multipart/form-data')) {
         return next.handle();
       }
 
       const { body, files, remove } = await handleMultipartAnyFiles(
         req,
-        this.options
+        this.options,
       );
 
       req.body = body;
       req.storageFiles = files;
 
-      return next.handle().pipe(tap(remove));
+      return next.handle().pipe(finalize(remove));
     }
   }