@nocobase/plugin-flow-engine 2.2.0-beta.2 → 2.2.0-beta.5

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

@@ -56,6 +56,7 @@ var import_executor = require("./executor");
 var import_reference_guards = require("./reference-guards");
 var import_key_registry = require("./planning/key-registry");
 var import_blueprint = require("./blueprint");
+var import_export_document = require("./blueprint/export-document");
 var import_compile_blocks = require("./blueprint/compile-blocks");
 var import_default_block_actions = require("./default-block-actions");
 var import_template_reference = require("./template-reference");
@@ -96,6 +97,7 @@ var import_meta = require("./reaction/meta");
 var import_resolver = require("./reaction/resolver");
 var import_association_title_field = require("./association-title-field");
 var import_default_action_popup = require("./default-action-popup");
+var import_relation_backing_foreign_key = require("./relation-backing-foreign-key");
 var import_defaults = require("./blueprint/defaults");
 var import_service_utils = require("./service-utils");
 var import_field_type_resolver = require("./field-type-resolver");
@@ -229,9 +231,11 @@ function isFlowSurfaceChartRepairError(error) {
   var _a, _b;
   return error instanceof import_errors.FlowSurfaceBadRequestError && ((_b = (_a = error.options) == null ? void 0 : _a.details) == null ? void 0 : _b.repairHint) === FLOW_SURFACE_CHART_REPAIR_HINT;
 }
+const FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE = "exportBlueprint v1 only supports root page export";
 const FORM_BLOCK_USES = /* @__PURE__ */ new Set(["FormBlockModel", "CreateFormModel", "EditFormModel", ...import_approval.APPROVAL_FORM_BLOCK_USES]);
 const AUTO_SUBMIT_FORM_BLOCK_USES = /* @__PURE__ */ new Set(["CreateFormModel", "EditFormModel"]);
 const FLOW_SURFACE_DEFAULT_ACTION_SETTINGS_KEYS = /* @__PURE__ */ new Set(["filter"]);
+const ACTION_BUTTON_GENERAL_SETTING_KEYS = ["title", "tooltip", "icon", "iconOnly", "type", "danger", "color"];
 const DETAILS_BLOCK_USES = /* @__PURE__ */ new Set(["DetailsBlockModel", ...import_approval.APPROVAL_DETAILS_BLOCK_USES]);
 const SIMPLE_FORM_BLOCK_USES = /* @__PURE__ */ new Set([
   "FormBlockModel",
@@ -1945,6 +1949,9 @@ class FlowSurfacesService {
     if (!(popupProfile == null ? void 0 : popupProfile.currentCollection)) {
       return popupProfile == null ? void 0 : popupProfile.filterByTk;
     }
+    if (popupProfile.popupKind === "recordPopup" && popupProfile.popupHostUse && POPUP_HOST_DEFAULT_RECORD_CONTEXT_ACTION_USES.has(popupProfile.popupHostUse)) {
+      return "{{ctx.view.inputArgs.filterByTk}}";
+    }
     if (popupProfile.popupKind !== "associationPopup") {
       return popupProfile.filterByTk;
     }
@@ -2300,10 +2307,18 @@ class FlowSurfacesService {
       if (!sameCurrentCollection || !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.filterByTk)) {
         return false;
       }
+      const expectedFilterByTk = this.resolvePopupCurrentRecordResourceFilterByTk(input.popupProfile, {
+        usePopupInputArgsWhenSourceIdInferred: true
+      });
+      const matchesCurrentRecordFilterByTk = this.isPopupCurrentRecordFilterByTkMatch(
+        input.popupProfile,
+        normalized.filterByTk,
+        expectedFilterByTk
+      );
       if (input.popupProfile.hasAssociationContext) {
-        return this.isSameConfiguredFlowContextValue(normalized.filterByTk, input.popupProfile.filterByTk) && normalized.associationName === input.popupProfile.associationName && this.isSameConfiguredFlowContextValue(normalized.sourceId, input.popupProfile.sourceId);
+        return matchesCurrentRecordFilterByTk && normalized.associationName === input.popupProfile.associationName && this.isSameConfiguredFlowContextValue(normalized.sourceId, input.popupProfile.sourceId);
       }
-      return this.isSameConfiguredFlowContextValue(normalized.filterByTk, input.popupProfile.filterByTk) && !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.associationName) && !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.sourceId);
+      return matchesCurrentRecordFilterByTk && !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.associationName) && !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.sourceId);
     }
     if (input.binding === "associatedRecords") {
       if (!(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.collectionName) || !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.associationName) || !(0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.sourceId) || (0, import_service_helpers.hasConfiguredFlowContextValue)(normalized.filterByTk)) {
@@ -2346,6 +2361,12 @@ class FlowSurfacesService {
     }
     return import_lodash.default.isEqual(this.normalizeFlowContextTemplateValue(left), this.normalizeFlowContextTemplateValue(right));
   }
