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

package/dist/server/flow-surfaces/field-binding-registry.js

@@ -0,0 +1,391 @@
+/**
+ * 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 field_binding_registry_exports = {};
+__export(field_binding_registry_exports, {
+  getRegisteredFieldUses: () => getRegisteredFieldUses,
+  resolveRegisteredFieldBinding: () => resolveRegisteredFieldBinding
+});
+module.exports = __toCommonJS(field_binding_registry_exports);
+var import_field_semantics = require("./field-semantics");
+var import_service_helpers = require("./service-helpers");
+const FILE_MANAGER_PLUGIN = "@nocobase/plugin-file-manager";
+const ATTACHMENT_URL_PLUGIN = "@nocobase/plugin-field-attachment-url";
+const CODE_PLUGIN = "@nocobase/plugin-field-code";
+const FORMULA_PLUGIN = "@nocobase/plugin-field-formula";
+const CHINA_REGION_PLUGIN = "@nocobase/plugin-field-china-region";
+const MAP_PLUGIN = "@nocobase/plugin-map";
+const MARKDOWN_VDITOR_PLUGIN = "@nocobase/plugin-field-markdown-vditor";
+const SORT_PLUGIN = "@nocobase/plugin-field-sort";
+function getCollectionTemplate(collection) {
+  var _a;
+  return (collection == null ? void 0 : collection.template) || ((_a = collection == null ? void 0 : collection.options) == null ? void 0 : _a.template);
+}
+function isAttachmentInterface(field) {
+  return String((0, import_service_helpers.getFieldInterface)(field) || "").trim() === "attachment";
+}
+function getFieldDataType(field) {
+  var _a;
+  return (field == null ? void 0 : field.dataType) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.dataType);
+}
+function isNumericFormulaDataType(dataType) {
+  return ["integer", "bigInt", "double", "decimal", "number"].includes(String(dataType || "").trim());
+}
+function resolveTargetCollection(input) {
+  var _a;
+  if ((_a = input.field) == null ? void 0 : _a.targetCollection) {
+    return input.field.targetCollection;
+  }
+  if (!input.getCollection || !input.dataSourceKey) {
+    return null;
+  }
+  return (0, import_service_helpers.resolveFieldTargetCollection)(input.field, input.dataSourceKey, input.getCollection);
+}
+function normalizeBindingContainerUse(containerUse) {
+  const normalized = String(containerUse || "").trim();
+  if (normalized === "FormAssociationItemModel") {
+    return "DetailsItemModel";
+  }
+  return normalized;
+}
+function resolveBindingScope(containerUse) {
+  switch ((0, import_field_semantics.normalizeFieldContainerKind)(normalizeBindingContainerUse(containerUse))) {
+    case "table":
+    case "details":
+      return "display";
+    case "form":
+      return "editable";
+    case "filter-form":
+      return "filter";
+    default:
+      return null;
+  }
+}
+function isRuleAvailable(rule, enabledPackages) {
+  if (!rule.ownerPlugin || !enabledPackages) {
+    return true;
+  }
+  return enabledPackages.has(rule.ownerPlugin);
+}
+function selectPreferredDefaultRule(rules) {
+  if (!rules.length) {
+    return null;
+  }
+  return rules.find((rule) => typeof rule.when === "function") || rules[0];
+}
+const FIELD_BINDING_RULE_DEFINITIONS = [
+  {
+    scope: "display",
+    modelClassName: "DisplayPreviewFieldModel",
+    interfaces: ["url", "attachment", "attachmentURL", "m2m", "m2o", "o2o", "o2m", "oho", "obo", "mbm"],
+    ownerPlugin: FILE_MANAGER_PLUGIN,
+    isDefault: true,
+    when: ({ field, targetCollection }) => isAttachmentInterface(field) || !targetCollection || getCollectionTemplate(targetCollection) === "file"
+  },
+  {
+    scope: "editable",
+    modelClassName: "UploadFieldModel",
+    interfaces: ["attachment", "m2m", "m2o", "o2o", "o2m", "oho", "obo", "updatedBy", "createdBy", "mbm"],
+    ownerPlugin: FILE_MANAGER_PLUGIN,
+    isDefault: true,
+    order: 30,
+    when: ({ field, targetCollection }) => isAttachmentInterface(field) || !targetCollection || getCollectionTemplate(targetCollection) === "file"
+  },
+  {
+    scope: "editable",
+    modelClassName: "AttachmentURLFieldModel",
+    interfaces: ["attachmentURL"],
+    ownerPlugin: ATTACHMENT_URL_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayTextFieldModel",
+    interfaces: ["attachmentURL"],
+    ownerPlugin: ATTACHMENT_URL_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "CodeFieldModel",
+    interfaces: ["code"],
+    ownerPlugin: CODE_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayCodeFieldModel",
+    interfaces: ["code"],
+    ownerPlugin: CODE_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "filter",
+    modelClassName: "InputFieldModel",
+    interfaces: ["code"],
+    ownerPlugin: CODE_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "VditorFieldModel",
+    interfaces: ["vditor", "markdown"],
+    ownerPlugin: MARKDOWN_VDITOR_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayVditorFieldModel",
+    interfaces: ["vditor", "markdown"],
+    ownerPlugin: MARKDOWN_VDITOR_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "ChinaRegionFieldModel",
+    interfaces: ["chinaRegion"],
+    ownerPlugin: CHINA_REGION_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayChinaRegionFieldModel",
+    interfaces: ["chinaRegion"],
+    ownerPlugin: CHINA_REGION_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "SortFieldModel",
+    interfaces: ["sort"],
+    ownerPlugin: SORT_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayNumberFieldModel",
+    interfaces: ["sort"],
+    ownerPlugin: SORT_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "PointFieldModel",
+    interfaces: ["point"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "CircleFieldModel",
+    interfaces: ["circle"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "PolygonFieldModel",
+    interfaces: ["polygon"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "LineStringFieldModel",
+    interfaces: ["lineString"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayPointFieldModel",
+    interfaces: ["point"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayCircleFieldModel",
+    interfaces: ["circle"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayPolygonFieldModel",
+    interfaces: ["polygon"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayLineStringFieldModel",
+    interfaces: ["lineString"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "FormulaFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayCheckboxFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true,
+    when: ({ field }) => getFieldDataType(field) === "boolean"
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayDateTimeFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true,
+    when: ({ field }) => getFieldDataType(field) === "date"
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayTextFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true,
+    when: ({ field }) => getFieldDataType(field) === "string"
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayNumberFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true,
+    when: ({ field }) => ["double", "bigInt", "integer"].includes(String(getFieldDataType(field) || "").trim())
+  },
+  {
+    scope: "filter",
+    modelClassName: "InputFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    when: ({ field }) => {
+      const dataType = String(getFieldDataType(field) || "").trim();
+      return !["date", "boolean", "integer", "bigInt", "double", "decimal", "number"].includes(dataType);
+    }
+  },
+  {
+    scope: "filter",
+    modelClassName: "DateTimeFilterFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    when: ({ field }) => getFieldDataType(field) === "date"
+  },
+  {
+    scope: "filter",
+    modelClassName: "CheckboxFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    when: ({ field }) => getFieldDataType(field) === "boolean"
+  },
+  {
+    scope: "filter",
+    modelClassName: "NumberFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    when: ({ field }) => isNumericFormulaDataType(getFieldDataType(field))
+  }
+];
+const FIELD_BINDING_RULES = FIELD_BINDING_RULE_DEFINITIONS.map((rule, index) => ({
+  ...rule,
+  index
+}));
+function getRegisteredFieldUses(scope, enabledPackages) {
+  const uses = /* @__PURE__ */ new Set();
+  FIELD_BINDING_RULES.forEach((rule) => {
+    if (scope && rule.scope !== scope) {
+      return;
+    }
+    if (!isRuleAvailable(rule, enabledPackages)) {
+      return;
+    }
+    uses.add(rule.modelClassName);
+  });
+  return uses;
+}
+function resolveRegisteredFieldBinding(input) {
+  const scope = resolveBindingScope(input.containerUse);
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(input.field) || "").trim();
+  if (!scope || !fieldInterface) {
+    return null;
+  }
+  const targetCollection = resolveTargetCollection(input);
+  const candidates = FIELD_BINDING_RULES.filter((rule) => {
+    if (rule.scope !== scope) {
+      return false;
+    }
+    if (!rule.interfaces.includes(fieldInterface)) {
+      return false;
+    }
+    if (!isRuleAvailable(rule, input.enabledPackages)) {
+      return false;
+    }
+    if (!rule.when) {
+      return true;
+    }
+    return rule.when({
+      ...input,
+      targetCollection
+    });
+  }).sort((a, b) => {
+    const orderDelta = Number(a.order || 0) - Number(b.order || 0);
+    return orderDelta || a.index - b.index;
+  });
+  const defaultRule = selectPreferredDefaultRule(candidates.filter((rule) => rule.isDefault));
+  if (defaultRule) {
+    return {
+      modelClassName: defaultRule.modelClassName,
+      ownerPlugin: defaultRule.ownerPlugin,
+      isDefault: true
+    };
+  }
+  if (input.useStrictOnly) {
+    return null;
+  }
+  const fallbackRule = candidates[0];
+  if (!fallbackRule) {
+    return null;
+  }
+  return {
+    modelClassName: fallbackRule.modelClassName,
+    ownerPlugin: fallbackRule.ownerPlugin,
+    isDefault: !!fallbackRule.isDefault
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRegisteredFieldUses,
+  resolveRegisteredFieldBinding
+});

