@nocobase/plugin-flow-engine 2.1.0-alpha.10 → 2.1.0-alpha.12

package/dist/server/flow-models/repository-internals/duplicate-helpers.js

@@ -0,0 +1,121 @@
+/**
+ * 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 duplicate_helpers_exports = {};
+__export(duplicate_helpers_exports, {
+  dedupeNodesForDuplicate: () => dedupeNodesForDuplicate,
+  replaceStepParamsModelUids: () => replaceStepParamsModelUids,
+  stripDuplicateReplayMarker: () => stripDuplicateReplayMarker
+});
+module.exports = __toCommonJS(duplicate_helpers_exports);
+var import_lodash = __toESM(require("lodash"));
+function dedupeNodesForDuplicate(nodes, rootUid) {
+  if (!Array.isArray(nodes) || nodes.length <= 1) {
+    return nodes;
+  }
+  const rowsByUid = import_lodash.default.groupBy(nodes, "uid");
+  const uniqueUids = Object.keys(rowsByUid);
+  if (uniqueUids.length === nodes.length) {
+    return nodes;
+  }
+  const uidsInSubtree = new Set(uniqueUids);
+  const rootDepthByUid = /* @__PURE__ */ new Map();
+  for (const uid of uniqueUids) {
+    const rows = rowsByUid[uid] || [];
+    const depths = rows.map((row) => Number((row == null ? void 0 : row.depth) ?? 0));
+    rootDepthByUid.set(uid, depths.length ? Math.min(...depths) : 0);
+  }
+  const pickRowForUid = (uid, rows) => {
+    if (!(rows == null ? void 0 : rows.length)) return null;
+    if (rows.length === 1) return rows[0];
+    if (uid === rootUid) return rows[0];
+    let bestRow = rows[0];
+    let bestParentRootDepth = -1;
+    for (const row of rows) {
+      const parentUid = row == null ? void 0 : row.parent;
+      if (!parentUid || !uidsInSubtree.has(parentUid)) {
+        continue;
+      }
+      const parentRootDepth = rootDepthByUid.get(parentUid) ?? -1;
+      if (parentRootDepth > bestParentRootDepth) {
+        bestParentRootDepth = parentRootDepth;
+        bestRow = row;
+      }
+    }
+    return bestRow;
+  };
+  const uidsInQueryOrder = [];
+  const seenUidsInQueryOrder = /* @__PURE__ */ new Set();
+  for (const row of nodes) {
+    const uid = row == null ? void 0 : row.uid;
+    if (!uid || seenUidsInQueryOrder.has(uid)) continue;
+    seenUidsInQueryOrder.add(uid);
+    uidsInQueryOrder.push(uid);
+  }
+  return uidsInQueryOrder.map((uid) => pickRowForUid(uid, rowsByUid[uid])).filter(Boolean);
+}
+function replaceStepParamsModelUids(options, uidMap) {
+  const opts = options && typeof options === "object" ? options : {};
+  const replaceUidString = (value) => typeof value === "string" && uidMap[value] ? uidMap[value] : value;
+  const replaceInPlace = (value) => {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        value[i] = replaceInPlace(value[i]);
+      }
+      return value;
+    }
+    if (value && typeof value === "object") {
+      for (const key of Object.keys(value)) {
+        value[key] = replaceInPlace(value[key]);
+      }
+      return value;
+    }
+    return replaceUidString(value);
+  };
+  if (opts.stepParams) {
+    opts.stepParams = replaceInPlace(opts.stepParams);
+  }
+  return opts;
+}
+function stripDuplicateReplayMarker(options) {
+  return import_lodash.default.omit(options, ["__mutateDuplicate"]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dedupeNodesForDuplicate,
+  replaceStepParamsModelUids,
+  stripDuplicateReplayMarker
+});

