@nocobase/flow-engine 2.1.0-beta.8 → 2.1.0

package/lib/flowContext.js

@@ -57,6 +57,7 @@ __export(flowContext_exports, {
 });
 module.exports = __toCommonJS(flowContext_exports);
 var import_reactive = require("@formily/reactive");
+var import_axios = __toESM(require("axios"));
 var antd = __toESM(require("antd"));
 var import_lodash = __toESM(require("lodash"));
 var import_qs = __toESM(require("qs"));
@@ -81,6 +82,28 @@ var import_dayjs = __toESM(require("dayjs"));
 var import_runjsLibs = require("./runjsLibs");
 var import_runjsModuleLoader = require("./utils/runjsModuleLoader");
 var _proxy, _FlowContext_instances, createChildNodes_fn, findMetaByPath_fn, findMetaInDelegatesDeep_fn, findMetaInProperty_fn, resolvePathInMeta_fn, resolvePathInMetaAsync_fn, buildParentTitles_fn, toTreeNode_fn;
+function normalizePathname(pathname) {
+  return pathname.endsWith("/") ? pathname : `${pathname}/`;
+}
+__name(normalizePathname, "normalizePathname");
+function shouldBypassApiClient(url, app) {
+  try {
+    const requestUrl = new URL(url);
+    if (!["http:", "https:"].includes(requestUrl.protocol)) {
+      return false;
+    }
+    if (!(app == null ? void 0 : app.getApiUrl)) {
+      return true;
+    }
+    const apiUrl = new URL(app.getApiUrl());
+    const apiPath = normalizePathname(apiUrl.pathname);
+    const requestPath = normalizePathname(requestUrl.pathname);
+    return requestUrl.origin !== apiUrl.origin || !requestPath.startsWith(apiPath);
+  } catch {
+    return false;
+  }
+}
+__name(shouldBypassApiClient, "shouldBypassApiClient");
 function isRecordRefLike(val) {
   return !!(val && typeof val === "object" && "collection" in val && "filterByTk" in val);
 }