package/dist/server/flow-surfaces/field-semantics.d.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 export declare const MULTI_VALUE_ASSOCIATION_INTERFACES: Set<string>;
-export declare function normalizeFieldContainerKind(containerUse?: string): "form" | "details" | "filter-form" | "table";
+export declare function normalizeFieldContainerKind(containerUse?: string): "form" | "details" | "table" | "filter-form";
 export declare function shouldUseAssociationTitleTextDisplay(input: {
     containerUse?: string;
     associationPathName?: string;

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

@@ -142,6 +142,81 @@ function registerFlowSurfacesResource(plugin) {
     get: async (ctx, next) => {
       await runFlowSurfaceAction(ctx, next, () => service.get(getReadValues(ctx)));
     },
+    describeSurface: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.describeSurface(getValues(ctx)));
+    },
+    getReactionMeta: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.getReactionMeta(getValues(ctx)));
+    },
+    setFieldValueRules: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.setFieldValueRules(getValues(ctx), { transaction }))
+      );
+    },
+    setBlockLinkageRules: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.setBlockLinkageRules(getValues(ctx), { transaction }))
+      );
+    },
+    setFieldLinkageRules: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.setFieldLinkageRules(getValues(ctx), { transaction }))
+      );
+    },
+    setActionLinkageRules: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.setActionLinkageRules(getValues(ctx), { transaction }))
+      );
+    },
+    applyBlueprint: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.applyBlueprint(getValues(ctx), { transaction }))
+      );
+    },
+    listTemplates: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.listTemplates(getValues(ctx)));
+    },
+    getTemplate: async (ctx, next) => {
+      await runFlowSurfaceAction(ctx, next, () => service.getTemplate(getValues(ctx)));
+    },
+    saveTemplate: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.saveTemplate(getValues(ctx), { transaction }))
+      );
+    },
+    updateTemplate: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.updateTemplate(getValues(ctx), { transaction }))
+      );
+    },
+    destroyTemplate: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.destroyTemplate(getValues(ctx), { transaction }))
+      );
+    },
+    convertTemplateToCopy: async (ctx, next) => {
+      await runFlowSurfaceAction(
+        ctx,
+        next,
+        () => service.transaction((transaction) => service.convertTemplateToCopy(getValues(ctx), { transaction }))
+      );
+    },
     compose: async (ctx, next) => {
       await runFlowSurfaceAction(
         ctx,

package/dist/server/flow-surfaces/node-use-sets.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare const COLLECTION_BLOCK_USES: Set<string>;
+export declare const STATIC_CONTENT_BLOCK_USES: Set<string>;
+export declare const FIELD_WRAPPER_USES: Set<string>;
+export declare const CREATABLE_STANDALONE_FIELD_USES: Set<string>;
+export declare const STANDALONE_FIELD_NODE_USES: Set<string>;
+export declare const ACTION_BUTTON_USES: Set<string>;
+export declare const JS_BLOCK_USES: Set<string>;

package/dist/server/flow-surfaces/node-use-sets.js

@@ -0,0 +1,114 @@
+/**
+ * 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 node_use_sets_exports = {};
+__export(node_use_sets_exports, {
+  ACTION_BUTTON_USES: () => ACTION_BUTTON_USES,
+  COLLECTION_BLOCK_USES: () => COLLECTION_BLOCK_USES,
+  CREATABLE_STANDALONE_FIELD_USES: () => CREATABLE_STANDALONE_FIELD_USES,
+  FIELD_WRAPPER_USES: () => FIELD_WRAPPER_USES,
+  JS_BLOCK_USES: () => JS_BLOCK_USES,
+  STANDALONE_FIELD_NODE_USES: () => STANDALONE_FIELD_NODE_USES,
+  STATIC_CONTENT_BLOCK_USES: () => STATIC_CONTENT_BLOCK_USES
+});
+module.exports = __toCommonJS(node_use_sets_exports);
+const COLLECTION_BLOCK_USES = /* @__PURE__ */ new Set([
+  "TableBlockModel",
+  "CreateFormModel",
+  "EditFormModel",
+  "FormBlockModel",
+  "DetailsBlockModel",
+  "FilterFormBlockModel",
+  "ListBlockModel",
+  "GridCardBlockModel",
+  "MapBlockModel",
+  "CommentsBlockModel"
+]);
+const STATIC_CONTENT_BLOCK_USES = /* @__PURE__ */ new Set([
+  "MarkdownBlockModel",
+  "IframeBlockModel",
+  "ChartBlockModel",
+  "ActionPanelBlockModel",
+  "JSBlockModel"
+]);
+const FIELD_WRAPPER_USES = /* @__PURE__ */ new Set([
+  "FormItemModel",
+  "FormAssociationItemModel",
+  "DetailsItemModel",
+  "FilterFormItemModel",
+  "TableColumnModel"
+]);
+const CREATABLE_STANDALONE_FIELD_USES = /* @__PURE__ */ new Set(["JSColumnModel", "JSItemModel"]);
+const STANDALONE_FIELD_NODE_USES = /* @__PURE__ */ new Set([...CREATABLE_STANDALONE_FIELD_USES, "FormJSFieldItemModel"]);
+const ACTION_BUTTON_USES = /* @__PURE__ */ new Set([
+  "AddNewActionModel",
+  "ViewActionModel",
+  "EditActionModel",
+  "PopupCollectionActionModel",
+  "DeleteActionModel",
+  "BulkDeleteActionModel",
+  "BulkEditActionModel",
+  "UpdateRecordActionModel",
+  "BulkUpdateActionModel",
+  "DuplicateActionModel",
+  "AddChildActionModel",
+  "FilterActionModel",
+  "ExpandCollapseActionModel",
+  "FormSubmitActionModel",
+  "FilterFormSubmitActionModel",
+  "FilterFormResetActionModel",
+  "FilterFormCollapseActionModel",
+  "RefreshActionModel",
+  "LinkActionModel",
+  "ExportActionModel",
+  "ExportAttachmentActionModel",
+  "ImportActionModel",
+  "UploadActionModel",
+  "TemplatePrintCollectionActionModel",
+  "TemplatePrintRecordActionModel",
+  "CollectionTriggerWorkflowActionModel",
+  "RecordTriggerWorkflowActionModel",
+  "FormTriggerWorkflowActionModel",
+  "WorkbenchTriggerWorkflowActionModel",
+  "MailSendActionModel",
+  "JSCollectionActionModel",
+  "JSRecordActionModel",
+  "JSFormActionModel",
+  "JSItemActionModel",
+  "FilterFormJSActionModel",
+  "JSActionModel"
+]);
+const JS_BLOCK_USES = /* @__PURE__ */ new Set(["JSBlockModel"]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTION_BUTTON_USES,
+  COLLECTION_BLOCK_USES,
+  CREATABLE_STANDALONE_FIELD_USES,
+  FIELD_WRAPPER_USES,
+  JS_BLOCK_USES,
+  STANDALONE_FIELD_NODE_USES,
+  STATIC_CONTENT_BLOCK_USES
+});

package/dist/server/flow-surfaces/payload-shape.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 declare function validateFlowSurfacePayloadShape(actionName: string, value: any, path: string): void;

package/dist/server/flow-surfaces/payload-shape.js

@@ -0,0 +1,61 @@
+/**
+ * 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 payload_shape_exports = {};
+__export(payload_shape_exports, {
+  validateFlowSurfacePayloadShape: () => validateFlowSurfacePayloadShape
+});
+module.exports = __toCommonJS(payload_shape_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+var import_key_registry = require("./planning/key-registry");
+function validateFlowSurfacePayloadShape(actionName, value, path) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => validateFlowSurfacePayloadShape(actionName, item, `${path}[${index}]`));
+    return;
+  }
+  if (!import_lodash.default.isPlainObject(value)) {
+    return;
+  }
+  if (import_lodash.default.isPlainObject(value.stepParams) && Object.prototype.hasOwnProperty.call(value.stepParams, import_key_registry.FLOW_SURFACE_INTERNAL_META_KEY)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.stepParams.${import_key_registry.FLOW_SURFACE_INTERNAL_META_KEY} is reserved`);
+  }
+  Object.entries(value).forEach(([key, child]) => validateFlowSurfacePayloadShape(actionName, child, `${path}.${key}`));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateFlowSurfacePayloadShape
+});