@xfe-repo/bff-transform 1.0.0

package/dist/transform.module.js

@@ -0,0 +1,887 @@
+"use strict";
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/transform.module.ts
+var transform_module_exports = {};
+__export(transform_module_exports, {
+  TransformModule: () => TransformModule
+});
+module.exports = __toCommonJS(transform_module_exports);
+var import_common5 = require("@nestjs/common");
+var import_core3 = require("@nestjs/core");
+
+// src/privacy/privacy.plugin.ts
+var import_common = require("@nestjs/common");
+
+// src/transform.iplugin.ts
+var INJECT_TRANSFORM_PLUGINS = "INJECT_TRANSFORM_PLUGINS";
+var _ITransformPlugin = class _ITransformPlugin {
+  /**
+  *  初始化插件
+  * 该方法会在插件被注册时调用
+  * 可以用于插件的初始化逻辑，例如加载配置、注册事件等
+  * 如果插件不需要初始化逻辑，可以不实现该方法
+  * @param request
+  */
+  initialize(_request) {
+  }
+  /**
+  * 执行前的钩子函数
+  * @returns {boolean} 返回 true 表示需要执行该插件，false 则不执行
+  * 这个方法可以用于判断插件是否需要在当前数据上执行操作
+  * 例如：可以根据插件的配置选项或数据状态来决定是否执行
+  * 如果返回 false，则该插件在当前数据上不执行任何操作
+  * 如果返回 true，则会执行 execute 方法
+  */
+  executeBefore(_request) {
+    return true;
+  }
+  /**
+  * 执行后的钩子函数
+  * 这个方法会在所有数据处理完成后被调用
+  * 可以用于清理资源或执行一些收尾工作
+  */
+  executeAfter(_request) {
+  }
+};
+__name(_ITransformPlugin, "ITransformPlugin");
+/**
+* 插件的名称
+* 用于标识插件，避免重复注册
+* 每个插件必须有唯一的名称
+*/
+__publicField(_ITransformPlugin, "pluginName");
+var ITransformPlugin = _ITransformPlugin;
+
+// src/privacy/desensitize.tool.ts
+var desensitizeMobile = /* @__PURE__ */ __name((mobile) => {
+  if (!mobile) return "";
+  return String(mobile).replace(/(\d{3})\d*(\d{4})/, "$1****$2");
+}, "desensitizeMobile");
+var desensitizeName = /* @__PURE__ */ __name((name = "", format = "firstAndLast") => {
+  const str = String(name || "").trim();
+  const len = str.length;
+  if (format === "first") {
+    return str.replace(/(?<=.)./g, "*");
+  }
+  if (format === "all") {
+    return "*";
+  }
+  if (format === "firstAndLast") {
+    if (len < 3) return str;
+    return `${str[0] || ""}${"*".repeat(len - 2)}${str[len - 1] || ""}`;
+  }
+  if (format === "pre2AndLast") {
+    if (len < 4) return str;
+    return `${str.slice(0, 2) || ""}${"*".repeat(len - 3)}${str[len - 1] || ""}`;
+  }
+  if (format === "maxFourLetter") {
+    if (len < 3) return `${str[0] || ""}*`;
+    return str.replace(/^(.).+(.)$/g, "$1**$2");
+  }
+  return str;
+}, "desensitizeName");
+var desensitizeEnterpriseName = /* @__PURE__ */ __name((str) => {
+  str = String(str || "").trim();
+  const len = str?.length;
+  if (!str || len < 3) return str;
+  return `${str.substring(0, 2)}${"*".repeat(len - 3)}${str[len - 1] || ""}`;
+}, "desensitizeEnterpriseName");
+var desensitizeEnterpriseNo = /* @__PURE__ */ __name((str) => {
+  if (!str) return str;
+  return str.replace(/SAAS\d+(?=\d{4})/, "SAAS****");
+}, "desensitizeEnterpriseNo");
+var desensitizeAddress = /* @__PURE__ */ __name((str = "", maskAll = false) => {
+  if (!str) return str;
+  if (maskAll) {
+    return "*".repeat(str.length);
+  }
+  return str.replace(/\d+(?=[室|号|楼])/g, "**");
+}, "desensitizeAddress");
+var desensitizePrice = /* @__PURE__ */ __name((len = 3, showUnit) => {
+  return `${showUnit ? "\xA5" : ""}  ${"*".repeat(len)}`;
+}, "desensitizePrice");
+var desensitizeAmount = /* @__PURE__ */ __name((_value, options) => {
+  const { length = 3, showUnit = false } = options || {};
+  return `${showUnit ? "\xA5" : ""}  ${"*".repeat(length)}`;
+}, "desensitizeAmount");
+var desensitizeNameAll = /* @__PURE__ */ __name((name = "") => {
+  return desensitizeName(name, "all");
+}, "desensitizeNameAll");
+var desensitizeUtil = {
+  mobile: desensitizeMobile,
+  name: desensitizeName,
+  enterpriseName: desensitizeEnterpriseName,
+  enterpriseNo: desensitizeEnterpriseNo,
+  address: desensitizeAddress,
+  price: desensitizePrice,
+  /** 和 price / desensitizeAmount 调用执行结果一致，但方法封装参数不一致 */
+  amount: desensitizeAmount,
+  nameAll: desensitizeNameAll
+};
+var desensitize_tool_default = desensitizeUtil;
+
+// src/privacy/apply/desensitize.ts
+function applyDesensitize(data, fieldName, originalValue, options, userPermission) {
+  const { permissionCode, method, params } = options;
+  if (originalValue == null) {
+    return;
+  }
+  if (permissionCode && userPermission?.includes(permissionCode)) {
+    return;
+  }
+  try {
+    const desensitizeFn = desensitize_tool_default[method];
+    data[fieldName] = desensitizeFn(originalValue, params);
+  } catch (error) {
+    console.error("\u8131\u654F\u5931\u8D25:", error);
+  }
+}
+__name(applyDesensitize, "applyDesensitize");
+
+// src/privacy/utils.ts
+var ENCRYPTION_KEY = "Ff3UCEPfizZmCjke1Xfi";
+function encryptValue(value) {
+  try {
+    const stringValue = String(value || "");
+    const key = Buffer.from(ENCRYPTION_KEY);
+    const data = Buffer.from(stringValue);
+    const result = Buffer.alloc(data.length);
+    for (let i = 0; i < data.length; i++) {
+      result[i] = data[i] ^ key[i % key.length];
+    }
+    return result.toString("base64");
+  } catch (error) {
+    console.error("\u52A0\u5BC6\u5931\u8D25:", error);
+    return `error:${Buffer.from(String(value || "")).toString("base64")}`;
+  }
+}
+__name(encryptValue, "encryptValue");
+
+// src/privacy/apply/encryption.ts
+function applyEncryption(data, fieldName, originalValue, options, userPermission) {
+  const { permissionCode } = options;
+  data[fieldName] = null;
+  const encryptedFieldName = `${fieldName}Encrypted`;
+  data[encryptedFieldName] = null;
+  const hasPermission = userPermission?.includes(permissionCode);
+  if (hasPermission && originalValue != null) {
+    try {
+      const stringValue = String(originalValue);
+      const encryptedValue = encryptValue(stringValue);
+      data[encryptedFieldName] = encryptedValue;
+    } catch (error) {
+      console.error("\u52A0\u5BC6\u5931\u8D25:", error);
+    }
+  }
+}
+__name(applyEncryption, "applyEncryption");
+
+// src/privacy/apply/isPermitted.ts
+function applyIsPermitted(data, fieldName, options, userPermission) {
+  const { permissionCode, condition = /* @__PURE__ */ __name((_data) => true, "condition") } = options;
+  const hasRequiredPermission = !permissionCode || (userPermission?.includes(permissionCode) ?? false);
+  data[fieldName] = hasRequiredPermission && condition(data);
+}
+__name(applyIsPermitted, "applyIsPermitted");
+
+// src/privacy/privacy.metadata-storage.ts
+var import_class_transformer = require("class-transformer");
+
+// src/transform.metadata-storage.ts
+var classTransformer = __toESM(require("class-transformer/cjs/storage"));
+var defaultMetadataStorage2 = classTransformer.defaultMetadataStorage;
+var _TransformMetadataStorage = class _TransformMetadataStorage {
+  constructor() {
+    /** 继承原实例数据 */
+    __publicField(this, "metadataStorage", defaultMetadataStorage2);
+  }
+  getMetadataStorage() {
+    return this.metadataStorage;
+  }
+};
+__name(_TransformMetadataStorage, "TransformMetadataStorage");
+var TransformMetadataStorage = _TransformMetadataStorage;
+
+// src/privacy/privacy.metadata-storage.ts
+var PrivacyTransformEnum = /* @__PURE__ */ function(PrivacyTransformEnum2) {
+  PrivacyTransformEnum2["PrivacyEncrypt"] = "PrivacyEncrypt";
+  PrivacyTransformEnum2["PrivacyDesensitize"] = "PrivacyDesensitize";
+  PrivacyTransformEnum2["PrivacyIsPermitted"] = "PrivacyIsPermitted";
+  return PrivacyTransformEnum2;
+}({});
+var _a;
+var PrivacyTransformMetadataStorage = (_a = class extends TransformMetadataStorage {
+  /**
+  * 添加隐私协议转换元数据
+  * @param metadata 隐私协议转换元数据
+  */
+  addPrivacyMetadata(metadata) {
+    this.getMetadataStorage().addTransformMetadata(metadata);
+  }
+  /**
+  *  查找隐私协议转换元数据
+  * @param target
+  * @param propertyName
+  * @param transformationType
+  * @returns
+  */
+  findPrivacyMetadata(target, propertyName, transformName) {
+    const unionQueryMetadatas = this.getMetadataStorage().findTransformMetadatas(target, propertyName, import_class_transformer.TransformationType.PLAIN_TO_CLASS);
+    return unionQueryMetadatas.find((meta) => meta.options?.transformName === transformName);
+  }
+}, __name(_a, "PrivacyTransformMetadataStorage"), _a);
+var privacyMetadataStorage = new PrivacyTransformMetadataStorage();
+
+// src/privacy/privacy.plugin.ts
+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");
+var _PrivacyPlugin = class _PrivacyPlugin extends ITransformPlugin {
+  execute(request, { parent, key, value }) {
+    const userPermission = request.user?.permission || [];
+    this.collectAndExcuteFields(parent, key, value, userPermission);
+  }
+  /**
+  * 处理对象的隐私字段
+  * @param data 待处理的对象数据
+  * @param privacyFields 隐私字段元数据
+  * @param userPermission 当前用户信息
+  */
+  collectAndExcuteFields(data, key, value, userPermission) {
+    if (typeof key !== "string") return;
+    const targetClass = data?.constructor;
+    if (!targetClass) return;
+    const originalValue = value;
+    const encryptOptions = privacyMetadataStorage.findPrivacyMetadata(targetClass, key, PrivacyTransformEnum.PrivacyEncrypt)?.options;
+    if (encryptOptions) {
+      applyEncryption(data, key, originalValue, encryptOptions, userPermission);
+    }
+    const desensitizeOptions = privacyMetadataStorage.findPrivacyMetadata(targetClass, key, PrivacyTransformEnum.PrivacyDesensitize)?.options;
+    if (desensitizeOptions) {
+      applyDesensitize(data, key, originalValue, desensitizeOptions, userPermission);
+    }
+    const isPermittedOptions = privacyMetadataStorage.findPrivacyMetadata(targetClass, key, PrivacyTransformEnum.PrivacyIsPermitted)?.options;
+    if (isPermittedOptions) {
+      applyIsPermitted(data, key, isPermittedOptions, userPermission);
+    }
+  }
+};
+__name(_PrivacyPlugin, "PrivacyPlugin");
+__publicField(_PrivacyPlugin, "pluginName", _PrivacyPlugin.name);
+var PrivacyPlugin = _PrivacyPlugin;
+PrivacyPlugin = _ts_decorate([
+  (0, import_common.Injectable)()
+], PrivacyPlugin);
+
+// src/transform.interceptor.ts
+var import_common3 = require("@nestjs/common");
+var import_operators = require("rxjs/operators");
+
+// src/transform.plugin.manager.ts
+var import_bff_core = require("@xfe-repo/bff-core");
+var import_common2 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+
+// src/traverse.utils.ts
+function traverse(obj, callback, options = {}) {
+  const { maxDepth = Infinity, detectCircular = false, method = "iterative" } = options;
+  if (method === "recursive") {
+    recursiveTraverse(obj, callback, maxDepth, detectCircular);
+  } else {
+    iterativeTraverse(obj, callback, maxDepth, detectCircular);
+  }
+}
+__name(traverse, "traverse");
+function recursiveTraverse(current, callback, maxDepth, detectCircular, path = [], parent = null, seen = /* @__PURE__ */ new WeakSet()) {
+  if (path.length > maxDepth) return;
+  const key = path.length > 0 ? path[path.length - 1] : null;
+  callback({
+    value: current,
+    key,
+    path,
+    parent
+  });
+  if (detectCircular && typeof current === "object" && current !== null) {
+    if (seen.has(current)) return;
+    seen.add(current);
+  }
+  if (current !== null && typeof current === "object" && path.length < maxDepth) {
+    if (Array.isArray(current)) {
+      for (let i = 0; i < current.length; i++) {
+        recursiveTraverse(current[i], callback, maxDepth, detectCircular, [
+          ...path,
+          i
+        ], current, seen);
+      }
+    } else {
+      for (const [k, v] of Object.entries(current)) {
+        recursiveTraverse(v, callback, maxDepth, detectCircular, [
+          ...path,
+          k
+        ], current, seen);
+      }
+    }
+  }
+}
+__name(recursiveTraverse, "recursiveTraverse");
+function iterativeTraverse(root, callback, maxDepth, detectCircular) {
+  const stack = [
+    {
+      value: root,
+      path: [],
+      parent: null
+    }
+  ];
+  const seen = detectCircular ? /* @__PURE__ */ new WeakSet() : null;
+  while (stack.length > 0) {
+    const { value, path, parent } = stack.pop();
+    if (path.length > maxDepth) continue;
+    const key = path.length > 0 ? path[path.length - 1] : null;
+    callback({
+      value,
+      key,
+      path,
+      parent
+    });
+    if (value !== null && typeof value === "object" && path.length < maxDepth) {
+      if (detectCircular) {
+        if (seen.has(value)) continue;
+        seen.add(value);
+      }
+      if (Array.isArray(value)) {
+        for (let i = value.length - 1; i >= 0; i--) {
+          stack.push({
+            value: value[i],
+            path: [
+              ...path,
+              i
+            ],
+            parent: value
+          });
+        }
+      } else {
+        const keys = Object.keys(value);
+        for (let i = keys.length - 1; i >= 0; i--) {
+          const k = keys[i];
+          stack.push({
+            value: value[k],
+            path: [
+              ...path,
+              k
+            ],
+            parent: value
+          });
+        }
+      }
+    }
+  }
+}
+__name(iterativeTraverse, "iterativeTraverse");
+
+// src/transform.plugin.manager.ts
+function _ts_decorate2(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_decorate2, "_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");
+var _TransformPluginManager = class _TransformPluginManager {
+  constructor(ctx, moduleRef, plugins) {
+    __publicField(this, "ctx");
+    __publicField(this, "moduleRef");
+    __publicField(this, "logger", new import_common2.Logger(_TransformPluginManager.name));
+    __publicField(this, "plugins", []);
+    this.ctx = ctx;
+    this.moduleRef = moduleRef;
+    this.registerAsyncPlugins(plugins);
+  }
+  async registerAsyncPlugins(plugins) {
+    const uniquePlugins = /* @__PURE__ */ new Map();
+    for (const plugin of plugins) {
+      if (!plugin.pluginName) {
+        this.logger.error(`${plugin.name} \u7F3A\u5C11\u63D2\u4EF6\u540D\u79F0 static readonly pluginName \u5C5E\u6027, \u8BF7\u786E\u4FDD\u6BCF\u4E2A\u63D2\u4EF6\u90FD\u6709\u552F\u4E00\u7684\u540D\u79F0\u3002`);
+        continue;
+      }
+      if (!uniquePlugins.has(plugin.pluginName)) {
+        const pluginInstance = await this.moduleRef.create(plugin);
+        uniquePlugins.set(plugin.pluginName, pluginInstance);
+      }
+    }
+    this.plugins = Array.from(uniquePlugins.values());
+  }
+  /**
+  * 主入口方法，处理请求数据
+  * @param data 实例化的数据对象
+  * @param request 请求对象, 非必传，如果没有传入，则从请求上下文中获取
+  */
+  async main(data) {
+    const request = this.ctx.req;
+    request.data = data;
+    this.initialize(request);
+    const excutePlugins = await this.executeBefore(request);
+    this.execute(request, excutePlugins);
+    await this.executeAfter(request, excutePlugins);
+  }
+  /**
+  * 初始化插件
+  * 可以用于插件的初始化逻辑，例如加载配置、注册事件等
+  * 如果插件不需要初始化逻辑，可以不实现该方法
+  * @param request 请求对象
+  */
+  initialize(request) {
+    this.plugins.forEach((plugin) => plugin.initialize?.(request));
+  }
+  /**
+  * 执行插件的 before 钩子函数
+  * 该方法会返回需要执行的插件列表
+  * 如果插件的 executeBefore 返回 false，则不执行该插件
+  * @param request 请求对象
+  */
+  async executeBefore(request) {
+    const beforeResList = await Promise.all(this.plugins.map((plugin) => plugin.executeBefore?.(request)));
+    return this.plugins.filter((_, index) => beforeResList[index]);
+  }
+  /**
+  * 执行插件的主要逻辑
+  * 该方法会在数据遍历过程中被调用
+  * 这个方法是插件的核心逻辑，用于处理数据的每个字段
+  * 此方法只调用一次递归遍历函数, 优化多个插件时的遍历性能
+  * @param request 请求对
+  * @param excutePlugins 需要执行的插件列表
+  */
+  execute(request, excutePlugins) {
+    traverse(request.data, (traverseFnOptions) => {
+      excutePlugins.forEach((plugin) => {
+        plugin.execute(request, traverseFnOptions);
+      });
+    });
+  }
+  /**
+  * 执行插件的 after 钩子函数
+  * 这个方法会在所有数据处理完成后被调用
+  * 可以用于清理资源或执行一些收尾工作
+  * @param request 请求对象
+  * @param excutePlugins 需要执行的插件列表
+  */
+  async executeAfter(request, excutePlugins) {
+    await Promise.all(excutePlugins.map((plugin) => plugin.executeAfter?.(request)));
+  }
+};
+__name(_TransformPluginManager, "TransformPluginManager");
+var TransformPluginManager = _TransformPluginManager;
+TransformPluginManager = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_param(2, (0, import_common2.Inject)(INJECT_TRANSFORM_PLUGINS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_bff_core.CtxService === "undefined" ? Object : import_bff_core.CtxService,
+    typeof import_core.ModuleRef === "undefined" ? Object : import_core.ModuleRef,
+    Array
+  ])
+], TransformPluginManager);
+
+// src/transform.interceptor.ts
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var _TransformInterceptor = class _TransformInterceptor {
+  constructor(transformPluginManager) {
+    __publicField(this, "transformPluginManager");
+    __publicField(this, "logger", new import_common3.Logger(_TransformInterceptor.name));
+    this.transformPluginManager = transformPluginManager;
+  }
+  intercept(_context, next) {
+    return next.handle().pipe((0, import_operators.mergeMap)(async (data) => {
+      if (!data) return data;
+      await this.transformPluginManager.main(data).catch((error) => {
+        this.logger.error("PluginManager execute failed:", error);
+      });
+      return data;
+    }));
+  }
+};
+__name(_TransformInterceptor, "TransformInterceptor");
+var TransformInterceptor = _TransformInterceptor;
+TransformInterceptor = _ts_decorate3([
+  (0, import_common3.Injectable)(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof TransformPluginManager === "undefined" ? Object : TransformPluginManager
+  ])
+], TransformInterceptor);
+
+// src/unionQuery/unionQuery.plugin.ts
+var import_common4 = require("@nestjs/common");
+var import_core2 = require("@nestjs/core");
+var import_bff_cache2 = require("@xfe-repo/bff-cache");
+
+// src/unionQuery/tasks/collectTasks.ts
+var import_qs = __toESM(require("qs"));
+
+// src/unionQuery/unionquery.metadata-storage.ts
+var import_class_transformer2 = require("class-transformer");
+var _a2;
+var UnionQueryTransformMetadataStorage = (_a2 = class extends TransformMetadataStorage {
+  /**
+  * 添加联合查询转换元数据
+  * @param metadata 联合查询转换元数据
+  */
+  addUnionQueryMetadata(metadata) {
+    const options = {
+      ...metadata.options,
+      toClassOnly: true
+    };
+    this.getMetadataStorage().addTransformMetadata({
+      ...metadata,
+      options
+    });
+  }
+  /**
+  * 查找联合查询转换元数据
+  * @param target
+  * @param propertyName
+  * @param transformationType
+  * @returns
+  */
+  findUnionQueryMetadata(target, propertyName) {
+    const unionQueryMetadatas = this.getMetadataStorage().findTransformMetadatas(target, propertyName, import_class_transformer2.TransformationType.PLAIN_TO_CLASS);
+    return unionQueryMetadatas.find((meta) => meta.options?.transformName === "UnionQuery");
+  }
+}, __name(_a2, "UnionQueryTransformMetadataStorage"), _a2);
+var unionQueryMetadataStorage = new UnionQueryTransformMetadataStorage();
+
+// src/unionQuery/tasks/utils.ts
+var import_constants = require("@nestjs/common/constants");
+function isNullOrUndefined(x) {
+  return x === null || x === void 0;
+}
+__name(isNullOrUndefined, "isNullOrUndefined");
+function getServiceName(service) {
+  if (typeof service === "function") return service.name;
+  if (typeof service === "object" && service !== null && "provide" in service) {
+    const token = service.provide;
+    if (typeof token === "string" || typeof token === "symbol") return token.toString();
+    if (typeof token === "function") return token.name;
+  }
+  return "\u672A\u77E5\u670D\u52A1";
+}
+__name(getServiceName, "getServiceName");
+function getServiceToken(service) {
+  if (typeof service === "function") return service;
+  if (typeof service === "object" && service !== null && "provide" in service) return service.provide;
+  throw new Error(`\u65E0\u6548\u7684\u670D\u52A1\u914D\u7F6E: ${JSON.stringify(service)}`);
+}
+__name(getServiceToken, "getServiceToken");
+var getServiceInstance = /* @__PURE__ */ __name((service, moduleRef) => {
+  const serviceName = getServiceName(service);
+  try {
+    const token = getServiceToken(service);
+    const instance = moduleRef.get(token, {
+      strict: false
+    });
+    if (!instance) {
+      throw new Error(`\u672A\u627E\u5230\u670D\u52A1 ${serviceName}\uFF0C\u8BF7\u68C0\u67E5 Provider \u914D\u7F6E\u3002`);
+    }
+    return instance;
+  } catch (error) {
+    throw new Error(`\u83B7\u53D6\u670D\u52A1\u5B9E\u4F8B ${serviceName} \u51FA\u9519: ${error instanceof Error ? error.message : String(error)}${error instanceof Error ? error.stack : ""}`);
+  }
+}, "getServiceInstance");
+
+// src/unionQuery/tasks/collectTasks.ts
+var TTL = 10 * 60 * 1e3;
+function collectTasks(data, propertyKey, _value, options) {
+  const { tasks, logger } = options;
+  if (typeof propertyKey !== "string") return;
+  const targetClass = data?.constructor;
+  if (!targetClass) return;
+  const UnionQueryOptions = unionQueryMetadataStorage.findUnionQueryMetadata(targetClass, propertyKey)?.options;
+  if (UnionQueryOptions) {
+    const { service, methodFn, inFn, cacheFn, ttl = TTL } = UnionQueryOptions;
+    let extractedObject;
+    try {
+      extractedObject = inFn?.(data) || {};
+    } catch (e) {
+      logger(`\u6267\u884C inFn \u51FA\u9519 (${targetClass.name}.${propertyKey}): ${e.message}, ${e.stack}`);
+    }
+    const methodName = String(methodFn).split(".")[1];
+    const taskKey = `${getServiceName(service)}:${String(methodFn)}`;
+    let task = tasks.get(taskKey);
+    if (!task) {
+      task = {
+        taskKey,
+        targetName: targetClass.name,
+        service,
+        methodFn,
+        methodName,
+        ttl,
+        paramAggregators: {},
+        cacheKeyList: [],
+        contexts: []
+      };
+    }
+    const context = {
+      context: data,
+      propertyKey,
+      options: UnionQueryOptions
+    };
+    if (cacheFn) {
+      const cacheKey = `${task.taskKey}:${import_qs.default.stringify(extractedObject)}`;
+      if (!task.cacheKeyList.includes(cacheKey)) {
+        task.cacheKeyList.push(cacheKey);
+      }
+      context.cacheKey = cacheKey;
+    }
+    for (const [extractedKey, extractedValue] of Object.entries(extractedObject)) {
+      if (!task.paramAggregators[extractedKey]) {
+        task.paramAggregators[extractedKey] = [];
+      }
+      if (!isNullOrUndefined(extractedValue) && !task.paramAggregators[extractedKey].includes(extractedValue)) {
+        task.paramAggregators[extractedKey].push(extractedValue);
+      }
+    }
+    task.contexts.push(context);
+    tasks.set(taskKey, task);
+  }
+}
+__name(collectTasks, "collectTasks");
+
+// src/unionQuery/tasks/executeTask.ts
+var import_bff_cache = require("@xfe-repo/bff-cache");
+var import_qs2 = __toESM(require("qs"));
+async function executeTask(task, options) {
+  const { moduleRef, cacheManagerService, logger } = options;
+  const serviceName = getServiceName(task.service);
+  const methodName = task.methodName;
+  const loggerPrifixed = `\u3010Vo: ${task.targetName}, key: ${task.taskKey}, params: ${JSON.stringify(task.paramAggregators)}}\u3011`;
+  const cacheResultList = await cacheManagerService.mget(import_bff_cache.CachePrefix.UnionQuery, task.cacheKeyList);
+  const cacheResultDic = {};
+  cacheResultList.forEach((result, index) => {
+    if (result) {
+      const cacheKey = task.cacheKeyList[index];
+      cacheResultDic[cacheKey] = result;
+      const inFnParamsFromCacheKey = import_qs2.default.parse(cacheKey.split(":")[2]);
+      for (const paramsKey in inFnParamsFromCacheKey) {
+        const paramsValue = inFnParamsFromCacheKey[paramsKey];
+        task.paramAggregators[paramsKey] = task.paramAggregators[paramsKey].filter((param) => param !== paramsValue);
+      }
+    }
+  });
+  const aggregatedParams = {};
+  for (const inField in task.paramAggregators) {
+    aggregatedParams[inField] = task.paramAggregators[inField].join(",");
+  }
+  try {
+    let unionResult = {};
+    const hasCacheResult = Object.keys(cacheResultDic).length > 0;
+    const hasAggregatedParams = Object.values(aggregatedParams).filter(Boolean).length > 0;
+    const shouldCallService = !hasCacheResult || hasAggregatedParams;
+    if (shouldCallService) {
+      const serviceInstance = getServiceInstance(task.service, moduleRef);
+      if (!serviceInstance) return;
+      const serviceMethod = task.methodFn(serviceInstance);
+      unionResult = await serviceMethod.call(serviceInstance, aggregatedParams);
+      logger(`${loggerPrifixed}\u6267\u884C\u67E5\u8BE2: ${serviceName}.${serviceMethod.name}(${JSON.stringify(aggregatedParams)})`, "Access");
+    } else {
+      logger(`${loggerPrifixed}\u4ECE\u7F13\u5B58\u83B7\u53D6\u6570\u636E\uFF0C\u5DF2\u8DF3\u8FC7\u67E5\u8BE2\u3002`, "Access");
+    }
+    const setCacheKeyList = [];
+    task.contexts.forEach((contextItem) => {
+      const { options: options2, context, propertyKey, cacheKey } = contextItem;
+      try {
+        const { cacheFn, outFn } = options2;
+        if (cacheFn && cacheKey) {
+          const cacheResult = cacheResultDic[cacheKey];
+          if (cacheResult) {
+            context[propertyKey] = outFn(cacheResult, context);
+            return;
+          }
+          const cachedValue = cacheFn(unionResult, context) || {};
+          const newValue = outFn(cachedValue, context);
+          context[propertyKey] = newValue;
+          if (!setCacheKeyList.find((item) => item.key === cacheKey)) {
+            setCacheKeyList.push({
+              key: cacheKey,
+              value: cachedValue
+            });
+          }
+        } else {
+          const newValue = outFn(unionResult, context);
+          context[propertyKey] = newValue;
+        }
+      } catch (e) {
+        logger(`${loggerPrifixed}\u6267\u884C ${String(propertyKey)}.outFn \u51FA\u9519: ${e.message} ${e.stack}`);
+      }
+    });
+    if (setCacheKeyList.length > 0) {
+      cacheManagerService.mset(import_bff_cache.CachePrefix.UnionQuery, setCacheKeyList, task.ttl);
+    }
+  } catch (error) {
+    logger(`${loggerPrifixed}\u6267\u884C ${serviceName}#${methodName}(${JSON.stringify(aggregatedParams)}) \u5931\u8D25: ${error instanceof Error ? error.message : String(error)} ${error instanceof Error ? error.stack : ""}`);
+  }
+}
+__name(executeTask, "executeTask");
+
+// src/unionQuery/unionQuery.plugin.ts
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var _UnionQueryPlugin = class _UnionQueryPlugin extends ITransformPlugin {
+  constructor(moduleRef, cacheManagerService) {
+    super();
+    __publicField(this, "moduleRef");
+    __publicField(this, "cacheManagerService");
+    __publicField(this, "logger", new import_common4.Logger(_UnionQueryPlugin.name));
+    __publicField(this, "emitLogger", /* @__PURE__ */ __name((message, type = "Error") => {
+      this.logger.log(`${type}: ${message}`);
+    }, "emitLogger"));
+    this.moduleRef = moduleRef, this.cacheManagerService = cacheManagerService;
+  }
+  initialize(request) {
+    if (!request._union_query_tasks) {
+      request._union_query_tasks = /* @__PURE__ */ new Map();
+    }
+  }
+  execute(request, { parent, key, value }) {
+    collectTasks(parent, key, value, {
+      tasks: request._union_query_tasks,
+      logger: this.emitLogger
+    });
+  }
+  async executeAfter(request) {
+    const { _union_query_tasks: tasks } = request;
+    if (tasks.size === 0) return;
+    const excuteTaskOptions = {
+      moduleRef: this.moduleRef,
+      cacheManagerService: this.cacheManagerService,
+      logger: this.emitLogger
+    };
+    await Promise.all(Array.from(tasks.values()).map((task) => executeTask(task, excuteTaskOptions)));
+  }
+};
+__name(_UnionQueryPlugin, "UnionQueryPlugin");
+__publicField(_UnionQueryPlugin, "pluginName", _UnionQueryPlugin.name);
+var UnionQueryPlugin = _UnionQueryPlugin;
+UnionQueryPlugin = _ts_decorate4([
+  (0, import_common4.Injectable)(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof import_core2.ModuleRef === "undefined" ? Object : import_core2.ModuleRef,
+    typeof import_bff_cache2.CacheManagerService === "undefined" ? Object : import_bff_cache2.CacheManagerService
+  ])
+], UnionQueryPlugin);
+
+// src/transform.module.ts
+function _ts_decorate5(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_decorate5, "_ts_decorate");
+var _TransformModule = class _TransformModule {
+  /* 注册插件
+  * @param global 是否全局模块，默认值为 false
+  * @param plugins 扩展插件列表
+  * @returns {DynamicModule} 动态模块
+  */
+  static register(options = {}) {
+    const corePlugins = [
+      UnionQueryPlugin,
+      PrivacyPlugin
+    ];
+    return {
+      global: options.global,
+      module: _TransformModule,
+      providers: [
+        {
+          provide: INJECT_TRANSFORM_PLUGINS,
+          // 将核心插件和自定义插件合并
+          // 此处注意约定注册顺序为: 自定义插件早于内置插件, 如果有同名插件, 可以保证自定义插件可以覆盖内置插件
+          useValue: options.plugins ? [
+            ...options.plugins,
+            ...corePlugins
+          ] : corePlugins
+        }
+      ]
+    };
+  }
+};
+__name(_TransformModule, "TransformModule");
+var TransformModule = _TransformModule;
+TransformModule = _ts_decorate5([
+  (0, import_common5.Module)({
+    providers: [
+      TransformPluginManager,
+      {
+        provide: import_core3.APP_INTERCEPTOR,
+        useClass: TransformInterceptor
+      }
+    ]
+  })
+], TransformModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformModule
+});