@nocobase/plugin-flow-engine 2.3.0-alpha.1 → 2.3.0-beta.3

package/dist/server/flow-surfaces/field-binding-registry.js

@@ -58,14 +58,7 @@ function isNumericFormulaDataType(dataType) {
   return ["integer", "bigInt", "double", "decimal", "number"].includes(String(dataType || "").trim());
 }
 function resolveTargetCollection(input) {
-  var _a;
-  if ((_a = input.field) == null ? void 0 : _a.targetCollection) {
-    return input.field.targetCollection;
-  }
-  if (!input.getCollection || !input.dataSourceKey) {
-    return null;
-  }
-  return (0, import_service_helpers.resolveFieldTargetCollection)(input.field, input.dataSourceKey, input.getCollection);
+  return (0, import_service_helpers.resolveFieldTargetCollection)(input.field, input.dataSourceKey || "main", input.getCollection || (() => null));
 }
 function normalizeBindingContainerUse(containerUse) {
   const normalized = String(containerUse || "").trim();
@@ -100,6 +93,14 @@ function selectPreferredDefaultRule(rules) {
   return rules.find((rule) => typeof rule.when === "function") || rules[0];
 }
 const FIELD_BINDING_RULE_DEFINITIONS = [
+  {
+    scope: "filter",
+    modelClassName: "CascadeSelectFieldModel",
+    interfaces: ["m2o", "o2o", "oho", "obo"],
+    isDefault: true,
+    order: 60,
+    when: ({ targetCollection }) => getCollectionTemplate(targetCollection) === "tree"
+  },
   {
     scope: "display",
     modelClassName: "DisplayPreviewFieldModel",

package/dist/server/flow-surfaces/service-utils.d.ts

@@ -98,6 +98,7 @@ export declare function joinRequiredFieldPaths(paths: string[]): string;
 export declare function normalizeSimpleLayoutValue(layout: any): any;
 export declare function normalizeGridCardColumns(columns: any): _.Dictionary<any>;
 export declare function normalizeSimpleConfirm(confirm: any): _.Dictionary<any>;
+export declare function normalizeAfterSuccess(afterSuccess: unknown): _.Dictionary<any>;
 export declare function assertSupportedSimpleChanges(context: string, changes: Record<string, any>, allowedKeys: string[]): void;
 export declare function hasLegacyLocatorFields(input: any, options?: {
     allowRootUid?: boolean;

package/dist/server/flow-surfaces/service-utils.js

@@ -59,6 +59,7 @@ __export(service_utils_exports, {
   isFieldNodeUse: () => isFieldNodeUse,
   isMissingRequiredResourceInitValue: () => isMissingRequiredResourceInitValue,
   joinRequiredFieldPaths: () => joinRequiredFieldPaths,
+  normalizeAfterSuccess: () => normalizeAfterSuccess,
   normalizeBlockTitleDescription: () => normalizeBlockTitleDescription,
   normalizeBlockTitleDescriptionValue: () => normalizeBlockTitleDescriptionValue,
   normalizeChartCardHeightModeForWrite: () => normalizeChartCardHeightModeForWrite,
@@ -598,6 +599,21 @@ function normalizeSimpleConfirm(confirm) {
   }
   (0, import_errors.throwBadRequest)("flowSurfaces configure confirm must be a boolean or object");
 }
+function normalizeAfterSuccess(afterSuccess) {
+  if (!import_lodash.default.isPlainObject(afterSuccess)) {
+    (0, import_errors.throwBadRequest)("flowSurfaces configure afterSuccess must be an object");
+  }
+  const input = afterSuccess;
+  if (input.actionAfterSuccess !== void 0 && !["stay", "previous", "redirect"].includes(String(input.actionAfterSuccess))) {
+    (0, import_errors.throwBadRequest)("flowSurfaces configure afterSuccess.actionAfterSuccess must be stay, previous, or redirect");
+  }
+  return buildDefinedPayload({
+    successMessage: input.successMessage,
+    manualClose: input.manualClose,
+    actionAfterSuccess: input.actionAfterSuccess,
+    redirectTo: input.redirectTo
+  });
+}
 function assertSupportedSimpleChanges(context, changes, allowedKeys) {
   const unknownKeys = Object.keys(changes).filter((key) => !allowedKeys.includes(key));
   if (!unknownKeys.length) {
@@ -881,6 +897,7 @@ function getFieldBindingDefaultProps(containerUse, fieldUse, field) {
   isFieldNodeUse,
   isMissingRequiredResourceInitValue,
   joinRequiredFieldPaths,
+  normalizeAfterSuccess,
   normalizeBlockTitleDescription,
   normalizeBlockTitleDescriptionValue,
   normalizeChartCardHeightModeForWrite,

package/dist/server/flow-surfaces/service.js

@@ -19739,6 +19739,15 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
         (0, import_errors.throwBadRequest)(`flowSurfaces configure action '${use}' does not support confirm`);
       }
     }
+    if ((0, import_service_utils.hasOwnDefined)(changes, "afterSuccess")) {
+      if (!UPDATE_ASSIGN_ACTION_USES.has(use)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces configure action '${use}' does not support afterSuccess`);
+      }
+      stepParams.assignSettings = {
+        ...stepParams.assignSettings || {},
+        afterSuccess: (0, import_service_utils.normalizeAfterSuccess)(changes.afterSuccess)
+      };
+    }
     if ((0, import_service_utils.hasOwnDefined)(changes, "assignValues")) {
       const assignValues = this.normalizeActionAssignValues("configure", changes.assignValues);
       if (APPROVAL_ASSIGN_ACTION_USES.has(use)) {

package/dist/server/index.d.ts

@@ -9,3 +9,5 @@
 export { default } from './plugin';
 export { FlowModelRepository } from './repository';
 export { resolveVariablesBatch, resolveVariablesTemplate } from './variables/resolve';
+export { createNestedRecordSlotResolver, getRecordSlotResolverRegistry, RecordSlotResolverRegistry, } from './variables/record-slot-resolvers';
+export type { RecordSlotResolved, RecordSlotResolverInput, RecordSlotResolverRegistration, RecordSlotResolverResult, } from './variables/record-slot-resolvers';

package/dist/server/index.js

@@ -37,7 +37,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var server_exports = {};
 __export(server_exports, {
   FlowModelRepository: () => import_repository.FlowModelRepository,
+  RecordSlotResolverRegistry: () => import_record_slot_resolvers.RecordSlotResolverRegistry,
+  createNestedRecordSlotResolver: () => import_record_slot_resolvers.createNestedRecordSlotResolver,
   default: () => import_plugin.default,
+  getRecordSlotResolverRegistry: () => import_record_slot_resolvers.getRecordSlotResolverRegistry,
   resolveVariablesBatch: () => import_resolve.resolveVariablesBatch,
   resolveVariablesTemplate: () => import_resolve.resolveVariablesTemplate
 });
@@ -45,9 +48,13 @@ module.exports = __toCommonJS(server_exports);
 var import_plugin = __toESM(require("./plugin"));
 var import_repository = require("./repository");
 var import_resolve = require("./variables/resolve");
+var import_record_slot_resolvers = require("./variables/record-slot-resolvers");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FlowModelRepository,
+  RecordSlotResolverRegistry,
+  createNestedRecordSlotResolver,
+  getRecordSlotResolverRegistry,
   resolveVariablesBatch,
   resolveVariablesTemplate
 });

package/dist/server/plugin.d.ts

@@ -6,16 +6,29 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+import type { ResourcerContext } from '@nocobase/resourcer';
 import PluginUISchemaStorageServer from './server';
+import { JSONValue } from './template/resolver';
 export declare class PluginFlowEngineServer extends PluginUISchemaStorageServer {
+    private recordSlotResolverDisposers;
     afterAdd(): Promise<void>;
     beforeLoad(): Promise<void>;
     getDatabaseByDataSourceKey(dataSourceKey?: string): import("@nocobase/database").default;
     runSQLByDataSourceKey(dataSourceKey: string | undefined, sql: string, options?: Record<string, unknown>): Promise<any>;
+    resolveFlowModelVariablesTemplate(ctx: ResourcerContext, options: {
+        contractRd?: string | number;
+        contextParams?: Record<string, unknown>;
+        rd?: string | number;
+        template: JSONValue;
+    }): Promise<any>;
+    isLegacyVariableTemplateSafe(template: JSONValue): boolean;
     load(): Promise<void>;
     install(): Promise<void>;
     afterEnable(): Promise<void>;
     afterDisable(): Promise<void>;
     remove(): Promise<void>;
+    private disposeRecordSlotResolvers;
+    private registerRecordSlotResolvers;
+    private ensureRecordSlotResolvers;
 }
 export default PluginFlowEngineServer;

package/dist/server/plugin.js

@@ -43,8 +43,13 @@ module.exports = __toCommonJS(plugin_exports);
 var import_utils = require("@nocobase/utils");
 var import_flow_surfaces = require("./flow-surfaces");
 var import_server = __toESM(require("./server"));
+var import_allow_list = require("./variables/allow-list");
+var import_form_item_record_slot_resolvers = require("./variables/form-item-record-slot-resolvers");
+var import_record_slot_policy = require("./variables/record-slot-policy");
+var import_record_slot_resolvers = require("./variables/record-slot-resolvers");
 var import_resolve = require("./variables/resolve");
 class PluginFlowEngineServer extends import_server.default {
+  recordSlotResolverDisposers = [];
   async afterAdd() {
   }
   async beforeLoad() {
@@ -71,8 +76,16 @@ class PluginFlowEngineServer extends import_server.default {
     }
     return await cm.db.runSQL(sql, options);
   }
+  async resolveFlowModelVariablesTemplate(ctx, options) {
+    this.ensureRecordSlotResolvers(ctx.app);
+    return await (0, import_resolve.resolveFlowModelVariablesTemplate)(ctx, options);
+  }
+  isLegacyVariableTemplateSafe(template) {
+    return (0, import_resolve.isLegacyVariableTemplateSafe)(template);
+  }
   async load() {
     await super.load();
+    this.registerRecordSlotResolvers();
     (0, import_flow_surfaces.registerFlowSurfacesResource)(this);
     this.app.auditManager.registerAction("flowSql:save");
     this.app.auditManager.registerAction("flowModels:save");
@@ -86,12 +99,56 @@ class PluginFlowEngineServer extends import_server.default {
       actions: {
         // 解析 JSON 模板中的 ctx 变量
         resolve: async (ctx, next) => {
-          var _a, _b;
+          var _a, _b, _c;
+          this.ensureRecordSlotResolvers(ctx.app);
           const raw = ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) ?? {};
           const values = typeof (raw == null ? void 0 : raw.values) !== "undefined" ? raw.values : raw;
           if (Array.isArray(values == null ? void 0 : values.batch)) {
             const batchItems = values.batch;
-            const results = await (0, import_resolve.resolveVariablesBatch)(ctx, batchItems);
+            const authorizedItems = [];
+            const passthroughResults = [];
+            for (const [index, item] of batchItems.entries()) {
+              const template2 = (item == null ? void 0 : item.template) ?? {};
+              const authorization2 = await (0, import_allow_list.authorizeVariablesResolve)(ctx, {
+                contractRd: item == null ? void 0 : item.contractRd,
+                contextParams: (item == null ? void 0 : item.contextParams) || {},
+                rd: item == null ? void 0 : item.rd,
+                template: template2
+              });
+              if (authorization2.allowed) {
+                const authorizedItem = {
+                  analysis: authorization2.analysis,
+                  bindingPlan: authorization2.bindingPlan,
+                  id: item == null ? void 0 : item.id,
+                  index,
+                  policy: authorization2.policy,
+                  template: template2
+                };
+                authorizedItems.push(authorizedItem);
+              } else {
+                passthroughResults[index] = { id: item == null ? void 0 : item.id, data: template2 };
+              }
+            }
+            const resolvedItems = await (0, import_resolve.resolveAnalyzedVariablesBatch)(
+              ctx,
+              authorizedItems.map((item) => ({
+                analysis: item.analysis,
+                bindingPlan: item.bindingPlan,
+                id: item.index,
+                template: item.template,
+                policy: item.policy
+              }))
+            );
+            for (const item of resolvedItems) {
+              const index = Number(item.id);
+              passthroughResults[index] = {
+                id: (_c = batchItems[index]) == null ? void 0 : _c.id,
+                data: item.data
+              };
+            }
+            const results = passthroughResults.filter(
+              (item) => !!item
+            );
             ctx.body = { results };
             await next();
             return;
@@ -104,7 +161,18 @@ class PluginFlowEngineServer extends import_server.default {
           }
           const template = values.template;
           const contextParams = (values == null ? void 0 : values.contextParams) || {};
-          ctx.body = await (0, import_resolve.resolveVariablesTemplate)(ctx, template, contextParams);
+          const authorization = await (0, import_allow_list.authorizeVariablesResolve)(ctx, {
+            contractRd: values == null ? void 0 : values.contractRd,
+            contextParams,
+            rd: values == null ? void 0 : values.rd,
+            template
+          });
+          ctx.body = authorization.allowed ? await (0, import_resolve.resolveAnalyzedVariablesTemplate)(
+            ctx,
+            authorization.analysis,
+            authorization.policy,
+            authorization.bindingPlan
+          ) : template;
           await next();
         }
       }
@@ -162,10 +230,29 @@ class PluginFlowEngineServer extends import_server.default {
   async install() {
   }
   async afterEnable() {
+    this.registerRecordSlotResolvers();
   }
   async afterDisable() {
+    this.disposeRecordSlotResolvers();
   }
   async remove() {
+    this.disposeRecordSlotResolvers();
+  }
+  disposeRecordSlotResolvers() {
+    this.recordSlotResolverDisposers.forEach((dispose) => dispose());
+    this.recordSlotResolverDisposers = [];
+  }
+  registerRecordSlotResolvers() {
+    this.disposeRecordSlotResolvers();
+    this.ensureRecordSlotResolvers(this.app);
+  }
+  ensureRecordSlotResolvers(app) {
+    const registry = (0, import_record_slot_resolvers.getRecordSlotResolverRegistry)(app);
+    for (const resolver of [...(0, import_record_slot_policy.createBuiltInRecordSlotResolvers)(), ...(0, import_form_item_record_slot_resolvers.createFormItemRecordSlotResolvers)()]) {
+      if (!registry.has(resolver.owner, resolver.id)) {
+        this.recordSlotResolverDisposers.push(registry.register(resolver));
+      }
+    }
   }
 }
 var plugin_default = PluginFlowEngineServer;

package/dist/server/repository.d.ts

@@ -18,6 +18,13 @@ export interface GetPropertiesOptions {
     readFromCache?: boolean;
     transaction?: Transaction;
 }
+export interface FlowModelNodeSnapshot {
+    uid: string;
+    options: Record<string, unknown>;
+    parentId: string | null;
+    subKey: string | null;
+    async: boolean;
+}
 export type FlowModelAttachPosition = 'first' | 'last' | TargetPosition;
 export interface FlowModelAttachOptions {
     parentId: string;
@@ -132,6 +139,11 @@ export declare class FlowModelRepository extends Repository {
     updateSingleNode(node: SchemaNode, options?: Transactionable): Promise<boolean>;
     upsertModel(model: any, options?: Transactionable): Promise<string>;
     findModelById(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
+    findModelNodeSnapshotById(uid: string, options?: Transactionable): Promise<FlowModelNodeSnapshot | null>;
+    private findModelUidByParentId;
+    findModelNodeSnapshotByParentId(parentUid: string, options?: Transactionable & {
+        subKey?: string;
+    }): Promise<FlowModelNodeSnapshot | null>;
     findModelByParentId(parentUid: string, options?: GetJsonSchemaOptions & {
         subKey?: string;
     }): Promise<any>;

package/dist/server/repository.js

@@ -1411,7 +1411,36 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     const nodes = await this.findNodesById(uid2, options);
     return _FlowModelRepository.nodesToModel(nodes, uid2);
   }
-  async findModelByParentId(parentUid, options) {
+  async findModelNodeSnapshotById(uid2, options) {
+    const transaction2 = options == null ? void 0 : options.transaction;
+    const model = await this.model.findByPk(uid2, { transaction: transaction2 });
+    if (!model) {
+      return null;
+    }
+    const paths = await this.database.getRepository("flowModelTreePath").find({
+      filter: {
+        descendant: uid2,
+        depth: { $in: [0, 1] }
+      },
+      transaction: transaction2
+    });
+    const nodePath = paths.find((path) => path.get("depth") === 0);
+    if (!nodePath) {
+      return null;
+    }
+    const parentPath = paths.find((path) => path.get("depth") === 1);
+    const nodeOptions = import_lodash.default.cloneDeep(
+      import_lodash.default.omit(_FlowModelRepository.optionsToJson(model.get("options") || {}), "subModels")
+    );
+    return {
+      uid: uid2,
+      options: nodeOptions,
+      parentId: parentPath ? parentPath.get("ancestor") : null,
+      subKey: nodePath.get("type") || null,
+      async: !!nodePath.get("async")
+    };
+  }
+  async findModelUidByParentId(parentUid, options) {
     const r = this.database.getRepository("flowModelTreePath");
     const treePaths = await r.model.findAll({
       where: {
@@ -1433,10 +1462,18 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
       transaction: options == null ? void 0 : options.transaction
     });
     if (treePath == null ? void 0 : treePath["descendant"]) {
-      return this.findModelById(treePath["descendant"], options);
+      return treePath["descendant"];
     }
     return null;
   }
+  async findModelNodeSnapshotByParentId(parentUid, options) {
+    const uid2 = await this.findModelUidByParentId(parentUid, options);
+    return uid2 ? this.findModelNodeSnapshotById(uid2, options) : null;
+  }
+  async findModelByParentId(parentUid, options) {
+    const uid2 = await this.findModelUidByParentId(parentUid, options);
+    return uid2 ? this.findModelById(uid2, options) : null;
+  }
   async attach(uid2, attachOptions, options) {
     const { transaction: transaction2 } = options || {};
     const modelUid = String(uid2 || "").trim();

package/dist/server/template/context-keys.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare const GLOBAL_CONTEXT_KEYS: readonly ["now", "timestamp", "env"];
+export declare const HTTP_REQUEST_CONTEXT_KEYS: readonly ["user", "roleName", "locale", "ip", "headers", "query", "params"];
+export declare const SERVER_CONTEXT_PROTOTYPE_KEYS: readonly ["__proto__", "prototype", "constructor", "then", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
+export declare const SERVER_CONTEXT_INTERNAL_KEYS: readonly ["_props", "_cache", "_delegates", "_proxy", "_getOwn", "defineProperty", "delegate", "clearDelegates", "getSandboxKeys", "getSandboxValue", "createProxy"];
+export declare const PROTECTED_SERVER_CONTEXT_KEYS: readonly ["now", "timestamp", "env", "user", "roleName", "locale", "ip", "headers", "query", "params", "__proto__", "prototype", "constructor", "then", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf", "_props", "_cache", "_delegates", "_proxy", "_getOwn", "defineProperty", "delegate", "clearDelegates", "getSandboxKeys", "getSandboxValue", "createProxy"];
+export declare function isProtectedServerContextKey(key: string): boolean;

package/dist/server/template/context-keys.js

@@ -0,0 +1,86 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_keys_exports = {};
+__export(context_keys_exports, {
+  GLOBAL_CONTEXT_KEYS: () => GLOBAL_CONTEXT_KEYS,
+  HTTP_REQUEST_CONTEXT_KEYS: () => HTTP_REQUEST_CONTEXT_KEYS,
+  PROTECTED_SERVER_CONTEXT_KEYS: () => PROTECTED_SERVER_CONTEXT_KEYS,
+  SERVER_CONTEXT_INTERNAL_KEYS: () => SERVER_CONTEXT_INTERNAL_KEYS,
+  SERVER_CONTEXT_PROTOTYPE_KEYS: () => SERVER_CONTEXT_PROTOTYPE_KEYS,
+  isProtectedServerContextKey: () => isProtectedServerContextKey
+});
+module.exports = __toCommonJS(context_keys_exports);
+const GLOBAL_CONTEXT_KEYS = ["now", "timestamp", "env"];
+const HTTP_REQUEST_CONTEXT_KEYS = ["user", "roleName", "locale", "ip", "headers", "query", "params"];
+const SERVER_CONTEXT_PROTOTYPE_KEYS = [
+  "__proto__",
+  "prototype",
+  "constructor",
+  "then",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "toLocaleString",
+  "toString",
+  "valueOf"
+];
+const SERVER_CONTEXT_INTERNAL_KEYS = [
+  "_props",
+  "_cache",
+  "_delegates",
+  "_proxy",
+  "_getOwn",
+  "defineProperty",
+  "delegate",
+  "clearDelegates",
+  "getSandboxKeys",
+  "getSandboxValue",
+  "createProxy"
+];
+const PROTECTED_SERVER_CONTEXT_KEYS = [
+  ...GLOBAL_CONTEXT_KEYS,
+  ...HTTP_REQUEST_CONTEXT_KEYS,
+  ...SERVER_CONTEXT_PROTOTYPE_KEYS,
+  ...SERVER_CONTEXT_INTERNAL_KEYS
+];
+const protectedServerContextKeys = new Set(PROTECTED_SERVER_CONTEXT_KEYS);
+function isProtectedServerContextKey(key) {
+  return protectedServerContextKeys.has(key);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLOBAL_CONTEXT_KEYS,
+  HTTP_REQUEST_CONTEXT_KEYS,
+  PROTECTED_SERVER_CONTEXT_KEYS,
+  SERVER_CONTEXT_INTERNAL_KEYS,
+  SERVER_CONTEXT_PROTOTYPE_KEYS,
+  isProtectedServerContextKey
+});

package/dist/server/template/contexts.d.ts

@@ -8,6 +8,7 @@
  */
 import { ResourcerContext } from '@nocobase/resourcer';
 type Getter<T = any> = (ctx: ServerBaseContext) => T | Promise<T>;
+export declare const SERVER_CONTEXT_PROVIDER_TOKEN: unique symbol;
 export interface PropertyOptions {
     /** 固定值，优先级高于 get */
     value?: any;
@@ -21,13 +22,11 @@ export interface PropertyOptions {
 /**
  * 服务器端上下文基础类。
  * - 支持以 defineProperty 定义惰性/常量属性，并可选择缓存
- * - 支持以 defineMethod 定义方法
- * - 支持 delegate 机制，属性与方法可回退到被委托的上游上下文
- * - 通过 Proxy 实现按需求值与 this 绑定
+ * - 支持 delegate 机制，属性可回退到被委托的上游上下文
+ * - 通过 Proxy 实现按需求值
  */
 export declare class ServerBaseContext {
     protected _props: Record<string, PropertyOptions>;
-    protected _methods: Record<string, (...args: any[]) => any>;
     protected _cache: Record<string, any>;
     protected _delegates: ServerBaseContext[];
     protected _proxy?: ServerBaseContext;
@@ -40,12 +39,10 @@ export declare class ServerBaseContext {
      * - get：惰性 getter（默认带缓存）
      * - once：已存在时忽略重复定义
      */
-    defineProperty(key: string, options: PropertyOptions): void;
-    /** 定义一个方法（不可枚举、不可写），访问时会自动绑定到对应实例 */
-    defineMethod(name: string, fn: (...args: any[]) => any): void;
+    defineProperty(key: string, options: PropertyOptions, providerToken?: typeof SERVER_CONTEXT_PROVIDER_TOKEN): void;
     /**
      * 委托到另一个 ServerBaseContext：
-     * - 访问属性/方法找不到时，会回退到被委托者进行解析
+     * - 访问属性找不到时，会回退到被委托者进行解析
      */
     delegate(ctx: ServerBaseContext): void;
     /** 清空所有委托 */