@nocobase/plugin-flow-engine 2.1.0-alpha.2 → 2.1.0-alpha.20

package/dist/server/flow-surfaces/template-service-utils.d.ts

@@ -0,0 +1,62 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import _ from 'lodash';
+import type { FlowSurfaceWriteTarget } from './types';
+export type FlowSurfaceTemplateRow = {
+    uid: string;
+    name?: string;
+    description?: string;
+    targetUid?: string;
+    useModel?: string;
+    type?: string;
+    dataSourceKey?: string;
+    collectionName?: string;
+    associationName?: string;
+    filterByTk?: string;
+    sourceId?: string;
+    usageCount?: number;
+    available?: boolean;
+    disabledReason?: string;
+};
+export type FlowSurfaceTemplateListValues = {
+    search?: string;
+    filter?: Record<string, any>;
+    sort?: string | string[];
+    page?: number;
+    pageSize?: number;
+    target?: FlowSurfaceWriteTarget;
+    type?: 'block' | 'popup';
+    usage?: 'block' | 'fields';
+    actionType?: string;
+    actionScope?: 'block' | 'record';
+};
+export type FlowSurfaceTemplateListPopupActionContext = {
+    hasCurrentRecord?: boolean;
+};
+export declare const FLOW_TEMPLATE_SUPPORTED_TYPES: Set<string>;
+export declare const FLOW_TEMPLATE_SUPPORTED_MODES: Set<string>;
+export declare const FLOW_TEMPLATE_BLOCK_USAGES: Set<string>;
+export declare const FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES: Set<string>;
+export declare const POPUP_HOST_STEP_PARAM_PATHS: readonly [readonly ["popupSettings", "openView"], readonly ["selectExitRecordSettings", "openView"], readonly ["openSelectRecordView", "openView"], readonly ["openAddRecordView", "openView"]];
+export declare function normalizeTemplateUidValue(actionName: string, values: Record<string, any>): string;
+export declare function normalizeRequiredTemplateString(actionName: string, value: any, field: string): string;
+export declare function normalizeTemplateSaveMode(actionName: string, value: any): "duplicate" | "convert";
+export declare function buildTemplateListFilter(existingFilter: any, search: any, requestedType?: 'block' | 'popup'): any;
+export declare function findFlowTemplateOpenViewStep(node: any): {
+    flowKey: "popupSettings" | "selectExitRecordSettings" | "openSelectRecordView" | "openAddRecordView";
+    stepKey: "openView";
+    openView: any;
+};
+export declare function buildFlowTemplateReferenceBlockStepParams(template: FlowSurfaceTemplateRow, templateTargetUid: string, resourceInit?: Record<string, any>): _.Dictionary<any>;
+export declare function collectFlowTemplateUsageMapFromModelOptions(modelUid: string, options: any, carry?: Map<string, Set<string>>): Map<string, Set<string>>;
+export declare function collectFlowTemplateModelUids(node: any, carry?: Set<string>): Set<string>;
+export declare function replaceFlowModelTreeUids(node: any, uidMap: Record<string, string>): any;
+export declare function stripTemplateInternalOpenViewFields(openView: any): any;
+export declare function stripTemplateInternalReferenceSettings(node: any): void;
+export declare function findFieldsTemplateReferenceGrid(node: any): import("./types").FlowSurfaceNodeSpec;

package/dist/server/flow-surfaces/template-service-utils.js

