@ibiz-template/model-helper 0.7.41-alpha.124 → 0.7.41-alpha.126

package/src/model-util.ts

@@ -1,7 +1,12 @@
 import { calcUniqueTag } from '@ibiz/rt-model-api';
 import { IAppDERS } from '@ibiz/model-core';
 import { isEmpty } from 'ramda';
-import { formatPath, mergeModel, ServicePathUtil } from './utils';
+import {
+  formatPath,
+  mergeModel,
+  ModelTransformer,
+  ServicePathUtil,
+} from './utils';
 import { PSSysApp } from './model/PSSYSAPP';
 
 /**
@@ -388,38 +393,49 @@ export class ModelUtil {
       return this.modelCache.get(url)!;
     }
     const model = await this.get(url, params);
+    const filledModel = this.deepFillModel(model);
     if (!isParams) {
-      this.modelCache.set(url, model);
+      this.modelCache.set(url, filledModel);
     }
-    this.deepFillAppId(model);
-    return model;
+    return filledModel;
   }
 
   /**
-   * 递归填充应用标识
+   * 递归填充模型，包括填充模型appId、变换模型
    *
    * @author chitanda
    * @date 2023-08-21 10:08:41
    * @protected
    * @param {IModel} model
+   * @return {*}  {IModel} 返回处理后的模型，若处理器返回新对象则替换原引用
    */