package/dist/server/flow-models/repository-internals/ensure-lock.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.
+ */
+import { Transaction } from '@nocobase/database';
+export declare function getEnsureObjectChildLockKey(parentId: string, subKey: string): string;
+export declare function getTransactionId(transaction?: Transaction): string;
+export declare function acquireEnsureObjectChildLock(key: string, ownerTransactionId?: string): Promise<() => void>;
+export declare function isEnsureObjectChildLockOwner(key: string, transaction?: Transaction): boolean;
+export declare function registerEnsureObjectChildLockRelease(database: any, transaction: Transaction | undefined, release: () => void): boolean;
+export declare function emitFlowModelTransactionRollback(database: any, transaction?: Transaction): Promise<void>;

package/dist/server/flow-models/repository-internals/ensure-lock.js

@@ -0,0 +1,117 @@
+/**
+ * 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 ensure_lock_exports = {};
+__export(ensure_lock_exports, {
+  acquireEnsureObjectChildLock: () => acquireEnsureObjectChildLock,
+  emitFlowModelTransactionRollback: () => emitFlowModelTransactionRollback,
+  getEnsureObjectChildLockKey: () => getEnsureObjectChildLockKey,
+  getTransactionId: () => getTransactionId,
+  isEnsureObjectChildLockOwner: () => isEnsureObjectChildLockOwner,
+  registerEnsureObjectChildLockRelease: () => registerEnsureObjectChildLockRelease
+});
+module.exports = __toCommonJS(ensure_lock_exports);
+const ensureObjectChildLockWaiters = /* @__PURE__ */ new Map();
+const ensureObjectChildLockOwners = /* @__PURE__ */ new Map();
+function getEnsureObjectChildLockKey(parentId, subKey) {
+  return `object-child:${parentId}\0${subKey}\0object`;
+}
+function getTransactionId(transaction) {
+  const rawTransactionId = transaction == null ? void 0 : transaction.id;
+  return rawTransactionId == null ? void 0 : String(rawTransactionId);
+}
+async function acquireEnsureObjectChildLock(key, ownerTransactionId) {
+  const previous = ensureObjectChildLockWaiters.get(key);
+  let releaseCurrent;
+  const current = new Promise((resolve) => {
+    releaseCurrent = resolve;
+  });
+  ensureObjectChildLockWaiters.set(key, current);
+  await previous;
+  if (ownerTransactionId) {
+    ensureObjectChildLockOwners.set(key, ownerTransactionId);
+  }
+  let released = false;
+  return () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    if (ownerTransactionId && ensureObjectChildLockOwners.get(key) === ownerTransactionId) {
+      ensureObjectChildLockOwners.delete(key);
+    }
+    releaseCurrent();
+    if (ensureObjectChildLockWaiters.get(key) === current) {
+      ensureObjectChildLockWaiters.delete(key);
+    }
+  };
+}
+function isEnsureObjectChildLockOwner(key, transaction) {
+  const transactionId = getTransactionId(transaction);
+  return !!transactionId && ensureObjectChildLockOwners.get(key) === transactionId;
+}
+function registerEnsureObjectChildLockRelease(database, transaction, release) {
+  const transactionId = getTransactionId(transaction);
+  if (!database || !transaction || !transactionId) {
+    return false;
+  }
+  const eventName = `transactionRollback:${transactionId}`;
+  let settled = false;
+  const releaseOnce = () => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    release();
+  };
+  const onRollback = () => {
+    releaseOnce();
+  };
+  database.once(eventName, onRollback);
+  transaction.afterCommit(() => {
+    var _a;
+    (_a = database.removeListener) == null ? void 0 : _a.call(database, eventName, onRollback);
+    releaseOnce();
+  });
+  return true;
+}
+async function emitFlowModelTransactionRollback(database, transaction) {
+  var _a;
+  const transactionId = getTransactionId(transaction);
+  if (!database || !transactionId) {
+    return;
+  }
+  await ((_a = database.emitAsync) == null ? void 0 : _a.call(database, `transactionRollback:${transactionId}`));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  acquireEnsureObjectChildLock,
+  emitFlowModelTransactionRollback,
+  getEnsureObjectChildLockKey,
+  getTransactionId,
+  isEnsureObjectChildLockOwner,
+  registerEnsureObjectChildLockRelease
+});

