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

package/dist/server/flow-surfaces/planning/compiler.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 _ from 'lodash';
+import type { FlowSurfacePlanSelector, FlowSurfacePlanRequestValues, FlowSurfacePlanStep, FlowSurfaceReadLocator, FlowSurfaceResolvedTarget } from '../types';
+import type { FlowSurfaceCompiledPlanStep, FlowSurfacePlanSurfaceContext } from './types';
+type NormalizePlanSelectorDeps = {
+    normalizeGetTarget: (value: any) => FlowSurfaceReadLocator;
+};
+type NormalizePlanSelectorOptions = {
+    allowKey?: boolean;
+};
+type NormalizePlanStepsDeps = NormalizePlanSelectorDeps & {
+    validatePayloadShape: (actionName: string, value: any, path: string) => void;
+};
+type CompilePlanStepDeps = NormalizePlanSelectorDeps & {
+    resolveLocator: (target: FlowSurfaceReadLocator, options?: {
+        transaction?: any;
+    }) => Promise<FlowSurfaceResolvedTarget>;
+    buildPlanKeyKind: (node: any, resolvedKind?: string) => string;
+};
+export declare function normalizePlanSelector(actionName: string, selector: any, deps: NormalizePlanSelectorDeps, fieldName?: string, options?: NormalizePlanSelectorOptions): FlowSurfacePlanSelector;
+export declare function normalizePlanSteps(actionName: string, values: FlowSurfacePlanRequestValues, deps: NormalizePlanStepsDeps): {
+    id: string;
+    action: "createMenu" | "setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "convertTemplateToCopy" | "compose" | "configure" | "createPage" | "destroyPage" | "addTab" | "updateTab" | "moveTab" | "removeTab" | "addPopupTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "updateSettings" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode";
+    selectors: _.Dictionary<any>;
+    values: Record<string, any>;
+}[];
+export declare function compilePlanStep(actionName: string, step: FlowSurfacePlanStep, index: number, context: FlowSurfacePlanSurfaceContext, deps: CompilePlanStepDeps, priorStepIds: Set<string>, priorCreatedKeys: Set<string>, options?: {
+    transaction?: any;
+}): Promise<FlowSurfaceCompiledPlanStep>;
+export {};

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

