@gct-paas/core 0.1.4-dev.10 → 0.1.4-dev.12

package/es/utils/model-loader/model-loader.mjs

@@ -1,326 +1,281 @@
-import { cloneDeep } from 'lodash-es';
-import { EntityModelCategoryEnum } from '../../enums/app-designer/index.mjs';
-import '../../enums/page-designer/designer.mjs';
-import '../../enums/breakpointEnum.mjs';
-
-class ModelLoader {
-  // 缓存过期时间（毫秒），默认10分钟
-  CACHE_EXPIRATION_TIME = 10 * 60 * 1e3;
-  modelCache = /* @__PURE__ */ new Map();
-  modelLoadingCache = /* @__PURE__ */ new Map();
-  modelsLoadingCache = /* @__PURE__ */ new Map();
-  enumCache = /* @__PURE__ */ new Map();
-  enumLoadingCache = /* @__PURE__ */ new Map();
-  queryRefDataCache = /* @__PURE__ */ new Map();
-  queryRefDataLoadingCache = /* @__PURE__ */ new Map();
-  /**
-   * 检查缓存条目是否过期
-   *
-   * @param {CacheEntry<any>} entry
-   * @returns {*}  {boolean}
-   */
-  isExpired(entry) {
-    return Date.now() > entry.expiresAt;
-  }
-  /**
-   * 创建缓存条目
-   *
-   * @param {T} data
-   * @returns {*}  {CacheEntry<T>}
-   */
-  createCacheEntry(data) {
-    return {
-      data,
-      expiresAt: Date.now() + this.CACHE_EXPIRATION_TIME
-    };
-  }
-  /**
-   * 加载模型信息，具有缓存和请求去重功能
-   *
-   * @author chitanda
-   * @date 2025-06-20 16:06:05
-   * @param {string} modelKey
-   * @returns {*}  {Promise<ModelMetaDTO>}
-   */
-  async loadModel(modelKey) {
-    if (this.modelCache.has(modelKey)) {
-      const cacheEntry = this.modelCache.get(modelKey);
-      if (!this.isExpired(cacheEntry)) {
-        return cacheEntry.data;
-      }
-      this.modelCache.delete(modelKey);
-    }
-    if (this.modelLoadingCache.has(modelKey)) {
-      return this.modelLoadingCache.get(modelKey);
-    }
-    const loadPromise = (async () => {
-      try {
-        const data = await _api.apaas.modelMeta.getDetail({ modelKey });
-        if (data) {
-          this.modelCache.set(modelKey, this.createCacheEntry(data));
-          return data;
-        }
-        return {};
-      } finally {
-        this.modelLoadingCache.delete(modelKey);
-      }
-    })();
-    this.modelLoadingCache.set(modelKey, loadPromise);
-    return loadPromise;
-  }
-  /**
-   * 加载多个模型信息
-   *
-   * @author chitanda
-   * @date 2025-06-22 15:06:54
-   * @param {string[]} modelKeys
-   * @returns {*}  {Promise<ModelMetaDTO[]>}
-   */
-  async loadModels(modelKeys) {
-    const cacheKey = modelKeys.join(",");
-    const allCached = modelKeys.every((key) => {
-      const entry = this.modelCache.get(key);
-      return entry && !this.isExpired(entry);
-    });
-    if (allCached) {
-      return modelKeys.map((key) => this.modelCache.get(key).data);
-    }
-    modelKeys.forEach((key) => {
-      const entry = this.modelCache.get(key);
-      if (entry && this.isExpired(entry)) {
-        this.modelCache.delete(key);
-      }
-    });
-    if (this.modelsLoadingCache.has(cacheKey)) {
-      return this.modelsLoadingCache.get(cacheKey);
-    }
-    const loadPromise = (async () => {
-      try {
-        const pendingKeys = modelKeys.filter((key) => !this.modelCache.has(key));
-        if (pendingKeys.length > 0) {
-          const data = await _api.apaas.modelMeta.getByKeys({
-            modelKeys: pendingKeys.join(",")
-          });
-          if (data && data.length > 0) {
-            data.forEach((model) => {
-              this.modelCache.set(model.key, this.createCacheEntry(model));
-              model.fieldMetaList = model.fieldMetas || [];
-            });
-          }
-        }
-        return modelKeys.map((key) => {
-          const entry = this.modelCache.get(key);
-          return entry.data;
-        });
-      } finally {
-        this.modelsLoadingCache.delete(cacheKey);
-      }
-    })();
-    this.modelsLoadingCache.set(cacheKey, loadPromise);
-    return loadPromise;
-  }
-  /**
-   * 加载指定模型的字段信息
-   *
-   * @author chitanda
-   * @date 2025-06-22 14:06:37
-   * @param {string} modelKey
-   * @param {string} fieldKey
-   * @returns {*}  {(Promise<FieldMetaDTO | undefined>)}
-   */
-  async loadField(modelKey, fieldKey) {
-    const model = await this.loadModel(modelKey);
-    if (model?.fieldMetaList) {
-      return model.fieldMetaList.find((field) => field.key === fieldKey);
-    }
-    return void 0;
-  }
-  /**
-   * 加载指定模型的字段路径信息
-   *
-   * @author chitanda
-   * @date 2025-06-22 14:06:11
-   * @param {string} modelKey
-   * @param {string} fieldKey
-   * @returns {*}  {Promise<string[]>}
-   */
-  async loadFieldPaths(modelKey, fieldKey, fieldCodeChain) {
-    if (!fieldCodeChain) {
-      return [];
-    }
-    const list = [];
-    const isFieldModel = !!fieldCodeChain.bindFieldKey;
-    const modelKeys = isFieldModel ? fieldCodeChain.modelLink || [
-      fieldCodeChain.belongModelKey,
-      fieldCodeChain.bindModelKey
-    ] : [fieldCodeChain.modelKey];
-    const models = await this.loadModels(modelKeys);
-    if (isFieldModel) {
-      list.push(...models.map((model2) => model2.name));
-    } else {
-      const model2 = await this.loadModel(fieldCodeChain.modelKey);
-      if (model2) {
-        list.push(model2.name);
-      }
-    }
-    const model = await this.loadModel(modelKey);
-    if (model?.fieldMetaList) {
-      const field = model.fieldMetaList.find((field2) => field2.key === fieldKey);
-      if (field) {
-        list.push(field.name);
-      }
-    }
-    return list;
-  }
-  /**
-   * 加载指定模型的枚举列表
-   *
-   * @param {string} modelKey
-   * @param {string} fieldKey
-   * @param {string} [modelCategory=EntityModelCategoryEnum.ENTITY]
-   * @returns {*}  {Promise<IObject[]>}
-   */
-  async loadEnumList(modelKey, fieldKey, modelCategory = EntityModelCategoryEnum.ENTITY) {
-    const cacheKey = `${modelCategory}:${modelKey}:${fieldKey}`;
-    if (this.enumCache.has(cacheKey)) {
-      const cacheEntry = this.enumCache.get(cacheKey);
-      if (!this.isExpired(cacheEntry)) {
-        return cloneDeep(cacheEntry.data);
-      }
-      this.enumCache.delete(cacheKey);
-      this.enumLoadingCache.delete(cacheKey);
-    }
-    if (this.enumLoadingCache.has(cacheKey)) {
-      return this.enumLoadingCache.get(cacheKey);
-    }
-    const loadPromise = (async () => {
-      try {
-        return [];
-      } finally {
-        this.enumLoadingCache.delete(cacheKey);
-      }
-    })();
-    this.enumLoadingCache.set(cacheKey, loadPromise);
-    return loadPromise;
-  }
-  /**
-   * 加载关联数据查询（QueryRef）
-   *
-   * @param {QueryRefDataRequest} request
-   * @returns {*}  {Promise<ModelPageableRow>}
-   */
-  async loadQueryRefData(request) {
-    if (!request || !request.modelKey) {
-      throw new Error(`queryRefData 参数缺失`);
-    }
-    const cacheKey = JSON.stringify(request);
-    if (this.queryRefDataCache.has(cacheKey)) {
-      const cacheEntry = this.queryRefDataCache.get(cacheKey);
-      if (!this.isExpired(cacheEntry)) {
-        return cloneDeep(cacheEntry.data);
-      }
-      this.queryRefDataCache.delete(cacheKey);
-      this.queryRefDataLoadingCache.delete(cacheKey);
-    }
-    if (this.queryRefDataLoadingCache.has(cacheKey)) {
-      return this.queryRefDataLoadingCache.get(cacheKey);
-    }
-    const loadPromise = (async () => {
-      try {
-        const data = await _api.apaas.modelData.postQueryRefData(request);
-        if (data) {
-          this.queryRefDataCache.set(cacheKey, this.createCacheEntry(data));
-          return cloneDeep(data);
-        }
-        return {};
-      } finally {
-        this.queryRefDataLoadingCache.delete(cacheKey);
-      }
-    })();
-    this.queryRefDataLoadingCache.set(cacheKey, loadPromise);
-    return loadPromise;
-  }
-  /**
-   * 获取已缓存的模型
-   * @param modelKey 模型键
-   * @returns ModelMetaDTO | undefined
-   */
-  getCachedModel(modelKey) {
-    const entry = this.modelCache.get(modelKey);
-    if (entry && !this.isExpired(entry)) {
-      return entry.data;
-    }
-    if (entry && this.isExpired(entry)) {
-      this.modelCache.delete(modelKey);
-    }
-    return void 0;
-  }
-  /**
-   * 清除指定模型的缓存
-   *
-   * @author chitanda
-   * @date 2025-06-20 16:06:41
-   * @param {string} modelKey
-   */
-  clear(modelKey) {
-    this.modelCache.delete(modelKey);
-    this.modelLoadingCache.delete(modelKey);
-    const keysToDelete = [];
-    this.modelsLoadingCache.forEach((_, cacheKey) => {
-      if (cacheKey.includes(modelKey)) {
-        keysToDelete.push(cacheKey);
-      }
-    });
-    keysToDelete.forEach((key) => {
-      this.modelsLoadingCache.delete(key);
-    });
-    const enumKeysToDelete = [];
-    this.enumCache.forEach((_, cacheKey) => {
-      if (cacheKey.includes(modelKey)) {
-        enumKeysToDelete.push(cacheKey);
-      }
-    });
-    enumKeysToDelete.forEach((key) => {
-      this.enumCache.delete(key);
-      this.enumLoadingCache.delete(key);
-    });
-    const queryRefKeysToDelete = [];
-    this.queryRefDataCache.forEach((_, cacheKey) => {
-      if (cacheKey.includes(`"modelKey":"${modelKey}"`)) {
-        queryRefKeysToDelete.push(cacheKey);
-      }
-    });
-    queryRefKeysToDelete.forEach((key) => {
-      this.queryRefDataCache.delete(key);
-      this.queryRefDataLoadingCache.delete(key);
-    });
-  }
-  /**
-   * 清除所有模型缓存
-   *
-   * @author chitanda
-   * @date 2025-06-20 16:06:35
-   */
-  clearAll() {
-    this.modelCache.clear();
-    this.modelLoadingCache.clear();
-    this.modelsLoadingCache.clear();
-    this.enumCache.clear();
-    this.enumLoadingCache.clear();
-    this.queryRefDataCache.clear();
-    this.queryRefDataLoadingCache.clear();
-  }
-  /**
-   * 获取所有已缓存的模型键
-   *
-   * @author chitanda
-   * @date 2025-06-20 16:06:55
-   * @returns {*}  {string[]}
-   */
-  keys() {
-    return Array.from(this.modelCache.keys());
-  }
-}
-const modelLoader = new ModelLoader();
-
+import { EntityModelCategoryEnum } from "../../enums/app-designer/index.mjs";
+import "../../enums/index.mjs";
+import { cloneDeep } from "lodash-es";
+//#region src/utils/model-loader/model-loader.ts
+/**
+* 模型加载器，提供模型缓存和请求去重功能
+*
+* @author chitanda
+* @date 2025-06-20 16:06:12
+* @class ModelLoader
+*/
+var ModelLoader = class {
+	CACHE_EXPIRATION_TIME = 600 * 1e3;
+	modelCache = /* @__PURE__ */ new Map();
+	modelLoadingCache = /* @__PURE__ */ new Map();
+	modelsLoadingCache = /* @__PURE__ */ new Map();
+	enumCache = /* @__PURE__ */ new Map();
+	enumLoadingCache = /* @__PURE__ */ new Map();
+	queryRefDataCache = /* @__PURE__ */ new Map();
+	queryRefDataLoadingCache = /* @__PURE__ */ new Map();
+	/**
+	* 检查缓存条目是否过期
+	*
+	* @param {CacheEntry<any>} entry
+	* @returns {*}  {boolean}
+	*/
+	isExpired(entry) {
+		return Date.now() > entry.expiresAt;
+	}
+	/**
+	* 创建缓存条目
+	*
+	* @param {T} data
+	* @returns {*}  {CacheEntry<T>}
+	*/
+	createCacheEntry(data) {
+		return {
+			data,
+			expiresAt: Date.now() + this.CACHE_EXPIRATION_TIME
+		};
+	}
+	/**
+	* 加载模型信息，具有缓存和请求去重功能
+	*
+	* @author chitanda
+	* @date 2025-06-20 16:06:05
+	* @param {string} modelKey
+	* @returns {*}  {Promise<ModelMetaDTO>}
+	*/
+	async loadModel(modelKey) {
+		if (this.modelCache.has(modelKey)) {
+			const cacheEntry = this.modelCache.get(modelKey);
+			if (!this.isExpired(cacheEntry)) return cacheEntry.data;
+			this.modelCache.delete(modelKey);
+		}
+		if (this.modelLoadingCache.has(modelKey)) return this.modelLoadingCache.get(modelKey);
+		const loadPromise = (async () => {
+			try {
+				const data = await _api.apaas.modelMeta.getDetail({ modelKey });
+				if (data) {
+					this.modelCache.set(modelKey, this.createCacheEntry(data));
+					return data;
+				}
+				return {};
+			} finally {
+				this.modelLoadingCache.delete(modelKey);
+			}
+		})();
+		this.modelLoadingCache.set(modelKey, loadPromise);
+		return loadPromise;
+	}
+	/**
+	* 加载多个模型信息
+	*
+	* @author chitanda
+	* @date 2025-06-22 15:06:54
+	* @param {string[]} modelKeys
+	* @returns {*}  {Promise<ModelMetaDTO[]>}
+	*/
+	async loadModels(modelKeys) {
+		const cacheKey = modelKeys.join(",");
+		if (modelKeys.every((key) => {
+			const entry = this.modelCache.get(key);
+			return entry && !this.isExpired(entry);
+		})) return modelKeys.map((key) => this.modelCache.get(key).data);
+		modelKeys.forEach((key) => {
+			const entry = this.modelCache.get(key);
+			if (entry && this.isExpired(entry)) this.modelCache.delete(key);
+		});
+		if (this.modelsLoadingCache.has(cacheKey)) return this.modelsLoadingCache.get(cacheKey);
+		const loadPromise = (async () => {
+			try {
+				const pendingKeys = modelKeys.filter((key) => !this.modelCache.has(key));
+				if (pendingKeys.length > 0) {
+					const data = await _api.apaas.modelMeta.getByKeys({ modelKeys: pendingKeys.join(",") });
+					if (data && data.length > 0) data.forEach((model) => {
+						this.modelCache.set(model.key, this.createCacheEntry(model));
+						model.fieldMetaList = model.fieldMetas || [];
+					});
+				}
+				return modelKeys.map((key) => {
+					return this.modelCache.get(key).data;
+				});
+			} finally {
+				this.modelsLoadingCache.delete(cacheKey);
+			}
+		})();
+		this.modelsLoadingCache.set(cacheKey, loadPromise);
+		return loadPromise;
+	}
+	/**
+	* 加载指定模型的字段信息
+	*
+	* @author chitanda
+	* @date 2025-06-22 14:06:37
+	* @param {string} modelKey
+	* @param {string} fieldKey
+	* @returns {*}  {(Promise<FieldMetaDTO | undefined>)}
+	*/
+	async loadField(modelKey, fieldKey) {
+		const model = await this.loadModel(modelKey);
+		if (model?.fieldMetaList) return model.fieldMetaList.find((field) => field.key === fieldKey);
+	}
+	/**
+	* 加载指定模型的字段路径信息
+	*
+	* @author chitanda
+	* @date 2025-06-22 14:06:11
+	* @param {string} modelKey
+	* @param {string} fieldKey
+	* @returns {*}  {Promise<string[]>}
+	*/
+	async loadFieldPaths(modelKey, fieldKey, fieldCodeChain) {
+		if (!fieldCodeChain) return [];
+		const list = [];
+		const isFieldModel = !!fieldCodeChain.bindFieldKey;
+		const modelKeys = isFieldModel ? fieldCodeChain.modelLink || [fieldCodeChain.belongModelKey, fieldCodeChain.bindModelKey] : [fieldCodeChain.modelKey];
+		const models = await this.loadModels(modelKeys);
+		if (isFieldModel) list.push(...models.map((model) => model.name));
+		else {
+			const model = await this.loadModel(fieldCodeChain.modelKey);
+			if (model) list.push(model.name);
+		}
+		const model = await this.loadModel(modelKey);
+		if (model?.fieldMetaList) {
+			const field = model.fieldMetaList.find((field) => field.key === fieldKey);
+			if (field) list.push(field.name);
+		}
+		return list;
+	}
+	/**
+	* 加载指定模型的枚举列表
+	*
+	* @param {string} modelKey
+	* @param {string} fieldKey
+	* @param {string} [modelCategory=EntityModelCategoryEnum.ENTITY]
+	* @returns {*}  {Promise<IObject[]>}
+	*/
+	async loadEnumList(modelKey, fieldKey, modelCategory = EntityModelCategoryEnum.ENTITY) {
+		const cacheKey = `${modelCategory}:${modelKey}:${fieldKey}`;
+		if (this.enumCache.has(cacheKey)) {
+			const cacheEntry = this.enumCache.get(cacheKey);
+			if (!this.isExpired(cacheEntry)) return cloneDeep(cacheEntry.data);
+			this.enumCache.delete(cacheKey);
+			this.enumLoadingCache.delete(cacheKey);
+		}
+		if (this.enumLoadingCache.has(cacheKey)) return this.enumLoadingCache.get(cacheKey);
+		const loadPromise = (async () => {
+			try {
+				return [];
+			} finally {
+				this.enumLoadingCache.delete(cacheKey);
+			}
+		})();
+		this.enumLoadingCache.set(cacheKey, loadPromise);
+		return loadPromise;
+	}
+	/**
+	* 加载关联数据查询（QueryRef）
+	*
+	* @param {QueryRefDataRequest} request
+	* @returns {*}  {Promise<ModelPageableRow>}
+	*/
+	async loadQueryRefData(request) {
+		if (!request || !request.modelKey) throw new Error(`queryRefData 参数缺失`);
+		const cacheKey = JSON.stringify(request);
+		if (this.queryRefDataCache.has(cacheKey)) {
+			const cacheEntry = this.queryRefDataCache.get(cacheKey);
+			if (!this.isExpired(cacheEntry)) return cloneDeep(cacheEntry.data);
+			this.queryRefDataCache.delete(cacheKey);
+			this.queryRefDataLoadingCache.delete(cacheKey);
+		}
+		if (this.queryRefDataLoadingCache.has(cacheKey)) return this.queryRefDataLoadingCache.get(cacheKey);
+		const loadPromise = (async () => {
+			try {
+				const data = await _api.apaas.modelData.postQueryRefData(request);
+				if (data) {
+					this.queryRefDataCache.set(cacheKey, this.createCacheEntry(data));
+					return cloneDeep(data);
+				}
+				return {};
+			} finally {
+				this.queryRefDataLoadingCache.delete(cacheKey);
+			}
+		})();
+		this.queryRefDataLoadingCache.set(cacheKey, loadPromise);
+		return loadPromise;
+	}
+	/**
+	* 获取已缓存的模型
+	* @param modelKey 模型键
+	* @returns ModelMetaDTO | undefined
+	*/
+	getCachedModel(modelKey) {
+		const entry = this.modelCache.get(modelKey);
+		if (entry && !this.isExpired(entry)) return entry.data;
+		if (entry && this.isExpired(entry)) this.modelCache.delete(modelKey);
+	}
+	/**
+	* 清除指定模型的缓存
+	*
+	* @author chitanda
+	* @date 2025-06-20 16:06:41
+	* @param {string} modelKey
+	*/
+	clear(modelKey) {
+		this.modelCache.delete(modelKey);
+		this.modelLoadingCache.delete(modelKey);
+		const keysToDelete = [];
+		this.modelsLoadingCache.forEach((_, cacheKey) => {
+			if (cacheKey.includes(modelKey)) keysToDelete.push(cacheKey);
+		});
+		keysToDelete.forEach((key) => {
+			this.modelsLoadingCache.delete(key);
+		});
+		const enumKeysToDelete = [];
+		this.enumCache.forEach((_, cacheKey) => {
+			if (cacheKey.includes(modelKey)) enumKeysToDelete.push(cacheKey);
+		});
+		enumKeysToDelete.forEach((key) => {
+			this.enumCache.delete(key);
+			this.enumLoadingCache.delete(key);
+		});
+		const queryRefKeysToDelete = [];
+		this.queryRefDataCache.forEach((_, cacheKey) => {
+			if (cacheKey.includes(`"modelKey":"${modelKey}"`)) queryRefKeysToDelete.push(cacheKey);
+		});
+		queryRefKeysToDelete.forEach((key) => {
+			this.queryRefDataCache.delete(key);
+			this.queryRefDataLoadingCache.delete(key);
+		});
+	}
+	/**
+	* 清除所有模型缓存
+	*
+	* @author chitanda
+	* @date 2025-06-20 16:06:35
+	*/
+	clearAll() {
+		this.modelCache.clear();
+		this.modelLoadingCache.clear();
+		this.modelsLoadingCache.clear();
+		this.enumCache.clear();
+		this.enumLoadingCache.clear();
+		this.queryRefDataCache.clear();
+		this.queryRefDataLoadingCache.clear();
+	}
+	/**
+	* 获取所有已缓存的模型键
+	*
+	* @author chitanda
+	* @date 2025-06-20 16:06:55
+	* @returns {*}  {string[]}
+	*/
+	keys() {
+		return Array.from(this.modelCache.keys());
+	}
+};
+var modelLoader = new ModelLoader();
+//#endregion
 export { modelLoader };