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

package/dist/server/flow-surfaces/compose-compiler.js

@@ -0,0 +1,162 @@
+/**
+ * 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 compose_compiler_exports = {};
+__export(compose_compiler_exports, {
+  compileComposeExecutionPlan: () => compileComposeExecutionPlan,
+  resolveComposeFieldContainerSource: () => resolveComposeFieldContainerSource,
+  resolveComposeTargetKey: () => resolveComposeTargetKey
+});
+module.exports = __toCommonJS(compose_compiler_exports);
+var import_errors = require("./errors");
+const LIST_LIKE_COMPOSE_BLOCK_TYPES = /* @__PURE__ */ new Set(["list", "gridCard"]);
+function compileComposeExecutionPlan(input) {
+  const blocks = compileComposeBlockTasks(input.gridUid, input.normalizedBlocks);
+  const fields = compileComposeFieldTasks(input.normalizedBlocks);
+  const actions = compileComposeActionTasks(input.normalizedBlocks);
+  const recordActions = compileComposeRecordActionTasks(input.normalizedBlocks);
+  return {
+    gridUid: input.gridUid,
+    mode: input.mode,
+    existingItemUids: Array.from(new Set((input.existingItemUids || []).filter(Boolean))),
+    blocks,
+    fields,
+    actions,
+    recordActions,
+    layoutPlan: buildComposeLayoutPlan({
+      mode: input.mode,
+      layout: input.layout,
+      hasBlocks: blocks.length > 0
+    })
+  };
+}
+function compileComposeBlockTasks(gridUid, normalizedBlocks) {
+  return normalizedBlocks.map((blockSpec) => ({
+    key: blockSpec.key,
+    spec: blockSpec,
+    payload: buildComposeBlockCreatePayload(gridUid, blockSpec)
+  }));
+}
+function compileComposeFieldTasks(normalizedBlocks) {
+  return normalizedBlocks.flatMap(
+    (blockSpec) => blockSpec.fields.map((fieldSpec) => ({
+      blockKey: blockSpec.key,
+      spec: fieldSpec,
+      containerSource: resolveComposeFieldContainerSource(blockSpec),
+      payload: buildComposeFieldCreatePayload(fieldSpec)
+    }))
+  );
+}
+function compileComposeActionTasks(normalizedBlocks) {
+  return normalizedBlocks.flatMap(
+    (blockSpec) => blockSpec.actions.map((actionSpec) => ({
+      blockKey: blockSpec.key,
+      spec: actionSpec,
+      payload: buildComposeActionCreatePayload(actionSpec)
+    }))
+  );
+}
+function compileComposeRecordActionTasks(normalizedBlocks) {
+  return normalizedBlocks.flatMap(
+    (blockSpec) => blockSpec.recordActions.map((actionSpec) => ({
+      blockKey: blockSpec.key,
+      spec: actionSpec,
+      payload: buildComposeRecordActionCreatePayload(actionSpec)
+    }))
+  );
+}
+function resolveComposeFieldContainerSource(blockSpec) {
+  return LIST_LIKE_COMPOSE_BLOCK_TYPES.has(blockSpec.type || "") ? "item" : "block";
+}
+function resolveComposeTargetKey(targetKey, keyMap, kind) {
+  var _a, _b;
+  const key = String(targetKey || "").trim();
+  if (!key) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces compose ${kind} target key cannot be empty`);
+  }
+  if (!((_a = keyMap[key]) == null ? void 0 : _a.uid)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces compose ${kind} target '${key}' was not created in the current compose call`);
+  }
+  return (_b = keyMap[key]) == null ? void 0 : _b.uid;
+}
+function buildComposeBlockCreatePayload(gridUid, blockSpec) {
+  var _a, _b;
+  return {
+    target: {
+      uid: gridUid
+    },
+    ...blockSpec.key ? { key: blockSpec.key } : {},
+    ...blockSpec.type ? { type: blockSpec.type } : {},
+    ...((_a = blockSpec.resource) == null ? void 0 : _a.kind) === "semantic" ? { resource: blockSpec.resource.value } : {},
+    ...((_b = blockSpec.resource) == null ? void 0 : _b.kind) === "raw" ? { resourceInit: blockSpec.resource.value } : {},
+    ...blockSpec.template ? { template: blockSpec.template } : {}
+  };
+}
+function buildComposeFieldCreatePayload(fieldSpec) {
+  return {
+    ...fieldSpec.key ? { key: fieldSpec.key } : {},
+    ...fieldSpec.fieldPath ? { fieldPath: fieldSpec.fieldPath } : {},
+    ...fieldSpec.associationPathName ? { associationPathName: fieldSpec.associationPathName } : {},
+    ...fieldSpec.renderer ? { renderer: fieldSpec.renderer } : {},
+    ...fieldSpec.type ? { type: fieldSpec.type } : {},
+    ...fieldSpec.popup ? { popup: fieldSpec.popup } : {}
+  };
+}
+function buildComposeActionCreatePayload(actionSpec) {
+  return {
+    ...actionSpec.key ? { key: actionSpec.key } : {},
+    type: actionSpec.type
+  };
+}
+function buildComposeRecordActionCreatePayload(actionSpec) {
+  return {
+    ...actionSpec.key ? { key: actionSpec.key } : {},
+    type: actionSpec.type
+  };
+}
+function buildComposeLayoutPlan(input) {
+  var _a;
+  if (((_a = input.layout) == null ? void 0 : _a.rows) || input.mode === "replace") {
+    return {
+      kind: "explicit",
+      layout: input.layout
+    };
+  }
+  if (input.mode === "append" && input.hasBlocks) {
+    return {
+      kind: "append"
+    };
+  }
+  return {
+    kind: "none"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileComposeExecutionPlan,
+  resolveComposeFieldContainerSource,
+  resolveComposeTargetKey
+});