@@ -0,0 +1,376 @@
+/**
+ * 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 compiler_exports = {};
+__export(compiler_exports, {
+  compilePlanStep: () => compilePlanStep,
+  normalizePlanSelector: () => normalizePlanSelector,
+  normalizePlanSteps: () => normalizePlanSteps
+});
+module.exports = __toCommonJS(compiler_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_service_utils = require("../service-utils");
+var import_action_specs = require("./action-specs");
+var import_step_link = require("./step-link");
+var import_created_keys = require("./created-keys");
+function isFlowSurfaceResolvedStepLink(selector) {
+  return "step" in selector && selector.summary.source === "step";
+}
+function normalizePlanSelector(actionName, selector, deps, fieldName = "selector", options = {}) {
+  const allowKey = options.allowKey !== false;
+  if (!import_lodash.default.isPlainObject(selector)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName} must be an object`);
+  }
+  if (allowKey && Object.keys(selector).length === 1 && typeof selector.key === "string" && selector.key.trim()) {
+    return {
+      key: selector.key.trim()
+    };
+  }
+  if (Object.keys(selector).length === 1 && import_lodash.default.isPlainObject(selector.locator)) {
+    return {
+      locator: deps.normalizeGetTarget(selector.locator)
+    };
+  }
+  if (Object.keys(selector).every((key) => ["step", "path"].includes(key)) && typeof selector.step === "string") {
+    return (0, import_step_link.normalizeFlowSurfacePlanStepLink)(actionName, selector, fieldName);
+  }
+  (0, import_errors.throwBadRequest)(
+    `flowSurfaces ${actionName} ${fieldName} must be ${allowKey ? "either { key }, { locator } or { step }" : "either { locator } or { step }"}`
+  );
+}
+function normalizePlanSteps(actionName, values, deps) {
+  if (!import_lodash.default.isPlainObject(values == null ? void 0 : values.plan) || !Array.isArray(values.plan.steps)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} requires plan.steps[]`);
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  return values.plan.steps.map((rawStep, index) => {
+    if (!import_lodash.default.isPlainObject(rawStep)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] must be an object`);
+    }
+    if (Object.prototype.hasOwnProperty.call(rawStep, "target") || Object.prototype.hasOwnProperty.call(rawStep, "source")) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] must use selectors.target / selectors.source`);
+    }
+    const action = String(rawStep.action || "").trim();
+    if (!action || !(0, import_action_specs.getFlowSurfacePlanActionSpec)(action)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}].action is not supported`);
+    }
+    const selectorsInput = import_lodash.default.isUndefined(rawStep.selectors) ? {} : rawStep.selectors;
+    if (!import_lodash.default.isPlainObject(selectorsInput)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}].selectors must be an object`);
+    }
+    const selectorKeys = Object.keys(selectorsInput || {});
+    if (selectorKeys.some((key) => !["target", "source"].includes(key))) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}].selectors only supports target/source`);
+    }
+    const stepValues = import_lodash.default.isUndefined(rawStep.values) ? {} : rawStep.values;
+    if (!import_lodash.default.isPlainObject(stepValues)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}].values must be an object`);
+    }
+    const forbiddenKeys = ["target", "uid", "sourceUid", "targetUid"].filter(
+      (key) => Object.prototype.hasOwnProperty.call(stepValues, key)
+    );
+    if (forbiddenKeys.length) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} plan.steps[${index}].values must not include ${forbiddenKeys.join(
+          ", "
+        )}; use selectors`
+      );
+    }
+    deps.validatePayloadShape(actionName, stepValues, `plan.steps[${index}].values`);
+    const id = typeof rawStep.id === "string" && rawStep.id.trim() ? rawStep.id.trim() : void 0;
+    if (id) {
+      if (seenIds.has(id)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}].id '${id}' is duplicated`);
+      }
+      seenIds.add(id);
+    }
+    return {
+      id,
+      action,
+      selectors: (0, import_service_utils.buildDefinedPayload)({
+        target: import_lodash.default.isUndefined(selectorsInput.target) ? void 0 : normalizePlanSelector(actionName, selectorsInput.target, deps, `plan.steps[${index}].selectors.target`),
+        source: import_lodash.default.isUndefined(selectorsInput.source) ? void 0 : normalizePlanSelector(actionName, selectorsInput.source, deps, `plan.steps[${index}].selectors.source`)
+      }),
+      values: import_lodash.default.cloneDeep(stepValues)
+    };
+  });
+}
+function buildPlanStepSelectorSummary(stepLink) {
+  return {
+    source: "step",
+    step: stepLink.step,
+    ...stepLink.path ? { path: stepLink.path } : {}
+  };
+}
+async function resolvePlanSelectorInContext(actionName, selector, context, deps, fieldName, priorStepIds, priorCreatedKeys, options = {}) {
+  const normalizedSelector = normalizePlanSelector(actionName, selector, deps, fieldName);
+  if ("step" in normalizedSelector) {
+    if (!priorStepIds.has(normalizedSelector.step)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} ${fieldName}.step '${normalizedSelector.step}' is not a previous step id`
+      );
+    }
+    return {
+      ...normalizedSelector,
+      summary: buildPlanStepSelectorSummary(normalizedSelector)
+    };
+  }
+  if ("key" in normalizedSelector) {
+    const keyInfo = context.keyMap.get(normalizedSelector.key);
+    if (keyInfo) {
+      return keyInfo;
+    }
+    if (priorCreatedKeys.has(normalizedSelector.key)) {
+      return {
+        key: normalizedSelector.key,
+        summary: {
+          source: "created",
+          key: normalizedSelector.key
+        }
+      };
+    }
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName}.key '${normalizedSelector.key}' is not defined`);
+  }
+  const resolved = await deps.resolveLocator(normalizedSelector.locator, options);
+  if (!context.surfaceResolved) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName} locator requires surface`);
+  }
+  if (!context.uidSet.has(resolved.uid)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} ${fieldName} locator must resolve inside the current surface '${context.surfaceResolved.uid}'`
+    );
+  }
+  const node = context.publicNodeMap[resolved.uid] || (resolved.uid === context.surfaceResolved.uid ? context.publicTree : void 0);
+  return {
+    key: "",
+    uid: resolved.uid,
+    source: "system",
+    kind: deps.buildPlanKeyKind(node, resolved.kind),
+    locator: (0, import_service_utils.buildDefinedPayload)({
+      uid: normalizedSelector.locator.uid,
+      pageSchemaUid: normalizedSelector.locator.pageSchemaUid,
+      tabSchemaUid: normalizedSelector.locator.tabSchemaUid,
+      routeId: normalizedSelector.locator.routeId
+    })
+  };
+}
+function buildMutateOp(type, payload, opId) {
+  if (import_lodash.default.isPlainObject(payload.target)) {
+    return {
+      ...opId ? { opId } : {},
+      type,
+      target: payload.target,
+      values: import_lodash.default.omit(payload, ["target"])
+    };
+  }
+  return {
+    ...opId ? { opId } : {},
+    type,
+    values: payload
+  };
+}
+function buildSelectorRuntimeValue(selector) {
+  if ("summary" in selector) {
+    if ("step" in selector) {
+      return {
+        step: selector.step,
+        ...selector.path ? { path: selector.path } : {}
+      };
+    }
+    return {
+      key: selector.key
+    };
+  }
+  return selector.uid;
+}
+async function compilePlanStep(actionName, step, index, context, deps, priorStepIds, priorCreatedKeys, options = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const runtimeValues = step.action === "compose" ? (0, import_created_keys.normalizeComposeInlineKeysForPlan)(step.values || {}, `plan.steps[${index}].values`) : import_lodash.default.cloneDeep(step.values || {});
+  const payload = (0, import_step_link.replaceFlowSurfacePlanStepLinks)(
+    actionName,
+    runtimeValues,
+    `plan.steps[${index}].values`,
+    priorStepIds,
+    /* @__PURE__ */ new Set([...context.keyMap.keys(), ...priorCreatedKeys])
+  );
+  const targetSelectorKey = (0, import_created_keys.isFlowSurfacePureKeyObject)((_a = step.selectors) == null ? void 0 : _a.target) ? String(step.selectors.target.key || "").trim() : void 0;
+  const createdKeys = (0, import_created_keys.collectFlowSurfaceCreatedKeys)(step.action, step.values || {}, {
+    targetSelectorKey
+  });
+  (0, import_created_keys.assertNoDuplicateFlowSurfaceCreatedKeys)(createdKeys, `flowSurfaces ${actionName} plan.steps[${index}]`, {
+    existingKeys: [...context.keyMap.keys(), ...priorCreatedKeys],
+    reservedNames: [...priorStepIds, ...step.id ? [step.id] : []]
+  });
+  const compiled = {
+    index,
+    ...step.id ? { id: step.id } : {},
+    action: step.action,
+    payload,
+    resolvedSelectors: {},
+    usedKeys: [],
+    usedStepLinks: [],
+    createdKeys
+  };
+  const addUsedKey = (selector) => {
+    if ("summary" in selector) {
+      if (isFlowSurfaceResolvedStepLink(selector)) {
+        compiled.usedStepLinks.push(selector);
+      }
+      return selector.summary;
+    }
+    if (selector.source === "request" || selector.source === "declared") {
+      compiled.usedKeys.push(selector);
+    }
+    return {
+      uid: selector.uid,
+      kind: selector.kind,
+      ...selector.key ? { key: selector.key } : {},
+      source: selector.source
+    };
+  };
+  const spec = (0, import_action_specs.getFlowSurfacePlanActionSpec)(step.action);
+  if (!spec) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}].action '${step.action}' is not supported`);
+  }
+  const selectorRequirements = (0, import_action_specs.getFlowSurfacePlanSelectorRequirements)(spec.selectorMode);
+  if (selectorRequirements.requiresTarget && !((_b = step.selectors) == null ? void 0 : _b.target)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.target`);
+  }
+  if (!selectorRequirements.requiresTarget && ((_c = step.selectors) == null ? void 0 : _c.target)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} plan.steps[${index}] action '${step.action}' does not support selectors.target`
+    );
+  }
+  if (selectorRequirements.requiresSource && !((_d = step.selectors) == null ? void 0 : _d.source)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.source`);
+  }
+  if (!selectorRequirements.requiresSource && ((_e = step.selectors) == null ? void 0 : _e.source)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} plan.steps[${index}] action '${step.action}' does not support selectors.source`
+    );
+  }
+  if (spec.selectorMode === "none") {
+    compiled.payload = payload;
+  } else if (spec.selectorMode === "target") {
+    const targetSelector = (_f = step.selectors) == null ? void 0 : _f.target;
+    if (!targetSelector) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.target`);
+    }
+    const target = await resolvePlanSelectorInContext(
+      actionName,
+      targetSelector,
+      context,
+      deps,
+      `plan.steps[${index}].selectors.target`,
+      priorStepIds,
+      priorCreatedKeys,
+      options
+    );
+    compiled.payload = {
+      ...payload,
+      target: {
+        uid: buildSelectorRuntimeValue(target)
+      }
+    };
+    compiled.resolvedSelectors.target = addUsedKey(target);
+  } else if (spec.selectorMode === "rootUidTarget") {
+    const targetSelector = (_g = step.selectors) == null ? void 0 : _g.target;
+    if (!targetSelector) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.target`);
+    }
+    const target = await resolvePlanSelectorInContext(
+      actionName,
+      targetSelector,
+      context,
+      deps,
+      `plan.steps[${index}].selectors.target`,
+      priorStepIds,
+      priorCreatedKeys,
+      options
+    );
+    compiled.payload = {
+      ...payload,
+      uid: buildSelectorRuntimeValue(target)
+    };
+    compiled.resolvedSelectors.target = addUsedKey(target);
+  } else if (spec.selectorMode === "sourceTarget") {
+    const sourceSelector = (_h = step.selectors) == null ? void 0 : _h.source;
+    const targetSelector = (_i = step.selectors) == null ? void 0 : _i.target;
+    if (!sourceSelector || !targetSelector) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}] requires selectors.source and selectors.target`);
+    }
+    const source = await resolvePlanSelectorInContext(
+      actionName,
+      sourceSelector,
+      context,
+      deps,
+      `plan.steps[${index}].selectors.source`,
+      priorStepIds,
+      priorCreatedKeys,
+      options
+    );
+    const target = await resolvePlanSelectorInContext(
+      actionName,
+      targetSelector,
+      context,
+      deps,
+      `plan.steps[${index}].selectors.target`,
+      priorStepIds,
+      priorCreatedKeys,
+      options
+    );
+    compiled.payload = {
+      ...payload,
+      sourceUid: buildSelectorRuntimeValue(source),
+      targetUid: buildSelectorRuntimeValue(target)
+    };
+    compiled.resolvedSelectors.source = addUsedKey(source);
+    compiled.resolvedSelectors.target = addUsedKey(target);
+  } else {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} plan.steps[${index}].action '${step.action}' is not supported`);
+  }
+  if (spec.executionKind === "mutate") {
+    compiled.mutateOp = buildMutateOp(step.action, compiled.payload, step.id);
+  }
+  return compiled;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compilePlanStep,
+  normalizePlanSelector,
+  normalizePlanSteps
+});

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

@@ -0,0 +1,30 @@
+/**
+ * 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, FlowSurfaceReadTarget, FlowSurfaceResolvedTarget, FlowSurfaceSurfaceSelector } from '../types';
+import type { FlowSurfacePlanSurfaceContext, FlowSurfaceResolvedKey } from './types';
+type BuildPlanSurfaceContextDeps = {
+    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;
+    buildPlanKeyKind: (node: any, resolvedKind?: string) => string;
+    assertBindKeyKind: (actionName: string, bindKey: FlowSurfaceBindKey, node: any, resolvedKind?: string) => void;
+    collectDeclaredKeysFromTree: (node: any) => Map<string, FlowSurfaceResolvedKey>;
+};
+export declare function buildPlanSurfaceContext(input: {
+    actionName: string;
+    surfaceSelector?: FlowSurfaceSurfaceSelector;
+    bindKeys: FlowSurfaceBindKey[];
+}, deps: BuildPlanSurfaceContextDeps, options?: {
+    transaction?: any;
+}): Promise<FlowSurfacePlanSurfaceContext>;
+export {};

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

@@ -0,0 +1,139 @@
+/**
+ * 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 context_exports = {};
+__export(context_exports, {
+  buildPlanSurfaceContext: () => buildPlanSurfaceContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_service_utils = require("../service-utils");
+var import_key_registry = require("./key-registry");
+async function buildPlanSurfaceContext(input, deps, options = {}) {
+  const { actionName, surfaceSelector, bindKeys } = input;
+  if (!surfaceSelector) {
+    if (bindKeys.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} bindKeys require surface`);
+    }
+    return {
+      publicNodeMap: {},
+      targetSummary: null,
+      fingerprint: null,
+      uidSet: /* @__PURE__ */ new Set(),
+      keyMap: /* @__PURE__ */ new Map(),
+      requestKeyMap: /* @__PURE__ */ new Map()
+    };
+  }
+  let surfaceTarget;
+  if ("key" in surfaceSelector) {
+    const matchedBindKey = bindKeys.find((item) => item.key === surfaceSelector.key);
+    if (!matchedBindKey) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} surface.key '${surfaceSelector.key}' must also appear in bindKeys`);
+    }
+    surfaceTarget = matchedBindKey.locator;
+  } else {
+    surfaceTarget = surfaceSelector.locator;
+  }
+  const surfaceResolved = await deps.resolveLocator(surfaceTarget, options);
+  const rawTree = await deps.loadResolvedSurfaceTree(surfaceResolved, options.transaction);
+  const publicTree = deps.stripInternalSurfaceMetaFromNodeTree(import_lodash.default.cloneDeep(rawTree));
+  const publicNodeMap = (0, import_service_utils.flattenModel)(publicTree);
+  const uidSet = /* @__PURE__ */ new Set([surfaceResolved.uid, ...Object.keys(publicNodeMap)]);
+  const keyMap = deps.collectDeclaredKeysFromTree(rawTree);
+  const requestKeyMap = /* @__PURE__ */ new Map();
+  for (const bindKey of bindKeys) {
+    const resolved = await deps.resolveLocator(bindKey.locator, options);
+    if (!uidSet.has(resolved.uid)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} bindKeys key '${bindKey.key}' must resolve inside the current surface '${surfaceResolved.uid}'`
+      );
+    }
+    const node = publicNodeMap[resolved.uid] || (resolved.uid === surfaceResolved.uid ? publicTree : void 0);
+    deps.assertBindKeyKind(actionName, bindKey, node, resolved.kind);
+    const existing = requestKeyMap.get(bindKey.key) || keyMap.get(bindKey.key);
+    if (existing && existing.uid !== resolved.uid && !bindKey.rebind) {
+      (0, import_errors.throwConflict)(
+        `flowSurfaces ${actionName} key '${bindKey.key}' is already bound to '${existing.uid}', set rebind=true to move it`,
+        "FLOW_SURFACE_DECLARED_KEY_CONFLICT"
+      );
+    }
+    requestKeyMap.set(bindKey.key, {
+      key: bindKey.key,
+      uid: resolved.uid,
+      source: "request",
+      kind: deps.buildPlanKeyKind(node, resolved.kind),
+      locator: {
+        uid: resolved.uid
+      },
+      rebind: bindKey.rebind === true,
+      reboundFromUid: existing && existing.uid !== resolved.uid ? existing.uid : void 0
+    });
+  }
+  requestKeyMap.forEach((value, key) => keyMap.set(key, value));
+  keyMap.set(import_key_registry.FLOW_SURFACE_SYSTEM_KEY, {
+    key: import_key_registry.FLOW_SURFACE_SYSTEM_KEY,
+    uid: surfaceResolved.uid,
+    source: "system",
+    kind: deps.buildPlanKeyKind(publicTree, surfaceResolved.kind),
+    locator: {
+      uid: surfaceResolved.uid
+    }
+  });
+  const targetSummary = deps.buildReadTargetSummary(surfaceTarget, surfaceResolved);
+  const fingerprint = deps.buildSurfaceContextFingerprint({
+    surfaceResolved,
+    publicTree,
+    keyMap
+  });
+  return {
+    surfaceSelector,
+    surfaceTarget,
+    surfaceResolved,
+    rawTree,
+    publicTree,
+    publicNodeMap,
+    targetSummary,
+    fingerprint,
+    uidSet,
+    keyMap,
+    requestKeyMap
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPlanSurfaceContext
+});

