nesties 1.1.23 → 1.1.25

package/dist/index.mjs

@@ -67,6 +67,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 {
@@ -259,7 +271,7 @@ import {
 import { ConfigService } from "@nestjs/config";
 import { ApiHeader as ApiHeader2 } from "@nestjs/swagger";
 
-// src/resolver.ts
+// src/resolver/resolver.ts
 import {
   createParamDecorator,
   Inject as Inject2,
@@ -303,7 +315,42 @@ var uniqBy = (arr, fn) => {
   return result;
 };
 
-// src/resolver.ts
+// src/metadata.ts
+import { MetadataSetter, Reflector } from "typed-reflector";
+var reflector = new Reflector();
+var Metadata = new 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",
@@ -385,7 +432,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() {
@@ -566,11 +618,136 @@ 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
+import {
+  PARAMTYPES_METADATA,
+  SELF_DECLARED_DEPS_METADATA
+} from "@nestjs/common/constants";
+function asArray(v) {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+function getCtorDepsFromClass(cls) {
+  const paramTypes = Reflect.getMetadata(PARAMTYPES_METADATA, cls) ?? [];
+  const selfDeclared = Reflect.getMetadata(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
-import { MetadataSetter, Reflector } from "typed-reflector";
 import { ModuleRef as ModuleRef2 } from "@nestjs/core";
-var reflector = new Reflector();
-var Metadata = new MetadataSetter();
 var defaultHeaderName = "x-server-token";
 var defaultConfigName = "SERVER_TOKEN";
 var defaultErrorCode = 401;
@@ -804,14 +981,20 @@ var I18nModuleOptionsToken = MODULE_OPTIONS_TOKEN;
 // src/i18n-module/i18n.service.ts
 import { ModuleRef as ModuleRef4 } from "@nestjs/core";
 import { I18n } from "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 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 ConsoleLogger("I18nService");
-    this.resolver = createResolver(this.i18nServiceOptions.resolver);
   }
   middleware(mw, prior = false) {
     const wrappedMw = async (locale, text, next, ctx) => {
@@ -838,19 +1021,20 @@ var I18nService = class extends 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([
   Injectable3(),
   __decorateParam(0, Inject6(I18nModuleOptionsToken)),
-  __decorateParam(1, Inject6(ModuleRef4))
+  __decorateParam(1, Inject6(ModuleRef4)),
+  __decorateParam(2, Inject6(I18nParamResolverToken))
 ], I18nService);
 
 // src/i18n-module/i18n.module.ts
@@ -893,12 +1077,26 @@ var _dec = createParamDecorator3(
 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([
   Global(),
   Module2({
-    providers: [I18nService, LocalePipe],
+    providers: [I18nService, LocalePipe, providerFromOptions],
     exports: [I18nService, LocalePipe]
   })
 ], I18nModule);
@@ -958,6 +1156,24 @@ var createI18nDecorator = (options) => {
   ]);
 };
 
+// src/i18n-module/locale.context.ts
+import { Inject as Inject9, Injectable as Injectable6, Scope as Scope4 } from "@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([
+  Injectable6({ scope: Scope4.REQUEST }),
+  __decorateParam(0, Inject9(I18nParamResolverProviderToken)),
+  __decorateParam(1, Inject9(I18nService))
+], LocaleContext);
+
 // src/i18n-module/i18n-factory.ts
 var createI18n = (options) => {
   if (!options.resolver) {
@@ -966,9 +1182,29 @@ var createI18n = (options) => {
       paramName: "x-client-language"
     };
   }
+  const resolver = getParamResolver(options.resolver);
+  const paramProvider = resolver.toRequestScopedProvider();
+  const module = I18nModule.register(options);
+  module.providers ??= [];
+  module.exports ??= [];
+  module.providers.push(
+    paramProvider.provider,
+    LocaleContext,
+    // re-exports the resolved param value for LocaleContext injection
+    createProvider(
+      {
+        provide: I18nParamResolverProviderToken,
+        inject: [paramProvider.token]
+      },
+      (s) => s
+    )
+  );
+  module.exports.push(paramProvider.provider, LocaleContext);
   return {
     UseI18n: createI18nDecorator(options),
-    I18nModule: I18nModule.register(options)
+    I18nModule: module,
+    I18nParamResolver: resolver,
+    I18nParamResolverProvider: paramProvider
   };
 };
 
@@ -983,6 +1219,7 @@ export {
   ApiError,
   ApiErrorTyped,
   ApiFromResolver,
+  ApiInject,
   ApiTypeResponse,
   As,
   BlankPaginatedReturnMessageDto,
@@ -991,6 +1228,7 @@ export {
   DataBody,
   DataPipe,
   DataQuery,
+  DefaultValueParamResolver,
   GenericPaginatedReturnMessageDto,
   GenericReturnMessageDto,
   I18nInterceptor,
@@ -1010,6 +1248,11 @@ export {
   ParamResolver,
   ParamResolverBase,
   ParamResolverPipe,
+  ParseBase64ParamResolver,
+  ParseBoolParamResolver,
+  ParseDateParamResolver,
+  ParseFloatParamResolver,
+  ParseIntParamResolver,
   PutLocale,
   RenameClass,
   RequireToken,
@@ -1021,6 +1264,7 @@ export {
   createAbortableProvider,
   createI18n,
   createI18nDecorator,
+  createLambdaParamResolver,
   createMutateInject,
   createProvider,
   createResolver,
@@ -1028,6 +1272,7 @@ export {
   getApiProperty,
   getClassFromClassOrArray,
   getParamResolver,
+  parseBool,
   takeUntilAbort
 };
 //# sourceMappingURL=index.mjs.map