nesties 1.1.23 → 1.1.25

package/dist/index.cjs

@@ -35,6 +35,7 @@ __export(index_exports, {
   ApiError: () => ApiError,
   ApiErrorTyped: () => ApiErrorTyped,
   ApiFromResolver: () => ApiFromResolver,
+  ApiInject: () => ApiInject,
   ApiTypeResponse: () => ApiTypeResponse,
   As: () => As,
   BlankPaginatedReturnMessageDto: () => BlankPaginatedReturnMessageDto,
@@ -43,6 +44,7 @@ __export(index_exports, {
   DataBody: () => DataBody,
   DataPipe: () => DataPipe,
   DataQuery: () => DataQuery,
+  DefaultValueParamResolver: () => DefaultValueParamResolver,
   GenericPaginatedReturnMessageDto: () => GenericPaginatedReturnMessageDto,
   GenericReturnMessageDto: () => GenericReturnMessageDto,
   I18nInterceptor: () => I18nInterceptor,
@@ -62,6 +64,11 @@ __export(index_exports, {
   ParamResolver: () => ParamResolver,
   ParamResolverBase: () => ParamResolverBase,
   ParamResolverPipe: () => ParamResolverPipe,
+  ParseBase64ParamResolver: () => ParseBase64ParamResolver,
+  ParseBoolParamResolver: () => ParseBoolParamResolver,
+  ParseDateParamResolver: () => ParseDateParamResolver,
+  ParseFloatParamResolver: () => ParseFloatParamResolver,
+  ParseIntParamResolver: () => ParseIntParamResolver,
   PutLocale: () => PutLocale,
   RenameClass: () => RenameClass,
   RequireToken: () => RequireToken,
@@ -73,6 +80,7 @@ __export(index_exports, {
   createAbortableProvider: () => createAbortableProvider,
   createI18n: () => createI18n,
   createI18nDecorator: () => createI18nDecorator,
+  createLambdaParamResolver: () => createLambdaParamResolver,
   createMutateInject: () => createMutateInject,
   createProvider: () => createProvider,
   createResolver: () => createResolver,
@@ -80,6 +88,7 @@ __export(index_exports, {
   getApiProperty: () => getApiProperty,
   getClassFromClassOrArray: () => getClassFromClassOrArray,
   getParamResolver: () => getParamResolver,
+  parseBool: () => parseBool,
   takeUntilAbort: () => takeUntilAbort
 });
 module.exports = __toCommonJS(index_exports);
@@ -141,6 +150,18 @@ var createMutateInject = (tokenResolver) => (token) => (target, propertyKey, par
   );
 };
 
+// src/utility/parse-bool.ts
+var parseBool = (value) => {
+  const trueValues = ["true", "1", "yes", "on", true, 1];
+  const falseValues = ["false", "0", "no", "off", false, 0];
+  if (trueValues.indexOf(value) !== -1) return true;
+  if (falseValues.indexOf(value) !== -1) return false;
+  if (!!value) {
+    return true;
+  }
+  return void 0;
+};
+
 // src/insert-field.ts
 function InsertField(cl, map, newName) {
   const extendedCl = class extends cl {
@@ -325,7 +346,7 @@ var import_common5 = require("@nestjs/common");
 var import_config = require("@nestjs/config");
 var import_swagger5 = require("@nestjs/swagger");
 
-// src/resolver.ts
+// src/resolver/resolver.ts
 var import_common4 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 var import_swagger4 = require("@nestjs/swagger");
@@ -361,7 +382,42 @@ var uniqBy = (arr, fn) => {
   return result;
 };
 
-// src/resolver.ts
+// src/metadata.ts
+var import_typed_reflector = require("typed-reflector");
+var reflector = new import_typed_reflector.Reflector();
+var Metadata = new import_typed_reflector.MetadataSetter();
+
+// src/utility/apply-decorator-unique.ts
+var ApplyDecoratorUnique = (dec, identifier) => ((...args) => {
+  const isClassRelated = args.length === 1 || args[1] === void 0;
+  const target = args[0];
+  const cls = typeof target === "function" ? target : target.constructor;
+  if (isClassRelated) {
+    const used = reflector.getArray("usedUniqueDecoratorIdentifiers", cls);
+    if (used.includes(identifier)) {
+      return;
+    }
+    Metadata.appendUnique("usedUniqueDecoratorIdentifiers", identifier)(cls);
+    return dec(...args);
+  } else {
+    const keyName = args[1];
+    const used = reflector.getProperty(
+      "usedUniqueDecoratorIdentifiers",
+      cls,
+      keyName
+    );
+    if (used.includes(identifier)) {
+      return;
+    }
+    Metadata.appendUnique("usedUniqueDecoratorIdentifiers", identifier)(
+      cls,
+      keyName
+    );
+    return dec(...args);
+  }
+});
+
+// src/resolver/resolver.ts
 var ParamResolverCopiedFieldsFromSwagger = [
   "required",
   "description",
@@ -443,7 +499,12 @@ var ParamResolverBase = class {
   toApiPropertyDecorator(extras = {}) {
     const swaggerInfo = uniqBy(this.toSwaggerInfo(), (info) => info.token);
     return (extras2 = {}) => MergeClassOrMethodDecorators(
-      swaggerInfo.map((info) => info.swagger({ ...extras, ...extras2 }))
+      swaggerInfo.map(
+        (info) => ApplyDecoratorUnique(
+          info.swagger({ ...extras, ...extras2 }),
+          info.token
+        )
+      )
     );
   }
   toResolverFunction() {
@@ -624,11 +685,133 @@ var ApiFromResolver = (_options, extras = {}) => {
   return getParamResolver(_options).toApiPropertyDecorator(extras)();
 };
 
+// src/resolver/lambda.ts
+var createLambdaParamResolver = (cb) => (resolver) => new TransformParamResolver(resolver, cb);
+var ParseIntParamResolver = createLambdaParamResolver((s) => {
+  if (s == null) {
+    return s;
+  }
+  const res = parseInt(s, 10);
+  if (isNaN(res)) {
+    throw new BlankReturnMessageDto(
+      400,
+      "Invalid integer parameter"
+    ).toException();
+  }
+  return res;
+});
+var ParseFloatParamResolver = createLambdaParamResolver(
+  (s) => {
+    if (s == null) {
+      return s;
+    }
+    const res = parseFloat(s);
+    if (isNaN(res)) {
+      throw new BlankReturnMessageDto(
+        400,
+        "Invalid float parameter"
+      ).toException();
+    }
+    return res;
+  }
+);
+var ParseBoolParamResolver = createLambdaParamResolver(parseBool);
+var ParseDateParamResolver = createLambdaParamResolver(
+  (s) => {
+    if (s == null) {
+      return s;
+    }
+    const res = new Date(s);
+    if (isNaN(res.getTime())) {
+      throw new BlankReturnMessageDto(
+        400,
+        "Invalid date parameter"
+      ).toException();
+    }
+    return res;
+  }
+);
+var ParseBase64ParamResolver = createLambdaParamResolver(
+  (s) => {
+    if (s == null) {
+      return s;
+    }
+    const normalized = s.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(padded)) {
+      throw new BlankReturnMessageDto(
+        400,
+        "Invalid base64 parameter"
+      ).toException();
+    }
+    const buf = Buffer.from(padded, "base64");
+    const re = buf.toString("base64").replace(/=+$/g, "");
+    const in0 = padded.replace(/=+$/g, "");
+    if (re !== in0) {
+      throw new BlankReturnMessageDto(
+        400,
+        "Invalid base64 parameter"
+      ).toException();
+    }
+    return buf;
+  }
+);
+var DefaultValueParamResolver = (r, defaultValue) => createLambdaParamResolver(
+  (value) => value === void 0 || value === null ? defaultValue : value
+)(r);
+
+// src/utility/collect-info-from-injection-token.ts
+var import_constants2 = require("@nestjs/common/constants");
+function asArray(v) {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+function getCtorDepsFromClass(cls) {
+  const paramTypes = Reflect.getMetadata(import_constants2.PARAMTYPES_METADATA, cls) ?? [];
+  const selfDeclared = Reflect.getMetadata(import_constants2.SELF_DECLARED_DEPS_METADATA, cls) ?? [];
+  const overrides = new Map(
+    selfDeclared.map((d) => [d.index, d.param])
+  );
+  return paramTypes.map((t, i) => overrides.get(i) ?? t).filter((t) => t != null && t !== Object);
+}
+var collectInfoFromInjectionToken = (map, token) => {
+  const visited = /* @__PURE__ */ new Set();
+  const out = /* @__PURE__ */ new Set();
+  const dfs = (t) => {
+    if (t == null) return;
+    if (visited.has(t)) return;
+    visited.add(t);
+    for (const v of asArray(map.get(t))) {
+      out.add(v);
+    }
+    const deps = InjectionTokenMap.get(t);
+    if (deps?.length) {
+      for (const d of deps) dfs(d);
+    }
+    if (typeof t === "function") {
+      const ctorDeps = getCtorDepsFromClass(t);
+      for (const d of ctorDeps) dfs(d);
+    }
+  };
+  dfs(token);
+  return Array.from(out);
+};
+var createCollectorFromInjectionToken = (map) => (token) => collectInfoFromInjectionToken(map, token);
+
+// src/utility/swagger-injection-collector.ts
+var swaggerInjectionCollector = createCollectorFromInjectionToken(ResolverSwaggerMap);
+
+// src/resolver/api-inject.ts
+var ApiInject = createMutateInject((token, cls) => {
+  const swaggers = swaggerInjectionCollector(token);
+  for (const swagger of swaggers) {
+    ApplyDecoratorUnique(swagger.swagger(), swagger.token)(cls);
+  }
+  return token;
+});
+
 // src/token.guard.ts
-var import_typed_reflector = require("typed-reflector");
 var import_core2 = require("@nestjs/core");
-var reflector = new import_typed_reflector.Reflector();
-var Metadata = new import_typed_reflector.MetadataSetter();
 var defaultHeaderName = "x-server-token";
 var defaultConfigName = "SERVER_TOKEN";
 var defaultErrorCode = 401;
@@ -857,14 +1040,20 @@ var I18nModuleOptionsToken = MODULE_OPTIONS_TOKEN;
 // src/i18n-module/i18n.service.ts
 var import_core5 = require("@nestjs/core");
 var import_nfkit2 = require("nfkit");
+
+// src/i18n-module/i18n-param-resolver.token.ts
+var I18nParamResolverToken = "I18N_PARAM_RESOLVER";
+var I18nParamResolverProviderToken = "I18N_PARAM_RESOLVER_PROVIDER";
+
+// src/i18n-module/i18n.service.ts
 var I18nService = class extends import_nfkit2.I18n {
-  constructor(i18nServiceOptions, moduleRef) {
+  constructor(i18nServiceOptions, moduleRef, resolver) {
     super(i18nServiceOptions);
     this.i18nServiceOptions = i18nServiceOptions;
     this.moduleRef = moduleRef;
+    this.resolver = resolver;
     this._shadowMiddlewareMap = /* @__PURE__ */ new Map();
     this.logger = new import_common11.ConsoleLogger("I18nService");
-    this.resolver = createResolver(this.i18nServiceOptions.resolver);
   }
   middleware(mw, prior = false) {
     const wrappedMw = async (locale, text, next, ctx) => {
@@ -891,19 +1080,20 @@ var I18nService = class extends import_nfkit2.I18n {
   }
   async getExactLocaleFromRequest(ctx) {
     const req = ctx.switchToHttp().getRequest();
-    const locale = await this.resolver(req, this.moduleRef);
+    const locale = await this.resolver.resolve(req, this.moduleRef);
     return this.getExactLocale(locale);
   }
   async translateRequest(ctx, obj) {
     const req = ctx.switchToHttp().getRequest();
-    const locale = await this.resolver(req, this.moduleRef);
+    const locale = await this.resolver.resolve(req, this.moduleRef);
     return this.translate(locale, obj, ctx);
   }
 };
 I18nService = __decorateClass([
   (0, import_common11.Injectable)(),
   __decorateParam(0, (0, import_common11.Inject)(I18nModuleOptionsToken)),
-  __decorateParam(1, (0, import_common11.Inject)(import_core5.ModuleRef))
+  __decorateParam(1, (0, import_common11.Inject)(import_core5.ModuleRef)),
+  __decorateParam(2, (0, import_common11.Inject)(I18nParamResolverToken))
 ], I18nService);
 
 // src/i18n-module/i18n.module.ts
@@ -942,12 +1132,26 @@ var _dec = (0, import_common12.createParamDecorator)(
 var PutLocale = (resolver) => _dec(resolver, LocalePipe);
 
 // src/i18n-module/i18n.module.ts
+var providerFromOptions = createProvider(
+  {
+    provide: I18nParamResolverToken,
+    inject: [I18nModuleOptionsToken]
+  },
+  (options) => getParamResolver(
+    options.resolver || {
+      paramType: "header",
+      paramName: "x-client-language"
+    }
+  )
+);
 var I18nModule = class extends ConfigurableModuleClass {
+  static forRoot(options) {
+  }
 };
 I18nModule = __decorateClass([
   (0, import_common13.Global)(),
   (0, import_common13.Module)({
-    providers: [I18nService, LocalePipe],
+    providers: [I18nService, LocalePipe, providerFromOptions],
     exports: [I18nService, LocalePipe]
   })
 ], I18nModule);
@@ -1003,6 +1207,24 @@ var createI18nDecorator = (options) => {
   ]);
 };
 
+// src/i18n-module/locale.context.ts
+var import_common16 = require("@nestjs/common");
+var LocaleContext = class {
+  constructor(localeInput, i18nService) {
+    this.localeInput = localeInput;
+    this.i18nService = i18nService;
+    this.locale = this.i18nService.getExactLocale(this.localeInput);
+  }
+  translate(v) {
+    return this.i18nService.translate(this.locale, v);
+  }
+};
+LocaleContext = __decorateClass([
+  (0, import_common16.Injectable)({ scope: import_common16.Scope.REQUEST }),
+  __decorateParam(0, (0, import_common16.Inject)(I18nParamResolverProviderToken)),
+  __decorateParam(1, (0, import_common16.Inject)(I18nService))
+], LocaleContext);
+
 // src/i18n-module/i18n-factory.ts
 var createI18n = (options) => {
   if (!options.resolver) {
@@ -1011,9 +1233,29 @@ var createI18n = (options) => {
       paramName: "x-client-language"
     };
   }
+  const resolver = getParamResolver(options.resolver);
+  const paramProvider = resolver.toRequestScopedProvider();
+  const module2 = I18nModule.register(options);
+  module2.providers ??= [];
+  module2.exports ??= [];
+  module2.providers.push(
+    paramProvider.provider,
+    LocaleContext,
+    // re-exports the resolved param value for LocaleContext injection
+    createProvider(
+      {
+        provide: I18nParamResolverProviderToken,
+        inject: [paramProvider.token]
+      },
+      (s) => s
+    )
+  );
+  module2.exports.push(paramProvider.provider, LocaleContext);
   return {
     UseI18n: createI18nDecorator(options),
-    I18nModule: I18nModule.register(options)
+    I18nModule: module2,
+    I18nParamResolver: resolver,
+    I18nParamResolverProvider: paramProvider
   };
 };
 
@@ -1029,6 +1271,7 @@ var I18nLookupMiddleware = (0, import_nfkit3.createI18nLookupMiddleware)();
   ApiError,
   ApiErrorTyped,
   ApiFromResolver,
+  ApiInject,
   ApiTypeResponse,
   As,
   BlankPaginatedReturnMessageDto,
@@ -1037,6 +1280,7 @@ var I18nLookupMiddleware = (0, import_nfkit3.createI18nLookupMiddleware)();
   DataBody,
   DataPipe,
   DataQuery,
+  DefaultValueParamResolver,
   GenericPaginatedReturnMessageDto,
   GenericReturnMessageDto,
   I18nInterceptor,
@@ -1056,6 +1300,11 @@ var I18nLookupMiddleware = (0, import_nfkit3.createI18nLookupMiddleware)();
   ParamResolver,
   ParamResolverBase,
   ParamResolverPipe,
+  ParseBase64ParamResolver,
+  ParseBoolParamResolver,
+  ParseDateParamResolver,
+  ParseFloatParamResolver,
+  ParseIntParamResolver,
   PutLocale,
   RenameClass,
   RequireToken,
@@ -1067,6 +1316,7 @@ var I18nLookupMiddleware = (0, import_nfkit3.createI18nLookupMiddleware)();
   createAbortableProvider,
   createI18n,
   createI18nDecorator,
+  createLambdaParamResolver,
   createMutateInject,
   createProvider,
   createResolver,
@@ -1074,6 +1324,7 @@ var I18nLookupMiddleware = (0, import_nfkit3.createI18nLookupMiddleware)();
   getApiProperty,
   getClassFromClassOrArray,
   getParamResolver,
+  parseBool,
   takeUntilAbort
 });
 //# sourceMappingURL=index.cjs.map