@@ -0,0 +1,281 @@
+/**
+ * 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 template_service_utils_exports = {};
+__export(template_service_utils_exports, {
+  FLOW_TEMPLATE_BLOCK_USAGES: () => FLOW_TEMPLATE_BLOCK_USAGES,
+  FLOW_TEMPLATE_SUPPORTED_MODES: () => FLOW_TEMPLATE_SUPPORTED_MODES,
+  FLOW_TEMPLATE_SUPPORTED_TYPES: () => FLOW_TEMPLATE_SUPPORTED_TYPES,
+  FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES: () => FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES,
+  POPUP_HOST_STEP_PARAM_PATHS: () => POPUP_HOST_STEP_PARAM_PATHS,
+  buildFlowTemplateReferenceBlockStepParams: () => buildFlowTemplateReferenceBlockStepParams,
+  buildTemplateListFilter: () => buildTemplateListFilter,
+  collectFlowTemplateModelUids: () => collectFlowTemplateModelUids,
+  collectFlowTemplateUsageMapFromModelOptions: () => collectFlowTemplateUsageMapFromModelOptions,
+  findFieldsTemplateReferenceGrid: () => findFieldsTemplateReferenceGrid,
+  findFlowTemplateOpenViewStep: () => findFlowTemplateOpenViewStep,
+  normalizeRequiredTemplateString: () => normalizeRequiredTemplateString,
+  normalizeTemplateSaveMode: () => normalizeTemplateSaveMode,
+  normalizeTemplateUidValue: () => normalizeTemplateUidValue,
+  replaceFlowModelTreeUids: () => replaceFlowModelTreeUids,
+  stripTemplateInternalOpenViewFields: () => stripTemplateInternalOpenViewFields,
+  stripTemplateInternalReferenceSettings: () => stripTemplateInternalReferenceSettings
+});
+module.exports = __toCommonJS(template_service_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_service_helpers = require("./service-helpers");
+var import_service_utils = require("./service-utils");
+var import_errors = require("./errors");
+const FLOW_TEMPLATE_SUPPORTED_TYPES = /* @__PURE__ */ new Set(["block", "popup"]);
+const FLOW_TEMPLATE_SUPPORTED_MODES = /* @__PURE__ */ new Set(["reference", "copy"]);
+const FLOW_TEMPLATE_BLOCK_USAGES = /* @__PURE__ */ new Set(["block", "fields"]);
+const FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES = /* @__PURE__ */ new Set([
+  "ApplyTaskCardDetailsModel",
+  "ApprovalTaskCardDetailsModel"
+]);
+const POPUP_HOST_STEP_PARAM_PATHS = [
+  ["popupSettings", "openView"],
+  ["selectExitRecordSettings", "openView"],
+  ["openSelectRecordView", "openView"],
+  ["openAddRecordView", "openView"]
+];
+function normalizeTemplateUidValue(actionName, values) {
+  const templateUid = String((values == null ? void 0 : values.filterByTk) || (values == null ? void 0 : values.uid) || "").trim();
+  if (!templateUid) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} template uid is required`, "FLOW_SURFACE_TEMPLATE_UID_REQUIRED");
+  }
+  return templateUid;
+}
+function normalizeRequiredTemplateString(actionName, value, field) {
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${field} is required`, "FLOW_SURFACE_TEMPLATE_REQUIRED_FIELD");
+  }
+  return normalized;
+}
+function normalizeTemplateSaveMode(actionName, value) {
+  const normalized = String(value || "duplicate").trim() || "duplicate";
+  if (normalized !== "duplicate" && normalized !== "convert") {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} saveMode only supports 'duplicate' or 'convert'`,
+      "FLOW_SURFACE_TEMPLATE_SAVE_MODE_UNSUPPORTED"
+    );
+  }
+  return normalized;
+}
+function buildTemplateListFilter(existingFilter, search, requestedType) {
+  const typeFilter = requestedType ? { type: requestedType } : void 0;
+  return (0, import_service_helpers.buildFlowTemplateSearchFilter)(
+    existingFilter && typeFilter ? { $and: [existingFilter, typeFilter] } : existingFilter || typeFilter,
+    search
+  );
+}
+function findFlowTemplateOpenViewStep(node) {
+  for (const [flowKey, stepKey] of POPUP_HOST_STEP_PARAM_PATHS) {
+    const openView = import_lodash.default.get(node, ["stepParams", flowKey, stepKey]);
+    if (import_lodash.default.isPlainObject(openView)) {
+      return {
+        flowKey,
+        stepKey,
+        openView
+      };
+    }
+  }
+  return null;
+}
+function buildFlowTemplateReferenceBlockStepParams(template, templateTargetUid, resourceInit) {
+  const normalizedResourceInit = (0, import_service_utils.buildDefinedPayload)(resourceInit || {});
+  return (0, import_service_utils.buildDefinedPayload)({
+    referenceSettings: {
+      target: {
+        targetUid: templateTargetUid,
+        mode: "reference"
+      },
+      useTemplate: {
+        templateUid: template.uid,
+        templateName: template.name,
+        templateDescription: template.description,
+        targetUid: templateTargetUid,
+        mode: "reference"
+      }
+    },
+    ...Object.keys(normalizedResourceInit).length ? {
+      resourceSettings: {
+        init: normalizedResourceInit
+      }
+    } : {}
+  });
+}
+function collectFlowTemplateUsageMapFromModelOptions(modelUid, options, carry = /* @__PURE__ */ new Map()) {
+  const normalizedModelUid = String(modelUid || "").trim();
+  if (!normalizedModelUid) {
+    return carry;
+  }
+  const addUsage = (templateUid) => {
+    var _a;
+    const normalizedTemplateUid = String(templateUid || "").trim();
+    if (!normalizedTemplateUid) {
+      return;
+    }
+    if (!carry.has(normalizedModelUid)) {
+      carry.set(normalizedModelUid, /* @__PURE__ */ new Set());
+    }
+    (_a = carry.get(normalizedModelUid)) == null ? void 0 : _a.add(normalizedTemplateUid);
+  };
+  const normalizedOptions = import_lodash.default.isPlainObject(options) || Array.isArray(options) ? options : typeof options === "string" ? JSON.parse(options) : {};
+  const useTemplate = import_lodash.default.get(normalizedOptions, ["stepParams", "referenceSettings", "useTemplate"]);
+  const useTemplateUid = String((useTemplate == null ? void 0 : useTemplate.templateUid) || "").trim();
+  const useTemplateMode = String((useTemplate == null ? void 0 : useTemplate.mode) || "reference").trim() || "reference";
+  if (useTemplateUid && useTemplateMode !== "copy") {
+    addUsage(useTemplateUid);
+  }
+  const popupGroups = [
+    import_lodash.default.get(normalizedOptions, ["stepParams", "popupSettings"]),
+    import_lodash.default.get(normalizedOptions, ["stepParams", "selectExitRecordSettings"])
+  ];
+  for (const group of popupGroups) {
+    if (!group || typeof group !== "object") {
+      continue;
+    }
+    for (const value of Object.values(group)) {
+      const popupTemplateUid = String((value == null ? void 0 : value.popupTemplateUid) || "").trim();
+      const popupTemplateMode = String((value == null ? void 0 : value.popupTemplateMode) || "reference").trim() || "reference";
+      if (popupTemplateUid && popupTemplateMode !== "copy") {
+        addUsage(popupTemplateUid);
+      }
+    }
+  }
+  return carry;
+}
+function collectFlowTemplateModelUids(node, carry = /* @__PURE__ */ new Set()) {
+  if (!(node == null ? void 0 : node.uid)) {
+    return carry;
+  }
+  carry.add(String(node.uid));
+  for (const child of Object.values(node.subModels || {})) {
+    for (const item of import_lodash.default.castArray(child)) {
+      collectFlowTemplateModelUids(item, carry);
+    }
+  }
+  return carry;
+}
+function replaceFlowModelTreeUids(node, uidMap) {
+  const replaceInPlace = (value) => {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        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 typeof value === "string" && uidMap[value] ? uidMap[value] : value;
+  };
+  const walk = (current) => {
+    if (!current || typeof current !== "object") {
+      return current;
+    }
+    if (typeof current.uid === "string" && uidMap[current.uid]) {
+      current.uid = uidMap[current.uid];
+    }
+    if (typeof current.parent === "string" && uidMap[current.parent]) {
+      current.parent = uidMap[current.parent];
+    }
+    if (typeof current.parentId === "string" && uidMap[current.parentId]) {
+      current.parentId = uidMap[current.parentId];
+    }
+    if (current.stepParams) {
+      current.stepParams = replaceInPlace(current.stepParams);
+    }
+    Object.values(current.subModels || {}).forEach((child) => {
+      import_lodash.default.castArray(child).forEach((item) => walk(item));
+    });
+    return current;
+  };
+  return walk(import_lodash.default.cloneDeep(node));
+}
+function stripTemplateInternalOpenViewFields(openView) {
+  if (!import_lodash.default.isPlainObject(openView)) {
+    return openView;
+  }
+  const hasTemplateState = !!String(openView.popupTemplateUid || "").trim() || !!openView.popupTemplateContext || !!String(openView.popupTemplateMode || "").trim();
+  return import_lodash.default.omit(openView, [
+    "popupTemplateUid",
+    "popupTemplateMode",
+    "popupTemplateContext",
+    "popupTemplateHasFilterByTk",
+    "popupTemplateHasSourceId",
+    ...hasTemplateState ? ["uid"] : []
+  ]);
+}
+function stripTemplateInternalReferenceSettings(node) {
+  var _a;
+  if (!import_lodash.default.isPlainObject((_a = node == null ? void 0 : node.stepParams) == null ? void 0 : _a.referenceSettings)) {
+    return;
+  }
+  delete node.stepParams.referenceSettings;
+  if (import_lodash.default.isPlainObject(node.stepParams) && !Object.keys(node.stepParams).length) {
+    delete node.stepParams;
+  }
+}
+function findFieldsTemplateReferenceGrid(node) {
+  var _a;
+  return (0, import_service_utils.getSingleNodeSubModel)((_a = node == null ? void 0 : node.subModels) == null ? void 0 : _a.grid);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_TEMPLATE_BLOCK_USAGES,
+  FLOW_TEMPLATE_SUPPORTED_MODES,
+  FLOW_TEMPLATE_SUPPORTED_TYPES,
+  FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES,
+  POPUP_HOST_STEP_PARAM_PATHS,
+  buildFlowTemplateReferenceBlockStepParams,
+  buildTemplateListFilter,
+  collectFlowTemplateModelUids,
+  collectFlowTemplateUsageMapFromModelOptions,
+  findFieldsTemplateReferenceGrid,
+  findFlowTemplateOpenViewStep,
+  normalizeRequiredTemplateString,
+  normalizeTemplateSaveMode,
+  normalizeTemplateUidValue,
+  replaceFlowModelTreeUids,
+  stripTemplateInternalOpenViewFields,
+  stripTemplateInternalReferenceSettings
+});

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

@@ -0,0 +1,287 @@
+/**
+ * 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 { FLOW_SURFACE_MUTATE_OP_TYPES, FLOW_SURFACE_PLAN_STEP_ACTIONS } from './constants';
+export type FlowSurfaceNodeDomain = 'props' | 'decoratorProps' | 'stepParams' | 'flowRegistry';
+export type FlowSurfaceMergeStrategy = 'deep' | 'replace';
+export type FlowSurfaceActionScope = 'block' | 'record' | 'form' | 'filterForm' | 'actionPanel';
+export type FlowSurfaceContainerKind = 'page' | 'tab' | 'grid' | 'block' | 'node';
+export type FlowSurfaceReadLocator = {
+    uid?: string;
+    pageSchemaUid?: string;
+    tabSchemaUid?: string;
+    routeId?: string;
+};
+export type FlowSurfacePlanStepLink = {
+    step: string;
+    path?: string;
+};
+export type FlowSurfaceKeySelector = {
+    key: string;
+};
+export type FlowSurfaceLocatorSelector = {
+    locator: FlowSurfaceReadLocator;
+};
+export type FlowSurfaceSurfaceSelector = FlowSurfaceKeySelector | FlowSurfaceLocatorSelector;
+export type FlowSurfacePlanSelector = FlowSurfaceSurfaceSelector | FlowSurfacePlanStepLink;
+export type FlowSurfaceBindKey = {
+    key: string;
+    locator: FlowSurfaceReadLocator;
+    expectedKind?: 'page' | 'tab' | 'grid' | 'block' | 'fieldHost' | 'action' | 'popupHost' | 'popupPage' | 'popupTab' | 'node';
+    rebind?: boolean;
+};
+export type FlowSurfaceWriteTarget = {
+    uid: string;
+};
+export type FlowSurfaceResolveTarget = FlowSurfaceReadLocator | FlowSurfaceWriteTarget;
+export type FlowSurfaceConfigureOptionValueType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+export type FlowSurfaceConfigureOption = {
+    type: FlowSurfaceConfigureOptionValueType;
+    description?: string;
+    enum?: Array<string | number | boolean>;
+    example?: any;
+    supportsFlowContext?: boolean;
+};
+export type FlowSurfaceConfigureOptions = Record<string, FlowSurfaceConfigureOption>;
+export type FlowSurfaceReadTarget = {
+    locator: FlowSurfaceReadLocator;
+    uid: string;
+    kind: FlowSurfaceContainerKind;
+};
+export type FlowSurfaceDomainContract = {
+    allowedKeys: string[];
+    wildcard?: boolean;
+    mergeStrategy: FlowSurfaceMergeStrategy;
+    schema: Record<string, any>;
+    groups?: Record<string, FlowSurfaceDomainGroupContract>;
+};
+export type FlowSurfaceEventCapabilities = {
+    direct?: string[];
+    object?: string[];
+};
+export type FlowSurfaceDomainGroupContract = {
+    allowedPaths: string[];
+    clearable?: boolean;
+    mergeStrategy: FlowSurfaceMergeStrategy;
+    schema: Record<string, any>;
+    eventBindingSteps?: string[] | '*';
+    pathSchemas?: Record<string, Record<string, any>>;
+};
+export type FlowSurfaceEventBindingContract = {
+    stepKeys?: string[] | '*';
+};
+export type FlowSurfaceLayoutCapabilities = {
+    supported: boolean;
+};
+export type FlowSurfaceNodeContract = {
+    editableDomains: FlowSurfaceNodeDomain[];
+    domains: Partial<Record<FlowSurfaceNodeDomain, FlowSurfaceDomainContract>>;
+    eventCapabilities?: FlowSurfaceEventCapabilities;
+    layoutCapabilities?: FlowSurfaceLayoutCapabilities;
+    eventBindings?: Record<string, FlowSurfaceEventBindingContract>;
+};
+export type FlowSurfaceResourceBindingKey = 'currentCollection' | 'currentRecord' | 'associatedRecords' | 'otherRecords';
+export type FlowSurfaceResourceBindingAssociationField = {
+    key: string;
+    label: string;
+    collectionName: string;
+    associationName?: string;
+};
+export type FlowSurfaceResourceBindingOption = {
+    key: FlowSurfaceResourceBindingKey;
+    label: string;
+    description?: string;
+    requires?: string[];
+    dataSourceKey?: string;
+    collectionName?: string;
+    associationFields?: FlowSurfaceResourceBindingAssociationField[];
+};
+export type FlowSurfaceSemanticResourceInput = {
+    binding: FlowSurfaceResourceBindingKey;
+    dataSourceKey?: string;
+    collectionName?: string;
+    associationField?: string;
+};
+export type FlowSurfaceCatalogItem = {
+    key: string;
+    label: string;
+    use: string;
+    kind: 'page' | 'tab' | 'block' | 'field' | 'action';
+    scope?: FlowSurfaceActionScope;
+    scene?: string;
+    requiredInitParams?: string[];
+    allowedContainerUses?: string[];
+    editableDomains?: FlowSurfaceNodeDomain[];
+    settingsSchema?: Record<string, any>;
+    settingsContract?: Partial<Record<FlowSurfaceNodeDomain, FlowSurfaceDomainContract>>;
+    configureOptions?: FlowSurfaceConfigureOptions;
+    resourceBindings?: FlowSurfaceResourceBindingOption[];
+    eventCapabilities?: FlowSurfaceEventCapabilities;
+    layoutCapabilities?: FlowSurfaceLayoutCapabilities;
+    createSupported?: boolean;
+    fieldUse?: string;
+    wrapperUse?: string;
+    renderer?: string;
+    type?: string;
+    associationPathName?: string;
+    defaultTargetUid?: string;
+    targetBlockUid?: string;
+};
+export type FlowSurfaceCatalogSection = 'blocks' | 'fields' | 'actions' | 'recordActions' | 'node';
+export type FlowSurfaceCatalogExpand = 'item.configureOptions' | 'item.contracts' | 'item.allowedContainerUses' | 'node.contracts';
+export type FlowSurfaceCatalogPopupScenario = {
+    kind: 'plainPopup' | 'recordPopup' | 'associationPopup';
+    scene: 'new' | 'one' | 'many' | 'select' | 'subForm' | 'bulkEditForm' | 'generic';
+    hasCurrentRecord: boolean;
+    hasAssociationContext: boolean;
+};
+export type FlowSurfaceCatalogFieldContainerScenario = {
+    kind: 'form' | 'details' | 'table' | 'filter-form';
+    targetMode?: 'single' | 'multiple';
+};
+export type FlowSurfaceCatalogActionContainerScenario = {
+    scope: FlowSurfaceActionScope;
+    ownerUse?: string;
+    recordActionContainerUse?: string;
+};
+export type FlowSurfaceCatalogScenario = {
+    surfaceKind: 'global' | FlowSurfaceContainerKind;
+    popup?: FlowSurfaceCatalogPopupScenario;
+    fieldContainer?: FlowSurfaceCatalogFieldContainerScenario;
+    actionContainer?: FlowSurfaceCatalogActionContainerScenario;
+};
+export type FlowSurfaceCatalogNodeInfo = {
+    editableDomains: FlowSurfaceNodeDomain[];
+    configureOptions: FlowSurfaceConfigureOptions;
+    settingsSchema?: Record<string, any>;
+    settingsContract?: Partial<Record<FlowSurfaceNodeDomain, FlowSurfaceDomainContract>>;
+    eventCapabilities?: FlowSurfaceEventCapabilities;
+    layoutCapabilities?: FlowSurfaceLayoutCapabilities;
+};
+export type FlowSurfaceCatalogValues = {
+    target?: FlowSurfaceWriteTarget;
+    sections?: FlowSurfaceCatalogSection[];
+    expand?: FlowSurfaceCatalogExpand[];
+};
+export type FlowSurfaceResolvedTarget = {
+    target: FlowSurfaceResolveTarget;
+    uid: string;
+    kind: FlowSurfaceContainerKind;
+    node?: any;
+    route?: any;
+    pageRoute?: any;
+    tabRoute?: any;
+    pageModel?: any;
+};
+export type FlowSurfaceCatalogResponse = {
+    target: FlowSurfaceResolvedTarget | null;
+    scenario: FlowSurfaceCatalogScenario;
+    selectedSections: FlowSurfaceCatalogSection[];
+    blocks?: FlowSurfaceCatalogItem[];
+    fields?: FlowSurfaceCatalogItem[];
+    actions?: FlowSurfaceCatalogItem[];
+    recordActions?: FlowSurfaceCatalogItem[];
+    node?: FlowSurfaceCatalogNodeInfo;
+};
+export type FlowSurfaceNodeSpec = {
+    uid?: string;
+    clientKey?: string;
+    sortIndex?: number;
+    async?: boolean;
+    use: string;
+    popup?: Record<string, any>;
+    props?: Record<string, any>;
+    decoratorProps?: Record<string, any>;
+    stepParams?: Record<string, any>;
+    flowRegistry?: Record<string, any>;
+    subModels?: Record<string, FlowSurfaceNodeSpec | FlowSurfaceNodeSpec[]>;
+};
+export type FlowSurfaceNodeSubModel = FlowSurfaceNodeSpec | FlowSurfaceNodeSpec[];
+export type FlowSurfaceNodeDefaults = Partial<Pick<FlowSurfaceNodeSpec, 'async' | 'props' | 'decoratorProps' | 'stepParams' | 'flowRegistry' | 'subModels'>>;
+export type FlowSurfaceApplyMode = 'replace';
+export type FlowSurfaceComposeMode = 'append' | 'replace';
+export type FlowSurfaceApplySpec = {
+    popup?: Record<string, any>;
+    props?: Record<string, any>;
+    decoratorProps?: Record<string, any>;
+    stepParams?: Record<string, any>;
+    flowRegistry?: Record<string, any>;
+    subModels?: Record<string, FlowSurfaceNodeSpec | FlowSurfaceNodeSpec[]>;
+};
+export type FlowSurfaceAtomicFlag = true;
+export type FlowSurfaceMutateValues = {
+    ops?: FlowSurfaceMutateOp[];
+    atomic?: true;
+};
+export type FlowSurfaceApplyValues = {
+    target: FlowSurfaceWriteTarget;
+    spec: FlowSurfaceApplySpec;
+    mode?: 'replace';
+};
+export type FlowSurfaceComposeValues = {
+    target: FlowSurfaceWriteTarget;
+    mode?: FlowSurfaceComposeMode;
+    blocks?: Array<Record<string, any>>;
+    layout?: Record<string, any>;
+};
+export type FlowSurfaceConfigureValues = {
+    target: FlowSurfaceWriteTarget;
+    changes: Record<string, any>;
+};
+export type FlowSurfaceContextVarInfo = {
+    title?: string;
+    type?: string;
+    interface?: string;
+    description?: string;
+    enumValues?: string[];
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    disabledReason?: string;
+    properties?: Record<string, FlowSurfaceContextVarInfo>;
+};
+export type FlowSurfaceContextValues = {
+    target: FlowSurfaceWriteTarget;
+    path?: string;
+    maxDepth?: number;
+};
+export type FlowSurfaceContextResponse = {
+    vars: Record<string, FlowSurfaceContextVarInfo>;
+};
+export type FlowSurfaceDescribeValues = {
+    locator: FlowSurfaceReadLocator;
+    bindKeys?: FlowSurfaceBindKey[];
+};
+export type FlowSurfacePlanStepAction = (typeof FLOW_SURFACE_PLAN_STEP_ACTIONS)[number];
+export type FlowSurfacePlanStep = {
+    id?: string;
+    action: FlowSurfacePlanStepAction;
+    selectors?: {
+        target?: FlowSurfacePlanSelector;
+        source?: FlowSurfacePlanSelector;
+    };
+    values?: Record<string, any>;
+};
+export type FlowSurfacePlanRequestValues = {
+    surface?: FlowSurfaceSurfaceSelector;
+    plan: {
+        steps?: FlowSurfacePlanStep[];
+    };
+};
+export type FlowSurfaceMutateOpType = (typeof FLOW_SURFACE_MUTATE_OP_TYPES)[number];
+export type FlowSurfaceMutateOp = {
+    opId?: string;
+    type: FlowSurfaceMutateOpType;
+    target?: FlowSurfaceWriteTarget;
+    values?: Record<string, any>;
+};
+export type FlowSurfaceExecutorContext = {
+    transaction?: any;
+    keys: Map<string, any>;
+    clientKeyToUid: Record<string, string>;
+};

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

@@ -0,0 +1,24 @@
+/**
+ * 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 __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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/server/index.d.ts

@@ -8,3 +8,4 @@
  */
 export { default } from './plugin';
 export { FlowModelRepository } from './repository';
+export { resolveVariablesBatch, resolveVariablesTemplate } from './variables/resolve';

package/dist/server/index.js

@@ -37,12 +37,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var server_exports = {};
 __export(server_exports, {
   FlowModelRepository: () => import_repository.FlowModelRepository,
-  default: () => import_plugin.default
+  default: () => import_plugin.default,
+  resolveVariablesBatch: () => import_resolve.resolveVariablesBatch,
+  resolveVariablesTemplate: () => import_resolve.resolveVariablesTemplate
 });
 module.exports = __toCommonJS(server_exports);
 var import_plugin = __toESM(require("./plugin"));
 var import_repository = require("./repository");
+var import_resolve = require("./variables/resolve");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  FlowModelRepository
+  FlowModelRepository,
+  resolveVariablesBatch,
+  resolveVariablesTemplate
 });