@nocobase/plugin-flow-engine 2.1.0-alpha.13 → 2.1.0-alpha.14

package/dist/server/flow-surfaces/contract-guard.js

@@ -0,0 +1,411 @@
+/**
+ * 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 contract_guard_exports = {};
+__export(contract_guard_exports, {
+  FlowSurfaceContractGuard: () => FlowSurfaceContractGuard
+});
+module.exports = __toCommonJS(contract_guard_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_utils = require("@nocobase/utils");
+var import_catalog = require("./catalog");
+var import_errors = require("./errors");
+const EMPTY_GRID_ITEM_UID = "__EMPTY__";
+const EMPTY_FILTER_GROUP = {
+  logic: "$and",
+  items: []
+};
+const FILTER_GROUP_EXAMPLE = JSON.stringify(EMPTY_FILTER_GROUP);
+class FlowSurfaceContractGuard {
+  mergeDomainValue(domain, currentValue, nextValue, contract, use) {
+    if (!import_lodash.default.isPlainObject(nextValue)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces updateSettings domain '${domain}' on '${use}' requires an object payload`);
+    }
+    if (contract.wildcard) {
+      if (!Object.keys(nextValue).length) {
+        return {};
+      }
+      return contract.mergeStrategy === "replace" ? import_lodash.default.cloneDeep(nextValue) : import_lodash.default.merge({}, currentValue || {}, nextValue);
+    }
+    if (contract.groups) {
+      const unknownGroups = Object.keys(nextValue).filter((key) => !contract.allowedKeys.includes(key));
+      if (unknownGroups.length) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces updateSettings domain '${domain}' on '${use}' does not allow groups: ${unknownGroups.join(
+            ", "
+          )}`
+        );
+      }
+      const next2 = import_lodash.default.cloneDeep(currentValue || {});
+      Object.entries(nextValue).forEach(([groupKey, value]) => {
+        var _a;
+        const groupContract = (_a = contract.groups) == null ? void 0 : _a[groupKey];
+        if (!groupContract) {
+          return;
+        }
+        if (value === null || import_lodash.default.isPlainObject(value) && !Object.keys(value).length) {
+          if (!groupContract.clearable) {
+            (0, import_errors.throwBadRequest)(
+              `flowSurfaces updateSettings domain '${domain}.${groupKey}' on '${use}' does not support clearing`
+            );
+          }
+          next2[groupKey] = {};
+          return;
+        }
+        if (!import_lodash.default.isPlainObject(value)) {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces updateSettings domain '${domain}.${groupKey}' on '${use}' requires an object payload`
+          );
+        }
+        const normalizedValue = normalizeGroupValue(value, groupContract, {
+          domain,
+          groupKey,
+          use
+        });
+        const invalidPaths = collectLeafPaths(normalizedValue).filter(
+          (path) => !isAllowedGroupPath(groupContract, path)
+        );
+        if (invalidPaths.length) {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces updateSettings domain '${domain}.${groupKey}' on '${use}' does not allow paths: ${invalidPaths.join(
+              ", "
+            )}`
+          );
+        }
+        const invalidValueTypes = collectTypedValueErrors(normalizedValue, groupContract.pathSchemas || {});
+        if (invalidValueTypes.length) {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces updateSettings domain '${domain}.${groupKey}' on '${use}' has invalid values: ${invalidValueTypes.join(
+              ", "
+            )}`
+          );
+        }
+        next2[groupKey] = groupContract.mergeStrategy === "replace" ? import_lodash.default.cloneDeep(normalizedValue) : import_lodash.default.merge({}, (currentValue == null ? void 0 : currentValue[groupKey]) || {}, normalizedValue);
+      });
+      return next2;
+    }
+    const unknownKeys = Object.keys(nextValue).filter((key) => !contract.allowedKeys.includes(key));
+    if (unknownKeys.length) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces updateSettings domain '${domain}' on '${use}' does not allow keys: ${unknownKeys.join(", ")}`
+      );
+    }
+    if (!Object.keys(nextValue).length) {
+      return {};
+    }
+    const next = import_lodash.default.cloneDeep(currentValue || {});
+    Object.entries(nextValue).forEach(([key, value]) => {
+      next[key] = contract.mergeStrategy === "replace" || !import_lodash.default.isPlainObject(value) || !Object.keys(value).length ? import_lodash.default.cloneDeep(value) : import_lodash.default.merge({}, (currentValue == null ? void 0 : currentValue[key]) || {}, value);
+    });
+    return next;
+  }
+  validateFlowRegistry(node, flowRegistry) {
+    var _a, _b, _c;
+    if (!import_lodash.default.isPlainObject(flowRegistry)) {
+      (0, import_errors.throwBadRequest)("flowSurfaces setEventFlows requires an object flowRegistry");
+    }
+    const contract = (0, import_catalog.getNodeContract)(node == null ? void 0 : node.use);
+    const allowedDirectEvents = new Set(((_a = contract.eventCapabilities) == null ? void 0 : _a.direct) || []);
+    const allowedObjectEvents = new Set(((_b = contract.eventCapabilities) == null ? void 0 : _b.object) || []);
+    const stepParamGroups = ((_c = contract.domains.stepParams) == null ? void 0 : _c.groups) || {};
+    Object.entries(flowRegistry).forEach(([key, flow]) => {
+      var _a2, _b2;
+      if (!import_lodash.default.isPlainObject(flow)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' must be an object`);
+      }
+      const on = flow.on;
+      if (!on) {
+        return;
+      }
+      const onObj = typeof on === "string" ? { eventName: on } : on;
+      const eventName = onObj == null ? void 0 : onObj.eventName;
+      if (!eventName || typeof eventName !== "string") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' has invalid eventName`);
+      }
+      if (typeof on === "string" && !allowedDirectEvents.has(eventName)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' event '${eventName}' is not allowed on '${node == null ? void 0 : node.use}'`);
+      }
+      if (typeof on !== "string" && !allowedObjectEvents.has(eventName)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' event '${eventName}' is not allowed on '${node == null ? void 0 : node.use}'`);
+      }
+      const phase = onObj == null ? void 0 : onObj.phase;
+      const allowedPhases = ["beforeAllFlows", "afterAllFlows", "beforeFlow", "afterFlow", "beforeStep", "afterStep"];
+      if (phase && !allowedPhases.includes(phase)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' has invalid phase '${phase}'`);
+      }
+      if (["beforeFlow", "afterFlow", "beforeStep", "afterStep"].includes(phase) && !onObj.flowKey) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' requires flowKey for phase '${phase}'`);
+      }
+      if (["beforeStep", "afterStep"].includes(phase) && !onObj.stepKey) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' requires stepKey for phase '${phase}'`);
+      }
+      if (onObj.flowKey && !stepParamGroups[onObj.flowKey]) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' references unknown flowKey '${onObj.flowKey}' on '${node == null ? void 0 : node.use}'`);
+      }
+      const allowedStepKeys = (_a2 = stepParamGroups[onObj.flowKey]) == null ? void 0 : _a2.eventBindingSteps;
+      if (onObj.stepKey && allowedStepKeys !== "*" && Array.isArray(allowedStepKeys) && !allowedStepKeys.includes(onObj.stepKey)) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces flow '${key}' references unknown stepKey '${onObj.stepKey}' for flowKey '${onObj.flowKey}' on '${node == null ? void 0 : node.use}'`
+        );
+      }
+      if (onObj.flowKey) {
+        const flowGroupContract = stepParamGroups[onObj.flowKey];
+        const flowGroup = (_b2 = node == null ? void 0 : node.stepParams) == null ? void 0 : _b2[onObj.flowKey];
+        const contractDefinesFlow = isContractDefinedFlowGroup(flowGroupContract);
+        const implicitStepAvailable = isImplicitContractStep(flowGroupContract, onObj.stepKey);
+        if ((!import_lodash.default.isPlainObject(flowGroup) || !Object.keys(flowGroup).length) && !contractDefinesFlow) {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces flow '${key}' references unavailable flowKey '${onObj.flowKey}' on '${node == null ? void 0 : node.use}'`
+          );
+        }
+        if (onObj.stepKey && import_lodash.default.isNil(flowGroup == null ? void 0 : flowGroup[onObj.stepKey]) && !implicitStepAvailable) {
+          (0, import_errors.throwBadRequest)(
+            `flowSurfaces flow '${key}' references unavailable stepKey '${onObj.stepKey}' for flowKey '${onObj.flowKey}' on '${node == null ? void 0 : node.use}'`
+          );
+        }
+      }
+    });
+  }
+  validateLayout(grid, layout) {
+    var _a;
+    const itemUids = new Set(import_lodash.default.castArray(((_a = grid == null ? void 0 : grid.subModels) == null ? void 0 : _a.items) || []).map((item) => item.uid));
+    const seen = /* @__PURE__ */ new Set();
+    Object.entries(layout.rows || {}).forEach(([rowId, cells]) => {
+      var _a2;
+      import_lodash.default.castArray(cells).forEach((cell) => {
+        import_lodash.default.castArray(cell).forEach((itemUid) => {
+          if (itemUid === EMPTY_GRID_ITEM_UID) {
+            return;
+          }
+          if (!itemUids.has(itemUid)) {
+            (0, import_errors.throwBadRequest)(`flowSurfaces layout item '${itemUid}' does not exist under grid '${grid.uid}'`);
+          }
+          if (seen.has(itemUid)) {
+            (0, import_errors.throwBadRequest)(`flowSurfaces layout item '${itemUid}' is duplicated under grid '${grid.uid}'`);
+          }
+          seen.add(itemUid);
+        });
+      });
+      const sizeArray = (_a2 = layout.sizes) == null ? void 0 : _a2[rowId];
+      if (!sizeArray) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces layout row '${rowId}' requires sizes definition`);
+      }
+      if (sizeArray.length !== import_lodash.default.castArray(cells).length) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces layout sizes length of row '${rowId}' does not match columns length`);
+      }
+    });
+    const declaredRows = Object.keys(layout.rows || {});
+    if (import_lodash.default.difference(declaredRows, layout.rowOrder || []).length || import_lodash.default.difference(layout.rowOrder || [], declaredRows).length) {
+      (0, import_errors.throwBadRequest)("flowSurfaces layout rowOrder must match rows");
+    }
+    if ((layout.rowOrder || []).length !== new Set(layout.rowOrder || []).size) {
+      (0, import_errors.throwBadRequest)("flowSurfaces layout rowOrder contains duplicate row ids");
+    }
+    if (seen.size !== itemUids.size) {
+      const missing = Array.from(itemUids).filter((uid) => !seen.has(uid));
+      (0, import_errors.throwBadRequest)(`flowSurfaces layout must cover all grid children, missing: ${missing.join(", ")}`);
+    }
+  }
+  validateNodeTreeAgainstContract(node) {
+    if (!(node == null ? void 0 : node.use)) {
+      return;
+    }
+    const contract = (0, import_catalog.getNodeContract)(node.use);
+    ["props", "decoratorProps", "stepParams", "flowRegistry"].forEach((domain) => {
+      if (import_lodash.default.isUndefined(node[domain])) {
+        return;
+      }
+      if (import_lodash.default.isPlainObject(node[domain]) && !Object.keys(node[domain]).length) {
+        return;
+      }
+      if (!contract.editableDomains.includes(domain)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces create tree domain '${domain}' is not editable on '${node.use}'`);
+      }
+      const domainContract = contract.domains[domain];
+      if (!domainContract) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces create tree domain '${domain}' is not supported by '${node.use}'`);
+      }
+      node[domain] = this.mergeDomainValue(domain, void 0, node[domain], domainContract, node.use);
+    });
+    if (import_lodash.default.isPlainObject(node.flowRegistry) && Object.keys(node.flowRegistry).length) {
+      this.validateFlowRegistry(node, node.flowRegistry);
+    }
+    Object.values(node.subModels || {}).forEach((value) => {
+      import_lodash.default.castArray(value).forEach((child) => this.validateNodeTreeAgainstContract(child));
+    });
+  }
+}
+function matchesContractPath(pattern, path) {
+  if (pattern === "*") {
+    return true;
+  }
+  if (pattern === path) {
+    return true;
+  }
+  if (pattern.endsWith(".*")) {
+    const prefix = pattern.slice(0, -2);
+    return path === prefix || path.startsWith(`${prefix}.`);
+  }
+  return false;
+}
+function isAllowedGroupPath(groupContract, path) {
+  return groupContract.allowedPaths.some((pattern) => {
+    var _a;
+    if (matchesContractPath(pattern, path)) {
+      return true;
+    }
+    const schema = (_a = groupContract.pathSchemas) == null ? void 0 : _a[pattern];
+    return (schema == null ? void 0 : schema.type) === "object" && path.startsWith(`${pattern}.`);
+  });
+}
+function collectLeafPaths(value, prefix = "") {
+  if (!import_lodash.default.isPlainObject(value) || !Object.keys(value).length) {
+    return prefix ? [prefix] : [];
+  }
+  return Object.entries(value).flatMap(([key, nested]) => collectLeafPaths(nested, prefix ? `${prefix}.${key}` : key));
+}
+function collectTypedValueErrors(value, pathSchemas) {
+  return Object.entries(pathSchemas).flatMap(([path, schema]) => {
+    if (!import_lodash.default.has(value, path)) {
+      return [];
+    }
+    const candidate = import_lodash.default.get(value, path);
+    return matchesValueSchema(candidate, schema) ? [] : [`${path} expected ${schema.type}`];
+  });
+}
+function normalizeGroupValue(value, groupContract, context) {
+  const normalized = import_lodash.default.cloneDeep(value);
+  Object.entries(groupContract.pathSchemas || {}).forEach(([path, schema]) => {
+    if (!import_lodash.default.has(normalized, path) || !isFilterGroupSchema(schema)) {
+      return;
+    }
+    import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+  });
+  return normalized;
+}
+function matchesValueSchema(value, schema) {
+  if (value === null) {
+    return (schema == null ? void 0 : schema.nullable) === true;
+  }
+  switch (schema == null ? void 0 : schema.type) {
+    case "string":
+      return typeof value === "string";
+    case "boolean":
+      return typeof value === "boolean";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "object":
+      return import_lodash.default.isPlainObject(value);
+    case "array":
+      return Array.isArray(value);
+    default:
+      return true;
+  }
+}
+function isFilterGroupSchema(schema) {
+  return (schema == null ? void 0 : schema["x-flowSurfaceFormat"]) === "filter-group";
+}
+function normalizeFilterGroupValue(value, context, path) {
+  if (value === null || import_lodash.default.isPlainObject(value) && !Object.keys(value).length) {
+    return import_lodash.default.cloneDeep(EMPTY_FILTER_GROUP);
+  }
+  try {
+    assertFilterGroupShape(value);
+    (0, import_utils.transformFilter)(value);
+    return import_lodash.default.cloneDeep(value);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces updateSettings domain '${context.domain}.${context.groupKey}.${path}' on '${context.use}' expects FilterGroup like ${FILTER_GROUP_EXAMPLE}: ${reason}`
+    );
+  }
+}
+function assertFilterGroupShape(filter) {
+  if (!import_lodash.default.isPlainObject(filter)) {
+    (0, import_errors.throwBadRequest)("Invalid filter: filter must be an object");
+  }
+  if (!("logic" in filter) || !("items" in filter)) {
+    (0, import_errors.throwBadRequest)("Invalid filter: filter must have logic and items properties");
+  }
+  if (filter.logic !== "$and" && filter.logic !== "$or") {
+    (0, import_errors.throwBadRequest)("Invalid filter: logic must be '$and' or '$or'");
+  }
+  if (!Array.isArray(filter.items)) {
+    (0, import_errors.throwBadRequest)("Invalid filter: items must be an array");
+  }
+  filter.items.forEach((item) => {
+    if (import_lodash.default.isPlainObject(item) && "logic" in item && "items" in item) {
+      assertFilterGroupShape(item);
+      return;
+    }
+    if (import_lodash.default.isPlainObject(item) && typeof item.path === "string" && typeof item.operator === "string") {
+      return;
+    }
+    (0, import_errors.throwBadRequest)("Invalid filter item type");
+  });
+}
+function isContractDefinedFlowGroup(groupContract) {
+  if (!groupContract) {
+    return false;
+  }
+  if (!Array.isArray(groupContract.allowedPaths) || groupContract.allowedPaths.length === 0) {
+    return true;
+  }
+  return hasImplicitContractSteps(groupContract);
+}
+function hasImplicitContractSteps(groupContract) {
+  if (groupContract.eventBindingSteps === "*") {
+    return false;
+  }
+  return import_lodash.default.castArray(groupContract.eventBindingSteps || []).some(
+    (stepKey) => isImplicitContractStep(groupContract, stepKey)
+  );
+}
+function isImplicitContractStep(groupContract, stepKey) {
+  if (!groupContract || !stepKey) {
+    return false;
+  }
+  if (groupContract.eventBindingSteps !== "*" && !import_lodash.default.castArray(groupContract.eventBindingSteps || []).includes(stepKey)) {
+    return false;
+  }
+  return !import_lodash.default.castArray(groupContract.allowedPaths || []).some(
+    (pattern) => pattern === stepKey || pattern === `${stepKey}.*` || pattern.startsWith(`${stepKey}.`)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowSurfaceContractGuard
+});

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

@@ -0,0 +1,47 @@
+/**
+ * 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 FlowSurfaceErrorType = 'bad_request' | 'forbidden' | 'conflict' | 'internal_error';
+export interface FlowSurfaceErrorItem {
+    message: string;
+    type: FlowSurfaceErrorType;
+    code: string;
+    status: number;
+}
+export declare class FlowSurfaceError extends Error {
+    readonly status: number;
+    readonly type: FlowSurfaceErrorType;
+    readonly code: string;
+    constructor(message: string, status: number, type: FlowSurfaceErrorType, code: string);
+    toResponseBody(): {
+        errors: FlowSurfaceErrorItem[];
+    };
+}
+export declare class FlowSurfaceBadRequestError extends FlowSurfaceError {
+    constructor(message: string, code?: string);
+}
+export declare class FlowSurfaceForbiddenError extends FlowSurfaceError {
+    constructor(message: string, code?: string);
+}
+export declare class FlowSurfaceConflictError extends FlowSurfaceError {
+    constructor(message: string, code?: string);
+}
+export declare class FlowSurfaceInternalError extends FlowSurfaceError {
+    constructor(message: string, code?: string);
+}
+export declare function isFlowSurfaceError(error: unknown): error is FlowSurfaceError;
+export declare function isFlowSurfaceBadRequestError(error: unknown): error is FlowSurfaceBadRequestError;
+export declare function isFlowSurfaceForbiddenError(error: unknown): error is FlowSurfaceForbiddenError;
+export declare function isFlowSurfaceConflictError(error: unknown): error is FlowSurfaceConflictError;
+export declare function isFlowSurfaceInternalError(error: unknown): error is FlowSurfaceInternalError;
+export declare function toFlowSurfaceErrorItem(error: FlowSurfaceError): FlowSurfaceErrorItem;
+export declare function normalizeFlowSurfaceError(error: unknown): FlowSurfaceError;
+export declare function throwBadRequest(message: string, code?: string): never;
+export declare function throwForbidden(message: string, code?: string): never;
+export declare function throwConflict(message: string, code?: string): never;
+export declare function throwInternalError(message: string, code?: string): never;

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

@@ -0,0 +1,145 @@
+/**
+ * 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 errors_exports = {};
+__export(errors_exports, {
+  FlowSurfaceBadRequestError: () => FlowSurfaceBadRequestError,
+  FlowSurfaceConflictError: () => FlowSurfaceConflictError,
+  FlowSurfaceError: () => FlowSurfaceError,
+  FlowSurfaceForbiddenError: () => FlowSurfaceForbiddenError,
+  FlowSurfaceInternalError: () => FlowSurfaceInternalError,
+  isFlowSurfaceBadRequestError: () => isFlowSurfaceBadRequestError,
+  isFlowSurfaceConflictError: () => isFlowSurfaceConflictError,
+  isFlowSurfaceError: () => isFlowSurfaceError,
+  isFlowSurfaceForbiddenError: () => isFlowSurfaceForbiddenError,
+  isFlowSurfaceInternalError: () => isFlowSurfaceInternalError,
+  normalizeFlowSurfaceError: () => normalizeFlowSurfaceError,
+  throwBadRequest: () => throwBadRequest,
+  throwConflict: () => throwConflict,
+  throwForbidden: () => throwForbidden,
+  throwInternalError: () => throwInternalError,
+  toFlowSurfaceErrorItem: () => toFlowSurfaceErrorItem
+});
+module.exports = __toCommonJS(errors_exports);
+class FlowSurfaceError extends Error {
+  constructor(message, status, type, code) {
+    super(message);
+    this.status = status;
+    this.type = type;
+    this.code = code;
+    this.name = "FlowSurfaceError";
+  }
+  toResponseBody() {
+    return {
+      errors: [toFlowSurfaceErrorItem(this)]
+    };
+  }
+}
+class FlowSurfaceBadRequestError extends FlowSurfaceError {
+  constructor(message, code = "FLOW_SURFACE_BAD_REQUEST") {
+    super(message, 400, "bad_request", code);
+    this.name = "FlowSurfaceBadRequestError";
+  }
+}
+class FlowSurfaceForbiddenError extends FlowSurfaceError {
+  constructor(message, code = "FLOW_SURFACE_FORBIDDEN") {
+    super(message, 403, "forbidden", code);
+    this.name = "FlowSurfaceForbiddenError";
+  }
+}
+class FlowSurfaceConflictError extends FlowSurfaceError {
+  constructor(message, code = "FLOW_SURFACE_CONFLICT") {
+    super(message, 409, "conflict", code);
+    this.name = "FlowSurfaceConflictError";
+  }
+}
+class FlowSurfaceInternalError extends FlowSurfaceError {
+  constructor(message, code = "FLOW_SURFACE_INTERNAL_ERROR") {
+    super(message, 500, "internal_error", code);
+    this.name = "FlowSurfaceInternalError";
+  }
+}
+function isFlowSurfaceError(error) {
+  return error instanceof FlowSurfaceError;
+}
+function isFlowSurfaceBadRequestError(error) {
+  return error instanceof FlowSurfaceBadRequestError;
+}
+function isFlowSurfaceForbiddenError(error) {
+  return error instanceof FlowSurfaceForbiddenError;
+}
+function isFlowSurfaceConflictError(error) {
+  return error instanceof FlowSurfaceConflictError;
+}
+function isFlowSurfaceInternalError(error) {
+  return error instanceof FlowSurfaceInternalError;
+}
+function toFlowSurfaceErrorItem(error) {
+  return {
+    message: error.message,
+    type: error.type,
+    code: error.code,
+    status: error.status
+  };
+}
+function normalizeFlowSurfaceError(error) {
+  if (error instanceof FlowSurfaceError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new FlowSurfaceInternalError(message);
+}
+function throwBadRequest(message, code) {
+  throw new FlowSurfaceBadRequestError(message, code);
+}
+function throwForbidden(message, code) {
+  throw new FlowSurfaceForbiddenError(message, code);
+}
+function throwConflict(message, code) {
+  throw new FlowSurfaceConflictError(message, code);
+}
+function throwInternalError(message, code) {
+  throw new FlowSurfaceInternalError(message, code);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowSurfaceBadRequestError,
+  FlowSurfaceConflictError,
+  FlowSurfaceError,
+  FlowSurfaceForbiddenError,
+  FlowSurfaceInternalError,
+  isFlowSurfaceBadRequestError,
+  isFlowSurfaceConflictError,
+  isFlowSurfaceError,
+  isFlowSurfaceForbiddenError,
+  isFlowSurfaceInternalError,
+  normalizeFlowSurfaceError,
+  throwBadRequest,
+  throwConflict,
+  throwForbidden,
+  throwInternalError,
+  toFlowSurfaceErrorItem
+});

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

@@ -0,0 +1,13 @@
+/**
+ * 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 { FlowSurfaceExecutorContext, FlowSurfaceMutateOp } from './types';
+export declare function executeMutateOps(ops: FlowSurfaceMutateOp[], ctx: FlowSurfaceExecutorContext, dispatcher: (op: FlowSurfaceMutateOp, values: Record<string, any>, ctx: FlowSurfaceExecutorContext) => Promise<any>): Promise<{
+    opId?: string;
+    result: any;
+}[]>;