nesties 1.1.14 → 1.1.16

package/dist/index.mjs

@@ -24,6 +24,22 @@ function getClassFromClassOrArray(o) {
   return o instanceof Array ? o[0] : o;
 }
 
+// src/utility/get-api-property.ts
+import { DECORATORS } from "@nestjs/swagger/dist/constants";
+var getApiProperty = (cls, key) => {
+  let proto = cls.prototype;
+  while (proto && proto !== Object.prototype) {
+    const meta = Reflect.getMetadata(
+      DECORATORS.API_MODEL_PROPERTIES,
+      proto,
+      key
+    );
+    if (meta) return meta;
+    proto = Object.getPrototypeOf(proto);
+  }
+  return {};
+};
+
 // src/insert-field.ts
 function InsertField(cl, map, newName) {
   const extendedCl = class extends cl {
@@ -209,18 +225,35 @@ var DataBody = createDataPipeDec(Body);
 
 // src/token.guard.ts
 import {
-  Inject,
-  Injectable,
+  Inject as Inject2,
+  Injectable as Injectable2,
   UseGuards
 } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { ApiHeader as ApiHeader2 } from "@nestjs/swagger";
 
 // src/resolver.ts
+import {
+  createParamDecorator,
+  Inject,
+  Injectable,
+  Scope
+} from "@nestjs/common";
+import { ModuleRef, REQUEST } from "@nestjs/core";
 import {
   ApiHeader,
   ApiQuery
 } from "@nestjs/swagger";
+
+// src/create-provider.ts
+var createProvider = (options, factory) => {
+  return {
+    useFactory: factory,
+    ...options
+  };
+};
+
+// src/resolver.ts
 var coerceToString = (v) => {
   if (v == null) return void 0;
   if (v === false) return void 0;
@@ -265,45 +298,161 @@ function getQueryValue(req, key) {
   }
   return void 0;
 }
-var createResolver = (_options) => {
-  if (typeof _options === "function") {
-    return _options;
-  }
-  const options = _options;
-  const field = options.paramType;
-  let name = options.paramName;
-  if (field === "header") name = name.toLowerCase();
-  return (ctx) => {
-    const req = ctx.switchToHttp().getRequest();
-    if (field === "header") {
-      let raw = getHeader(req, name);
-      if (name === "accept-language") raw = pickPrimaryFromAcceptLanguage(raw);
-      return raw;
-    }
-    if (field === "query") {
-      return getQueryValue(req, name);
+var ParamResolverPipe = class {
+  constructor(moduleRef) {
+    this.moduleRef = moduleRef;
+  }
+  async transform(params, metadata) {
+    return params.resolver.resolve(params.req, this.moduleRef);
+  }
+};
+ParamResolverPipe = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(ModuleRef))
+], ParamResolverPipe);
+var usedParamResolverTokens = /* @__PURE__ */ new Set();
+var ParamResolverBase = class {
+  toResolverFunction() {
+    return async (req, ref) => this.resolve(req, ref);
+  }
+  toParamDecorator() {
+    const dec = createParamDecorator((_, ctx) => {
+      const req = ctx.switchToHttp().getRequest();
+      return { req, resolver: this };
+    });
+    return (...pipes) => dec(ParamResolverPipe, ...pipes);
+  }
+  // for override
+  toString() {
+    return "ParamResolverBase";
+  }
+  toRequestScopedProvider() {
+    const token = `PARAM_RESOLVER_${this.toString()}`;
+    let useToken = token;
+    if (usedParamResolverTokens.has(token)) {
+      let suffix = 0;
+      const tryToken = `${token}__${suffix}`;
+      while (usedParamResolverTokens.has(tryToken)) {
+        suffix++;
+      }
+      useToken = tryToken;
     }
-    throw new Error(`Unsupported paramType: ${field}`);
-  };
+    const provider = createProvider(
+      {
+        provide: useToken,
+        inject: [REQUEST, ModuleRef],
+        scope: Scope.REQUEST
+      },
+      this.toResolverFunction()
+    );
+    return {
+      token: useToken,
+      provider,
+      inject: () => Inject(useToken)
+    };
+  }
 };
-var ApiFromResolver = (_options, extras = {}) => {
-  if (typeof _options === "function") {
-    return () => {
+var ParamResolver = class extends ParamResolverBase {
+  constructor(input) {
+    super();
+    if (typeof input === "function") {
+      this.dynamic = input;
+    } else {
+      this.info = { ...input };
+      if (this.info.paramType === "header") {
+        this.info.paramName = this.info.paramName.toLowerCase();
+      }
+    }
+  }
+  resolve(req, ref) {
+    if (this.info) {
+      if (this.info.paramType === "header") {
+        const name = this.info.paramName;
+        let raw = getHeader(req, name);
+        if (name === "accept-language")
+          raw = pickPrimaryFromAcceptLanguage(raw);
+        return raw;
+      }
+      if (this.info.paramType === "query") {
+        return getQueryValue(req, this.info.paramName);
+      }
+      throw new Error(`Unsupported paramType: ${this.info.paramType}`);
+    } else if (this.dynamic) {
+      return this.dynamic(req, ref);
+    }
+  }
+  toString() {
+    const suffix = this.info ? `${this.info.paramType.toUpperCase()}_${this.info.paramName}` : `DYNAMIC`;
+    return `ParamResolver_${suffix}`;
+  }
+  toApiPropertyDecorator(extras = {}) {
+    return (extras2 = {}) => {
+      if (this.info) {
+        const paramType = this.info.paramType;
+        const apiOptions = {
+          name: this.info.paramName,
+          ...extras,
+          ...extras2
+        };
+        return paramType === "header" ? ApiHeader(apiOptions) : paramType === "query" ? ApiQuery({ type: "string", ...apiOptions }) : () => {
+        };
+      }
+      return () => {
+      };
     };
   }
-  const options = _options;
-  const paramType = options?.paramType;
-  const apiOptions = {
-    name: options.paramName,
-    ...extras
-  };
-  return paramType === "header" ? ApiHeader(apiOptions) : paramType === "query" ? ApiQuery({ type: "string", ...apiOptions }) : () => {
-  };
+};
+var CombinedParamResolver = class extends ParamResolverBase {
+  constructor(resolvers) {
+    super();
+    this.resolvers = resolvers;
+  }
+  async resolve(req, ref) {
+    const result = {};
+    await Promise.all(
+      Object.entries(this.resolvers).map(async ([key, resolver]) => {
+        result[key] = await resolver.resolve(
+          req,
+          ref
+        );
+      })
+    );
+    return result;
+  }
+  toString() {
+    const suffix = Object.entries(this.resolvers).map(([key, resolver]) => `${key.toString()}_${resolver.toString()}`).join("__");
+    return `CombinedParamResolver_${suffix}`;
+  }
+  toApiPropertyDecorator(extras = {}) {
+    const decs = Object.values(this.resolvers).map(
+      (resolver) => resolver.toApiPropertyDecorator(extras)
+    );
+    return (extras2) => MergeClassOrMethodDecorators(
+      decs.map(
+        (dec) => dec({
+          ...extras,
+          ...extras2
+        })
+      )
+    );
+  }
+};
+var getParamResolver = (input) => {
+  if (input instanceof ParamResolverBase) {
+    return input;
+  }
+  return new ParamResolver(input);
+};
+var createResolver = (_options) => {
+  return getParamResolver(_options).toResolverFunction();
+};
+var ApiFromResolver = (_options, extras = {}) => {
+  return getParamResolver(_options).toApiPropertyDecorator(extras)();
 };
 
 // src/token.guard.ts
 import { MetadataSetter, Reflector } from "typed-reflector";
-import { ModuleRef } from "@nestjs/core";
+import { ModuleRef as ModuleRef2 } from "@nestjs/core";
 var reflector = new Reflector();
 var Metadata = new MetadataSetter();
 var defaultHeaderName = "x-server-token";
@@ -329,9 +478,10 @@ var TokenGuard = class {
       config.resolver || { paramType: "header", paramName: defaultHeaderName }
     );
     const tokenSource = config.tokenSource || defaultConfigName;
+    const req = context.switchToHttp().getRequest();
     const [tokenFromClient, tokenFromConfig] = await Promise.all([
-      resolver(context, this.moduleRef),
-      typeof tokenSource === "function" ? tokenSource(context, this.moduleRef) : this.config.get(tokenSource)
+      resolver(req, this.moduleRef),
+      typeof tokenSource === "function" ? tokenSource(req, this.moduleRef) : this.config.get(tokenSource)
     ]);
     if (tokenFromConfig && tokenFromConfig !== tokenFromClient) {
       throw new BlankReturnMessageDto(
@@ -343,9 +493,9 @@ var TokenGuard = class {
   }
 };
 TokenGuard = __decorateClass([
-  Injectable(),
-  __decorateParam(0, Inject(ConfigService)),
-  __decorateParam(1, Inject(ModuleRef))
+  Injectable2(),
+  __decorateParam(0, Inject2(ConfigService)),
+  __decorateParam(1, Inject2(ModuleRef2))
 ], TokenGuard);
 var RequireToken = (options = {}) => {
   const swaggerDec = options.resolver ? ApiFromResolver(options.resolver, {
@@ -369,7 +519,7 @@ var RequireToken = (options = {}) => {
 
 // src/abort-utils.ts
 import { Observable, takeUntil } from "rxjs";
-import { createParamDecorator } from "@nestjs/common";
+import { createParamDecorator as createParamDecorator2 } from "@nestjs/common";
 
 // src/utility/abort-http-signal.ts
 function toRawReq(req) {
@@ -435,7 +585,7 @@ var takeUntilAbort = (signal) => {
     );
   };
 };
-var As = createParamDecorator(
+var As = createParamDecorator2(
   (_data, ctx) => {
     const req = ctx.switchToHttp().getRequest();
     return createAbortSignalFromHttp(req);
@@ -443,37 +593,27 @@ var As = createParamDecorator(
 );
 
 // src/abortable-module/abortable.token.ts
-import { Inject as Inject3, Scope as Scope2 } from "@nestjs/common";
+import { Inject as Inject4, Scope as Scope3 } from "@nestjs/common";
 import { abortable } from "nfkit";
 
 // src/abortable-module/abort-signal.provider.ts
-import { Inject as Inject2, Scope } from "@nestjs/common";
-import { REQUEST } from "@nestjs/core";
-
-// src/create-provider.ts
-var createProvider = (options, factory) => {
-  return {
-    useFactory: factory,
-    ...options
-  };
-};
-
-// src/abortable-module/abort-signal.provider.ts
+import { Inject as Inject3, Scope as Scope2 } from "@nestjs/common";
+import { REQUEST as REQUEST2 } from "@nestjs/core";
 var ABORT_SIGNAL = Symbol(
   "ABORT_SIGNAL"
 );
 var AbortSignalProvider = createProvider(
   {
     provide: ABORT_SIGNAL,
-    scope: Scope.REQUEST,
-    inject: [REQUEST]
+    scope: Scope2.REQUEST,
+    inject: [REQUEST2]
   },
   createAbortSignalFromHttp
 );
-var InjectAbortSignal = () => Inject2(ABORT_SIGNAL);
+var InjectAbortSignal = () => Inject3(ABORT_SIGNAL);
 
 // src/abortable-module/abortable.token.ts
-import { ContextIdFactory, ModuleRef as ModuleRef2, REQUEST as REQUEST2 } from "@nestjs/core";
+import { ContextIdFactory, ModuleRef as ModuleRef3, REQUEST as REQUEST3 } from "@nestjs/core";
 var tokenMemo = /* @__PURE__ */ new Map();
 var abortableToken = (token) => {
   if (tokenMemo.has(token)) return tokenMemo.get(token);
@@ -494,7 +634,7 @@ function InjectAbortable(token) {
         );
       }
     }
-    Inject3(abortableToken(actualToken))(target, propertyKey, parameterIndex);
+    Inject4(abortableToken(actualToken))(target, propertyKey, parameterIndex);
   };
 }
 function createAbortableProvider(token, opts) {
@@ -502,8 +642,8 @@ function createAbortableProvider(token, opts) {
   return createProvider(
     {
       provide,
-      scope: Scope2.REQUEST,
-      inject: [ModuleRef2, REQUEST2, ABORT_SIGNAL]
+      scope: Scope3.REQUEST,
+      inject: [ModuleRef3, REQUEST3, ABORT_SIGNAL]
     },
     async (moduleRef, req, signal) => {
       const ctxId = ContextIdFactory.getByRequest(req);
@@ -550,8 +690,8 @@ AbortableModule = __decorateClass([
 import {
   ConsoleLogger,
   HttpException as HttpException2,
-  Inject as Inject4,
-  Injectable as Injectable2
+  Inject as Inject5,
+  Injectable as Injectable3
 } from "@nestjs/common";
 
 // src/i18n-module/i18n-token.ts
@@ -560,7 +700,7 @@ var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new ConfigurableModuleBu
 var I18nModuleOptionsToken = MODULE_OPTIONS_TOKEN;
 
 // src/i18n-module/i18n.service.ts
-import { ModuleRef as ModuleRef3 } from "@nestjs/core";
+import { ModuleRef as ModuleRef4 } from "@nestjs/core";
 import { I18n } from "nfkit";
 var I18nService = class extends I18n {
   constructor(i18nServiceOptions, moduleRef) {
@@ -595,18 +735,20 @@ var I18nService = class extends I18n {
     return this;
   }
   async getExactLocaleFromRequest(ctx) {
-    const locale = await this.resolver(ctx, this.moduleRef);
+    const req = ctx.switchToHttp().getRequest();
+    const locale = await this.resolver(req, this.moduleRef);
     return this.getExactLocale(locale);
   }
   async translateRequest(ctx, obj) {
-    const locale = await this.resolver(ctx, this.moduleRef);
+    const req = ctx.switchToHttp().getRequest();
+    const locale = await this.resolver(req, this.moduleRef);
     return this.translate(locale, obj, ctx);
   }
 };
 I18nService = __decorateClass([
-  Injectable2(),
-  __decorateParam(0, Inject4(I18nModuleOptionsToken)),
-  __decorateParam(1, Inject4(ModuleRef3))
+  Injectable3(),
+  __decorateParam(0, Inject5(I18nModuleOptionsToken)),
+  __decorateParam(1, Inject5(ModuleRef4))
 ], I18nService);
 
 // src/i18n-module/i18n.module.ts
@@ -614,11 +756,11 @@ import { Global, Module as Module2 } from "@nestjs/common";
 
 // src/i18n-module/locale.pipe.ts
 import {
-  createParamDecorator as createParamDecorator2,
-  Inject as Inject5,
-  Injectable as Injectable3
+  createParamDecorator as createParamDecorator3,
+  Inject as Inject6,
+  Injectable as Injectable4
 } from "@nestjs/common";
-import { ModuleRef as ModuleRef4 } from "@nestjs/core";
+import { ModuleRef as ModuleRef5 } from "@nestjs/core";
 var LocalePipe = class {
   constructor(i18nService, moduleRef) {
     this.i18nService = i18nService;
@@ -628,7 +770,8 @@ var LocalePipe = class {
     const resolver = ctx.resolver;
     if (resolver) {
       const _resolver = createResolver(resolver);
-      const locale = await _resolver(ctx.ctx, this.moduleRef);
+      const req = ctx.ctx.switchToHttp().getRequest();
+      const locale = await _resolver(req, this.moduleRef);
       return this.i18nService.getExactLocale(locale);
     } else {
       return this.i18nService.getExactLocaleFromRequest(ctx.ctx);
@@ -636,13 +779,15 @@ var LocalePipe = class {
   }
 };
 LocalePipe = __decorateClass([
-  Injectable3(),
-  __decorateParam(0, Inject5(I18nService)),
-  __decorateParam(1, Inject5(ModuleRef4))
+  Injectable4(),
+  __decorateParam(0, Inject6(I18nService)),
+  __decorateParam(1, Inject6(ModuleRef5))
 ], LocalePipe);
-var _dec = createParamDecorator2((resolver, ctx) => {
-  return { ctx, resolver };
-});
+var _dec = createParamDecorator3(
+  (resolver, ctx) => {
+    return { ctx, resolver };
+  }
+);
 var PutLocale = (resolver) => _dec(resolver, LocalePipe);
 
 // src/i18n-module/i18n.module.ts
@@ -662,8 +807,8 @@ import { UseInterceptors } from "@nestjs/common";
 // src/i18n-module/i18n.interceptor.ts
 import {
   HttpException as HttpException3,
-  Inject as Inject6,
-  Injectable as Injectable4
+  Inject as Inject7,
+  Injectable as Injectable5
 } from "@nestjs/common";
 import { from, throwError } from "rxjs";
 import { catchError, mergeMap } from "rxjs/operators";
@@ -694,8 +839,8 @@ var I18nInterceptor = class {
   }
 };
 I18nInterceptor = __decorateClass([
-  Injectable4(),
-  __decorateParam(0, Inject6(I18nService))
+  Injectable5(),
+  __decorateParam(0, Inject7(I18nService))
 ], I18nInterceptor);
 
 // src/i18n-module/i18n-decorator.ts
@@ -740,6 +885,7 @@ export {
   As,
   BlankPaginatedReturnMessageDto,
   BlankReturnMessageDto,
+  CombinedParamResolver,
   DataBody,
   DataPipe,
   DataQuery,
@@ -759,6 +905,9 @@ export {
   MergeParameterDecorators,
   MergePropertyDecorators,
   PaginatedReturnMessageDto,
+  ParamResolver,
+  ParamResolverBase,
+  ParamResolverPipe,
   PutLocale,
   RenameClass,
   RequireToken,
@@ -772,7 +921,9 @@ export {
   createProvider,
   createResolver,
   fromAbortable,
+  getApiProperty,
   getClassFromClassOrArray,
+  getParamResolver,
   takeUntilAbort
 };
 //# sourceMappingURL=index.mjs.map