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

package/dist/server/flow-surfaces/planning/key-registry.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { FlowSurfaceBindKey, FlowSurfaceReadLocator } from '../types';
+import type { FlowSurfaceCompiledPlanStep, FlowSurfacePlanSurfaceContext, FlowSurfaceResolvedKey } from './types';
+export declare const FLOW_SURFACE_SYSTEM_KEY = "surface";
+export declare const FLOW_SURFACE_RESERVED_KEYS: Set<string>;
+export declare const FLOW_SURFACE_INTERNAL_META_KEY = "__flowSurfaceMeta";
+export declare const FLOW_SURFACE_DECLARED_KEY_KEY = "declaredKey";
+export declare const FLOW_SURFACE_KEY_NOT_PERSISTABLE_CODE = "FLOW_SURFACE_KEY_NOT_PERSISTABLE";
+export declare function getDeclaredKeyFromNode(node: any): string;
+export declare function normalizeBindKeys(actionName: string, bindKeys: any, deps: {
+    normalizeGetTarget: (value: any) => FlowSurfaceReadLocator;
+}): FlowSurfaceBindKey[];
+export declare function collectDeclaredKeysFromTree(node: any, deps: {
+    actionName?: string;
+    buildPlanKeyKind: (node: any, resolvedKind?: string) => string;
+}, carry?: Map<string, FlowSurfaceResolvedKey>): Map<string, FlowSurfaceResolvedKey>;
+export declare function annotateTreeKey(tree: any, keyByUid: Map<string, string>): any;
+export declare function buildSurfaceKeysObject(keyMap: Map<string, FlowSurfaceResolvedKey>): {
+    [k: string]: {
+        uid: string;
+        kind: string;
+        source: "declared" | "request" | "system";
+        locator: FlowSurfaceReadLocator;
+    };
+};
+export declare function buildSurfaceFingerprintKeysObject(keyMap: Map<string, FlowSurfaceResolvedKey>): {
+    [k: string]: {
+        uid: string;
+        kind: string;
+    };
+};
+export declare function getSurfaceSelectorRequestKey(context: FlowSurfacePlanSurfaceContext): FlowSurfaceResolvedKey;
+export declare function collectRequestKeysToPersist(context: FlowSurfacePlanSurfaceContext, compiledSteps: FlowSurfaceCompiledPlanStep[]): Map<string, FlowSurfaceResolvedKey>;

package/dist/server/flow-surfaces/planning/key-registry.js