-  protected deepFillAppId(model: IModel): void {
-    model.appId = this.appId;
-    const keys = Object.keys(model);
+  protected deepFillModel(model: IModel): IModel {
+    // 变换模型
+    let result = model;
+    if (model.dynaModelFilePath) {
+      result = ModelTransformer.getInstance().transform(
+        model.dynaModelFilePath,
+        model,
+      );
+    }
+    // 填充模型appId
+    result.appId = this.appId;
+    const keys = Object.keys(result);
     keys.forEach(key => {
-      const value = model[key];
+      const value = result[key];
       if (value && typeof value === 'object') {
         if (Array.isArray(value)) {
-          value.forEach(item => {
+          value.forEach((item, index) => {
             if (item && typeof item === 'object') {
-              this.deepFillAppId(item);
+              value[index] = this.deepFillModel(item);
             }
           });
         } else {
-          this.deepFillAppId(value);
+          result[key] = this.deepFillModel(value);
         }
       }
     });
+    return result;
   }
 
   /**

package/src/utils/index.ts

@@ -7,3 +7,6 @@ export {
   ServicePathUtil,
 } from './service-path-util/service-path-util';
 export { MergeSubModelHelper } from './merge-model/merge-model-helper';
+export { ModelHandler } from './model-transformer/model-handler';
+export { ModelTransformer } from './model-transformer/model-transformer';
+export { registerModelHandler } from './model-transformer/model-register';

package/src/utils/model-transformer/model-handler.ts

@@ -0,0 +1,36 @@
+import { IModelHandler } from '../../interface';
+
+/**
+ * @description 模型变换处理器
+ * @export
+ * @abstract
+ * @class ModelHandler
+ * @implements {IModelHandler}
+ */
+export abstract class ModelHandler implements IModelHandler {
+  /**
+   * @description 优先级，默认值为1
+   * @public
+   * @type {number}
+   * @memberof ModelHandler
+   */
+  public priority: number = 1;
+
+  /**
+   * Creates an instance of ModelHandler.
+   * @param {number} [priority=1] 优先级，数值越小越先执行
+   * @memberof ModelHandler
+   */
+  constructor(priority: number = 1) {
+    this.priority = priority;
+  }
+
+  /**
+   * @description 执行器
+   * @abstract
+   * @param {IModel} model
+   * @returns {*}  {IModel}
+   * @memberof ModelHandler
+   */
+  abstract execute(model: IModel): IModel;
+}

package/src/utils/model-transformer/model-register.ts

@@ -0,0 +1,15 @@
+import { ModelHandler } from './model-handler';
+import { ModelTransformer } from './model-transformer';
+
+/**
+ * @description 注册模型处理器
+ * @export
+ * @param {string} dynaModelFilePath 模型路径
+ * @param {ModelHandler} handler 模型处理器
+ */
+export function registerModelHandler(
+  dynaModelFilePath: string,
+  handler: ModelHandler,
+): void {
+  ModelTransformer.getInstance().registerHandler(dynaModelFilePath, handler);
+}

package/src/utils/model-transformer/model-transformer.ts

@@ -0,0 +1,124 @@
+import { ModelHandler } from './model-handler';
+
+/**
+ * @description 模型变换器
+ * @author tony001
+ * @date 2026-08-13 09:08:03
+ * @export
+ * @class ModelTransformer
+ */
+export class ModelTransformer {
+  /**
+   * @description 单例变量声明
+   * @private
+   * @static
+   * @type {ModelTransformer}
+   * @memberof ModelTransformer
+   */
+  private static modelTransformer: ModelTransformer;
+
+  /**
+   * @description 获取 ModelTransformer 单例对象
+   * @static
+   * @returns {*}  {ModelTransformer}
+   * @memberof ModelTransformer
+   */
+  public static getInstance(): ModelTransformer {
+    if (!this.modelTransformer) {
+      this.modelTransformer = new ModelTransformer();
+    }
+    return this.modelTransformer;
+  }
+
+  /**
+   * @description 模型处理器Map
+   * @private
+   * @type {Map<string, ModelHandler[]>}
+   * @memberof ModelTransformer
+   */
+  private handlerMap: Map<string, ModelHandler[]> = new Map();
+
+  /**
+   * @description 模型缓存Map
+   * @private
+   * @type {Map<string, IModel>}
+   * @memberof ModelTransformer
+   */
+  private modelCacheMap: Map<string, IModel> = new Map();
+
+  /**
+   * @description 注册模型处理器
+   * @param {string} dynaModelFilePath 模型路径
+   * @param {IModelHandler} handler 执行器
+   * @memberof ModelTransformer
+   */
+  public registerHandler(
+    dynaModelFilePath: string,
+    handler: ModelHandler,
+  ): void {
+    const handlers = this.handlerMap.get(dynaModelFilePath);
+    if (handlers) {
+      handlers.push(handler);
+    } else {
+      this.handlerMap.set(dynaModelFilePath, [handler]);
+    }
+    // 注册新处理器后清除该路径的模型缓存，确保新处理器能生效
+    this.modelCacheMap.delete(dynaModelFilePath);
+  }
+
+  /**
+   * @description 变换模型
+   * @param {string} dynaModelFilePath 模型路径
+   * @param {IModel} model 原始模型
+   * @returns {*}  {IModel}
+   * @memberof ModelTransformer
+   */
+  public transform(dynaModelFilePath: string, model: IModel): IModel {
+    ibiz.log.debug(
+      ibiz.i18n.t('modelHelper.utils.tryGetModel', {
+        dynaModelFilePath,
+      }),
+    );
+    if (this.modelCacheMap.has(dynaModelFilePath)) {
+      return this.modelCacheMap.get(dynaModelFilePath)!;
+    }
+    const handlers = this.handlerMap.get(dynaModelFilePath);
+    if (!handlers || handlers.length === 0) {
+      this.modelCacheMap.set(dynaModelFilePath, model);
+      return model;
+    }
+    // 按照优先级升序排序，优先级高的后执行
+    const sortedHandlers = [...handlers].sort(
+      (a: ModelHandler, b: ModelHandler) => a.priority - b.priority,
+    );
+    // 模型处理
+    let result = model;
+    for (const handler of sortedHandlers) {
+      try {
+        const next = handler.execute(result);
+        if (next) {
+          result = next;
+        } else {
+          ibiz.log.error(
+            ibiz.i18n.t('modelHelper.utils.transformNoModelData', {
+              dynaModelFilePath,
+            }),
+          );
+          // 未返回模型数据时返回传入的原始模型，防止界面异常
+          return model;
+        }
+      } catch (error) {
+        ibiz.log.error(
+          ibiz.i18n.t('modelHelper.utils.transformException', {
+            dynaModelFilePath,
+          }),
+          error,
+        );
+        // 执行异常时返回传入的原始模型，防止界面异常
+        return model;
+      }
+    }
+    this.modelCacheMap.set(dynaModelFilePath, result);
+    return result;
+  }
+}