package/dist/server/flow-surfaces/planning/created-keys.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 FlowSurfaceCreatedKeySpec = {
+    key: string;
+    resultPath: string;
+};
+type CollectFlowSurfaceCreatedKeysOptions = {
+    targetSelectorKey?: string;
+};
+export declare function normalizeFlowSurfaceCreatedKey(key: any, context: string): string;
+export declare function collectFlowSurfaceCreatedKeys(action: string, values: any, options?: CollectFlowSurfaceCreatedKeysOptions): FlowSurfaceCreatedKeySpec[];
+export declare function assertNoDuplicateFlowSurfaceCreatedKeys(specs: FlowSurfaceCreatedKeySpec[], context: string, options?: {
+    existingKeys?: Iterable<string>;
+    reservedNames?: Iterable<string>;
+}): void;
+export declare function registerFlowSurfaceCreatedKeys(result: any, specs: FlowSurfaceCreatedKeySpec[], keys: Map<string, any>): {
+    key: string;
+    uid: string;
+}[];
+export declare function collectPersistableFlowSurfaceCreatedKeys(result: any, specs: FlowSurfaceCreatedKeySpec[]): {
+    key: string;
+    uid: string;
+}[];
+export declare function isFlowSurfacePureKeyObject(input: any): input is {
+    key: string;
+};
+export declare function normalizeComposeInlineKeysForPlan(values: any, contextPath: string): any;
+export {};