nesties 1.1.5 → 1.1.6

package/dist/index.mjs

@@ -240,7 +240,7 @@ var RequireToken = () => MergeClassOrMethodDecorators([
 import { Observable, takeUntil } from "rxjs";
 import { createParamDecorator } from "@nestjs/common";
 
-// src/abort-http-signal.ts
+// src/utility/abort-http-signal.ts
 function toRawReq(req) {
   if (req?.raw?.socket) return req.raw;
   return req;
@@ -414,6 +414,516 @@ var AbortableModule = class {
 AbortableModule = __decorateClass([
   Module({})
 ], AbortableModule);
+
+// src/i18n-module/i18n.service.ts
+import {
+  ConsoleLogger,
+  HttpException as HttpException2,
+  Inject as Inject4,
+  Injectable as Injectable2
+} from "@nestjs/common";
+
+// src/i18n-module/i18n-token.ts
+import { ConfigurableModuleBuilder } from "@nestjs/common";
+var I18nResolverToken = Symbol("I18nResolverToken");
+var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new ConfigurableModuleBuilder().build();
+var I18nModuleOptionsToken = MODULE_OPTIONS_TOKEN;
+
+// src/utility/parse-i18n.ts
+var parseI18n = (text) => {
+  const pieces = [];
+  if (!text) return pieces;
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    const start = text.indexOf("#{", i);
+    if (start === -1) {
+      if (i < n) pieces.push({ type: "raw", value: text.slice(i) });
+      break;
+    }
+    let j = start + 2;
+    let depth = 1;
+    while (j < n && depth > 0) {
+      const ch = text.charCodeAt(j);
+      if (ch === 123) depth++;
+      else if (ch === 125) depth--;
+      j++;
+    }
+    if (depth !== 0) {
+      pieces.push({ type: "raw", value: text.slice(i) });
+      break;
+    }
+    if (start > i) {
+      pieces.push({ type: "raw", value: text.slice(i, start) });
+    }
+    const rawInner = text.slice(start + 2, j - 1);
+    const key = rawInner.trim();
+    pieces.push({ type: "ph", rawInner, key });
+    i = j;
+  }
+  return pieces;
+};
+
+// src/i18n-module/i18n.service.ts
+import { ModuleRef as ModuleRef2 } from "@nestjs/core";
+var I18nService = class {
+  constructor(resolver, options, moduleRef) {
+    this.resolver = resolver;
+    this.options = options;
+    this.moduleRef = moduleRef;
+    this.locales = new Set(this.options.locales);
+    this.defaultLocale = this.options.defaultLocale ?? this.options.locales[0];
+    this.middlewares = [];
+    this.logger = new ConsoleLogger("I18nService");
+  }
+  middleware(mw, prior = false) {
+    if (prior) {
+      this.middlewares.unshift(mw);
+    } else {
+      this.middlewares.push(mw);
+    }
+  }
+  buildFallbackChain(locale) {
+    const best = this.getExactLocale(locale);
+    const parts = [];
+    const segs = best.split("-");
+    for (let i = segs.length; i > 1; i--)
+      parts.push(segs.slice(0, i).join("-"));
+    parts.push(segs[0]);
+    if (!parts.includes(this.defaultLocale)) parts.push(this.defaultLocale);
+    return Array.from(new Set(parts)).filter((p) => this.locales.has(p));
+  }
+  async applyMiddlewares(locale, text, ctx) {
+    const mws = this.middlewares;
+    const tryLocale = async (loc) => {
+      const dispatch = async (i) => {
+        if (i >= mws.length) return void 0;
+        const mw = mws[i];
+        let nextCalled = false;
+        const next = async () => {
+          nextCalled = true;
+          return dispatch(i + 1);
+        };
+        try {
+          const res = await mw(loc, text, next, ctx);
+          if (res == null && !nextCalled) {
+            return dispatch(i + 1);
+          }
+          return res;
+        } catch (e) {
+          if (e instanceof HttpException2) {
+            throw e;
+          }
+          this.logger.warn(`Middleware at index ${i} threw an error: ${e}`);
+          return dispatch(i + 1);
+        }
+      };
+      return dispatch(0);
+    };
+    for (const loc of this.buildFallbackChain(locale)) {
+      const result = await tryLocale(loc);
+      if (result != null) {
+        return result;
+      }
+    }
+    return void 0;
+  }
+  getExactLocale(locale) {
+    const input = (locale ?? "").trim();
+    if (!input) return this.defaultLocale;
+    if (this.locales.has(input)) return input;
+    const entries = Array.from(this.locales).map((l) => ({
+      orig: l,
+      lower: l.toLowerCase()
+    }));
+    const lower = input.toLowerCase();
+    const exact = entries.find((e) => e.lower === lower);
+    if (exact) return exact.orig;
+    const parts = lower.split("-");
+    while (parts.length > 1) {
+      parts.pop();
+      const candidate = parts.join("-");
+      const hit = entries.find((e) => e.lower === candidate);
+      if (hit) return hit.orig;
+    }
+    return this.defaultLocale;
+  }
+  async getExactLocaleFromRequest(ctx) {
+    const locale = await this.resolver(ctx, this.moduleRef);
+    return this.getExactLocale(locale);
+  }
+  async translateString(locale, text, ctx) {
+    if (!text) return text;
+    locale = this.getExactLocale(locale);
+    const pieces = parseI18n(text);
+    if (!pieces.some((p) => p.type === "ph")) {
+      return pieces.map((p) => p.type === "raw" ? p.value : `#{${p.rawInner}}`).join("");
+    }
+    const promises = [];
+    for (const p of pieces) {
+      if (p.type === "ph") {
+        promises.push(this.applyMiddlewares(locale, p.key, ctx));
+      }
+    }
+    const results = await Promise.all(promises);
+    let out = "";
+    let k = 0;
+    for (const p of pieces) {
+      if (p.type === "raw") {
+        out += p.value;
+      } else {
+        const r = results[k++];
+        out += r == null ? `#{${p.rawInner}}` : r;
+      }
+    }
+    return out;
+  }
+  async translate(locale, obj, ctx) {
+    const visited = /* @__PURE__ */ new WeakSet();
+    const isBuiltInObject = (v) => {
+      if (v == null || typeof v !== "object") return false;
+      if (v instanceof Date || v instanceof RegExp || v instanceof Map || v instanceof Set || v instanceof WeakMap || v instanceof WeakSet || v instanceof ArrayBuffer || v instanceof DataView || ArrayBuffer.isView(v))
+        return true;
+      const tag = Object.prototype.toString.call(v);
+      switch (tag) {
+        case "[object URL]":
+        case "[object URLSearchParams]":
+        case "[object Error]":
+        case "[object Blob]":
+        case "[object File]":
+        case "[object FormData]":
+          return true;
+        default:
+          return false;
+      }
+    };
+    const translateObjectPreservingProto = async (value) => {
+      const proto = Object.getPrototypeOf(value);
+      const out = Object.create(proto);
+      const keys = Reflect.ownKeys(value);
+      await Promise.all(
+        keys.map(async (key) => {
+          const desc = Object.getOwnPropertyDescriptor(value, key);
+          if (!desc) return;
+          if ("value" in desc) {
+            const newVal = await visit(desc.value);
+            Object.defineProperty(out, key, { ...desc, value: newVal });
+            return;
+          }
+          Object.defineProperty(out, key, desc);
+          let current = void 0;
+          if (typeof desc.get === "function") {
+            try {
+              current = desc.get.call(value);
+            } catch {
+            }
+          }
+          if (current === void 0) return;
+          try {
+            const newVal = await visit(current);
+            if (typeof desc.set === "function") {
+              try {
+                desc.set.call(out, newVal);
+              } catch {
+              }
+            }
+          } catch {
+          }
+        })
+      );
+      return out;
+    };
+    const isTranslatable = (v) => {
+      if (!v) return { ok: false };
+      const t = typeof v;
+      if (t === "number" || t === "bigint" || t === "symbol" || t === "function") {
+        return { ok: false };
+      }
+      if (t === "string") return { ok: true, kind: "string" };
+      if (t === "object") {
+        return { ok: true, kind: "object" };
+      }
+      return { ok: false };
+    };
+    const visit = async (value) => {
+      const check = isTranslatable(value);
+      if (!check.ok) {
+        return value;
+      }
+      if (check.kind === "string") {
+        return this.translateString(locale, value, ctx);
+      }
+      if (value instanceof Promise) {
+        return value.then((resolved) => visit(resolved));
+      }
+      if (typeof value === "object") {
+        if (!Array.isArray(value) && isBuiltInObject(value)) return value;
+        if (visited.has(value)) return value;
+        visited.add(value);
+        if (Array.isArray(value)) {
+          const out = await Promise.all(value.map((v) => visit(v)));
+          return out;
+        }
+        return translateObjectPreservingProto(value);
+      }
+      return value;
+    };
+    return visit(obj);
+  }
+  async translateRequest(ctx, obj) {
+    const locale = await this.resolver(ctx, this.moduleRef);
+    return this.translate(locale, obj, ctx);
+  }
+};
+I18nService = __decorateClass([
+  Injectable2(),
+  __decorateParam(0, Inject4(I18nResolverToken)),
+  __decorateParam(1, Inject4(I18nModuleOptionsToken)),
+  __decorateParam(2, Inject4(ModuleRef2))
+], I18nService);
+
+// src/i18n-module/i18n.module.ts
+import { Global, Module as Module2 } from "@nestjs/common";
+
+// src/i18n-module/i18n-resolver.ts
+var coerceToString = (v) => {
+  if (v == null) return void 0;
+  if (v === false) return void 0;
+  if (Array.isArray(v)) return v.length ? coerceToString(v[0]) : void 0;
+  if (typeof v === "string") return v;
+  if (typeof v === "number") return String(v);
+  return void 0;
+};
+var getHeader = (req, name) => {
+  const viaMethod = typeof req.getHeader === "function" && req.getHeader(name) || typeof req.header === "function" && req.header(name) || typeof req.get === "function" && req.get(name);
+  if (viaMethod) {
+    return coerceToString(viaMethod);
+  }
+  const n = name.toLowerCase();
+  const headers = req.headers ?? {};
+  if (n in headers) return coerceToString(headers[n]);
+  const hit = Object.entries(headers).find(([k]) => k.toLowerCase() === n)?.[1];
+  return coerceToString(hit);
+};
+var pickPrimaryFromAcceptLanguage = (v) => {
+  if (!v) return void 0;
+  const first = v.split(",")[0]?.trim();
+  return first?.split(";")[0]?.trim() || first;
+};
+function getQueryValue(req, key) {
+  const q = req.query;
+  if (q && typeof q === "object" && !("raw" in q)) {
+    const v = q[key];
+    if (v != null) return coerceToString(v);
+  }
+  const rawUrl = req.originalUrl ?? req.url;
+  if (typeof rawUrl === "string" && rawUrl.includes("?")) {
+    try {
+      const search = rawUrl.startsWith("http") ? new URL(rawUrl).search : new URL(rawUrl, "http://localhost").search;
+      if (search) {
+        const params = new URLSearchParams(search);
+        const val = params.get(key);
+        if (val != null) return val;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+var createDynamicResolverFromStatic = (_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);
+    }
+    throw new Error(`Unsupported paramType: ${field}`);
+  };
+};
+
+// src/i18n-module/locale.pipe.ts
+import {
+  createParamDecorator as createParamDecorator2,
+  Inject as Inject5,
+  Injectable as Injectable3
+} from "@nestjs/common";
+var LocalePipe = class {
+  constructor(i18nService) {
+    this.i18nService = i18nService;
+  }
+  async transform(ctx, metadata) {
+    const resolver = ctx.resolver;
+    if (resolver) {
+      const _resolver = createDynamicResolverFromStatic(resolver);
+      const locale = await _resolver(ctx.ctx, void 0);
+      return this.i18nService.getExactLocale(locale);
+    } else {
+      return this.i18nService.getExactLocaleFromRequest(ctx.ctx);
+    }
+  }
+};
+LocalePipe = __decorateClass([
+  Injectable3(),
+  __decorateParam(0, Inject5(I18nService))
+], LocalePipe);
+var _dec = createParamDecorator2((resolver, ctx) => {
+  return { ctx, resolver };
+});
+var PutLocale = (resolver) => _dec(resolver, LocalePipe);
+
+// src/i18n-module/i18n.module.ts
+var I18nModule = class extends ConfigurableModuleClass {
+};
+I18nModule = __decorateClass([
+  Global(),
+  Module2({
+    providers: [
+      createProvider(
+        {
+          provide: I18nResolverToken,
+          inject: [I18nModuleOptionsToken]
+        },
+        (o) => createDynamicResolverFromStatic(o.resolver)
+      ),
+      I18nService,
+      LocalePipe
+    ],
+    exports: [I18nService, LocalePipe]
+  })
+], I18nModule);
+
+// src/i18n-module/i18n-decorator.ts
+import { UseInterceptors } from "@nestjs/common";
+
+// src/i18n-module/i18n.interceptor.ts
+import {
+  HttpException as HttpException3,
+  Inject as Inject6,
+  Injectable as Injectable4
+} from "@nestjs/common";
+import { from, throwError } from "rxjs";
+import { catchError, mergeMap } from "rxjs/operators";
+var I18nInterceptor = class {
+  constructor(i18nService) {
+    this.i18nService = i18nService;
+  }
+  intercept(context, next) {
+    return next.handle().pipe(
+      // 成功路径：把响应体交给 i18n 做异步翻译
+      mergeMap((data) => this.i18nService.translateRequest(context, data)),
+      // 错误路径：若是 HttpException，把其 response 翻译后再抛
+      catchError((err) => {
+        if (err instanceof HttpException3) {
+          const status = err.getStatus();
+          const resp = err.getResponse();
+          return from(this.i18nService.translateRequest(context, resp)).pipe(
+            mergeMap(
+              (translated) => throwError(
+                () => new HttpException3(translated, status, { cause: err })
+              )
+            )
+          );
+        }
+        return throwError(() => err);
+      })
+    );
+  }
+};
+I18nInterceptor = __decorateClass([
+  Injectable4(),
+  __decorateParam(0, Inject6(I18nService))
+], I18nInterceptor);
+
+// src/i18n-module/i18n-decorator.ts
+import {
+  ApiHeader as ApiHeader2,
+  ApiQuery
+} from "@nestjs/swagger";
+var createI18nDecorator = (options) => {
+  const paramType = options.resolver?.paramType;
+  const apiOptions = {
+    name: options.resolver.paramName,
+    description: "Locale for internationalization",
+    required: false,
+    default: options.defaultLocale ?? options.locales[0],
+    enum: options.locales
+  };
+  const dec = paramType === "header" ? () => ApiHeader2(apiOptions) : paramType === "query" ? () => ApiQuery({ ...apiOptions, type: "string" }) : () => () => {
+  };
+  return () => MergeClassOrMethodDecorators([
+    UseInterceptors(I18nInterceptor),
+    ...paramType ? [dec()] : []
+  ]);
+};
+
+// src/i18n-module/i18n-factory.ts
+var createI18n = (options) => {
+  if (!options.resolver) {
+    options.resolver = {
+      paramType: "header",
+      paramName: "x-client-language"
+    };
+  }
+  return {
+    UseI18n: createI18nDecorator(options),
+    I18nModule: I18nModule.register(options)
+  };
+};
+
+// src/i18n-module/middelewares/lookup.ts
+var I18nLookupMiddleware = (dict, options) => {
+  const matchType = options?.matchType ?? "exact";
+  const dictFactory = typeof dict === "function" ? dict : () => dict;
+  const pickBestByHierarchy = (input, locales) => {
+    if (!input) return void 0;
+    const entries = locales.map((l) => ({ orig: l, lower: l.toLowerCase() }));
+    const lower = input.toLowerCase();
+    const exact = entries.find((e) => e.lower === lower);
+    if (exact) return exact.orig;
+    const parts = lower.split("-");
+    while (parts.length > 1) {
+      parts.pop();
+      const candidate = parts.join("-");
+      const hit = entries.find((e) => e.lower === candidate);
+      if (hit) return hit.orig;
+    }
+    return void 0;
+  };
+  return async (locale, key, next, ctx) => {
+    const dictResolved = await dictFactory(locale, key, ctx);
+    let dictionary = dictResolved[locale];
+    if (!dictionary) {
+      if (matchType === "hierarchy") {
+        const best = pickBestByHierarchy(locale, Object.keys(dictResolved));
+        if (best) dictionary = dictResolved[best];
+      } else if (matchType === "startsWith") {
+        const keys = Object.keys(dictResolved).filter(
+          (k) => locale.startsWith(k)
+        );
+        if (keys.length) {
+          const best = keys.reduce((a, b) => b.length > a.length ? b : a);
+          dictionary = dictResolved[best];
+        }
+      }
+    }
+    if (dictionary && Object.prototype.hasOwnProperty.call(dictionary, key)) {
+      const val = dictionary[key];
+      if (val != null) return val;
+    }
+    return next();
+  };
+};
 export {
   ABORT_SIGNAL,
   AbortSignalProvider,
@@ -430,21 +940,29 @@ export {
   DataQuery,
   GenericPaginatedReturnMessageDto,
   GenericReturnMessageDto,
+  I18nInterceptor,
+  I18nLookupMiddleware,
+  I18nModule,
+  I18nService,
   InjectAbortSignal,
   InjectAbortable,
   InsertField,
+  LocalePipe,
   MergeClassDecorators,
   MergeClassOrMethodDecorators,
   MergeMethodDecorators,
   MergeParameterDecorators,
   MergePropertyDecorators,
   PaginatedReturnMessageDto,
+  PutLocale,
   RequireToken,
   ReturnMessageDto,
   StringReturnMessageDto,
   TokenGuard,
   abortableToken,
   createAbortableProvider,
+  createI18n,
+  createI18nDecorator,
   createProvider,
   fromAbortable,
   getClassFromClassOrArray,