package/dist/server/flow-surfaces/compose-runtime.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 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 { type FlowSurfaceCompiledComposePlan, type FlowSurfaceComposeNormalizedActionSpec, type FlowSurfaceComposeNormalizedBlockSpec, type FlowSurfaceComposeNormalizedFieldSpec, type FlowSurfaceComposeObject, type FlowSurfaceComposeTargetKey } from './compose-compiler';
+export type FlowSurfaceComposeBlockResult = {
+    uid: string;
+    gridUid?: string;
+    itemUid?: string;
+    itemGridUid?: string;
+    actionsColumnUid?: string;
+};
+export type FlowSurfaceComposeFieldResult = {
+    uid?: string;
+    wrapperUid?: string;
+    fieldUid?: string;
+    innerFieldUid?: string;
+    popupPageUid?: string;
+    popupTabUid?: string;
+    popupGridUid?: string;
+};
+export type FlowSurfaceComposeActionResult = {
+    uid: string;
+    parentUid?: string;
+    scope?: string;
+};
+export type FlowSurfaceComposeRuntimeBlockState = {
+    spec: FlowSurfaceComposeNormalizedBlockSpec;
+    result: FlowSurfaceComposeBlockResult;
+    fieldResults: Array<Record<string, unknown>>;
+    actionResults: Array<Record<string, unknown>>;
+    recordActionResults: Array<Record<string, unknown>>;
+};
+export type FlowSurfaceComposeRuntimeState = {
+    keyMap: Record<string, FlowSurfaceComposeTargetKey & Partial<FlowSurfaceComposeBlockResult>>;
+    blocks: FlowSurfaceComposeRuntimeBlockState[];
+};
+export type FlowSurfaceComposeExecutionResult = {
+    target: {
+        uid: string;
+    };
+    mode: FlowSurfaceCompiledComposePlan['mode'];
+    blocks: Array<{
+        key: string;
+        type?: string;
+        uid: string;
+        gridUid?: string;
+        itemUid?: string;
+        itemGridUid?: string;
+        actionsColumnUid?: string;
+        fields: Array<Record<string, unknown>>;
+        actions: Array<Record<string, unknown>>;
+        recordActions: Array<Record<string, unknown>>;
+    }>;
+    layout?: unknown;
+};
+export type FlowSurfaceComposeRuntimeDeps = {
+    removeExistingItem?: (uid: string) => Promise<void>;
+    createBlock: (payload: Record<string, unknown>, spec: FlowSurfaceComposeNormalizedBlockSpec) => Promise<FlowSurfaceComposeBlockResult>;
+    applyNodeSettings?: (actionName: string, targetUid: string | undefined, settings?: FlowSurfaceComposeObject) => Promise<void>;
+    createField: (payload: Record<string, unknown>, spec: FlowSurfaceComposeNormalizedFieldSpec, blockResult: FlowSurfaceComposeBlockResult) => Promise<FlowSurfaceComposeFieldResult | null>;
+    applyFieldSettings?: (actionName: string, result: FlowSurfaceComposeFieldResult, settings?: FlowSurfaceComposeObject) => Promise<void>;
+    onFieldError?: (input: {
+        error: unknown;
+        spec: FlowSurfaceComposeNormalizedFieldSpec;
+        blockSpec: FlowSurfaceComposeNormalizedBlockSpec;
+        blockResult: FlowSurfaceComposeBlockResult;
+    }) => Promise<'continue' | void> | 'continue' | void;
+    createAction: (payload: Record<string, unknown>, spec: FlowSurfaceComposeNormalizedActionSpec, blockResult: FlowSurfaceComposeBlockResult) => Promise<FlowSurfaceComposeActionResult>;
+    createRecordAction: (payload: Record<string, unknown>, spec: FlowSurfaceComposeNormalizedActionSpec, blockResult: FlowSurfaceComposeBlockResult) => Promise<FlowSurfaceComposeActionResult>;
+    applyActionPopup?: (actionName: string, actionUid: string, popup?: FlowSurfaceComposeObject) => Promise<void>;
+    collectActionKeys?: (actionUid: string) => Promise<Record<string, unknown>>;
+    buildExplicitLayoutPayload?: (input: {
+        layout?: FlowSurfaceComposeObject;
+        createdByKey: Record<string, FlowSurfaceComposeTargetKey & Partial<FlowSurfaceComposeBlockResult>>;
+        gridUid: string;
+    }) => Promise<Record<string, unknown>> | Record<string, unknown>;
+    buildAppendLayoutPayload?: (input: {
+        gridUid: string;
+        appendedItemUids: string[];
+    }) => Promise<Record<string, unknown>> | Record<string, unknown>;
+    setLayout?: (payload: Record<string, unknown>) => Promise<unknown>;
+};
+export declare function executeComposeRuntime(plan: FlowSurfaceCompiledComposePlan, deps: FlowSurfaceComposeRuntimeDeps): Promise<FlowSurfaceComposeExecutionResult>;
+export declare function createComposeRuntimeState(): FlowSurfaceComposeRuntimeState;

