@akanjs/nest 0.0.39 → 0.0.40

package/src/index.js

@@ -0,0 +1,73 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  Exporter: () => Exporter,
+  guards: () => guards
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./authorization"), module.exports);
+__reExport(src_exports, require("./authGuards"), module.exports);
+var guards = __toESM(require("./authGuards"));
+__reExport(src_exports, require("./authentication"), module.exports);
+__reExport(src_exports, require("./interceptors"), module.exports);
+__reExport(src_exports, require("./redis-io.adapter"), module.exports);
+__reExport(src_exports, require("./pipes"), module.exports);
+var Exporter = __toESM(require("./exporter"));
+__reExport(src_exports, require("./exporter"), module.exports);
+__reExport(src_exports, require("./verifyPayment"), module.exports);
+__reExport(src_exports, require("./sso"), module.exports);
+__reExport(src_exports, require("./exceptions"), module.exports);
+__reExport(src_exports, require("./generateSecrets"), module.exports);
+__reExport(src_exports, require("./mongoose"), module.exports);
+__reExport(src_exports, require("./searchClient"), module.exports);
+__reExport(src_exports, require("./cacheClient"), module.exports);
+__reExport(src_exports, require("./databaseClient"), module.exports);
+__reExport(src_exports, require("./decorators"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Exporter,
+  guards,
+  ...require("./authorization"),
+  ...require("./authGuards"),
+  ...require("./authentication"),
+  ...require("./interceptors"),
+  ...require("./redis-io.adapter"),
+  ...require("./pipes"),
+  ...require("./exporter"),
+  ...require("./verifyPayment"),
+  ...require("./sso"),
+  ...require("./exceptions"),
+  ...require("./generateSecrets"),
+  ...require("./mongoose"),
+  ...require("./searchClient"),
+  ...require("./cacheClient"),
+  ...require("./databaseClient"),
+  ...require("./decorators")
+});

package/src/interceptors.d.ts

@@ -0,0 +1,47 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { RedisClientType } from 'redis';
+import { Observable } from 'rxjs';
+
+declare const logLevels: readonly ["trace", "verbose", "debug", "log", "info", "warn", "error"];
+type LogLevel = (typeof logLevels)[number];
+declare class Logger {
+    #private;
+    static level: LogLevel;
+    static setLevel(level: LogLevel): void;
+    name?: string;
+    constructor(name?: string);
+    trace(msg: string, context?: string): void;
+    verbose(msg: string, context?: string): void;
+    debug(msg: string, context?: string): void;
+    log(msg: string, context?: string): void;
+    info(msg: string, context?: string): void;
+    warn(msg: string, context?: string): void;
+    error(msg: string, context?: string): void;
+    raw(msg: string, method?: "console" | "process"): void;
+    rawLog(msg: string, method?: "console" | "process"): void;
+    static trace(msg: string, context?: string): void;
+    static verbose(msg: string, context?: string): void;
+    static debug(msg: string, context?: string): void;
+    static log(msg: string, context?: string): void;
+    static info(msg: string, context?: string): void;
+    static warn(msg: string, context?: string): void;
+    static error(msg: string, context?: string): void;
+    static rawLog(msg: string, method?: "console" | "process"): void;
+    static raw(msg: string, method?: "console" | "process"): void;
+}
+
+declare class CacheInterceptor implements NestInterceptor {
+    #private;
+    private readonly redis;
+    constructor(redis: RedisClientType<any, any, any>);
+    intercept<T>(context: ExecutionContext, next: CallHandler): Promise<Observable<T>>;
+}
+declare class TimeoutInterceptor implements NestInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}
+declare class LoggingInterceptor implements NestInterceptor {
+    logger: Logger;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}
+
+export { CacheInterceptor, LoggingInterceptor, TimeoutInterceptor };

package/src/interceptors.js