+  isPopupCurrentRecordFilterByTkMatch(popupProfile, filterByTk, expectedFilterByTk) {
+    if (this.isSameConfiguredFlowContextValue(filterByTk, expectedFilterByTk)) {
+      return true;
+    }
+    return popupProfile.popupKind === "associationPopup" && this.isSameConfiguredFlowContextValue(filterByTk, popupProfile.filterByTk);
+  }
   isPopupAssociatedRecordsSourceIdMatch(popupProfile, associationField, sourceId) {
     var _a, _b;
     if (!(0, import_service_helpers.hasConfiguredFlowContextValue)(sourceId)) {
@@ -2621,6 +2642,28 @@ class FlowSurfacesService {
     }
     return capability;
   }
+  async getLiveFieldValueCapability(writeTarget, resolvedTarget, node, options = {}) {
+    const context = await this.context(
+      {
+        target: writeTarget
+      },
+      options
+    );
+    const { capabilities } = (0, import_meta.buildReactionMetaCapabilities)({
+      resolvedTarget: {
+        ...resolvedTarget,
+        node
+      },
+      context
+    });
+    const capability = capabilities.find((item) => item.kind === "fieldValue");
+    if (!capability) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces reaction target '${resolvedTarget.use || resolvedTarget.target.uid}' does not support fieldValue`
+      );
+    }
+    return capability;
+  }
   async getReactionMeta(values, options = {}) {
     (0, import_payload_shape.validateFlowSurfacePayloadShape)("getReactionMeta", values, "values");
     const { writeTarget, node, resolvedTarget } = await this.resolveReactionRequest("getReactionMeta", values == null ? void 0 : values.target, {
@@ -2666,6 +2709,8 @@ class FlowSurfacesService {
       },
       rules: Array.isArray(values == null ? void 0 : values.rules) ? values.rules : []
     });
+    const liveCapability = await this.getLiveFieldValueCapability(writeTarget, resolvedTarget, node, options);
+    (0, import_field_value.validateFieldValueRulesAgainstCapability)(result.normalizedRules, liveCapability);
     await this.persistReactionSlot(storageNode, capability.resolvedSlot, result.canonicalRules, options);
     return result;
   }
@@ -2873,6 +2918,41 @@ class FlowSurfacesService {
     const publicNode = this.stripInternalSurfaceMetaFromNodeTree(import_lodash.default.cloneDeep(rawNode));
     return this.buildSurfaceReadPayload(target, resolved, publicNode, options);
   }
+  async exportBlueprint(input, options = {}) {
+    const request = this.normalizeExportBlueprintRequest(input);
+    const resolved = await this.locator.resolve(request.target, options);
+    if (resolved.kind !== "page" || !resolved.pageRoute) {
+      (0, import_errors.throwBadRequest)(FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE);
+    }
+    const pageSchemaUid = this.resolveExportBlueprintPageSchemaUid(request.target, resolved);
+    await this.assertExportBlueprintRootTarget(request.target, resolved, pageSchemaUid, options.transaction);
+    const rawNode = await this.decorateTemplateReadbackTree(
+      this.normalizePopupTreeShape(
+        await this.loadResolvedNode(resolved, options.transaction, {
+          persistCalendarPopupHosts: false
+        })
+      ),
+      options.transaction
+    );
+    if (!(rawNode == null ? void 0 : rawNode.uid)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint target '${pageSchemaUid}' could not resolve a readable page tree`);
+    }
+    const pageRoute = resolved.pageRoute ? await this.routeSync.hydrateRoute(resolved.pageRoute, options.transaction) : void 0;
+    const result = (0, import_export_document.exportFlowSurfaceBlueprintDocument)({
+      page: rawNode,
+      pageRoute,
+      target: {
+        pageSchemaUid
+      },
+      unsupportedPolicy: request.unsupportedPolicy
+    });
+    return {
+      ...result,
+      document: (0, import_blueprint.prepareFlowSurfaceApplyBlueprintDocument)(
+        result.document
+      )
+    };
+  }
   getDeclaredKeyPersistenceDeps() {
     return {
       findModelById: (uid2, findOptions) => this.repository.findModelById(uid2, findOptions),
@@ -4474,10 +4554,16 @@ class FlowSurfacesService {
     return this.buildPopupTemplateOpenView(template, "reference", templateTargetUid, options);
   }
   shouldHydrateDetachedPopupTemplateBlockResourceContext(blockNode, context) {
-    if (!this.isCollectionBlockUse(blockNode == null ? void 0 : blockNode.use) || !context.associationName || !context.sourceId) {
+    if (!this.isCollectionBlockUse(blockNode == null ? void 0 : blockNode.use)) {
       return false;
     }
     const init = import_lodash.default.get(blockNode, ["stepParams", "resourceSettings", "init"]) || {};
+    if (this.resolveDetachedPopupTemplateBlockCurrentRecordFilterByTk(init, context)) {
+      return true;
+    }
+    if (!context.associationName || !context.sourceId) {
+      return false;
+    }
     const popupDataSourceKey = context.dataSourceKey || "main";
     const blockDataSourceKey = init.dataSourceKey || "main";
     if (!context.collectionName || blockDataSourceKey !== popupDataSourceKey || init.collectionName !== context.collectionName) {
@@ -4492,6 +4578,28 @@ class FlowSurfacesService {
     }
     return blockAssociationName !== context.associationName || !this.isSameConfiguredFlowContextValue(init.sourceId, context.sourceId);
   }
+  resolveDetachedPopupTemplateBlockCurrentRecordFilterByTk(init, context) {
+    if (!(0, import_service_helpers.hasConfiguredFlowContextValue)(init.filterByTk)) {
+      return void 0;
+    }
+    if (this.isSameConfiguredFlowContextValue(init.filterByTk, "{{ctx.view.inputArgs.filterByTk}}")) {
+      return void 0;
+    }
+    const popupDataSourceKey = context.dataSourceKey || "main";
+    const blockDataSourceKey = init.dataSourceKey || "main";
+    if (!context.collectionName || blockDataSourceKey !== popupDataSourceKey || init.collectionName !== context.collectionName) {
+      return void 0;
+    }
+    if (context.filterByTk && this.isSameConfiguredFlowContextValue(init.filterByTk, context.filterByTk)) {
+      return "{{ctx.view.inputArgs.filterByTk}}";
+    }
+    const collection = this.getCollection(popupDataSourceKey, context.collectionName);
+    const filterTargetKey = this.getCollectionFilterTargetKey(collection);
+    if (this.isSameConfiguredFlowContextValue(init.filterByTk, `{{ctx.record.${filterTargetKey}}}`)) {
+      return "{{ctx.view.inputArgs.filterByTk}}";
+    }
+    return void 0;
+  }
   collectDetachedPopupTemplateBlockResourceContextPatches(node, context, patches = []) {
     if (!node || typeof node !== "object") {
       return patches;
@@ -4499,6 +4607,7 @@ class FlowSurfacesService {
     if (node.uid && this.shouldHydrateDetachedPopupTemplateBlockResourceContext(node, context)) {
       const nextStepParams = import_lodash.default.cloneDeep(node.stepParams || {});
       const currentInit = import_lodash.default.get(nextStepParams, ["resourceSettings", "init"]) || {};
+      const filterByTk = this.resolveDetachedPopupTemplateBlockCurrentRecordFilterByTk(currentInit, context);
       import_lodash.default.set(
         nextStepParams,
         ["resourceSettings", "init"],
@@ -4506,8 +4615,11 @@ class FlowSurfacesService {
           ...currentInit,
           dataSourceKey: context.dataSourceKey || currentInit.dataSourceKey || "main",
           collectionName: context.collectionName || currentInit.collectionName,
-          associationName: context.associationName,
-          sourceId: context.sourceId
+          ...context.associationName && context.sourceId ? {
+            associationName: context.associationName,
+            sourceId: context.sourceId
+          } : {},
+          ...filterByTk ? { filterByTk } : {}
         })
       );
       patches.push({
@@ -6679,11 +6791,6 @@ class FlowSurfacesService {
           requiredFieldCount: options.requiredFieldCount
         }
       );
-      if (!(0, import_service_utils.hasOwnDefined)(normalizedSettings, "filterableFieldNames")) {
-        normalizedSettings.filterableFieldNames = (0, import_public_data_surface_default_filter.resolveFlowSurfaceDefaultFilterFieldNames)(
-          normalizedSettings.defaultFilter
-        );
-      }
     }
     return normalizedSettings;
   }
@@ -11511,6 +11618,7 @@ class FlowSurfacesService {
       normalizedValues,
       nextPayload
     );
+    this.syncActionButtonSettingsForUpdateSettings(current, normalizedValues, nextPayload);
     this.syncActionTriggerWorkflowsForUpdateSettings(current, normalizedValues, nextPayload);
     const popupActionContext = options.popupActionContext || await this.resolveRecordContextPopupActionContextForHost(current, options.transaction);
     await this.normalizeOpenViewForUpdateSettings(
@@ -11972,17 +12080,6 @@ class FlowSurfacesService {
       const filterValue = this.normalizeEffectivePublicDataSurfaceDefaultFilter(normalizedFilterValue, {
         requiredFieldCount: options.requiredFieldCount
       });
-      if (!hasPropsFilterableFieldNames && !hasStepFilterableFieldNames) {
-        const filterableFieldNames = (0, import_public_data_surface_default_filter.resolveFlowSurfaceDefaultFilterFieldNames)(filterValue);
-        if (filterableFieldNames.length) {
-          nextProps.filterableFieldNames = filterableFieldNames;
-          import_lodash.default.set(
-            nextStepParams,
-            ["filterSettings", "filterableFieldNames", "filterableFieldNames"],
-            import_lodash.default.cloneDeep(filterableFieldNames)
-          );
-        }
-      }
       nextProps.defaultFilterValue = import_lodash.default.cloneDeep(filterValue);
       nextProps.filterValue = import_lodash.default.cloneDeep(filterValue);
       import_lodash.default.set(nextStepParams, ["filterSettings", "defaultFilter", "defaultFilter"], import_lodash.default.cloneDeep(filterValue));
@@ -12029,6 +12126,65 @@ class FlowSurfacesService {
       nextPayload.stepParams = nextStepParams;
     }
   }
+  syncActionButtonSettingsForUpdateSettings(current, normalizedValues, nextPayload) {
+    if (!this.supportsActionButtonSettingsSync(current)) {
+      return;
+    }
+    const requestedProps = this.pickRequestedActionButtonSettings(normalizedValues.props);
+    const requestedButtonGeneral = this.pickRequestedActionButtonSettings(
+      import_lodash.default.get(normalizedValues, ["stepParams", "buttonSettings", "general"])
+    );
+    const hasRequestedProps = Object.keys(requestedProps).length > 0;
+    const hasRequestedButtonGeneral = Object.keys(requestedButtonGeneral).length > 0;
+    if (!hasRequestedProps && !hasRequestedButtonGeneral) {
+      return;
+    }
+    const hasRequestedTitle = Object.prototype.hasOwnProperty.call(requestedProps, "title") || Object.prototype.hasOwnProperty.call(requestedButtonGeneral, "title");
+    const shouldStripImplicitTitle = (requestedProps.iconOnly === true || requestedButtonGeneral.iconOnly === true) && !hasRequestedTitle;
+    const nextProps = import_lodash.default.cloneDeep(
+      import_lodash.default.isPlainObject(nextPayload.props) ? nextPayload.props : import_lodash.default.isPlainObject(current == null ? void 0 : current.props) ? current.props : {}
+    );
+    const nextStepParams = import_lodash.default.cloneDeep(
+      import_lodash.default.isPlainObject(nextPayload.stepParams) ? nextPayload.stepParams : import_lodash.default.isPlainObject(current == null ? void 0 : current.stepParams) ? current.stepParams : {}
+    );
+    Object.entries(requestedProps).forEach(([key, value]) => {
+      if (Object.prototype.hasOwnProperty.call(requestedButtonGeneral, key)) {
+        return;
+      }
+      import_lodash.default.set(nextStepParams, ["buttonSettings", "general", key], import_lodash.default.cloneDeep(value));
+    });
+    Object.entries(requestedButtonGeneral).forEach(([key, value]) => {
+      if (Object.prototype.hasOwnProperty.call(requestedProps, key)) {
+        return;
+      }
+      nextProps[key] = import_lodash.default.cloneDeep(value);
+    });
+    if (shouldStripImplicitTitle) {
+      delete nextProps.title;
+      if (import_lodash.default.isPlainObject(import_lodash.default.get(nextStepParams, ["buttonSettings", "general"]))) {
+        delete nextStepParams.buttonSettings.general.title;
+      }
+    }
+    nextPayload.props = nextProps;
+    nextPayload.stepParams = nextStepParams;
+  }
+  supportsActionButtonSettingsSync(current) {
+    var _a, _b, _c, _d, _e, _f;
+    const contract = (0, import_catalog.getNodeContract)(current == null ? void 0 : current.use);
+    return ((_b = (_a = contract.domains.props) == null ? void 0 : _a.allowedKeys) == null ? void 0 : _b.includes("iconOnly")) && ((_f = (_e = (_d = (_c = contract.domains.stepParams) == null ? void 0 : _c.groups) == null ? void 0 : _d.buttonSettings) == null ? void 0 : _e.allowedPaths) == null ? void 0 : _f.includes("general.iconOnly"));
+  }
+  pickRequestedActionButtonSettings(input) {
+    const picked = {};
+    if (!import_lodash.default.isPlainObject(input)) {
+      return picked;
+    }
+    ACTION_BUTTON_GENERAL_SETTING_KEYS.forEach((key) => {
+      if (Object.prototype.hasOwnProperty.call(input, key) && !import_lodash.default.isUndefined(input[key])) {
+        picked[key] = import_lodash.default.cloneDeep(input[key]);
+      }
+    });
+    return picked;
+  }
   syncCreatedFieldWrapperTitleFieldStepParams(node) {
     const mirror = (UPDATE_SETTINGS_STEP_PARAM_MIRRORS_BY_USE[(node == null ? void 0 : node.use) || ""] || []).find(
       (item) => item.domain === "props" && item.key === "titleField"
@@ -13694,6 +13850,111 @@ class FlowSurfacesService {
     }
     return target;
   }
+  normalizeExportBlueprintRequest(input) {
+    if (!import_lodash.default.isPlainObject(input)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint payload must be an object`);
+    }
+    const unsupportedKeys = Object.keys(input).filter((key) => key !== "target" && key !== "options");
+    if (unsupportedKeys.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint only accepts target and options`);
+    }
+    if (!import_lodash.default.isPlainObject(input.target)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint requires target`);
+    }
+    const targetInput = input.target;
+    const target = (0, import_service_utils.buildDefinedPayload)({
+      uid: this.normalizeExportBlueprintLocatorValue(targetInput.uid, "uid"),
+      pageSchemaUid: this.normalizeExportBlueprintLocatorValue(targetInput.pageSchemaUid, "pageSchemaUid"),
+      tabSchemaUid: this.normalizeExportBlueprintLocatorValue(targetInput.tabSchemaUid, "tabSchemaUid"),
+      routeId: this.normalizeExportBlueprintLocatorValue(targetInput.routeId, "routeId")
+    });
+    const unsupportedTargetKeys = Object.keys(targetInput).filter(
+      (key) => !["uid", "pageSchemaUid", "tabSchemaUid", "routeId"].includes(key)
+    );
+    if (unsupportedTargetKeys.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint target only accepts uid, pageSchemaUid, tabSchemaUid or routeId`);
+    }
+    if (!Object.keys(target).length) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces exportBlueprint target requires one of uid, pageSchemaUid, tabSchemaUid or routeId`
+      );
+    }
+    if (Object.keys(target).length > 1) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces exportBlueprint target only accepts exactly one locator: uid, pageSchemaUid, tabSchemaUid or routeId`
+      );
+    }
+    if (target.tabSchemaUid) {
+      (0, import_errors.throwBadRequest)(FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE);
+    }
+    return {
+      target,
+      unsupportedPolicy: this.normalizeExportBlueprintUnsupportedPolicy(input.options)
+    };
+  }
+  normalizeExportBlueprintUnsupportedPolicy(input) {
+    if (import_lodash.default.isUndefined(input)) {
+      return "error";
+    }
+    if (!import_lodash.default.isPlainObject(input)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint options must be an object`);
+    }
+    const options = input;
+    const unsupportedKeys = Object.keys(options).filter((key) => key !== "unsupported");
+    if (unsupportedKeys.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint options only accepts unsupported`);
+    }
+    const policy = options.unsupported;
+    if (import_lodash.default.isUndefined(policy)) {
+      return "error";
+    }
+    if (policy === "error" || policy === "warn") {
+      return policy;
+    }
+    (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint options.unsupported must be 'error' or 'warn'`);
+  }
+  normalizeExportBlueprintLocatorValue(value, key) {
+    if (import_lodash.default.isNil(value)) {
+      return void 0;
+    }
+    if (typeof value !== "string" && typeof value !== "number") {
+      (0, import_errors.throwBadRequest)(`flowSurfaces exportBlueprint target.${key} must be a string`);
+    }
+    const normalized = String(value).trim();
+    return normalized || void 0;
+  }
+  readRouteString(route, key) {
+    var _a;
+    const routeRecord = route;
+    const value = ((_a = routeRecord == null ? void 0 : routeRecord.get) == null ? void 0 : _a.call(routeRecord, key)) ?? (routeRecord == null ? void 0 : routeRecord[key]);
+    const normalized = typeof value === "string" ? value.trim() : "";
+    return normalized || void 0;
+  }
+  resolveExportBlueprintPageSchemaUid(target, resolved) {
+    const pageSchemaUid = this.readRouteString(resolved.pageRoute, "schemaUid") || (target.pageSchemaUid ? String(target.pageSchemaUid).trim() : "");
+    if (!pageSchemaUid) {
+      (0, import_errors.throwBadRequest)(FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE);
+    }
+    return pageSchemaUid;
+  }
+  async assertExportBlueprintRootTarget(target, resolved, pageSchemaUid, transaction) {
+    const targetUid = target.uid ? String(target.uid).trim() : "";
+    if (!targetUid) {
+      return;
+    }
+    if (targetUid === pageSchemaUid) {
+      return;
+    }
+    const rootPageModel = await this.repository.findModelByParentId(pageSchemaUid, {
+      transaction,
+      subKey: "page",
+      includeAsyncNode: false
+    });
+    if ((rootPageModel == null ? void 0 : rootPageModel.uid) && targetUid === String(rootPageModel.uid).trim()) {
+      return;
+    }
+    (0, import_errors.throwBadRequest)(FLOW_SURFACE_EXPORT_BLUEPRINT_ROOT_ONLY_MESSAGE);
+  }
   normalizeContextPath(path) {
     if (import_lodash.default.isUndefined(path) || import_lodash.default.isNull(path)) {
       return void 0;
@@ -18441,13 +18702,14 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     }
     const normalizedDefaultFilter = (0, import_service_utils.hasOwnDefined)(changes, "defaultFilter") ? this.normalizeFilterActionDefaultFilterValue(changes.defaultFilter) : void 0;
     const stepParams = {};
-    if ((0, import_service_utils.hasDefinedValue)(changes, ["title", "tooltip", "icon", "type", "danger", "color", "linkageRules"])) {
+    if ((0, import_service_utils.hasDefinedValue)(changes, ["title", "tooltip", "icon", "iconOnly", "type", "danger", "color", "linkageRules"])) {
       stepParams.buttonSettings = {
-        ...(0, import_service_utils.hasDefinedValue)(changes, ["title", "tooltip", "icon", "type", "danger", "color"]) ? {
+        ...(0, import_service_utils.hasDefinedValue)(changes, ["title", "tooltip", "icon", "iconOnly", "type", "danger", "color"]) ? {
           general: (0, import_service_utils.buildDefinedPayload)({
             title: changes.title,
             tooltip: changes.tooltip,
             icon: changes.icon,
+            iconOnly: changes.iconOnly,
             type: changes.type,
             danger: changes.danger,
             color: changes.color
@@ -18657,6 +18919,7 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       title: changes.title,
       tooltip: changes.tooltip,
       icon: changes.icon,
+      iconOnly: changes.iconOnly,
       type: changes.type,
       htmlType: changes.htmlType,
       position: changes.position,
@@ -18786,6 +19049,11 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       useStrictOnly: input.useStrictOnly
     });
   }
+  isCollectionTitleField(collection, fieldName) {
+    const normalizedFieldName = String(fieldName || "").trim();
+    const titleFieldName = String((0, import_service_helpers.getCollectionTitleFieldName)(collection) || "").trim();
+    return !!normalizedFieldName && normalizedFieldName === titleFieldName;
+  }
   resolveAssociationLeafDisplaySemantics(field, dataSourceKey, enabledPackages) {
     const registeredBinding = this.resolveRegisteredFieldBinding({
       containerUse: "DetailsItemModel",
@@ -18821,6 +19089,9 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
   }
   buildFieldMenuDirectCandidates(input) {
     const collection = this.getCollection(input.resourceInit.dataSourceKey, input.resourceInit.collectionName);
+    const explicitDefaultFieldPaths = (0, import_default_action_popup.collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths)(
+      input.defaultFieldGroups
+    );
     return (0, import_service_helpers.getCollectionFields)(collection).flatMap((field) => {
       var _a;
       const fieldName = (0, import_service_helpers.getFieldName)(field);
@@ -18831,6 +19102,9 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       if (input.generatedPopupOnly && !(0, import_default_action_popup.isFlowSurfaceDefaultActionPopupBusinessField)(field)) {
         return [];
       }
+      if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(collection, field) && !explicitDefaultFieldPaths.has(fieldName)) {
+        return [];
+      }
       if (input.mode === "table" && ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.treeChildren)) {
         return [];
       }
@@ -18918,6 +19192,9 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
         if (!targetFieldName) {
           continue;
         }
+        if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(targetCollection, targetField) && !this.isCollectionTitleField(targetCollection, targetFieldName)) {
+          continue;
+        }
         nextCandidates.push({
           field: targetField,
           fieldPath: `${associationPathName}.${targetFieldName}`,
@@ -19092,7 +19369,7 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     const getFields = (targetCollection) => (0, import_service_helpers.getCollectionFields)(targetCollection);
     const isFilterFieldVisible = (field) => (0, import_service_helpers.getFieldFilterable)(field) !== false && !!(0, import_service_helpers.getFieldInterface)(field);
     const directFields = getFields(collection).filter(
-      (field) => ["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"].includes(input.ownerUse) ? isFilterFieldVisible(field) : !!(0, import_service_helpers.getFieldInterface)(field)
+      (field) => !(0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(collection, field) && (["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"].includes(input.ownerUse) ? isFilterFieldVisible(field) : !!(0, import_service_helpers.getFieldInterface)(field))
     );
     if (!directFields.length && !collection) {
       return [];
@@ -19106,9 +19383,13 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       if (!(0, import_service_helpers.isAssociationField)(field) || !targetCollection) {
         return [];
       }
-      return getFields(targetCollection).filter(
-        (targetField) => ["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"].includes(input.ownerUse) ? isFilterFieldVisible(targetField) : !!(0, import_service_helpers.getFieldInterface)(targetField)
-      ).map((targetField) => ({
+      return getFields(targetCollection).filter((targetField) => {
+        const targetFieldName = (0, import_service_helpers.getFieldName)(targetField);
+        if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(targetCollection, targetField) && !this.isCollectionTitleField(targetCollection, targetFieldName)) {
+          return false;
+        }
+        return ["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"].includes(input.ownerUse) ? isFilterFieldVisible(targetField) : !!(0, import_service_helpers.getFieldInterface)(targetField);
+      }).map((targetField) => ({
         field: targetField,
         fieldPath: `${(0, import_service_helpers.getFieldName)(field)}.${(0, import_service_helpers.getFieldName)(targetField)}`,
         associationPathName: (0, import_service_helpers.getFieldName)(field),

package/dist/server/variables/registry.js

@@ -89,6 +89,9 @@ class VariableRegistry {
 }
 const GLOBAL_KEY = "__ncbVarRegistry__";
 const g = typeof globalThis !== "undefined" ? globalThis : global;
+if (g[GLOBAL_KEY] && typeof g[GLOBAL_KEY] === "object") {
+  Object.setPrototypeOf(g[GLOBAL_KEY], VariableRegistry.prototype);
+}
 if (!g[GLOBAL_KEY]) {
   g[GLOBAL_KEY] = new VariableRegistry();
 }