package/dist/server/flow-surfaces/compose-runtime.js

@@ -0,0 +1,338 @@
+/**
+ * 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 compose_runtime_exports = {};
+__export(compose_runtime_exports, {
+  createComposeRuntimeState: () => createComposeRuntimeState,
+  executeComposeRuntime: () => executeComposeRuntime
+});
+module.exports = __toCommonJS(compose_runtime_exports);
+var import_errors = require("./errors");
+var import_default_action_popup = require("./default-action-popup");
+var import_compose_compiler = require("./compose-compiler");
+async function executeComposeRuntime(plan, deps) {
+  assertComposeRuntimeDeps(plan, deps);
+  const state = createComposeRuntimeState();
+  await removeExistingItemsForReplace(plan, deps);
+  await createBlocks(plan, deps, state);
+  await applyBlockSettings(deps, state);
+  await createFields(plan, deps, state);
+  await createActions(plan, deps, state);
+  await createRecordActions(plan, deps, state);
+  const layoutResult = await applyComposeLayout(plan, deps, state);
+  return {
+    target: {
+      uid: plan.gridUid
+    },
+    mode: plan.mode,
+    blocks: state.blocks.map((block) => ({
+      key: block.spec.key,
+      type: block.spec.type,
+      uid: block.result.uid,
+      gridUid: block.result.gridUid,
+      itemUid: block.result.itemUid,
+      itemGridUid: block.result.itemGridUid,
+      actionsColumnUid: block.result.actionsColumnUid,
+      fields: block.fieldResults,
+      actions: block.actionResults,
+      recordActions: block.recordActionResults
+    })),
+    ...typeof layoutResult === "undefined" ? {} : { layout: layoutResult }
+  };
+}
+function createComposeRuntimeState() {
+  return {
+    keyMap: {},
+    blocks: []
+  };
+}
+function shouldApplyActionPopupAfterEffect(spec) {
+  return hasPopupAfterEffect(spec.popup) || (0, import_default_action_popup.isFlowSurfaceDefaultActionPopupType)(spec.type);
+}
+function assertComposeRuntimeDeps(plan, deps) {
+  if (plan.mode === "replace" && plan.existingItemUids.length) {
+    requireComposeRuntimeDep("removeExistingItem", deps.removeExistingItem, "replace");
+  }
+  if (plan.blocks.some((block) => hasInlineSettings(block.spec.settings))) {
+    requireComposeRuntimeDep("applyNodeSettings", deps.applyNodeSettings, "block settings");
+  }
+  if (plan.fields.some((field) => hasInlineSettings(field.spec.settings))) {
+    requireComposeRuntimeDep("applyFieldSettings", deps.applyFieldSettings, "field settings");
+  }
+  if ([...plan.actions, ...plan.recordActions].some(
+    (action) => hasInlineSettings(action.spec.settings) || shouldApplyActionPopupAfterEffect(action.spec)
+  )) {
+    if ([...plan.actions, ...plan.recordActions].some((action) => hasInlineSettings(action.spec.settings))) {
+      requireComposeRuntimeDep("applyNodeSettings", deps.applyNodeSettings, "action settings");
+    }
+    if ([...plan.actions, ...plan.recordActions].some((action) => shouldApplyActionPopupAfterEffect(action.spec))) {
+      requireComposeRuntimeDep("applyActionPopup", deps.applyActionPopup, "action popup");
+    }
+  }
+}
+function requireComposeRuntimeDep(name, dep, stage) {
+  if (dep) {
+    return;
+  }
+  (0, import_errors.throwConflict)(
+    `flowSurfaces compose ${stage} runtime deps missing '${name}'`,
+    "FLOW_SURFACE_COMPOSE_RUNTIME_DEPS_MISSING"
+  );
+}
+async function removeExistingItemsForReplace(plan, deps) {
+  if (plan.mode !== "replace" || !plan.existingItemUids.length) {
+    return;
+  }
+  const removeExistingItem = deps.removeExistingItem;
+  requireComposeRuntimeDep("removeExistingItem", removeExistingItem, "replace");
+  for (const uid of plan.existingItemUids) {
+    await removeExistingItem(uid);
+  }
+}
+async function createBlocks(plan, deps, state) {
+  for (const blockTask of plan.blocks) {
+    const result = await deps.createBlock(blockTask.payload, blockTask.spec);
+    state.blocks.push({
+      spec: blockTask.spec,
+      result,
+      fieldResults: [],
+      actionResults: [],
+      recordActionResults: []
+    });
+    state.keyMap[blockTask.key] = {
+      uid: result.uid,
+      gridUid: result.gridUid,
+      itemUid: result.itemUid,
+      itemGridUid: result.itemGridUid,
+      actionsColumnUid: result.actionsColumnUid
+    };
+  }
+}
+async function applyBlockSettings(deps, state) {
+  const applyNodeSettings = deps.applyNodeSettings;
+  if (!applyNodeSettings) {
+    return;
+  }
+  for (const block of state.blocks) {
+    if (!hasInlineSettings(block.spec.settings)) {
+      continue;
+    }
+    await applyNodeSettings("compose block", block.result.uid, block.spec.settings);
+  }
+}
+async function createFields(plan, deps, state) {
+  for (const fieldTask of plan.fields) {
+    const block = requireBlockState(fieldTask.blockKey, state);
+    const targetUid = fieldTask.containerSource === "item" ? block.result.itemUid || block.result.uid : block.result.uid;
+    let createdField;
+    try {
+      createdField = await deps.createField(
+        {
+          target: {
+            uid: targetUid
+          },
+          ...fieldTask.payload,
+          ...readComposeFieldTargetKey(fieldTask.spec.target) ? {
+            defaultTargetUid: (0, import_compose_compiler.resolveComposeTargetKey)(
+              readComposeFieldTargetKey(fieldTask.spec.target),
+              state.keyMap,
+              "field"
+            )
+          } : {}
+        },
+        fieldTask.spec,
+        block.result
+      );
+    } catch (error) {
+      const decision = deps.onFieldError ? await deps.onFieldError({
+        error,
+        spec: fieldTask.spec,
+        blockSpec: block.spec,
+        blockResult: block.result
+      }) : void 0;
+      if (decision === "continue") {
+        continue;
+      }
+      throw error;
+    }
+    if (!createdField) {
+      continue;
+    }
+    if (deps.applyFieldSettings && hasInlineSettings(fieldTask.spec.settings)) {
+      await deps.applyFieldSettings("compose field", createdField, fieldTask.spec.settings);
+    }
+    block.fieldResults.push(buildFieldResultSummary(fieldTask.spec, createdField));
+  }
+}
+async function createActions(plan, deps, state) {
+  for (const actionTask of plan.actions) {
+    const block = requireBlockState(actionTask.blockKey, state);
+    const createdAction = await deps.createAction(
+      {
+        target: {
+          uid: block.result.uid
+        },
+        ...actionTask.payload
+      },
+      actionTask.spec,
+      block.result
+    );
+    if (deps.applyNodeSettings && hasInlineSettings(actionTask.spec.settings)) {
+      await deps.applyNodeSettings("compose action", createdAction.uid, actionTask.spec.settings);
+    }
+    if (deps.applyActionPopup && shouldApplyActionPopupAfterEffect(actionTask.spec)) {
+      await deps.applyActionPopup("compose action", createdAction.uid, actionTask.spec.popup);
+    }
+    const actionKeys = deps.collectActionKeys ? await deps.collectActionKeys(createdAction.uid) : {};
+    block.actionResults.push(buildActionResultSummary(actionTask.spec, createdAction, actionKeys));
+  }
+}
+async function createRecordActions(plan, deps, state) {
+  for (const recordActionTask of plan.recordActions) {
+    const block = requireBlockState(recordActionTask.blockKey, state);
+    const createdAction = await deps.createRecordAction(
+      {
+        target: {
+          uid: block.result.uid
+        },
+        ...recordActionTask.payload
+      },
+      recordActionTask.spec,
+      block.result
+    );
+    if (!block.result.actionsColumnUid && block.spec.type === "table" && createdAction.parentUid) {
+      block.result.actionsColumnUid = createdAction.parentUid;
+      state.keyMap[recordActionTask.blockKey] = {
+        ...state.keyMap[recordActionTask.blockKey],
+        actionsColumnUid: createdAction.parentUid
+      };
+    }
+    if (deps.applyNodeSettings && hasInlineSettings(recordActionTask.spec.settings)) {
+      await deps.applyNodeSettings("compose recordAction", createdAction.uid, recordActionTask.spec.settings);
+    }
+    if (deps.applyActionPopup && shouldApplyActionPopupAfterEffect(recordActionTask.spec)) {
+      await deps.applyActionPopup("compose recordAction", createdAction.uid, recordActionTask.spec.popup);
+    }
+    const actionKeys = deps.collectActionKeys ? await deps.collectActionKeys(createdAction.uid) : {};
+    block.recordActionResults.push(buildActionResultSummary(recordActionTask.spec, createdAction, actionKeys));
+  }
+}
+async function applyComposeLayout(plan, deps, state) {
+  if (plan.layoutPlan.kind === "none") {
+    return void 0;
+  }
+  if (plan.layoutPlan.kind === "explicit") {
+    const buildExplicitLayoutPayload = deps.buildExplicitLayoutPayload;
+    const setLayout2 = deps.setLayout;
+    requireComposeRuntimeDep("buildExplicitLayoutPayload", buildExplicitLayoutPayload, "explicit layout");
+    requireComposeRuntimeDep("setLayout", setLayout2, "explicit layout");
+    const layoutPayload2 = await buildExplicitLayoutPayload({
+      layout: plan.layoutPlan.layout,
+      createdByKey: state.keyMap,
+      gridUid: plan.gridUid
+    });
+    return setLayout2({
+      target: {
+        uid: plan.gridUid
+      },
+      ...layoutPayload2
+    });
+  }
+  const buildAppendLayoutPayload = deps.buildAppendLayoutPayload;
+  const setLayout = deps.setLayout;
+  requireComposeRuntimeDep("buildAppendLayoutPayload", buildAppendLayoutPayload, "append layout");
+  requireComposeRuntimeDep("setLayout", setLayout, "append layout");
+  const layoutPayload = await buildAppendLayoutPayload({
+    gridUid: plan.gridUid,
+    appendedItemUids: state.blocks.map((block) => block.result.uid)
+  });
+  return setLayout({
+    target: {
+      uid: plan.gridUid
+    },
+    ...layoutPayload
+  });
+}
+function requireBlockState(blockKey, state) {
+  const matched = state.blocks.find((block) => block.spec.key === blockKey);
+  if (!matched) {
+    (0, import_errors.throwConflict)(
+      `flowSurfaces compose block '${blockKey}' is missing from runtime state`,
+      "FLOW_SURFACE_COMPOSE_BLOCK_MISSING"
+    );
+  }
+  return matched;
+}
+function buildFieldResultSummary(spec, createdField) {
+  return {
+    key: spec.key,
+    uid: createdField.uid,
+    ...spec.type ? { type: spec.type } : {},
+    ...spec.renderer ? { renderer: spec.renderer } : {},
+    fieldPath: spec.fieldPath,
+    associationPathName: spec.associationPathName,
+    wrapperUid: createdField.wrapperUid,
+    fieldUid: createdField.fieldUid,
+    innerFieldUid: createdField.innerFieldUid,
+    popupPageUid: createdField.popupPageUid,
+    popupTabUid: createdField.popupTabUid,
+    popupGridUid: createdField.popupGridUid,
+    ...spec.target ? { target: spec.target } : {}
+  };
+}
+function buildActionResultSummary(spec, createdAction, actionKeys) {
+  return {
+    key: spec.key,
+    type: spec.type,
+    scope: createdAction.scope,
+    uid: createdAction.uid,
+    parentUid: createdAction.parentUid,
+    ...actionKeys
+  };
+}
+function hasInlineSettings(value) {
+  return !!value && Object.keys(value).length > 0;
+}
+function hasPopupAfterEffect(value) {
+  return typeof value !== "undefined";
+}
+function readComposeFieldTargetKey(target) {
+  if (typeof target === "string") {
+    const normalized2 = target.trim();
+    return normalized2 || void 0;
+  }
+  if (!target || typeof target !== "object") {
+    return void 0;
+  }
+  const key = typeof target.composeKey === "string" ? target.composeKey : target.key;
+  const normalized = typeof key === "string" ? key.trim() : "";
+  return normalized || void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createComposeRuntimeState,
+  executeComposeRuntime
+});

package/dist/server/flow-surfaces/configure-options.js

@@ -151,7 +151,10 @@ const FORM_COMMON_OPTIONS = {
   labelAlign: stringOption("Label alignment", { example: "left" }),
   labelWidth: stringOption("Label width", { example: "120px" }),
   labelWrap: booleanOption("Whether labels should wrap", { example: false }),
-  assignRules: objectOption("Assignment rules", { example: {} }),
+  assignRules: objectOption(
+    "Raw assignment-rules payload. For AI/CLI authoring, prefer `getReactionMeta` + `setFieldValueRules` or blueprint `reaction.items[]` instead of guessing this configure key directly.",
+    { example: {} }
+  ),
   colon: booleanOption("Whether to display a colon after the label", { example: true })
 };
 const EDIT_FORM_OPTIONS = {
@@ -168,7 +171,10 @@ const DETAILS_OPTIONS = {
   colon: booleanOption("Whether to display a colon after the label", { example: true }),
   sorting: SORTING,
   dataScope: FILTER_GROUP,
-  linkageRules: arrayOption("Linkage rules", { example: [] })
+  linkageRules: arrayOption(
+    "Raw linkage-rules payload. For AI/CLI authoring, prefer `getReactionMeta` + `setFieldLinkageRules` instead of guessing this configure key directly.",
+    { example: [] }
+  )
 };
 const FILTER_FORM_OPTIONS = {
   ...COMMON_BLOCK_TITLE_OPTIONS,
@@ -437,7 +443,10 @@ const ACTION_ASSIGN_OPTIONS = {
   updateMode: stringOption("Update mode", { example: "overwrite" })
 };
 const ACTION_LINKAGE_OPTIONS = {
-  linkageRules: arrayOption("Linkage rules", { example: [] })
+  linkageRules: arrayOption(
+    "Raw linkage-rules payload. For AI/CLI authoring, prefer `getReactionMeta` + `setActionLinkageRules` instead of guessing this configure key directly.",
+    { example: [] }
+  )
 };
 const ACTION_JS_OPTIONS = {
   code: JS_CODE,

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

@@ -6,8 +6,9 @@
  * 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 FLOW_SURFACES_ACTION_NAMES: readonly ["catalog", "context", "get", "compose", "configure", "createMenu", "updateMenu", "createPage", "destroyPage", "addTab", "updateTab", "moveTab", "removeTab", "addPopupTab", "updatePopupTab", "movePopupTab", "removePopupTab", "addBlock", "addBlocks", "addField", "addFields", "addAction", "addActions", "addRecordAction", "addRecordActions", "updateSettings", "setEventFlows", "setLayout", "moveNode", "removeNode", "mutate", "apply"];
+export { FLOW_SURFACE_PLAN_STEP_ACTIONS } from './planning/action-specs';
+export declare const FLOW_SURFACES_ACTION_NAMES: readonly ["catalog", "context", "get", "describeSurface", "getReactionMeta", "setFieldValueRules", "setBlockLinkageRules", "setFieldLinkageRules", "setActionLinkageRules", "applyBlueprint", "listTemplates", "getTemplate", "saveTemplate", "updateTemplate", "destroyTemplate", "convertTemplateToCopy", "compose", "configure", "createMenu", "updateMenu", "createPage", "destroyPage", "addTab", "updateTab", "moveTab", "removeTab", "addPopupTab", "updatePopupTab", "movePopupTab", "removePopupTab", "addBlock", "addBlocks", "addField", "addFields", "addAction", "addActions", "addRecordAction", "addRecordActions", "updateSettings", "setEventFlows", "setLayout", "moveNode", "removeNode", "mutate", "apply"];
 export type FlowSurfacesActionName = (typeof FLOW_SURFACES_ACTION_NAMES)[number];
-export declare const FLOW_SURFACES_READ_ACTION_NAMES: readonly ["catalog", "context", "get"];
+export declare const FLOW_SURFACES_READ_ACTION_NAMES: readonly ["catalog", "context", "get", "describeSurface", "getReactionMeta", "listTemplates", "getTemplate"];
 export declare const FLOW_SURFACE_MUTATE_OP_TYPES: readonly ["createMenu", "updateMenu", "createPage", "destroyPage", "addTab", "updateTab", "moveTab", "removeTab", "addPopupTab", "updatePopupTab", "movePopupTab", "removePopupTab", "addBlock", "addField", "addAction", "addRecordAction", "updateSettings", "setEventFlows", "setLayout", "moveNode", "removeNode"];
 export declare const FLOW_SURFACES_ACTION_METHODS: Record<FlowSurfacesActionName, 'get' | 'post'>;