@@ -0,0 +1,176 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interceptors_exports = {};
+__export(interceptors_exports, {
+  CacheInterceptor: () => CacheInterceptor,
+  LoggingInterceptor: () => LoggingInterceptor,
+  TimeoutInterceptor: () => TimeoutInterceptor
+});
+module.exports = __toCommonJS(interceptors_exports);
+var import_common = require("@akanjs/common");
+var import_signal = require("@akanjs/signal");
+var import_common2 = require("@nestjs/common");
+var import_graphql = require("@nestjs/graphql");
+var import_rxjs = require("rxjs");
+var import_operators = require("rxjs/operators");
+var import_authGuards = require("./authGuards");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+class CacheInterceptor {
+  static {
+    __name(this, "CacheInterceptor");
+  }
+  redis;
+  #logger;
+  #CACHE_PREFIX;
+  constructor(redis) {
+    this.redis = redis;
+    this.#logger = new import_common.Logger("CacheInterceptor");
+    this.#CACHE_PREFIX = "signal:";
+  }
+  async intercept(context, next) {
+    const handler = context.getHandler();
+    const signalKey = handler.name;
+    const gqlMeta = (0, import_signal.getGqlMeta)(context.getClass(), signalKey);
+    if (gqlMeta.type !== "Query" || !gqlMeta.signalOption.cache) {
+      if (gqlMeta.signalOption.cache) this.#logger.warn(`CacheInterceptor: ${signalKey} is not Query endpoint or cache is not set`);
+      return next.handle();
+    }
+    const args = (0, import_authGuards.getArgs)(context);
+    const cacheKey = this.#generateCacheKey(signalKey, args);
+    const cachedData = await this.#getCache(cacheKey);
+    if (cachedData) {
+      this.#logger.debug(`Cache hit for key: ${cacheKey}`);
+      return next.handle().pipe((0, import_operators.map)(() => cachedData), (0, import_operators.catchError)((error) => {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        this.#logger.error(`Error in cache interceptor for ${cacheKey}: ${errorMessage}`);
+        return (0, import_rxjs.throwError)(() => error);
+      }));
+    }
+    return next.handle().pipe((0, import_operators.map)((data) => {
+      const cacheDuration = gqlMeta.signalOption.cache;
+      if (typeof cacheDuration === "number") {
+        void this.#setCache(cacheKey, data, cacheDuration);
+        this.#logger.debug(`Cache set for key: ${cacheKey}`);
+      }
+      return data;
+    }), (0, import_operators.catchError)((error) => {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.#logger.error(`Error in cache interceptor for ${cacheKey}: ${errorMessage}`);
+      return (0, import_rxjs.throwError)(() => error);
+    }));
+  }
+  #generateCacheKey(signalKey, args) {
+    return `${this.#CACHE_PREFIX}${signalKey}:${JSON.stringify(args)}`;
+  }
+  async #getCache(key) {
+    try {
+      const cached = await this.redis.get(key);
+      if (!cached) return null;
+      const { data } = JSON.parse(cached);
+      return data;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.#logger.error(`Error retrieving cache for key ${key}: ${errorMessage}`);
+      return null;
+    }
+  }
+  async #setCache(key, data, ttlMs) {
+    try {
+      const cacheData = {
+        data,
+        timestamp: Date.now()
+      };
+      await this.redis.set(key, JSON.stringify(cacheData), {
+        PX: ttlMs
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.#logger.error(`Error setting cache for key ${key}: ${errorMessage}`);
+    }
+  }
+}
+CacheInterceptor = _ts_decorate([
+  (0, import_common2.Injectable)(),
+  _ts_param(0, (0, import_common2.Inject)("REDIS_CLIENT")),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof RedisClientType === "undefined" ? Object : RedisClientType
+  ])
+], CacheInterceptor);
+class TimeoutInterceptor {
+  static {
+    __name(this, "TimeoutInterceptor");
+  }
+  intercept(context, next) {
+    const gqlMeta = (0, import_signal.getGqlMeta)(context.getClass(), context.getHandler().name);
+    const timeoutMs = gqlMeta.signalOption.timeout ?? 3e4;
+    if (timeoutMs === 0) return next.handle();
+    return next.handle().pipe((0, import_operators.timeout)(timeoutMs), (0, import_operators.catchError)((err) => {
+      if (err instanceof import_rxjs.TimeoutError) return (0, import_rxjs.throwError)(() => new import_common2.RequestTimeoutException());
+      return (0, import_rxjs.throwError)(() => err);
+    }));
+  }
+}
+TimeoutInterceptor = _ts_decorate([
+  (0, import_common2.Injectable)()
+], TimeoutInterceptor);
+class LoggingInterceptor {
+  static {
+    __name(this, "LoggingInterceptor");
+  }
+  logger = new import_common.Logger("IO");
+  intercept(context, next) {
+    const gqlReq = context.getArgByIndex(3);
+    const req = (0, import_authGuards.getRequest)(context);
+    const reqType = gqlReq?.parentType?.name ?? req.method;
+    const reqName = gqlReq?.fieldName ?? req.url;
+    const before = Date.now();
+    const ip = import_graphql.GqlExecutionContext.create(context).getContext().req.ip;
+    this.logger.debug(`Before ${reqType}-${reqName} / ${ip} / ${before}`);
+    return next.handle().pipe((0, import_operators.tap)(() => {
+      const after = Date.now();
+      this.logger.debug(`After  ${reqType}-${reqName} / ${ip} / ${after} (${after - before}ms)`);
+    }));
+  }
+}
+LoggingInterceptor = _ts_decorate([
+  (0, import_common2.Injectable)()
+], LoggingInterceptor);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheInterceptor,
+  LoggingInterceptor,
+  TimeoutInterceptor
+});