package/dist/server/flow-models/repository-internals/errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 class FlowModelOperationError extends Error {
+    status: number;
+    code: string;
+    details?: any;
+    constructor(params: {
+        status: number;
+        code: string;
+        message: string;
+        details?: any;
+    });
+}
+export declare function unwrapFlowModelSqlError(error: any): any;
+export declare function isFlowModelUniqueConstraintError(error: any): boolean;

package/dist/server/flow-models/repository-internals/errors.js

@@ -0,0 +1,78 @@
+/**
+ * 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, {
+  FlowModelOperationError: () => FlowModelOperationError,
+  isFlowModelUniqueConstraintError: () => isFlowModelUniqueConstraintError,
+  unwrapFlowModelSqlError: () => unwrapFlowModelSqlError
+});
+module.exports = __toCommonJS(errors_exports);
+class FlowModelOperationError extends Error {
+  status;
+  code;
+  details;
+  constructor(params) {
+    super(params.message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.status = params.status;
+    this.code = params.code;
+    this.details = params.details;
+    this.name = "FlowModelOperationError";
+  }
+}
+function unwrapFlowModelSqlError(error) {
+  var _a;
+  return ((_a = error == null ? void 0 : error.original) == null ? void 0 : _a.parent) ?? (error == null ? void 0 : error.parent) ?? (error == null ? void 0 : error.original) ?? error;
+}
+function isFlowModelUniqueConstraintError(error) {
+  if (!error) {
+    return false;
+  }
+  if ((error == null ? void 0 : error.name) === "SequelizeUniqueConstraintError") {
+    return true;
+  }
+  const sqlError = unwrapFlowModelSqlError(error);
+  if (!sqlError) {
+    return false;
+  }
+  if ((sqlError == null ? void 0 : sqlError.code) === "23505") {
+    return true;
+  }
+  if ((sqlError == null ? void 0 : sqlError.errno) === 1062) {
+    return true;
+  }
+  if (typeof (sqlError == null ? void 0 : sqlError.code) === "string" && sqlError.code.startsWith("SQLITE_CONSTRAINT")) {
+    return true;
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowModelOperationError,
+  isFlowModelUniqueConstraintError,
+  unwrapFlowModelSqlError
+});

package/dist/server/flow-models/schema-contribution-collector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { FlowFieldBindingContextContribution, FlowFieldBindingContribution, FlowSchemaInventoryContribution } from '@nocobase/flow-engine';
+import { FlowSchemaService } from '../flow-schema-service';
+export type RegisterFlowSchemasOptions = {
+    models?: Record<string, any>;
+    actions?: Record<string, any>;
+    modelContributions?: any[] | Record<string, any>;
+    actionContributions?: any[] | Record<string, any>;
+    fieldBindingContexts?: FlowFieldBindingContextContribution[] | Record<string, FlowFieldBindingContextContribution>;
+    fieldBindings?: FlowFieldBindingContribution[] | Record<string, FlowFieldBindingContribution | FlowFieldBindingContribution[]>;
+    inventory?: FlowSchemaInventoryContribution;
+};
+export declare class FlowSchemaContributionCollector {
+    private readonly app;
+    private readonly flowSchemaService;
+    constructor(app: any, flowSchemaService: FlowSchemaService);
+    collectPluginFlowSchemaContributions(): Promise<void>;
+    registerFlowSchemas(options: RegisterFlowSchemasOptions): void;
+    private registerContribution;
+}

package/dist/server/flow-models/schema-contribution-collector.js

@@ -0,0 +1,217 @@
+/**
+ * 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 schema_contribution_collector_exports = {};
+__export(schema_contribution_collector_exports, {
+  FlowSchemaContributionCollector: () => FlowSchemaContributionCollector
+});
+module.exports = __toCommonJS(schema_contribution_collector_exports);
+var import_lodash = __toESM(require("lodash"));
+function inferFlowSchemaContributionSource(plugin) {
+  var _a;
+  const packageName = String(((_a = plugin == null ? void 0 : plugin.options) == null ? void 0 : _a.packageName) || "").trim();
+  if ((plugin == null ? void 0 : plugin.name) === "flow-engine" || packageName === "@nocobase/plugin-flow-engine") {
+    return "official";
+  }
+  if (packageName.startsWith("@nocobase/")) {
+    return "plugin";
+  }
+  return "third-party";
+}
+function normalizeActionContributions(contributions, defaults) {
+  if (!contributions) {
+    return [];
+  }
+  if (Array.isArray(contributions)) {
+    return contributions.filter(Boolean).map((contribution) => ({
+      ...contribution,
+      source: contribution.source ?? defaults.source,
+      strict: contribution.strict ?? defaults.strict
+    }));
+  }
+  return Object.entries(contributions).filter(([, contribution]) => !!contribution).map(([name, contribution]) => ({
+    ...contribution,
+    name: contribution.name || name,
+    source: contribution.source ?? defaults.source,
+    strict: contribution.strict ?? defaults.strict
+  }));
+}
+function normalizeModelContributions(contributions, defaults) {
+  if (!contributions) {
+    return [];
+  }
+  if (Array.isArray(contributions)) {
+    return contributions.filter(Boolean).map((contribution) => ({
+      ...contribution,
+      source: contribution.source ?? defaults.source,
+      strict: contribution.strict ?? defaults.strict
+    }));
+  }
+  return Object.entries(contributions).filter(([, contribution]) => !!contribution).map(([use, contribution]) => ({
+    ...contribution,
+    use: contribution.use || use,
+    source: contribution.source ?? defaults.source,
+    strict: contribution.strict ?? defaults.strict
+  }));
+}
+function normalizeFieldBindingContexts(contributions) {
+  if (!contributions) {
+    return [];
+  }
+  if (Array.isArray(contributions)) {
+    return contributions.filter(Boolean);
+  }
+  return Object.entries(contributions).filter(([, contribution]) => !!contribution).map(([name, contribution]) => ({
+    ...contribution,
+    name: contribution.name || name
+  }));
+}
+function normalizeFieldBindings(contributions) {
+  if (!contributions) {
+    return [];
+  }
+  if (Array.isArray(contributions)) {
+    return contributions.filter(Boolean);
+  }
+  return Object.entries(contributions).flatMap(([context, contribution]) => {
+    const items = Array.isArray(contribution) ? contribution : contribution ? [contribution] : [];
+    return items.filter(Boolean).map((item) => ({
+      ...item,
+      context: item.context || context
+    }));
+  });
+}
+function normalizeInventoryContribution(inventory) {
+  if (!inventory) {
+    return void 0;
+  }
+  const publicTreeRoots = Array.isArray(inventory.publicTreeRoots) ? import_lodash.default.uniq(inventory.publicTreeRoots.map((item) => String(item || "").trim()).filter(Boolean)) : [];
+  const slotUseExpansions = Array.isArray(inventory.slotUseExpansions) ? inventory.slotUseExpansions.map((item) => {
+    const parentUse = String((item == null ? void 0 : item.parentUse) || "").trim();
+    const slotKey = String((item == null ? void 0 : item.slotKey) || "").trim();
+    const uses = Array.isArray(item == null ? void 0 : item.uses) ? import_lodash.default.uniq(item.uses.map((use) => String(use || "").trim()).filter(Boolean)) : [];
+    if (!parentUse || !slotKey || uses.length === 0) {
+      return void 0;
+    }
+    return {
+      parentUse,
+      slotKey,
+      uses
+    };
+  }).filter(Boolean) : [];
+  if (!publicTreeRoots.length && !slotUseExpansions.length) {
+    return void 0;
+  }
+  return {
+    publicTreeRoots,
+    slotUseExpansions
+  };
+}
+class FlowSchemaContributionCollector {
+  constructor(app, flowSchemaService) {
+    this.app = app;
+    this.flowSchemaService = flowSchemaService;
+  }
+  async collectPluginFlowSchemaContributions() {
+    var _a, _b;
+    for (const plugin of this.app.pm.getPlugins().values()) {
+      if (!(plugin == null ? void 0 : plugin.enabled)) {
+        continue;
+      }
+      const provider = plugin;
+      if (typeof provider.getFlowSchemaContributions !== "function") {
+        continue;
+      }
+      const contribution = await provider.getFlowSchemaContributions();
+      if (!contribution) {
+        continue;
+      }
+      this.registerContribution(contribution, {
+        source: ((_a = contribution.defaults) == null ? void 0 : _a.source) ?? inferFlowSchemaContributionSource(plugin),
+        strict: (_b = contribution.defaults) == null ? void 0 : _b.strict
+      });
+    }
+  }
+  registerFlowSchemas(options) {
+    const defaults = {
+      source: "third-party",
+      strict: void 0
+    };
+    if (options == null ? void 0 : options.models) {
+      this.flowSchemaService.registerModels(options.models);
+    }
+    if (options == null ? void 0 : options.actions) {
+      this.flowSchemaService.registerActions(options.actions);
+    }
+    this.registerContribution(
+      {
+        models: options == null ? void 0 : options.modelContributions,
+        actions: options == null ? void 0 : options.actionContributions,
+        fieldBindingContexts: options == null ? void 0 : options.fieldBindingContexts,
+        fieldBindings: options == null ? void 0 : options.fieldBindings,
+        inventory: options == null ? void 0 : options.inventory,
+        defaults
+      },
+      defaults
+    );
+  }
+  registerContribution(contribution, defaults) {
+    const actionContributions = normalizeActionContributions(contribution.actions, defaults);
+    const modelContributions = normalizeModelContributions(contribution.models, defaults);
+    const fieldBindingContexts = normalizeFieldBindingContexts(contribution.fieldBindingContexts);
+    const fieldBindings = normalizeFieldBindings(contribution.fieldBindings);
+    const inventory = normalizeInventoryContribution(contribution.inventory);
+    if (actionContributions.length > 0) {
+      this.flowSchemaService.registerActionContributions(actionContributions);
+    }
+    if (modelContributions.length > 0) {
+      this.flowSchemaService.registerModelContributions(modelContributions);
+    }
+    if (fieldBindingContexts.length > 0) {
+      this.flowSchemaService.registerFieldBindingContexts(fieldBindingContexts);
+    }
+    if (fieldBindings.length > 0) {
+      this.flowSchemaService.registerFieldBindings(fieldBindings, defaults.source);
+    }
+    if (inventory) {
+      this.flowSchemaService.registerInventory(inventory, defaults.source);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowSchemaContributionCollector
+});

package/dist/server/flow-models/validation-facade.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { FlowSchemaService } from '../flow-schema-service';
+import FlowModelRepository from '../repository';
+export declare class FlowModelValidationFacade {
+    private readonly flowSchemaService;
+    private readonly app;
+    constructor(flowSchemaService: FlowSchemaService, app: any);
+    prepareEnsureValues(values: any, repository: FlowModelRepository, options?: {
+        transaction?: any;
+    }): Promise<any>;
+    assertValidFlowModelSchema(values: any, options?: {
+        allowRootObjectLocator?: boolean;
+    }): any;
+    assertValidFlowModelSchemaForSave(values: any, repository: FlowModelRepository): Promise<any>;
+    validateNormalizedFlowModelSchema(normalizedValues: any, options?: {
+        allowRootObjectLocator?: boolean;
+        existingNodeUids?: ReadonlySet<string>;
+    }): any;
+    private getExistingFlowModelSaveTreeMetadata;
+    private patchExistingFlowModelUses;
+    private toValidationError;
+}