@@ -0,0 +1,206 @@
+/**
+ * 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 key_registry_exports = {};
+__export(key_registry_exports, {
+  FLOW_SURFACE_DECLARED_KEY_KEY: () => FLOW_SURFACE_DECLARED_KEY_KEY,
+  FLOW_SURFACE_INTERNAL_META_KEY: () => FLOW_SURFACE_INTERNAL_META_KEY,
+  FLOW_SURFACE_KEY_NOT_PERSISTABLE_CODE: () => FLOW_SURFACE_KEY_NOT_PERSISTABLE_CODE,
+  FLOW_SURFACE_RESERVED_KEYS: () => FLOW_SURFACE_RESERVED_KEYS,
+  FLOW_SURFACE_SYSTEM_KEY: () => FLOW_SURFACE_SYSTEM_KEY,
+  annotateTreeKey: () => annotateTreeKey,
+  buildSurfaceFingerprintKeysObject: () => buildSurfaceFingerprintKeysObject,
+  buildSurfaceKeysObject: () => buildSurfaceKeysObject,
+  collectDeclaredKeysFromTree: () => collectDeclaredKeysFromTree,
+  collectRequestKeysToPersist: () => collectRequestKeysToPersist,
+  getDeclaredKeyFromNode: () => getDeclaredKeyFromNode,
+  getSurfaceSelectorRequestKey: () => getSurfaceSelectorRequestKey,
+  normalizeBindKeys: () => normalizeBindKeys
+});
+module.exports = __toCommonJS(key_registry_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_service_utils = require("../service-utils");
+const FLOW_SURFACE_SYSTEM_KEY = "surface";
+const FLOW_SURFACE_RESERVED_KEYS = /* @__PURE__ */ new Set([FLOW_SURFACE_SYSTEM_KEY]);
+const FLOW_SURFACE_INTERNAL_META_KEY = "__flowSurfaceMeta";
+const FLOW_SURFACE_DECLARED_KEY_KEY = "declaredKey";
+const FLOW_SURFACE_KEY_NOT_PERSISTABLE_CODE = "FLOW_SURFACE_KEY_NOT_PERSISTABLE";
+function getDeclaredKeyFromNode(node) {
+  const declaredKey = import_lodash.default.get(node, ["stepParams", FLOW_SURFACE_INTERNAL_META_KEY, FLOW_SURFACE_DECLARED_KEY_KEY]);
+  return typeof declaredKey === "string" && declaredKey.trim() ? declaredKey.trim() : void 0;
+}
+function normalizeBindKeys(actionName, bindKeys, deps) {
+  if (import_lodash.default.isUndefined(bindKeys)) {
+    return [];
+  }
+  if (!Array.isArray(bindKeys)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} bindKeys must be an array`);
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  return bindKeys.map((item, index) => {
+    if (!import_lodash.default.isPlainObject(item)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} bindKeys[${index}] must be an object`);
+    }
+    const key = String(item.key || "").trim();
+    if (!key) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} bindKeys[${index}].key is required`);
+    }
+    if (FLOW_SURFACE_RESERVED_KEYS.has(key)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} bindKeys[${index}].key '${key}' is reserved`);
+    }
+    if (seenKeys.has(key)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} bindKeys[${index}].key '${key}' is duplicated`);
+    }
+    seenKeys.add(key);
+    if (!import_lodash.default.isPlainObject(item.locator)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} bindKeys[${index}].locator is required`);
+    }
+    return (0, import_service_utils.buildDefinedPayload)({
+      key,
+      locator: deps.normalizeGetTarget(item.locator),
+      expectedKind: typeof item.expectedKind === "string" ? String(item.expectedKind).trim() : void 0,
+      rebind: item.rebind === true
+    });
+  });
+}
+function collectDeclaredKeysFromTree(node, deps, carry = /* @__PURE__ */ new Map()) {
+  if (!node || typeof node !== "object") {
+    return carry;
+  }
+  if (node.uid) {
+    const declaredKey = getDeclaredKeyFromNode(node);
+    if (declaredKey && !FLOW_SURFACE_RESERVED_KEYS.has(declaredKey)) {
+      const existing = carry.get(declaredKey);
+      if (existing && existing.uid !== node.uid) {
+        (0, import_errors.throwConflict)(
+          `flowSurfaces ${deps.actionName || "describeSurface"} declared key '${declaredKey}' is duplicated on '${existing.uid}' and '${node.uid}'`,
+          "FLOW_SURFACE_DECLARED_KEY_CONFLICT"
+        );
+      }
+      carry.set(declaredKey, {
+        key: declaredKey,
+        uid: node.uid,
+        source: "declared",
+        kind: deps.buildPlanKeyKind(node),
+        locator: {
+          uid: node.uid
+        }
+      });
+    }
+  }
+  for (const value of Object.values(node.subModels || {})) {
+    import_lodash.default.castArray(value).forEach((child) => collectDeclaredKeysFromTree(child, deps, carry));
+  }
+  return carry;
+}
+function annotateTreeKey(tree, keyByUid) {
+  const visit = (current) => {
+    if (!current || typeof current !== "object") {
+      return;
+    }
+    const currentKey = current.uid ? keyByUid.get(current.uid) : void 0;
+    if (currentKey && typeof current.key === "undefined") {
+      current.key = currentKey;
+    }
+    for (const value of Object.values(current.subModels || {})) {
+      import_lodash.default.castArray(value).forEach((child) => visit(child));
+    }
+  };
+  visit(tree);
+  return tree;
+}
+function buildSurfaceKeysObject(keyMap) {
+  return Object.fromEntries(
+    Array.from(keyMap.entries()).map(([key, info]) => [
+      key,
+      {
+        uid: info.uid,
+        kind: info.kind,
+        source: info.source,
+        locator: info.locator
+      }
+    ])
+  );
+}
+function buildSurfaceFingerprintKeysObject(keyMap) {
+  return Object.fromEntries(
+    Array.from(keyMap.entries()).map(([key, info]) => [
+      key,
+      {
+        uid: info.uid,
+        kind: info.kind
+      }
+    ])
+  );
+}
+function getSurfaceSelectorRequestKey(context) {
+  if (!context.surfaceSelector || !("key" in context.surfaceSelector)) {
+    return void 0;
+  }
+  return context.requestKeyMap.get(context.surfaceSelector.key);
+}
+function collectRequestKeysToPersist(context, compiledSteps) {
+  const keys = /* @__PURE__ */ new Map();
+  const surfaceRequestKey = getSurfaceSelectorRequestKey(context);
+  if (surfaceRequestKey) {
+    keys.set(surfaceRequestKey.key, surfaceRequestKey);
+  }
+  for (const compiled of compiledSteps) {
+    for (const keyInfo of compiled.usedKeys) {
+      if (keyInfo.source === "request") {
+        keys.set(keyInfo.key, keyInfo);
+      }
+    }
+  }
+  return keys;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_DECLARED_KEY_KEY,
+  FLOW_SURFACE_INTERNAL_META_KEY,
+  FLOW_SURFACE_KEY_NOT_PERSISTABLE_CODE,
+  FLOW_SURFACE_RESERVED_KEYS,
+  FLOW_SURFACE_SYSTEM_KEY,
+  annotateTreeKey,
+  buildSurfaceFingerprintKeysObject,
+  buildSurfaceKeysObject,
+  collectDeclaredKeysFromTree,
+  collectRequestKeysToPersist,
+  getDeclaredKeyFromNode,
+  getSurfaceSelectorRequestKey,
+  normalizeBindKeys
+});

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