@@ -376,10 +399,11 @@ const _FlowContext = class _FlowContext {
    * - 输出仅来自 RunJS doc 与 defineProperty/defineMethod 的 info
    * - 不读取/展开 PropertyMeta（变量结构）
    * - 不自动展开深层 properties
-   * - 不返回自动补全字段（例如 completion）
+   * - 默认不返回自动补全字段（例如 completion），传入 includeCompletion=true 时返回
    */
   async getApiInfos(options = {}) {
     const version = options.version || "v1";
+    const includeCompletion = !!options.includeCompletion;
     const evalCtx = this.createProxy();
     const isPrivateKey = /* @__PURE__ */ __name((key) => typeof key === "string" && key.startsWith("_"), "isPrivateKey");
     const isVarRootKey = /* @__PURE__ */ __name((key) => key === "record" || key === "formValues" || key === "popup", "isVarRootKey");
@@ -416,7 +440,14 @@ const _FlowContext = class _FlowContext {
       const src = toDocObject(obj);
       if (!src) return {};
       const out2 = {};
-      for (const k of ["description", "examples", "ref", "params", "returns"]) {
+      for (const k of [
+        "description",
+        "examples",
+        ...includeCompletion ? ["completion"] : [],
+        "ref",
+        "params",
+        "returns"
+      ]) {
         const v = src[k];
         if (typeof v !== "undefined") out2[k] = v;
       }
@@ -429,7 +460,17 @@ const _FlowContext = class _FlowContext {
       const src = toDocObject(obj);
       if (!src) return {};
       const out2 = {};
-      for (const k of ["title", "type", "interface", "description", "examples", "ref", "params", "returns"]) {
+      for (const k of [
+        "title",
+        "type",
+        "interface",
+        "description",
+        "examples",
+        ...includeCompletion ? ["completion"] : [],
+        "ref",
+        "params",
+        "returns"
+      ]) {
         const v = src[k];
         if (typeof v !== "undefined") out2[k] = v;
       }
@@ -516,7 +557,7 @@ const _FlowContext = class _FlowContext {
       node = { ...node, ...pickPropertyInfo(docObj) };
       node = { ...node, ...pickPropertyInfo(infoObj) };
       delete node.properties;
-      delete node.completion;
+      if (!includeCompletion) delete node.completion;
       if (!Object.keys(node).length) continue;
       const outKey = mapDocKeyToApiKey(key, docNode);
       out[outKey] = out[outKey] ? { ...out[outKey] || {}, ...node || {} } : node;
@@ -531,7 +572,7 @@ const _FlowContext = class _FlowContext {
       node = { ...node, ...pickMethodInfo(docObj) };
       node = { ...node, ...pickMethodInfo(info) };
       delete node.properties;
-      delete node.completion;
+      if (!includeCompletion) delete node.completion;
       if (!Object.keys(node).length) continue;
       node.type = "function";
       if (!out[key]) out[key] = node;
@@ -548,7 +589,7 @@ const _FlowContext = class _FlowContext {
         let node = {};
         node = { ...node, ...pickPropertyInfo(childObj) };
         delete node.properties;
-        delete node.completion;
+        if (!includeCompletion) delete node.completion;
         if (!node.description || !String(node.description).trim()) continue;
         out[outKey] = node;
       }
@@ -2211,6 +2252,10 @@ const _BaseFlowEngineContext = class _BaseFlowEngineContext extends FlowContext
       return this.engine.getModel(modelName, searchInPreviousEngines);
     });
     this.defineMethod("request", (options) => {
+      const app = this.app;
+      if (typeof (options == null ? void 0 : options.url) === "string" && shouldBypassApiClient(options.url, app)) {
+        return import_axios.default.request(options);
+      }
       return this.api.request(options);
     });
     this.defineMethod(
@@ -2228,6 +2273,17 @@ const _BaseFlowEngineContext = class _BaseFlowEngineContext extends FlowContext
         });
         const jsCode = await (0, import_utils.prepareRunJsCode)(String(code ?? ""), { preprocessTemplates: shouldPreprocessTemplates });
         return runner.run(jsCode);
+      },
+      {
+        description: "Execute a RunJS code string in the current Flow context.",
+        detail: "(code: string, variables?: Record<string, any>, options?: JSRunnerOptions) => Promise<RunJSResult>",
+        params: [
+          { name: "code", type: "string", description: "RunJS code to execute." },
+          { name: "variables", type: "Record<string, any>", optional: true, description: "Additional globals." },
+          { name: "options", type: "JSRunnerOptions", optional: true, description: "Runner options." }
+        ],
+        returns: { type: "Promise<{ success: boolean; value?: any; error?: any; timeout?: boolean }>" },
+        completion: { insertText: `await ctx.runjs('return 1')` }
       }
     );
   }
@@ -2280,6 +2336,18 @@ const _FlowEngineContext = class _FlowEngineContext extends BaseFlowEngineContex
     this.defineMethod("t", (keyOrTemplate, options) => {
       return i18n.translate(keyOrTemplate, options);
     });
+    this.defineProperty("locale", {
+      get: /* @__PURE__ */ __name(() => {
+        var _a, _b, _c;
+        return ((_b = (_a = this.api) == null ? void 0 : _a.auth) == null ? void 0 : _b.locale) || ((_c = this.i18n) == null ? void 0 : _c.language);
+      }, "get"),
+      cache: false,
+      meta: Object.assign(() => ({ type: "string", title: this.t("Current language"), sort: 970 }), {
+        title: (0, import_utils.escapeT)("Current language"),
+        sort: 970,
+        hasChildren: false
+      })
+    });
     this.defineMethod("renderJson", function(template) {
       return this.resolveJsonTemplate(template);
     });
@@ -2658,6 +2726,9 @@ const _FlowEngineContext = class _FlowEngineContext extends BaseFlowEngineContex
       }, "get")
     });
     this.defineMethod("aclCheck", function(params) {
+      if (this.skipAclCheck) {
+        return true;
+      }
       return this.acl.aclCheck(params);
     });
     this.defineMethod("createResource", function(resourceType) {

package/lib/flowEngine.d.ts

@@ -8,7 +8,7 @@ import { FlowResource } from './resources';
 import { Emitter } from './emitter';
 import ModelOperationScheduler from './scheduler/ModelOperationScheduler';
 import type { ScheduleOptions, ScheduledCancel } from './scheduler/ModelOperationScheduler';
-import type { ActionDefinition, ApplyFlowCacheEntry, CreateModelOptions, EventDefinition, FlowModelOptions, IFlowModelRepository, ModelConstructor, PersistOptions, ResourceType } from './types';
+import type { ActionDefinition, ApplyFlowCacheEntry, CreateModelOptions, EnsureBatchResult, EventDefinition, FlowModelLoaderInputMap, FlowModelOptions, IFlowModelRepository, ModelConstructor, PersistOptions, ResourceType } from './types';
 /**
  * FlowEngine is the core class of the flow engine, responsible for managing flow models, actions, model repository, and more.
  * It provides capabilities for registering, creating, finding, persisting, replacing, and moving models.
@@ -47,6 +47,28 @@ export declare class FlowEngine {
      * @private
      */
     private _modelClasses;
+    /**
+     * Registered model entries.
+     * Key is the model class name, value is the model loader entry.
+     * @private
+     */
+    private _modelLoaders;
+    /**
+     * In-flight model loading promises.
+     * Key is the model class name, value is the loading promise.
+     * @private
+     */
+    private _loadingModelPromises;
+    /**
+     * Whether model-loader preload has completed in this session.
+     * @private
+     */
+    private _modelLoadersPreloaded;
+    /**
+     * In-flight model-loader preload promise.
+     * @private
+     */
+    private _modelLoadersPreloadPromise?;
     /**
      * Created model instances.
      * Key is the model instance UID, value is the model instance object.
@@ -71,6 +93,7 @@ export declare class FlowEngine {
      * @private
      */
     private _savingModels;
+    private _loadedPageCache;
     /**
      * Flow engine context object.
      * @private
@@ -226,6 +249,10 @@ export declare class FlowEngine {
      * Get all registered global events.
      */
     getEvents<TModel extends FlowModel = FlowModel>(): Map<string, EventDefinition<TModel>>;
+    /**
+     * for proxy instance, the #registerModel can't be called.
+     */
+    private _registerModel;
     /**
      * Register multiple model classes.
      * @param {Record<string, ModelConstructor>} models Model class map, key is model name, value is model constructor
@@ -234,6 +261,102 @@ export declare class FlowEngine {
      * flowEngine.registerModels({ UserModel, OrderModel });
      */
     registerModels(models: Record<string, ModelConstructor | typeof FlowModel<any>>): void;
+    /**
+     * Register multiple model loader entries.
+     * The `extends` field declares parent class(es) for async subclass discovery via `getSubclassesOfAsync`.
+     * It accepts `string | ModelConstructor | (string | ModelConstructor)[]` and is normalized to `string[]` internally.
+     * @param {FlowModelLoaderInputMap} loaders Model loader input map
+     * @returns {void}
+     * @example
+     * flowEngine.registerModelLoaders({
+     *   DemoModel: {
+     *     extends: 'BaseModel',
+     *     loader: () => import('./models/DemoModel'),
+     *   },
+     * });
+     */
+    registerModelLoaders(loaders: FlowModelLoaderInputMap): void;
+    /**
+     * Get a registered model class (constructor) asynchronously.
+     * This will first ensure the model loader entry is resolved.
+     * @param {string} name Model class name
+     * @returns {Promise<ModelConstructor | undefined>} Model constructor, or undefined if not found
+     */
+    getModelClassAsync(name: string): Promise<ModelConstructor | undefined>;
+    /**
+     * Get all registered model classes asynchronously.
+     * This will first ensure all registered model loader entries are resolved.
+     * @returns {Promise<Map<string, ModelConstructor>>} Model class map
+     */
+    getModelClassesAsync(): Promise<Map<string, ModelConstructor>>;
+    /**
+     * Create and register a model instance asynchronously.
+     * This will first ensure all string-based model references in the model tree are resolved.
+     * @template T FlowModel subclass type, defaults to FlowModel.
+     * @param {CreateModelOptions} options Model creation options
+     * @returns {Promise<T>} Created model instance
+     */
+    createModelAsync<T extends FlowModel = FlowModel>(options: CreateModelOptions, extra?: {
+        delegateToParent?: boolean;
+        delegate?: FlowContext;
+    }): Promise<T>;
+    /**
+     * Normalize a loader result into a model constructor.
+     * @param {string} name Model class name
+     * @param {FlowModelLoaderResult} loaded Loader result
+     * @returns {ModelConstructor | null} Normalized model constructor
+     * @private
+     */
+    private normalizeModelLoaderResult;
+    /**
+     * Collect string-based model names from a model tree.
+     * @param {unknown} data Model tree data
+     * @param {Set<string>} names Model name set
+     * @private
+     */
+    private collectModelNamesFromTree;
+    /**
+     * Collect additional model names from object-form meta.createModelOptions defaults.
+     * @param {ModelConstructor} modelClass Model class constructor
+     * @param {Set<string>} names Model name set
+     * @private
+     */
+    private collectModelNamesFromMetaDefaults;
+    /**
+     * Ensure a single model class is available.
+     * @param {string} name Model class name
+     * @returns {Promise<ModelConstructor | null>} Model constructor or null when resolution fails
+     * @private
+     */
+    private ensureModel;
+    /**
+     * Ensure multiple model classes are available.
+     * @param {string[]} names Model class names
+     * @returns {Promise<EnsureBatchResult>} Batch ensure result
+     * @private
+     */
+    private ensureModels;
+    /**
+     * Resolve all unresolved string-based model references in a model tree before synchronous creation begins.
+     *
+     * Use this when you already have a model tree object, such as repository-returned data or resolved
+     * `createModelOptions`, and you need to ensure every string `use` in that tree has been loaded and
+     * registered into `_modelClasses` before calling `createModel()`.
+     *
+     * @param {unknown} data Model tree data
+     * @returns {Promise<EnsureBatchResult>} Batch ensure result
+     */
+    resolveModelTree(data: unknown): Promise<EnsureBatchResult>;
+    /**
+     * Preload all currently registered unresolved model loaders.
+     *
+     * This method is intended for flow-settings/discovery style entry points that need registered model
+     * classes to exist before UI is rendered, without requiring callers to know which specific models
+     * will be touched next.
+     *
+     * @returns {Promise<EnsureBatchResult>} Batch ensure result
+     */
+    preloadModelLoaders(): Promise<EnsureBatchResult>;
     registerResources(resources: Record<string, any>): void;
     createResource<T = FlowResource>(resourceType: ResourceType<T>, options?: {
         context?: FlowContext;
@@ -262,6 +385,15 @@ export declare class FlowEngine {
      * @returns {Map<string, ModelConstructor>} Model classes inherited from base class and passed the filter
      */
     getSubclassesOf(baseClass: string | ModelConstructor, filter?: (ModelClass: ModelConstructor, className: string) => boolean): Map<string, ModelConstructor>;
+    /**
+     * Asynchronously get all subclasses of a base class, including those registered via model loaders.
+     * Merges results from already-loaded classes (_modelClasses) and async loader entries with matching `extends` declarations.
+     * Loader-resolved classes are validated with `isInheritedFrom`; mismatches are warned and excluded.
+     * @param {string | ModelConstructor} baseClass Base class name or constructor
+     * @param {(ModelClass: ModelConstructor, className: string) => boolean} [filter] Optional filter function
+     * @returns {Promise<Map<string, ModelConstructor>>} Model classes that are subclasses of the base class
+     */
+    getSubclassesOfAsync(baseClass: string | ModelConstructor, filter?: (ModelClass: ModelConstructor, className: string) => boolean): Promise<Map<string, ModelConstructor>>;
     /**
      * Create and register a model instance.
      * If an instance with the same UID exists, returns the existing instance.
@@ -406,11 +538,11 @@ export declare class FlowEngine {
     replaceModel<T extends FlowModel = FlowModel>(uid: string, optionsOrFn?: Partial<FlowModelOptions> | ((currentOptions: FlowModelOptions) => Partial<FlowModelOptions>)): Promise<T | null>;
     /**
      * Move a model instance within its parent model.
-     * @param {any} sourceId Source model UID
-     * @param {any} targetId Target model UID
+     * @param {string | number} sourceId Source model UID
+     * @param {string | number} targetId Target model UID
      * @returns {Promise<void>} No return value
      */
-    moveModel(sourceId: any, targetId: any, options?: PersistOptions): Promise<void>;
+    moveModel(sourceId: string | number, targetId: string | number, options?: PersistOptions): Promise<void>;
     /**
      * Filter model classes by parent class (supports multi-level inheritance).
      * @param {string | ModelConstructor} parentClass Parent class name or constructor