package/src/mongoose.d.ts

@@ -0,0 +1,7 @@
+declare const initMongoDB: ({ logging, threshold, sendReport, }: {
+    logging: boolean;
+    threshold?: number;
+    sendReport?: boolean;
+}) => void;
+
+export { initMongoDB };

package/src/mongoose.js

@@ -0,0 +1,87 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mongoose_exports = {};
+__export(mongoose_exports, {
+  initMongoDB: () => initMongoDB
+});
+module.exports = __toCommonJS(mongoose_exports);
+var import_common = require("@akanjs/common");
+var import_mongoose = __toESM(require("mongoose"));
+const initMongoDB = /* @__PURE__ */ __name(({ logging, threshold = 5e3, sendReport = false }) => {
+  const mongoDBLogger = new import_common.Logger("MongoDB");
+  if (logging) import_mongoose.default.set("debug", function(collection, method, ...methodArgs) {
+    mongoDBLogger.verbose(`${collection}.${method}(${methodArgs.slice(0, -1).map((arg) => JSON.stringify(arg)).join(", ")})`);
+  });
+  const originalExec = import_mongoose.default.Query.prototype.exec;
+  const getQueryInfo = /* @__PURE__ */ __name((queryAgent) => {
+    const model = queryAgent.model;
+    const collectionName = model.collection.collectionName;
+    const dbName = model.db.name;
+    const query = queryAgent.getQuery();
+    const queryOptions = queryAgent.getOptions();
+    return {
+      dbName,
+      collectionName,
+      query,
+      queryOptions
+    };
+  }, "getQueryInfo");
+  import_mongoose.default.Query.prototype.exec = function(...args) {
+    const start = Date.now();
+    return originalExec.apply(this, args).then((result) => {
+      const duration = Date.now() - start;
+      const { dbName, collectionName, query, queryOptions } = getQueryInfo(this);
+      if (logging) mongoDBLogger.verbose(`Queried ${dbName}.${collectionName}.query(${JSON.stringify(query)}, ${JSON.stringify(queryOptions)}) - ${duration}ms`);
+      return result;
+    });
+  };
+  const originalAggregate = import_mongoose.default.Model.aggregate;
+  const getAggregateInfo = /* @__PURE__ */ __name((aggregateModel) => {
+    const dbName = aggregateModel.db.db?.databaseName ?? "unknown";
+    const collectionName = aggregateModel.collection.collectionName;
+    return {
+      dbName,
+      collectionName
+    };
+  }, "getAggregateInfo");
+  import_mongoose.default.Model.aggregate = function(...args) {
+    const startTime = Date.now();
+    return originalAggregate.apply(this, args).then((result) => {
+      const duration = Date.now() - startTime;
+      const { dbName, collectionName } = getAggregateInfo(this);
+      if (logging) mongoDBLogger.verbose(`Aggregated ${dbName}.${collectionName}.aggregate(${args.map((arg) => JSON.stringify(arg)).join(", ")}) - ${duration}ms`);
+      return result;
+    });
+  };
+  import_mongoose.default.set("transactionAsyncLocalStorage", true);
+}, "initMongoDB");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initMongoDB
+});

