@nocobase/plugin-flow-engine 2.1.0-alpha.15 → 2.1.0-alpha.17

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

@@ -29,13 +29,28 @@ __export(constants_exports, {
   FLOW_SURFACES_ACTION_METHODS: () => FLOW_SURFACES_ACTION_METHODS,
   FLOW_SURFACES_ACTION_NAMES: () => FLOW_SURFACES_ACTION_NAMES,
   FLOW_SURFACES_READ_ACTION_NAMES: () => FLOW_SURFACES_READ_ACTION_NAMES,
-  FLOW_SURFACE_MUTATE_OP_TYPES: () => FLOW_SURFACE_MUTATE_OP_TYPES
+  FLOW_SURFACE_MUTATE_OP_TYPES: () => FLOW_SURFACE_MUTATE_OP_TYPES,
+  FLOW_SURFACE_PLAN_STEP_ACTIONS: () => import_action_specs.FLOW_SURFACE_PLAN_STEP_ACTIONS
 });
 module.exports = __toCommonJS(constants_exports);
+var import_action_specs = require("./planning/action-specs");
 const FLOW_SURFACES_ACTION_NAMES = [
   "catalog",
   "context",
   "get",
+  "describeSurface",
+  "getReactionMeta",
+  "setFieldValueRules",
+  "setBlockLinkageRules",
+  "setFieldLinkageRules",
+  "setActionLinkageRules",
+  "applyBlueprint",
+  "listTemplates",
+  "getTemplate",
+  "saveTemplate",
+  "updateTemplate",
+  "destroyTemplate",
+  "convertTemplateToCopy",
   "compose",
   "configure",
   "createMenu",
@@ -69,7 +84,11 @@ const FLOW_SURFACES_ACTION_NAMES = [
 const FLOW_SURFACES_READ_ACTION_NAMES = [
   "catalog",
   "context",
-  "get"
+  "get",
+  "describeSurface",
+  "getReactionMeta",
+  "listTemplates",
+  "getTemplate"
 ];
 const FLOW_SURFACE_MUTATE_OP_TYPES = [
   "createMenu",
@@ -98,6 +117,19 @@ const FLOW_SURFACES_ACTION_METHODS = {
   catalog: "post",
   context: "post",
   get: "get",
+  describeSurface: "post",
+  getReactionMeta: "post",
+  setFieldValueRules: "post",
+  setBlockLinkageRules: "post",
+  setFieldLinkageRules: "post",
+  setActionLinkageRules: "post",
+  applyBlueprint: "post",
+  listTemplates: "post",
+  getTemplate: "post",
+  saveTemplate: "post",
+  updateTemplate: "post",
+  destroyTemplate: "post",
+  convertTemplateToCopy: "post",
   compose: "post",
   configure: "post",
   createMenu: "post",
@@ -133,5 +165,6 @@ const FLOW_SURFACES_ACTION_METHODS = {
   FLOW_SURFACES_ACTION_METHODS,
   FLOW_SURFACES_ACTION_NAMES,
   FLOW_SURFACES_READ_ACTION_NAMES,
-  FLOW_SURFACE_MUTATE_OP_TYPES
+  FLOW_SURFACE_MUTATE_OP_TYPES,
+  FLOW_SURFACE_PLAN_STEP_ACTIONS
 });

package/dist/server/flow-surfaces/default-action-popup.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+import _ from 'lodash';
+export type FlowSurfaceDefaultActionPopupType = 'addNew' | 'view' | 'edit';
+export type FlowSurfaceDefaultActionPopupUse = 'AddNewActionModel' | 'ViewActionModel' | 'EditActionModel';
+type FlowSurfaceDefaultActionPopupSubmitAction = {
+    key: string;
+    type: 'submit';
+    settings: {
+        title: string;
+        type: string;
+        confirm: boolean;
+    };
+};
+export type FlowSurfaceDefaultActionPopupConfig = {
+    type: FlowSurfaceDefaultActionPopupType;
+    use: FlowSurfaceDefaultActionPopupUse;
+    defaultButtonTitle: string;
+    defaultPopupTabTitle: string;
+    blockKey: string;
+    blockType: 'createForm' | 'editForm' | 'details';
+    blockUse: 'CreateFormModel' | 'EditFormModel' | 'DetailsBlockModel';
+    resourceBinding: 'currentCollection' | 'currentRecord';
+    blockSettings: Record<string, any>;
+    submitAction?: FlowSurfaceDefaultActionPopupSubmitAction;
+};
+export type FlowSurfaceDefaultActionPopupFieldCandidate = {
+    field?: any;
+    fieldPath?: string;
+};
+type FlowSurfaceDefaultActionPopupFieldFilterOptions = {
+    excludeAuditTimestampFields?: boolean;
+};
+export declare const FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES: Set<FlowSurfaceDefaultActionPopupType>;
+export declare const FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES: Set<FlowSurfaceDefaultActionPopupUse>;
+export declare function isFlowSurfaceDefaultActionPopupType(type?: string): type is FlowSurfaceDefaultActionPopupType;
+export declare function isFlowSurfaceDefaultActionPopupUse(use?: string): use is FlowSurfaceDefaultActionPopupUse;
+export declare function getFlowSurfaceDefaultActionPopupConfigByUse(use?: string): FlowSurfaceDefaultActionPopupConfig;
+export declare function resolveFlowSurfaceDefaultActionPopupTabTitle(use?: string, currentTitle?: string | null): string;
+export declare function pickFlowSurfaceDefaultActionPopupFieldPaths(candidates: FlowSurfaceDefaultActionPopupFieldCandidate[], options?: FlowSurfaceDefaultActionPopupFieldFilterOptions): string[];
+export declare function buildFlowSurfaceDefaultActionPopupBlocks(use: string | undefined, fieldPaths: string[]): _.Dictionary<string | string[] | Record<string, any> | FlowSurfaceDefaultActionPopupSubmitAction[] | {
+    binding: "currentCollection" | "currentRecord";
+}>[];
+export declare function hasFlowSurfaceInlinePopupTemplate(popup?: Record<string, any>): boolean;
+export declare function hasFlowSurfaceInlinePopupBlocks(popup?: Record<string, any>): boolean;
+export {};

package/dist/server/flow-surfaces/default-action-popup.js

@@ -0,0 +1,258 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var default_action_popup_exports = {};
+__export(default_action_popup_exports, {
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES: () => FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES,
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES: () => FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES,
+  buildFlowSurfaceDefaultActionPopupBlocks: () => buildFlowSurfaceDefaultActionPopupBlocks,
+  getFlowSurfaceDefaultActionPopupConfigByUse: () => getFlowSurfaceDefaultActionPopupConfigByUse,
+  hasFlowSurfaceInlinePopupBlocks: () => hasFlowSurfaceInlinePopupBlocks,
+  hasFlowSurfaceInlinePopupTemplate: () => hasFlowSurfaceInlinePopupTemplate,
+  isFlowSurfaceDefaultActionPopupType: () => isFlowSurfaceDefaultActionPopupType,
+  isFlowSurfaceDefaultActionPopupUse: () => isFlowSurfaceDefaultActionPopupUse,
+  pickFlowSurfaceDefaultActionPopupFieldPaths: () => pickFlowSurfaceDefaultActionPopupFieldPaths,
+  resolveFlowSurfaceDefaultActionPopupTabTitle: () => resolveFlowSurfaceDefaultActionPopupTabTitle
+});
+module.exports = __toCommonJS(default_action_popup_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_field_semantics = require("./field-semantics");
+var import_service_helpers = require("./service-helpers");
+const DEFAULT_ACTION_POPUP_SYSTEM_FIELD_NAMES = /* @__PURE__ */ new Set(["id", "createdBy", "createdById", "updatedBy", "updatedById"]);
+const DEFAULT_ACTION_POPUP_SYSTEM_FIELD_INTERFACES = /* @__PURE__ */ new Set([
+  "id",
+  "snowflakeId",
+  "createdBy",
+  "createdById",
+  "updatedBy",
+  "updatedById"
+]);
+const DEFAULT_ACTION_POPUP_AUDIT_TIMESTAMP_FIELD_NAMES = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
+const DEFAULT_ACTION_POPUP_AUDIT_TIMESTAMP_FIELD_INTERFACES = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIGS = [
+  {
+    type: "addNew",
+    use: "AddNewActionModel",
+    defaultButtonTitle: "Add new",
+    defaultPopupTabTitle: "Add new",
+    blockKey: "defaultCreateForm",
+    blockType: "createForm",
+    blockUse: "CreateFormModel",
+    resourceBinding: "currentCollection",
+    blockSettings: {
+      layout: "vertical",
+      colon: false,
+      assignRules: []
+    },
+    submitAction: {
+      key: "defaultSubmit",
+      type: "submit",
+      settings: {
+        title: "Save",
+        type: "",
+        confirm: false
+      }
+    }
+  },
+  {
+    type: "view",
+    use: "ViewActionModel",
+    defaultButtonTitle: "View",
+    defaultPopupTabTitle: "Details",
+    blockKey: "defaultDetails",
+    blockType: "details",
+    blockUse: "DetailsBlockModel",
+    resourceBinding: "currentRecord",
+    blockSettings: {
+      layout: "vertical",
+      colon: true,
+      dataScope: {
+        logic: "$and",
+        items: []
+      },
+      linkageRules: []
+    }
+  },
+  {
+    type: "edit",
+    use: "EditActionModel",
+    defaultButtonTitle: "Edit",
+    defaultPopupTabTitle: "Edit",
+    blockKey: "defaultEditForm",
+    blockType: "editForm",
+    blockUse: "EditFormModel",
+    resourceBinding: "currentRecord",
+    blockSettings: {
+      layout: "vertical",
+      colon: false,
+      assignRules: [],
+      dataScope: {
+        logic: "$and",
+        items: []
+      }
+    },
+    submitAction: {
+      key: "defaultSubmit",
+      type: "submit",
+      settings: {
+        title: "Save Changes",
+        type: "",
+        confirm: false
+      }
+    }
+  }
+];
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES = new Set(
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIGS.map((item) => item.type)
+);
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES = new Set(
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIGS.map((item) => item.use)
+);
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIG_BY_USE = FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIGS.reduce(
+  (result, item) => {
+    result[item.use] = item;
+    return result;
+  },
+  {}
+);
+function isFlowSurfaceDefaultActionPopupType(type) {
+  return FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES.has(String(type || "").trim());
+}
+function isFlowSurfaceDefaultActionPopupUse(use) {
+  return FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES.has(String(use || "").trim());
+}
+function getFlowSurfaceDefaultActionPopupConfigByUse(use) {
+  const normalizedUse = String(use || "").trim();
+  if (!isFlowSurfaceDefaultActionPopupUse(normalizedUse)) {
+    return void 0;
+  }
+  return FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIG_BY_USE[normalizedUse];
+}
+function resolveFlowSurfaceDefaultActionPopupTabTitle(use, currentTitle) {
+  const actionConfig = getFlowSurfaceDefaultActionPopupConfigByUse(use);
+  if (!actionConfig) {
+    return void 0;
+  }
+  const normalizedTitle = String(currentTitle || "").trim();
+  if (normalizedTitle && normalizedTitle !== actionConfig.defaultButtonTitle) {
+    return normalizedTitle;
+  }
+  return actionConfig.defaultPopupTabTitle;
+}
+function isFlowSurfaceDefaultActionPopupSystemField(field) {
+  var _a, _b;
+  const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  return DEFAULT_ACTION_POPUP_SYSTEM_FIELD_NAMES.has(fieldName) || DEFAULT_ACTION_POPUP_SYSTEM_FIELD_INTERFACES.has(fieldInterface) || !!(field == null ? void 0 : field.primaryKey) || !!((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.primaryKey) || !!(field == null ? void 0 : field.autoIncrement) || !!((_b = field == null ? void 0 : field.options) == null ? void 0 : _b.autoIncrement);
+}
+function isFlowSurfaceDefaultActionPopupTechnicalIdField(field) {
+  var _a, _b;
+  const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  return fieldName === "id" || fieldInterface === "id" || fieldInterface === "snowflakeId" || !!(field == null ? void 0 : field.primaryKey) || !!((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.primaryKey) || !!(field == null ? void 0 : field.autoIncrement) || !!((_b = field == null ? void 0 : field.options) == null ? void 0 : _b.autoIncrement);
+}
+function isFlowSurfaceDefaultActionPopupAuditTimestampField(field) {
+  const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  return DEFAULT_ACTION_POPUP_AUDIT_TIMESTAMP_FIELD_NAMES.has(fieldName) || DEFAULT_ACTION_POPUP_AUDIT_TIMESTAMP_FIELD_INTERFACES.has(fieldInterface);
+}
+function isFlowSurfaceDefaultActionPopupMultiValueAssociationField(field) {
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  return import_field_semantics.MULTI_VALUE_ASSOCIATION_INTERFACES.has(fieldInterface);
+}
+function collectFlowSurfaceDefaultActionPopupAssociationForeignKeys(candidates) {
+  return new Set(
+    candidates.map((candidate) => candidate == null ? void 0 : candidate.field).filter((field) => (0, import_service_helpers.getFieldType)(field) === "belongsTo").map((field) => {
+      var _a;
+      return String((field == null ? void 0 : field.foreignKey) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.foreignKey) || "").trim();
+    }).filter(Boolean)
+  );
+}
+function isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(field, associationForeignKeys) {
+  const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+  return !!fieldName && associationForeignKeys.has(fieldName);
+}
+function pickFlowSurfaceDefaultActionPopupFieldPaths(candidates, options = {}) {
+  const associationForeignKeys = collectFlowSurfaceDefaultActionPopupAssociationForeignKeys(candidates);
+  const preferredCandidates = candidates.filter(
+    (candidate) => !isFlowSurfaceDefaultActionPopupSystemField(candidate.field) && (!options.excludeAuditTimestampFields || !isFlowSurfaceDefaultActionPopupAuditTimestampField(candidate.field)) && !isFlowSurfaceDefaultActionPopupMultiValueAssociationField(candidate.field) && !isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(candidate.field, associationForeignKeys)
+  );
+  const fallbackCandidates = candidates.filter(
+    (candidate) => !isFlowSurfaceDefaultActionPopupTechnicalIdField(candidate.field) && (!options.excludeAuditTimestampFields || !isFlowSurfaceDefaultActionPopupAuditTimestampField(candidate.field)) && !isFlowSurfaceDefaultActionPopupMultiValueAssociationField(candidate.field) && !isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(candidate.field, associationForeignKeys)
+  );
+  const baseCandidates = preferredCandidates.length ? preferredCandidates : fallbackCandidates;
+  return baseCandidates.map((candidate) => String((candidate == null ? void 0 : candidate.fieldPath) || "").trim()).filter(Boolean);
+}
+function buildFlowSurfaceDefaultActionPopupBlocks(use, fieldPaths) {
+  const actionConfig = getFlowSurfaceDefaultActionPopupConfigByUse(use);
+  if (!actionConfig) {
+    return [];
+  }
+  return [
+    import_lodash.default.pickBy(
+      {
+        key: actionConfig.blockKey,
+        type: actionConfig.blockType,
+        resource: {
+          binding: actionConfig.resourceBinding
+        },
+        settings: import_lodash.default.cloneDeep(actionConfig.blockSettings),
+        fields: fieldPaths,
+        actions: actionConfig.submitAction ? [import_lodash.default.cloneDeep(actionConfig.submitAction)] : void 0
+      },
+      (value) => !import_lodash.default.isUndefined(value)
+    )
+  ];
+}
+function hasFlowSurfaceInlinePopupTemplate(popup) {
+  return typeof popup !== "undefined" && typeof (popup == null ? void 0 : popup.template) !== "undefined";
+}
+function hasFlowSurfaceInlinePopupBlocks(popup) {
+  return Array.isArray(popup == null ? void 0 : popup.blocks) && popup.blocks.length > 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES,
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES,
+  buildFlowSurfaceDefaultActionPopupBlocks,
+  getFlowSurfaceDefaultActionPopupConfigByUse,
+  hasFlowSurfaceInlinePopupBlocks,
+  hasFlowSurfaceInlinePopupTemplate,
+  isFlowSurfaceDefaultActionPopupType,
+  isFlowSurfaceDefaultActionPopupUse,
+  pickFlowSurfaceDefaultActionPopupFieldPaths,
+  resolveFlowSurfaceDefaultActionPopupTabTitle
+});

package/dist/server/flow-surfaces/executor.d.ts

@@ -11,3 +11,13 @@ export declare function executeMutateOps(ops: FlowSurfaceMutateOp[], ctx: FlowSu
     opId?: string;
     result: any;
 }[]>;
+export declare function resolveFlowSurfaceValueKeys(input: any, keys: Map<string, any>): any;
+export declare function inspectFlowSurfaceValueKey(path: string, keys: Map<string, any>): {
+    found: true;
+    value: any;
+    missingHead?: undefined;
+} | {
+    found: false;
+    missingHead: string;
+    value?: undefined;
+};

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

@@ -36,62 +36,97 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var executor_exports = {};
 __export(executor_exports, {
-  executeMutateOps: () => executeMutateOps
+  executeMutateOps: () => executeMutateOps,
+  inspectFlowSurfaceValueKey: () => inspectFlowSurfaceValueKey,
+  resolveFlowSurfaceValueKeys: () => resolveFlowSurfaceValueKeys
 });
 module.exports = __toCommonJS(executor_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_errors = require("./errors");
+var import_reference_guards = require("./reference-guards");
+var import_created_keys = require("./planning/created-keys");
 async function executeMutateOps(ops, ctx, dispatcher) {
   const results = [];
   for (const op of ops) {
-    const resolvedValues = resolveRefs(
+    const resolvedValues = resolveFlowSurfaceValueKeys(
       import_lodash.default.cloneDeep({
         ...op.target ? { target: op.target } : {},
         ...op.values || {}
       }),
-      ctx.refs
+      ctx.keys
     );
     const result = await dispatcher(op, resolvedValues, ctx);
     if (op.opId) {
-      ctx.refs.set(op.opId, result);
+      ctx.keys.set(op.opId, result);
     }
     results.push({ opId: op.opId, result });
   }
   return results;
 }
-function resolveRefs(input, refs) {
+function resolveFlowSurfaceValueKeys(input, keys) {
   if (Array.isArray(input)) {
-    return input.map((item) => resolveRefs(item, refs));
+    return input.map((item) => resolveFlowSurfaceValueKeys(item, keys));
   }
   if (import_lodash.default.isPlainObject(input)) {
-    if (Object.prototype.hasOwnProperty.call(input, "$ref")) {
-      throw new import_errors.FlowSurfaceBadRequestError(
-        `flowSurfaces mutate refs must use { ref: "op.path" }; "$ref" is no longer supported`
-      );
+    (0, import_reference_guards.assertNoFlowSurfaceLegacyRef)(input, {
+      actionName: "mutate",
+      path: "values",
+      dollarRefAllowed: "{ key } or { step, path }",
+      refAllowed: "{ key } or { step, path }"
+    });
+    if ((0, import_reference_guards.isFlowSurfacePlanStepValue)(input)) {
+      return readStepResult(input, keys);
     }
-    if (Object.prototype.hasOwnProperty.call(input, "ref")) {
-      if (typeof input.ref !== "string") {
-        throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate ref must be a string`);
-      }
-      return readRef(input.ref, refs);
+    if ((0, import_created_keys.isFlowSurfacePureKeyObject)(input)) {
+      return readKey(input.key, keys);
     }
-    return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, resolveRefs(value, refs)]));
+    return Object.fromEntries(
+      Object.entries(input).map(([key, value]) => [key, resolveFlowSurfaceValueKeys(value, keys)])
+    );
   }
   return input;
 }
-function readRef(path, refs) {
+function inspectFlowSurfaceValueKey(path, keys) {
   const trimmedPath = String(path || "").trim();
   if (!trimmedPath) {
-    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate ref cannot be empty`);
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate key cannot be empty`);
+  }
+  if (keys.has(trimmedPath)) {
+    return {
+      found: true,
+      value: keys.get(trimmedPath)
+    };
+  }
+  return {
+    found: false,
+    missingHead: trimmedPath
+  };
+}
+function readKey(path, keys) {
+  const resolved = inspectFlowSurfaceValueKey(path, keys);
+  if (!resolved.found) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate key '${resolved.missingHead}' not found`);
+  }
+  return resolved.value;
+}
+function readStepResult(input, keys) {
+  const step = String(input.step || "").trim();
+  if (!step) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate step cannot be empty`);
+  }
+  if (!keys.has(step)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate step '${step}' not found`);
   }
-  const [opId, ...segments] = trimmedPath.split(".");
-  if (!refs.has(opId)) {
-    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate ref '${opId}' not found`);
+  const value = keys.get(step);
+  const path = import_lodash.default.isUndefined(input.path) ? void 0 : String(input.path || "").trim();
+  if (import_lodash.default.has(input, "path") && !path) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate path cannot be empty`);
   }
-  const value = refs.get(opId);
-  return segments.length ? import_lodash.default.get(value, segments.join(".")) : value;
+  return path ? import_lodash.default.get(value, path) : value;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  executeMutateOps
+  executeMutateOps,
+  inspectFlowSurfaceValueKey,
+  resolveFlowSurfaceValueKeys
 });

package/dist/server/flow-surfaces/field-binding-registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 type FlowSurfaceFieldBindingScope = 'display' | 'editable' | 'filter';
+export type FlowSurfaceFieldBindingResolution = {
+    modelClassName: string;
+    ownerPlugin?: string;
+    isDefault: boolean;
+};
+export declare function getRegisteredFieldUses(scope?: FlowSurfaceFieldBindingScope, enabledPackages?: ReadonlySet<string>): ReadonlySet<string>;
+export declare function resolveRegisteredFieldBinding(input: {
+    containerUse?: string;
+    field: any;
+    dataSourceKey?: string;
+    enabledPackages?: ReadonlySet<string>;
+    getCollection?: (dataSourceKey: string, collectionName: string) => any;
+    useStrictOnly?: boolean;
+}): FlowSurfaceFieldBindingResolution | null;