@nocobase/plugin-flow-engine 2.1.0-beta.14 → 2.1.0-beta.16

package/dist/server/flow-surfaces/planning/created-keys.js

@@ -0,0 +1,375 @@
+/**
+ * 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 created_keys_exports = {};
+__export(created_keys_exports, {
+  assertNoDuplicateFlowSurfaceCreatedKeys: () => assertNoDuplicateFlowSurfaceCreatedKeys,
+  collectFlowSurfaceCreatedKeys: () => collectFlowSurfaceCreatedKeys,
+  collectPersistableFlowSurfaceCreatedKeys: () => collectPersistableFlowSurfaceCreatedKeys,
+  isFlowSurfacePureKeyObject: () => isFlowSurfacePureKeyObject,
+  normalizeComposeInlineKeysForPlan: () => normalizeComposeInlineKeysForPlan,
+  normalizeFlowSurfaceCreatedKey: () => normalizeFlowSurfaceCreatedKey,
+  registerFlowSurfaceCreatedKeys: () => registerFlowSurfaceCreatedKeys
+});
+module.exports = __toCommonJS(created_keys_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_key_registry = require("./key-registry");
+function normalizeFlowSurfaceCreatedKey(key, context) {
+  const normalized = typeof key === "string" ? key.trim() : String(key || "").trim();
+  if (!normalized) {
+    (0, import_errors.throwBadRequest)(`${context} key cannot be empty`);
+  }
+  if (import_key_registry.FLOW_SURFACE_RESERVED_KEYS.has(normalized)) {
+    (0, import_errors.throwBadRequest)(`${context} key '${normalized}' is reserved`);
+  }
+  return normalized;
+}
+function collectFlowSurfaceCreatedKeys(action, values, options = {}) {
+  if (!import_lodash.default.isPlainObject(values)) {
+    return [];
+  }
+  switch (action) {
+    case "createPage":
+      return collectBaseKey(values.key, `flowSurfaces ${action}`, [
+        ["", "pageUid"],
+        ["tab", "tabSchemaUid"],
+        ["grid", "gridUid"]
+      ]);
+    case "addTab":
+      return collectBaseKey(values.key, `flowSurfaces ${action}`, [
+        ["", "tabSchemaUid"],
+        ["grid", "gridUid"]
+      ]);
+    case "addPopupTab":
+      return collectBaseKey(values.key, `flowSurfaces ${action}`, [
+        ["", "popupTabUid"],
+        ["grid", "popupGridUid"]
+      ]);
+    case "addBlock":
+      return collectBaseKey(values.key, `flowSurfaces ${action}`, [
+        ["", "uid"],
+        ["grid", "blockGridUid"],
+        ["item", "itemUid"],
+        ["itemGrid", "itemGridUid"],
+        ["actionsColumn", "actionsColumnUid"]
+      ]);
+    case "addField":
+      return [
+        ...collectBaseKey(values.key, `flowSurfaces ${action}`, [
+          ["", "uid"],
+          ["field", "fieldUid"],
+          ["innerField", "innerFieldUid"]
+        ]),
+        ...shouldCollectAddFieldPopupKeys(values) ? collectDerivedKey(values.key, `flowSurfaces ${action}`, [
+          ["popupPage", "popupPageUid"],
+          ["popupTab", "popupTabUid"],
+          ["popupGrid", "popupGridUid"]
+        ]) : []
+      ];
+    case "addAction":
+    case "addRecordAction":
+      return collectBaseKey(values.key, `flowSurfaces ${action}`, [
+        ["", "uid"],
+        ["assignForm", "assignFormUid"],
+        ["assignFormGrid", "assignFormGridUid"],
+        ["popupPage", "popupPageUid"],
+        ["popupTab", "popupTabUid"],
+        ["popupGrid", "popupGridUid"]
+      ]);
+    case "configure":
+      return collectConfigureCreatedKeys(values, options);
+    case "compose":
+      return collectComposeCreatedKeys(values);
+    default:
+      return [];
+  }
+}
+function collectBaseKey(keyValue, context, defs) {
+  if (import_lodash.default.isUndefined(keyValue)) {
+    return [];
+  }
+  const baseKey = normalizeFlowSurfaceCreatedKey(keyValue, context);
+  return defs.map(([suffix, resultPath]) => ({
+    key: suffix ? `${baseKey}.${suffix}` : baseKey,
+    resultPath
+  }));
+}
+function collectDerivedKey(keyValue, context, defs) {
+  if (import_lodash.default.isUndefined(keyValue)) {
+    return [];
+  }
+  const baseKey = normalizeFlowSurfaceCreatedKey(keyValue, context);
+  return defs.map(([suffix, resultPath]) => ({
+    key: `${baseKey}.${suffix}`,
+    resultPath
+  }));
+}
+function shouldCollectAddFieldPopupKeys(values) {
+  return !import_lodash.default.isUndefined(values == null ? void 0 : values.popup);
+}
+function inferConfigureCreatedKeyBase(targetSelectorKey) {
+  if (import_lodash.default.isUndefined(targetSelectorKey)) {
+    return void 0;
+  }
+  const normalizedKey = normalizeFlowSurfaceCreatedKey(targetSelectorKey, "flowSurfaces configure target key");
+  if (normalizedKey.endsWith(".innerField")) {
+    return normalizedKey.slice(0, -".innerField".length);
+  }
+  if (normalizedKey.endsWith(".field")) {
+    return normalizedKey.slice(0, -".field".length);
+  }
+  return void 0;
+}
+function collectConfigureCreatedKeys(values, options = {}) {
+  var _a;
+  if (!import_lodash.default.isPlainObject((_a = values == null ? void 0 : values.changes) == null ? void 0 : _a.openView)) {
+    return [];
+  }
+  const keyBase = !import_lodash.default.isUndefined(values.key) ? values.key : inferConfigureCreatedKeyBase(options.targetSelectorKey);
+  if (import_lodash.default.isUndefined(keyBase)) {
+    return [];
+  }
+  return collectDerivedKey(keyBase, "flowSurfaces configure", [
+    ["popupPage", "popupPageUid"],
+    ["popupTab", "popupTabUid"],
+    ["popupGrid", "popupGridUid"]
+  ]);
+}
+function collectComposeCreatedKeys(values) {
+  const blocks = import_lodash.default.castArray((values == null ? void 0 : values.blocks) || []);
+  const specs = [];
+  blocks.forEach((block, blockIndex) => {
+    const blockContext = `flowSurfaces compose block #${blockIndex + 1}`;
+    if (import_lodash.default.isPlainObject(block) && !import_lodash.default.isUndefined(block.key)) {
+      specs.push(
+        ...collectBaseKey(block.key, blockContext, [
+          ["", `blocks.${blockIndex}.uid`],
+          ["grid", `blocks.${blockIndex}.gridUid`],
+          ["item", `blocks.${blockIndex}.itemUid`],
+          ["itemGrid", `blocks.${blockIndex}.itemGridUid`],
+          ["actionsColumn", `blocks.${blockIndex}.actionsColumnUid`]
+        ])
+      );
+    }
+    import_lodash.default.castArray((block == null ? void 0 : block.fields) || []).forEach((field, fieldIndex) => {
+      const fieldKey = resolveComposeFieldKey(field, `${blockContext} field #${fieldIndex + 1}`);
+      if (!fieldKey) {
+        return;
+      }
+      specs.push(
+        ...collectBaseKey(fieldKey, `${blockContext} field #${fieldIndex + 1}`, [
+          ["", `blocks.${blockIndex}.fields.${fieldIndex}.uid`],
+          ["field", `blocks.${blockIndex}.fields.${fieldIndex}.fieldUid`],
+          ["innerField", `blocks.${blockIndex}.fields.${fieldIndex}.innerFieldUid`],
+          ["popupPage", `blocks.${blockIndex}.fields.${fieldIndex}.popupPageUid`],
+          ["popupTab", `blocks.${blockIndex}.fields.${fieldIndex}.popupTabUid`],
+          ["popupGrid", `blocks.${blockIndex}.fields.${fieldIndex}.popupGridUid`]
+        ])
+      );
+    });
+    import_lodash.default.castArray((block == null ? void 0 : block.actions) || []).forEach((action, actionIndex) => {
+      const actionKey = resolveComposeActionKey(action, `${blockContext} action #${actionIndex + 1}`);
+      if (!actionKey) {
+        return;
+      }
+      specs.push(
+        ...collectBaseKey(actionKey, `${blockContext} action #${actionIndex + 1}`, [
+          ["", `blocks.${blockIndex}.actions.${actionIndex}.uid`],
+          ["assignForm", `blocks.${blockIndex}.actions.${actionIndex}.assignFormUid`],
+          ["assignFormGrid", `blocks.${blockIndex}.actions.${actionIndex}.assignFormGridUid`],
+          ["popupPage", `blocks.${blockIndex}.actions.${actionIndex}.popupPageUid`],
+          ["popupTab", `blocks.${blockIndex}.actions.${actionIndex}.popupTabUid`],
+          ["popupGrid", `blocks.${blockIndex}.actions.${actionIndex}.popupGridUid`]
+        ])
+      );
+    });
+    import_lodash.default.castArray((block == null ? void 0 : block.recordActions) || []).forEach((action, actionIndex) => {
+      const actionKey = resolveComposeActionKey(action, `${blockContext} recordAction #${actionIndex + 1}`);
+      if (!actionKey) {
+        return;
+      }
+      specs.push(
+        ...collectBaseKey(actionKey, `${blockContext} recordAction #${actionIndex + 1}`, [
+          ["", `blocks.${blockIndex}.recordActions.${actionIndex}.uid`],
+          ["assignForm", `blocks.${blockIndex}.recordActions.${actionIndex}.assignFormUid`],
+          ["assignFormGrid", `blocks.${blockIndex}.recordActions.${actionIndex}.assignFormGridUid`],
+          ["popupPage", `blocks.${blockIndex}.recordActions.${actionIndex}.popupPageUid`],
+          ["popupTab", `blocks.${blockIndex}.recordActions.${actionIndex}.popupTabUid`],
+          ["popupGrid", `blocks.${blockIndex}.recordActions.${actionIndex}.popupGridUid`]
+        ])
+      );
+    });
+  });
+  return specs;
+}
+function resolveComposeFieldKey(field, context) {
+  if (typeof field === "string") {
+    return normalizeFlowSurfaceCreatedKey(field, context);
+  }
+  if (!import_lodash.default.isPlainObject(field)) {
+    return void 0;
+  }
+  const semanticType = String(field.type || "").trim();
+  const fieldPath = String(field.fieldPath || "").trim();
+  const renderer = typeof field.renderer === "undefined" ? void 0 : String(field.renderer || "").trim();
+  const rawKey = String(field.key || semanticType || (renderer === "js" ? `js:${fieldPath}` : fieldPath)).trim();
+  return rawKey ? normalizeFlowSurfaceCreatedKey(rawKey, context) : void 0;
+}
+function resolveComposeActionKey(action, context) {
+  if (typeof action === "string") {
+    return normalizeFlowSurfaceCreatedKey(action, context);
+  }
+  if (!import_lodash.default.isPlainObject(action)) {
+    return void 0;
+  }
+  const rawKey = String(action.key || action.type || "").trim();
+  return rawKey ? normalizeFlowSurfaceCreatedKey(rawKey, context) : void 0;
+}
+function assertNoDuplicateFlowSurfaceCreatedKeys(specs, context, options = {}) {
+  const seen = /* @__PURE__ */ new Map();
+  const existing = new Set(options.existingKeys || []);
+  const reservedNames = new Set(options.reservedNames || []);
+  specs.forEach((spec, index) => {
+    if (reservedNames.has(spec.key)) {
+      (0, import_errors.throwBadRequest)(`${context} key '${spec.key}' conflicts with an existing step id`);
+    }
+    if (existing.has(spec.key)) {
+      (0, import_errors.throwBadRequest)(`${context} key '${spec.key}' is already defined`);
+    }
+    const previousIndex = seen.get(spec.key);
+    if (typeof previousIndex === "number") {
+      (0, import_errors.throwBadRequest)(`${context} key '${spec.key}' is duplicated at #${previousIndex + 1} and #${index + 1}`);
+    }
+    seen.set(spec.key, index);
+  });
+}
+function registerFlowSurfaceCreatedKeys(result, specs, keys) {
+  const registered = resolveFlowSurfaceCreatedKeyResults(result, specs);
+  registered.forEach((item) => keys.set(item.key, item.uid));
+  return registered;
+}
+function collectPersistableFlowSurfaceCreatedKeys(result, specs) {
+  const persistedUidSet = /* @__PURE__ */ new Set();
+  const persisted = [];
+  for (const item of resolveFlowSurfaceCreatedKeyResults(result, specs)) {
+    if (persistedUidSet.has(item.uid)) {
+      continue;
+    }
+    persistedUidSet.add(item.uid);
+    persisted.push(item);
+  }
+  return persisted;
+}
+function resolveFlowSurfaceCreatedKeyResults(result, specs) {
+  const registered = [];
+  for (const spec of specs) {
+    const value = import_lodash.default.get(result, spec.resultPath);
+    if (typeof value !== "string" || !value.trim()) {
+      continue;
+    }
+    registered.push({
+      key: spec.key,
+      uid: value.trim()
+    });
+  }
+  return registered;
+}
+function isFlowSurfacePureKeyObject(input) {
+  return import_lodash.default.isPlainObject(input) && Object.keys(input).length === 1 && typeof input.key === "string" && !!input.key.trim();
+}
+function normalizeComposeInlineKeysForPlan(values, contextPath) {
+  var _a;
+  if (!import_lodash.default.isPlainObject(values)) {
+    return values;
+  }
+  const cloned = import_lodash.default.cloneDeep(values);
+  const blockKeys = new Set(
+    import_lodash.default.castArray(cloned.blocks || []).map((block, index) => {
+      if (!import_lodash.default.isPlainObject(block) || import_lodash.default.isUndefined(block.key)) {
+        return "";
+      }
+      return normalizeFlowSurfaceCreatedKey(block.key, `${contextPath}.blocks[${index}]`);
+    }).filter(Boolean)
+  );
+  import_lodash.default.castArray(cloned.blocks || []).forEach((block, blockIndex) => {
+    import_lodash.default.castArray((block == null ? void 0 : block.fields) || []).forEach((field, fieldIndex) => {
+      if (typeof (field == null ? void 0 : field.target) !== "string" || !field.target.trim()) {
+        return;
+      }
+      const targetKey = normalizeFlowSurfaceCreatedKey(
+        field.target,
+        `${contextPath}.blocks[${blockIndex}].fields[${fieldIndex}].target`
+      );
+      if (!blockKeys.has(targetKey)) {
+        return;
+      }
+      field.target = targetKey;
+    });
+  });
+  import_lodash.default.castArray(((_a = cloned.layout) == null ? void 0 : _a.rows) || []).forEach((row, rowIndex) => {
+    if (!Array.isArray(row)) {
+      return;
+    }
+    row.forEach((cell, cellIndex) => {
+      if (typeof cell === "string") {
+        return;
+      }
+      if (!import_lodash.default.isPlainObject(cell) || typeof cell.key !== "string" || !cell.key.trim()) {
+        return;
+      }
+      const key = normalizeFlowSurfaceCreatedKey(cell.key, `${contextPath}.layout.rows[${rowIndex}][${cellIndex}]`);
+      if (!blockKeys.has(key)) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces compose local layout key '${key}' must match a block key in the same compose step`
+        );
+      }
+      delete cell.key;
+      cell.composeKey = key;
+    });
+  });
+  return cloned;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertNoDuplicateFlowSurfaceCreatedKeys,
+  collectFlowSurfaceCreatedKeys,
+  collectPersistableFlowSurfaceCreatedKeys,
+  isFlowSurfacePureKeyObject,
+  normalizeComposeInlineKeysForPlan,
+  normalizeFlowSurfaceCreatedKey,
+  registerFlowSurfaceCreatedKeys
+});

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

@@ -0,0 +1,11 @@
+/**
+ * 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 } from '../types';
+export declare function buildPlanKeyKind(node: any, resolvedKind?: string): string;
+export declare function assertBindKeyKind(actionName: string, bindKey: FlowSurfaceBindKey, node: any, resolvedKind?: string): void;

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

@@ -0,0 +1,88 @@
+/**
+ * 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 key_kind_exports = {};
+__export(key_kind_exports, {
+  assertBindKeyKind: () => assertBindKeyKind,
+  buildPlanKeyKind: () => buildPlanKeyKind
+});
+module.exports = __toCommonJS(key_kind_exports);
+var import_node_use_sets = require("../node-use-sets");
+var import_approval = require("../approval");
+var import_errors = require("../errors");
+var import_placement = require("../placement");
+var import_service_utils = require("../service-utils");
+function buildPlanKeyKind(node, resolvedKind) {
+  const use = String((node == null ? void 0 : node.use) || "").trim();
+  const semanticUse = (0, import_approval.normalizeApprovalSemanticUse)(use);
+  if (semanticUse === "RootPageModel" || resolvedKind === "page") {
+    return "page";
+  }
+  if (semanticUse === "RootPageTabModel" || resolvedKind === "tab") {
+    return "tab";
+  }
+  if (semanticUse === "ChildPageModel") {
+    return "popupPage";
+  }
+  if (semanticUse === "ChildPageTabModel") {
+    return "popupTab";
+  }
+  if (semanticUse === "BlockGridModel" || resolvedKind === "grid") {
+    return "grid";
+  }
+  if ((0, import_placement.isPopupHostUse)(use)) {
+    return "popupHost";
+  }
+  if (import_node_use_sets.ACTION_BUTTON_USES.has(use)) {
+    return "action";
+  }
+  if (import_node_use_sets.FIELD_WRAPPER_USES.has(use) || import_node_use_sets.STANDALONE_FIELD_NODE_USES.has(use) || (0, import_service_utils.isFieldNodeUse)(use)) {
+    return "fieldHost";
+  }
+  if (import_node_use_sets.COLLECTION_BLOCK_USES.has(use) || import_node_use_sets.STATIC_CONTENT_BLOCK_USES.has(use) || import_node_use_sets.JS_BLOCK_USES.has(use) || use.endsWith("BlockModel")) {
+    return "block";
+  }
+  return resolvedKind || "node";
+}
+function assertBindKeyKind(actionName, bindKey, node, resolvedKind) {
+  if (!bindKey.expectedKind) {
+    return;
+  }
+  const actualKind = buildPlanKeyKind(node, resolvedKind);
+  const expectedKind = String(bindKey.expectedKind || "").trim();
+  const matched = expectedKind === "node" || expectedKind === actualKind || expectedKind === "block" && actualKind === "block" || expectedKind === "fieldHost" && actualKind === "fieldHost" || expectedKind === "popupHost" && actualKind === "popupHost" || expectedKind === "popupTab" && actualKind === "popupTab" || expectedKind === "action" && actualKind === "action";
+  if (matched) {
+    return;
+  }
+  (0, import_errors.throwBadRequest)(
+    `flowSurfaces ${actionName} bindKeys key '${bindKey.key}' expected kind '${expectedKind}', got '${actualKind}'`
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertBindKeyKind,
+  buildPlanKeyKind
+});

package/dist/server/flow-surfaces/planning/key-persistence.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.
+ */
+import type { FlowSurfaceResolvedKey } from './types';
+type FlowSurfaceDeclaredKeyPersistenceDeps = {
+    findModelById: (uid: string, options?: {
+        transaction?: any;
+        includeAsyncNode?: boolean;
+    }) => Promise<any>;
+    patchModel: (values: Record<string, any>, options?: {
+        transaction?: any;
+    }) => Promise<any>;
+    getDeclaredKeyFromNode: (node: any) => string | undefined;
+};
+export declare function assertKeyPersistable(actionName: string, keyInfo: FlowSurfaceResolvedKey, node: any): void;
+export declare function assertRequestKeysPersistable(actionName: string, keys: Map<string, FlowSurfaceResolvedKey>, deps: FlowSurfaceDeclaredKeyPersistenceDeps, transaction?: any): Promise<void>;
+export declare function clearDeclaredKeyForNode(uid: string, deps: FlowSurfaceDeclaredKeyPersistenceDeps, transaction?: any): Promise<void>;
+export declare function persistDeclaredKeyForNode(keyInfo: FlowSurfaceResolvedKey, deps: FlowSurfaceDeclaredKeyPersistenceDeps, transaction?: any): Promise<{
+    key: string;
+    uid: string;
+    persisted: boolean;
+    skipped: string;
+} | {
+    key: string;
+    uid: string;
+    persisted: boolean;
+    skipped?: undefined;
+}>;
+export {};

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

@@ -0,0 +1,148 @@
+/**
+ * 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_persistence_exports = {};
+__export(key_persistence_exports, {
+  assertKeyPersistable: () => assertKeyPersistable,
+  assertRequestKeysPersistable: () => assertRequestKeysPersistable,
+  clearDeclaredKeyForNode: () => clearDeclaredKeyForNode,
+  persistDeclaredKeyForNode: () => persistDeclaredKeyForNode
+});
+module.exports = __toCommonJS(key_persistence_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_key_registry = require("./key-registry");
+function getPersistableDeclaredKey(deps, node) {
+  const declaredKey = deps.getDeclaredKeyFromNode(node);
+  if (!declaredKey || import_key_registry.FLOW_SURFACE_RESERVED_KEYS.has(declaredKey)) {
+    return void 0;
+  }
+  return declaredKey;
+}
+function assertKeyPersistable(actionName, keyInfo, node) {
+  if (import_key_registry.FLOW_SURFACE_RESERVED_KEYS.has(keyInfo.key)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} key '${keyInfo.key}' is reserved and cannot be persisted`,
+      import_key_registry.FLOW_SURFACE_KEY_NOT_PERSISTABLE_CODE
+    );
+  }
+}
+async function assertRequestKeysPersistable(actionName, keys, deps, transaction) {
+  for (const keyInfo of keys.values()) {
+    const node = await deps.findModelById(keyInfo.uid, {
+      transaction,
+      includeAsyncNode: true
+    });
+    if (!(node == null ? void 0 : node.uid)) {
+      continue;
+    }
+    assertKeyPersistable(actionName, keyInfo, node);
+  }
+}
+async function clearDeclaredKeyForNode(uid, deps, transaction) {
+  const node = await deps.findModelById(uid, {
+    transaction,
+    includeAsyncNode: true
+  });
+  if (!(node == null ? void 0 : node.uid) || !import_lodash.default.isPlainObject(node.stepParams)) {
+    return;
+  }
+  const nextStepParams = import_lodash.default.cloneDeep(node.stepParams || {});
+  import_lodash.default.unset(nextStepParams, [import_key_registry.FLOW_SURFACE_INTERNAL_META_KEY, import_key_registry.FLOW_SURFACE_DECLARED_KEY_KEY]);
+  if (import_lodash.default.isEmpty(import_lodash.default.get(nextStepParams, [import_key_registry.FLOW_SURFACE_INTERNAL_META_KEY]))) {
+    import_lodash.default.unset(nextStepParams, [import_key_registry.FLOW_SURFACE_INTERNAL_META_KEY]);
+  }
+  await deps.patchModel(
+    {
+      uid: node.uid,
+      ...Object.keys(nextStepParams).length ? { stepParams: nextStepParams } : { stepParams: {} }
+    },
+    { transaction }
+  );
+}
+async function persistDeclaredKeyForNode(keyInfo, deps, transaction) {
+  const node = await deps.findModelById(keyInfo.uid, {
+    transaction,
+    includeAsyncNode: true
+  });
+  if (!(node == null ? void 0 : node.uid)) {
+    return {
+      key: keyInfo.key,
+      uid: keyInfo.uid,
+      persisted: false,
+      skipped: "not_found"
+    };
+  }
+  assertKeyPersistable("key persistence", keyInfo, node);
+  if (keyInfo.reboundFromUid && keyInfo.reboundFromUid !== keyInfo.uid) {
+    await clearDeclaredKeyForNode(keyInfo.reboundFromUid, deps, transaction);
+  }
+  const currentDeclaredKey = getPersistableDeclaredKey(deps, node);
+  if (currentDeclaredKey && currentDeclaredKey !== keyInfo.key && !keyInfo.rebind) {
+    (0, import_errors.throwConflict)(
+      `flowSurfaces node '${node.uid}' already has declared key '${currentDeclaredKey}'`,
+      "FLOW_SURFACE_DECLARED_KEY_CONFLICT"
+    );
+  }
+  if (currentDeclaredKey === keyInfo.key) {
+    return {
+      key: keyInfo.key,
+      uid: keyInfo.uid,
+      persisted: true
+    };
+  }
+  const nextStepParams = import_lodash.default.cloneDeep(node.stepParams || {});
+  import_lodash.default.set(nextStepParams, [import_key_registry.FLOW_SURFACE_INTERNAL_META_KEY, import_key_registry.FLOW_SURFACE_DECLARED_KEY_KEY], keyInfo.key);
+  await deps.patchModel(
+    {
+      uid: node.uid,
+      stepParams: nextStepParams
+    },
+    { transaction }
+  );
+  return {
+    key: keyInfo.key,
+    uid: keyInfo.uid,
+    persisted: true
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertKeyPersistable,
+  assertRequestKeysPersistable,
+  clearDeclaredKeyForNode,
+  persistDeclaredKeyForNode
+});