package/src/pipes.d.ts

@@ -0,0 +1,52 @@
+import * as dayjsLib from 'dayjs';
+import { Readable } from 'stream';
+import { T as Type, a as ArgMeta } from '../signalDecorators-Bh7Aniud.js';
+import { PipeTransform, ArgumentMetadata } from '@nestjs/common';
+import '../baseEnv-Qb_Lg-a-.js';
+import 'tunnel-ssh';
+
+declare class ArrayifyPipe implements PipeTransform {
+    transform(value: string | string[], metadata: ArgumentMetadata): string[];
+}
+declare class IntPipe implements PipeTransform {
+    transform(value: string, metadata: ArgumentMetadata): number[];
+}
+declare class FloatPipe implements PipeTransform {
+    transform(value: string, metadata: ArgumentMetadata): number[];
+}
+declare class BooleanPipe implements PipeTransform {
+    transform(value: string, metadata: ArgumentMetadata): boolean[];
+}
+declare class DayjsPipe implements PipeTransform {
+    transform(value: string, metadata: ArgumentMetadata): dayjsLib.Dayjs[];
+}
+declare class JSONPipe implements PipeTransform {
+    transform(value: string | object, metadata: ArgumentMetadata): object;
+}
+interface FileStream {
+    originalname: string;
+    mimetype: string;
+    encoding: string;
+    buffer: Buffer;
+}
+declare class MulterToUploadPipe implements PipeTransform {
+    transform(value: FileStream, metadata: ArgumentMetadata): {
+        filename: string;
+        mimetype: string;
+        encoding: string;
+        createReadStream: () => Readable;
+    } | {
+        filename: string;
+        mimetype: string;
+        encoding: string;
+        createReadStream: () => Readable;
+    }[];
+}
+declare const getQueryPipes: (modelRef: Type, arrDepth: number) => Type[];
+declare const getBodyPipes: (argMeta: ArgMeta) => {
+    new (): {
+        transform(value: any, metadata: ArgumentMetadata): object[] | null;
+    };
+}[];
+
+export { ArrayifyPipe, BooleanPipe, DayjsPipe, FloatPipe, IntPipe, JSONPipe, MulterToUploadPipe, getBodyPipes, getQueryPipes };

package/src/pipes.js