@@ -0,0 +1,37 @@
+/**
+ * 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 { FlowSurfaceDescribeValues, FlowSurfaceExecutorContext, FlowSurfaceMutateOp, FlowSurfacePlanRequestValues, FlowSurfaceReadLocator, FlowSurfaceReadTarget, FlowSurfaceResolvedTarget } from '../types';
+import { type FlowSurfacePlanOnlyActionName } from './action-specs';
+import type { FlowSurfacePlanSurfaceContext } from './types';
+type FlowSurfacePlanningRuntimeDeps = {
+    normalizeGetTarget: (value: any) => FlowSurfaceReadLocator;
+    resolveLocator: (target: FlowSurfaceReadLocator, options?: {
+        transaction?: any;
+    }) => Promise<FlowSurfaceResolvedTarget>;
+    loadResolvedSurfaceTree: (resolved: FlowSurfaceResolvedTarget, transaction?: any) => Promise<any>;
+    stripInternalSurfaceMetaFromNodeTree: <T = any>(node: T) => T;
+    buildReadTargetSummary: (target: FlowSurfaceReadLocator, resolved: FlowSurfaceResolvedTarget) => FlowSurfaceReadTarget;
+    buildSurfaceContextFingerprint: (context: Pick<FlowSurfacePlanSurfaceContext, 'surfaceResolved' | 'publicTree' | 'keyMap'>) => string;
+    buildSurfaceReadPayload: (target: FlowSurfaceReadLocator, resolved: FlowSurfaceResolvedTarget, node: any, options?: {
+        transaction?: any;
+    }) => Promise<any>;
+    dispatchPlanOnlyAction: (action: FlowSurfacePlanOnlyActionName, payload: Record<string, any>, transaction?: any) => Promise<any>;
+    dispatchOp: (op: FlowSurfaceMutateOp, resolvedValues: Record<string, any>, currentCtx: FlowSurfaceExecutorContext) => Promise<any>;
+};
+export declare function describeSurface(values: FlowSurfaceDescribeValues, deps: FlowSurfacePlanningRuntimeDeps, options?: {
+    transaction?: any;
+}): Promise<any>;
+type FlowSurfaceInternalPlanExecutionValues = Pick<FlowSurfacePlanRequestValues, 'surface' | 'plan'>;
+export type FlowSurfaceInternalPlanExecutionResult = {
+    results: Array<Record<string, any>>;
+};
+export declare function executeInternalPlan(values: FlowSurfaceInternalPlanExecutionValues, deps: FlowSurfacePlanningRuntimeDeps, options?: {
+    transaction?: any;
+}): Promise<FlowSurfaceInternalPlanExecutionResult>;
+export {};

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

@@ -0,0 +1,259 @@
+/**
+ * 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 runtime_exports = {};
+__export(runtime_exports, {
+  describeSurface: () => describeSurface,
+  executeInternalPlan: () => executeInternalPlan
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_executor = require("../executor");
+var import_action_specs = require("./action-specs");
+var import_context = require("./context");
+var import_compiler = require("./compiler");
+var import_key_kind = require("./key-kind");
+var import_key_registry = require("./key-registry");
+var import_created_keys = require("./created-keys");
+var import_payload_shape = require("../payload-shape");
+async function buildPlanSurfaceContext(surfaceSelectorInput, bindKeysInput, actionName, deps, options = {}) {
+  const bindKeys = (0, import_key_registry.normalizeBindKeys)(actionName, bindKeysInput, {
+    normalizeGetTarget: deps.normalizeGetTarget
+  });
+  if (import_lodash.default.isUndefined(surfaceSelectorInput) || import_lodash.default.isNil(surfaceSelectorInput)) {
+    return (0, import_context.buildPlanSurfaceContext)(
+      {
+        actionName,
+        bindKeys
+      },
+      {
+        resolveLocator: deps.resolveLocator,
+        loadResolvedSurfaceTree: deps.loadResolvedSurfaceTree,
+        stripInternalSurfaceMetaFromNodeTree: deps.stripInternalSurfaceMetaFromNodeTree,
+        buildReadTargetSummary: deps.buildReadTargetSummary,
+        buildSurfaceContextFingerprint: deps.buildSurfaceContextFingerprint,
+        buildPlanKeyKind: import_key_kind.buildPlanKeyKind,
+        assertBindKeyKind: import_key_kind.assertBindKeyKind,
+        collectDeclaredKeysFromTree: (node) => (0, import_key_registry.collectDeclaredKeysFromTree)(
+          node,
+          {
+            actionName,
+            buildPlanKeyKind: import_key_kind.buildPlanKeyKind
+          },
+          /* @__PURE__ */ new Map()
+        )
+      },
+      options
+    );
+  }
+  const normalizedSurfaceSelector = (0, import_compiler.normalizePlanSelector)(
+    actionName,
+    surfaceSelectorInput,
+    {
+      normalizeGetTarget: deps.normalizeGetTarget
+    },
+    "surface",
+    {
+      allowKey: true
+    }
+  );
+  if ("step" in normalizedSurfaceSelector) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} surface only supports { key } or { locator }`);
+  }
+  return (0, import_context.buildPlanSurfaceContext)(
+    {
+      actionName,
+      surfaceSelector: normalizedSurfaceSelector,
+      bindKeys
+    },
+    {
+      resolveLocator: deps.resolveLocator,
+      loadResolvedSurfaceTree: deps.loadResolvedSurfaceTree,
+      stripInternalSurfaceMetaFromNodeTree: deps.stripInternalSurfaceMetaFromNodeTree,
+      buildReadTargetSummary: deps.buildReadTargetSummary,
+      buildSurfaceContextFingerprint: deps.buildSurfaceContextFingerprint,
+      buildPlanKeyKind: import_key_kind.buildPlanKeyKind,
+      assertBindKeyKind: import_key_kind.assertBindKeyKind,
+      collectDeclaredKeysFromTree: (node) => (0, import_key_registry.collectDeclaredKeysFromTree)(
+        node,
+        {
+          actionName,
+          buildPlanKeyKind: import_key_kind.buildPlanKeyKind
+        },
+        /* @__PURE__ */ new Map()
+      )
+    },
+    options
+  );
+}
+async function buildDescribeSurfaceResponse(context, deps, options = {}) {
+  if (!context.surfaceTarget || !context.surfaceResolved) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces describeSurface requires locator`);
+  }
+  const tree = import_lodash.default.cloneDeep(context.publicTree);
+  const keyByUid = /* @__PURE__ */ new Map();
+  context.keyMap.forEach((value, key) => {
+    if (!keyByUid.has(value.uid)) {
+      keyByUid.set(value.uid, key);
+    }
+  });
+  (0, import_key_registry.annotateTreeKey)(tree, keyByUid);
+  const result = await deps.buildSurfaceReadPayload(context.surfaceTarget, context.surfaceResolved, tree, options);
+  result.fingerprint = context.fingerprint;
+  result.keys = (0, import_key_registry.buildSurfaceKeysObject)(context.keyMap);
+  return result;
+}
+function normalizePlanSteps(actionName, values, deps) {
+  return (0, import_compiler.normalizePlanSteps)(actionName, values, {
+    normalizeGetTarget: deps.normalizeGetTarget,
+    validatePayloadShape: import_payload_shape.validateFlowSurfacePayloadShape
+  });
+}
+async function compilePlanStep(actionName, step, index, context, deps, priorStepIds, priorCreatedKeys, options = {}) {
+  return (0, import_compiler.compilePlanStep)(
+    actionName,
+    step,
+    index,
+    context,
+    {
+      normalizeGetTarget: deps.normalizeGetTarget,
+      resolveLocator: deps.resolveLocator,
+      buildPlanKeyKind: import_key_kind.buildPlanKeyKind
+    },
+    priorStepIds,
+    priorCreatedKeys,
+    options
+  );
+}
+async function executeCompiledPlanStep(compiled, deps, execCtx, transaction) {
+  var _a;
+  if (compiled.mutateOp) {
+    const mutateResults = await (0, import_executor.executeMutateOps)(
+      [compiled.mutateOp],
+      execCtx,
+      async (op, resolvedValues, currentCtx) => deps.dispatchOp(op, resolvedValues, currentCtx)
+    );
+    return (_a = mutateResults[0]) == null ? void 0 : _a.result;
+  }
+  if (!(0, import_action_specs.isFlowSurfacePlanOnlyAction)(compiled.action)) {
+    (0, import_errors.throwInternalError)(`flowSurfaces internal plan action '${compiled.action}' is not supported`);
+  }
+  const result = await deps.dispatchPlanOnlyAction(
+    compiled.action,
+    (0, import_executor.resolveFlowSurfaceValueKeys)(import_lodash.default.cloneDeep(compiled.payload), execCtx.keys),
+    transaction
+  );
+  if (compiled.id) {
+    execCtx.keys.set(compiled.id, result);
+  }
+  return result;
+}
+function assertBootstrapPlanConstraints(actionName, compiledSteps) {
+  for (const compiled of compiledSteps) {
+    for (const selector of Object.values(compiled.resolvedSelectors)) {
+      if (!selector) {
+        continue;
+      }
+      if (selector.source !== "step" && selector.source !== "created") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} bootstrap plan only supports step or created-key selectors`);
+      }
+    }
+  }
+}
+async function describeSurface(values, deps, options = {}) {
+  if (!import_lodash.default.isPlainObject(values) || !import_lodash.default.isPlainObject(values.locator)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces describeSurface requires locator`);
+  }
+  const locator = deps.normalizeGetTarget(values.locator);
+  const context = await buildPlanSurfaceContext({ locator }, values.bindKeys, "describeSurface", deps, options);
+  return buildDescribeSurfaceResponse(context, deps, options);
+}
+async function executeInternalPlan(values, deps, options = {}) {
+  if (!import_lodash.default.isPlainObject(values)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint requires plan`);
+  }
+  const context = await buildPlanSurfaceContext(values.surface, void 0, "applyBlueprint", deps, options);
+  const steps = normalizePlanSteps("applyBlueprint", values, deps);
+  const compiledSteps = [];
+  const priorStepIds = /* @__PURE__ */ new Set();
+  const priorCreatedKeys = /* @__PURE__ */ new Set();
+  for (const [index, step] of steps.entries()) {
+    const compiled = await compilePlanStep(
+      "applyBlueprint",
+      step,
+      index,
+      context,
+      deps,
+      priorStepIds,
+      priorCreatedKeys,
+      options
+    );
+    compiledSteps.push(compiled);
+    if (step.id) {
+      priorStepIds.add(step.id);
+    }
+    for (const createdKey of compiled.createdKeys) {
+      priorCreatedKeys.add(createdKey.key);
+    }
+  }
+  if (!context.surfaceSelector) {
+    assertBootstrapPlanConstraints("applyBlueprint", compiledSteps);
+  }
+  const results = [];
+  const execCtx = {
+    transaction: options.transaction,
+    keys: new Map(Array.from(context.keyMap.entries()).map(([key, info]) => [key, info.uid])),
+    clientKeyToUid: {}
+  };
+  for (const compiled of compiledSteps) {
+    const result = await executeCompiledPlanStep(compiled, deps, execCtx, options.transaction);
+    const createdKeys = (0, import_created_keys.registerFlowSurfaceCreatedKeys)(result, compiled.createdKeys, execCtx.keys);
+    results.push({
+      index: compiled.index,
+      ...compiled.id ? { id: compiled.id } : {},
+      action: compiled.action,
+      result,
+      ...createdKeys.length ? { createdKeys } : {}
+    });
+  }
+  return { results };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  describeSurface,
+  executeInternalPlan
+});

package/dist/server/flow-surfaces/planning/step-link.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.
+ */
+import { isFlowSurfacePlanStepValue } from '../reference-guards';
+import type { FlowSurfacePlanStepLink } from '../types';
+export declare const isFlowSurfacePlanStepLink: typeof isFlowSurfacePlanStepValue;
+export declare function normalizeFlowSurfacePlanStepLink(actionName: string, input: any, fieldName: string): FlowSurfacePlanStepLink;
+export declare function assertFlowSurfaceKnownPlanStepLink(actionName: string, stepLink: FlowSurfacePlanStepLink, fieldName: string, knownStepIds?: Set<string>): void;
+export declare function replaceFlowSurfacePlanStepLinks(actionName: string, input: any, path: string, knownStepIds?: Set<string>, knownRuntimeKeys?: Set<string>): any;

package/dist/server/flow-surfaces/planning/step-link.js

@@ -0,0 +1,104 @@
+/**
+ * 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 step_link_exports = {};
+__export(step_link_exports, {
+  assertFlowSurfaceKnownPlanStepLink: () => assertFlowSurfaceKnownPlanStepLink,
+  isFlowSurfacePlanStepLink: () => isFlowSurfacePlanStepLink,
+  normalizeFlowSurfacePlanStepLink: () => normalizeFlowSurfacePlanStepLink,
+  replaceFlowSurfacePlanStepLinks: () => replaceFlowSurfacePlanStepLinks
+});
+module.exports = __toCommonJS(step_link_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_reference_guards = require("../reference-guards");
+var import_created_keys = require("./created-keys");
+const isFlowSurfacePlanStepLink = import_reference_guards.isFlowSurfacePlanStepValue;
+function normalizeFlowSurfacePlanStepLink(actionName, input, fieldName) {
+  return (0, import_reference_guards.normalizeFlowSurfacePlanStepValue)(actionName, input, fieldName);
+}
+function assertFlowSurfaceKnownPlanStepLink(actionName, stepLink, fieldName, knownStepIds) {
+  if (!knownStepIds || knownStepIds.has(stepLink.step)) {
+    return;
+  }
+  (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName}.step '${stepLink.step}' is not a previous step id`);
+}
+function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds, knownRuntimeKeys) {
+  if (Array.isArray(input)) {
+    return input.map(
+      (item, index) => replaceFlowSurfacePlanStepLinks(actionName, item, `${path}[${index}]`, knownStepIds, knownRuntimeKeys)
+    );
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    return input;
+  }
+  (0, import_reference_guards.assertNoFlowSurfaceLegacyRef)(input, {
+    actionName,
+    path,
+    dollarRefAllowed: "{ step, path }",
+    refAllowed: "{ key } or { step, path }"
+  });
+  if (isFlowSurfacePlanStepLink(input)) {
+    const stepLink = normalizeFlowSurfacePlanStepLink(actionName, input, path);
+    assertFlowSurfaceKnownPlanStepLink(actionName, stepLink, path, knownStepIds);
+    return stepLink;
+  }
+  if ((0, import_created_keys.isFlowSurfacePureKeyObject)(input)) {
+    const runtimeKey = String(input.key || "").trim();
+    if (!runtimeKey) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.key cannot be empty`);
+    }
+    if (!(knownRuntimeKeys == null ? void 0 : knownRuntimeKeys.has(runtimeKey))) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.key '${runtimeKey}' is not defined`);
+    }
+    return {
+      key: runtimeKey
+    };
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [
+      key,
+      replaceFlowSurfacePlanStepLinks(actionName, value, `${path}.${key}`, knownStepIds, knownRuntimeKeys)
+    ])
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertFlowSurfaceKnownPlanStepLink,
+  isFlowSurfacePlanStepLink,
+  normalizeFlowSurfacePlanStepLink,
+  replaceFlowSurfacePlanStepLinks
+});