@xfe-repo/bff-transform 1.0.0

package/dist/chunk-NZ6LDQJI.mjs

@@ -0,0 +1,564 @@
+import {
+  TransformInterceptor
+} from "./chunk-MWZOUQAS.mjs";
+import {
+  TransformMetadataStorage
+} from "./chunk-O7SEPPUS.mjs";
+import {
+  TransformPluginManager
+} from "./chunk-YP5H6IG4.mjs";
+import {
+  INJECT_TRANSFORM_PLUGINS,
+  ITransformPlugin
+} from "./chunk-XUGPHFIH.mjs";
+import {
+  __name,
+  __publicField
+} from "./chunk-Q7G5RLD4.mjs";
+
+// src/transform.module.ts
+import { Module } from "@nestjs/common";
+import { APP_INTERCEPTOR } from "@nestjs/core";
+
+// src/privacy/privacy.plugin.ts
+import { Injectable } from "@nestjs/common";
+
+// 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
+import { TransformationType } from "class-transformer";
+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, 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([
+  Injectable()
+], PrivacyPlugin);
+
+// src/unionQuery/unionQuery.plugin.ts
+import { Injectable as Injectable2, Logger } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+import { CacheManagerService } from "@xfe-repo/bff-cache";
+
+// src/unionQuery/tasks/collectTasks.ts
+import qs from "qs";
+
+// src/unionQuery/unionquery.metadata-storage.ts
+import { TransformationType as TransformationType2 } from "class-transformer";
+var UnionQueryTransformEnum = /* @__PURE__ */ function(UnionQueryTransformEnum2) {
+  UnionQueryTransformEnum2["UnionQuery"] = "UnionQuery";
+  return UnionQueryTransformEnum2;
+}({});
+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, TransformationType2.PLAIN_TO_CLASS);
+    return unionQueryMetadatas.find((meta) => meta.options?.transformName === "UnionQuery");
+  }
+}, __name(_a2, "UnionQueryTransformMetadataStorage"), _a2);
+var unionQueryMetadataStorage = new UnionQueryTransformMetadataStorage();
+
+// src/unionQuery/tasks/utils.ts
+import { INJECTABLE_WATERMARK } from "@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}:${qs.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
+import { CachePrefix } from "@xfe-repo/bff-cache";
+import qs2 from "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(CachePrefix.UnionQuery, task.cacheKeyList);
+  const cacheResultDic = {};
+  cacheResultList.forEach((result, index) => {
+    if (result) {
+      const cacheKey = task.cacheKeyList[index];
+      cacheResultDic[cacheKey] = result;
+      const inFnParamsFromCacheKey = qs2.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(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_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");
+var _UnionQueryPlugin = class _UnionQueryPlugin extends ITransformPlugin {
+  constructor(moduleRef, cacheManagerService) {
+    super();
+    __publicField(this, "moduleRef");
+    __publicField(this, "cacheManagerService");
+    __publicField(this, "logger", new 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_decorate2([
+  Injectable2(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ModuleRef === "undefined" ? Object : ModuleRef,
+    typeof CacheManagerService === "undefined" ? Object : CacheManagerService
+  ])
+], UnionQueryPlugin);
+
+// src/transform.module.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");
+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_decorate3([
+  Module({
+    providers: [
+      TransformPluginManager,
+      {
+        provide: APP_INTERCEPTOR,
+        useClass: TransformInterceptor
+      }
+    ]
+  })
+], TransformModule);
+
+export {
+  PrivacyTransformEnum,
+  privacyMetadataStorage,
+  PrivacyPlugin,
+  UnionQueryTransformEnum,
+  unionQueryMetadataStorage,
+  TransformModule
+};

package/dist/chunk-O7SEPPUS.mjs

@@ -0,0 +1,23 @@
+import {
+  __name,
+  __publicField
+} from "./chunk-Q7G5RLD4.mjs";
+
+// src/transform.metadata-storage.ts
+import * as classTransformer from "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;
+
+export {
+  TransformMetadataStorage
+};

package/dist/chunk-Q7G5RLD4.mjs

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __name,
+  __publicField
+};

package/dist/chunk-V62BSXTW.mjs

@@ -0,0 +1,28 @@
+import {
+  __name
+} from "./chunk-Q7G5RLD4.mjs";
+
+// src/transform.decorators.ts
+import { applyDecorators } from "@nestjs/common";
+import { Transform } from "class-transformer";
+var TransformTyped = /* @__PURE__ */ __name((transformFn, options) => {
+  const _transformFn = /* @__PURE__ */ __name((params) => transformFn(params.obj), "_transformFn");
+  return Transform(_transformFn, {
+    toClassOnly: true,
+    ...options
+  });
+}, "TransformTyped");
+function TransformCurrency(props) {
+  const { unit } = props;
+  return applyDecorators(Transform(({ value }) => {
+    return unit === "Fen2Yuan" ? value / 100 : value * 100;
+  }, {
+    toClassOnly: true
+  }));
+}
+__name(TransformCurrency, "TransformCurrency");
+
+export {
+  TransformTyped,
+  TransformCurrency
+};

package/dist/chunk-XUGPHFIH.mjs

@@ -0,0 +1,49 @@
+import {
+  __name,
+  __publicField
+} from "./chunk-Q7G5RLD4.mjs";
+
+// 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;
+
+export {
+  INJECT_TRANSFORM_PLUGINS,
+  ITransformPlugin
+};