@@ -0,0 +1,195 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pipes_exports = {};
+__export(pipes_exports, {
+  ArrayifyPipe: () => ArrayifyPipe,
+  BooleanPipe: () => BooleanPipe,
+  DayjsPipe: () => DayjsPipe,
+  FloatPipe: () => FloatPipe,
+  IntPipe: () => IntPipe,
+  JSONPipe: () => JSONPipe,
+  MulterToUploadPipe: () => MulterToUploadPipe,
+  getBodyPipes: () => getBodyPipes,
+  getQueryPipes: () => getQueryPipes
+});
+module.exports = __toCommonJS(pipes_exports);
+var import_base = require("@akanjs/base");
+var import_signal = require("@akanjs/signal");
+var import_common = require("@nestjs/common");
+var import_stream = require("stream");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+class ArrayifyPipe {
+  static {
+    __name(this, "ArrayifyPipe");
+  }
+  transform(value, metadata) {
+    return Array.isArray(value) ? value : value.split(",");
+  }
+}
+ArrayifyPipe = _ts_decorate([
+  (0, import_common.Injectable)()
+], ArrayifyPipe);
+class IntPipe {
+  static {
+    __name(this, "IntPipe");
+  }
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(parseInt) : [
+      parseInt(value)
+    ];
+  }
+}
+IntPipe = _ts_decorate([
+  (0, import_common.Injectable)()
+], IntPipe);
+class FloatPipe {
+  static {
+    __name(this, "FloatPipe");
+  }
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(parseFloat) : [
+      parseFloat(value)
+    ];
+  }
+}
+FloatPipe = _ts_decorate([
+  (0, import_common.Injectable)()
+], FloatPipe);
+class BooleanPipe {
+  static {
+    __name(this, "BooleanPipe");
+  }
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map((v) => Boolean(v)) : [
+      Boolean(value)
+    ];
+  }
+}
+BooleanPipe = _ts_decorate([
+  (0, import_common.Injectable)()
+], BooleanPipe);
+class DayjsPipe {
+  static {
+    __name(this, "DayjsPipe");
+  }
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(import_base.dayjs) : [
+      (0, import_base.dayjs)(value)
+    ];
+  }
+}
+DayjsPipe = _ts_decorate([
+  (0, import_common.Injectable)()
+], DayjsPipe);
+class JSONPipe {
+  static {
+    __name(this, "JSONPipe");
+  }
+  transform(value, metadata) {
+    const transformable = typeof value === "string" && value.length;
+    const obj = transformable ? JSON.parse(atob(value)) : value;
+    return obj;
+  }
+}
+JSONPipe = _ts_decorate([
+  (0, import_common.Injectable)()
+], JSONPipe);
+const convertToFileStream = /* @__PURE__ */ __name((value) => ({
+  filename: value.originalname,
+  mimetype: value.mimetype,
+  encoding: value.encoding,
+  createReadStream: /* @__PURE__ */ __name(() => import_stream.Readable.from(value.buffer), "createReadStream")
+}), "convertToFileStream");
+class MulterToUploadPipe {
+  static {
+    __name(this, "MulterToUploadPipe");
+  }
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(convertToFileStream) : convertToFileStream(value);
+  }
+}
+MulterToUploadPipe = _ts_decorate([
+  (0, import_common.Injectable)()
+], MulterToUploadPipe);
+const gqlScalarPipeMap = /* @__PURE__ */ new Map([
+  [
+    import_base.Int,
+    IntPipe
+  ],
+  [
+    import_base.Float,
+    FloatPipe
+  ],
+  [
+    Boolean,
+    BooleanPipe
+  ],
+  [
+    Date,
+    DayjsPipe
+  ],
+  [
+    import_base.JSON,
+    JSONPipe
+  ]
+]);
+const getQueryPipes = /* @__PURE__ */ __name((modelRef, arrDepth) => {
+  const pipes = arrDepth ? [
+    ArrayifyPipe
+  ] : [];
+  const scalarPipe = gqlScalarPipeMap.get(modelRef);
+  if (scalarPipe) pipes.push(scalarPipe);
+  return pipes;
+}, "getQueryPipes");
+const getBodyPipes = /* @__PURE__ */ __name((argMeta) => {
+  const [returnRef] = (0, import_base.getNonArrayModel)(argMeta.returns());
+  if (returnRef.prototype !== Date.prototype && !(0, import_base.isGqlScalar)(returnRef)) return [];
+  let BodyPipe = class BodyPipe {
+    static {
+      __name(this, "BodyPipe");
+    }
+    transform(value, metadata) {
+      return (0, import_signal.deserializeArg)(argMeta, value);
+    }
+  };
+  BodyPipe = _ts_decorate([
+    (0, import_common.Injectable)()
+  ], BodyPipe);
+  return [
+    BodyPipe
+  ];
+}, "getBodyPipes");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayifyPipe,
+  BooleanPipe,
+  DayjsPipe,
+  FloatPipe,
+  IntPipe,
+  JSONPipe,
+  MulterToUploadPipe,
+  getBodyPipes,
+  getQueryPipes
+});

package/src/redis-io.adapter.d.ts

@@ -0,0 +1,21 @@
+import { INestApplicationContext } from '@nestjs/common';
+import { IoAdapter } from '@nestjs/platform-socket.io';
+import { ServerOptions } from 'socket.io';
+
+interface RedisIoAdapterOption extends Partial<ServerOptions> {
+    jwtSecret: string;
+}
+declare class RedisIoAdapter extends IoAdapter {
+    private adapterConstructor;
+    private readonly logger;
+    private server;
+    private pubClient;
+    private subClient;
+    option: RedisIoAdapterOption;
+    constructor(appOrHttpServer: INestApplicationContext, option: RedisIoAdapterOption);
+    connectToRedis(url: string): Promise<void>;
+    createIOServer(port: number, options?: ServerOptions): any;
+    destroy(): Promise<void>;
+}
+
+export { RedisIoAdapter };