@nocobase/plugin-flow-engine 2.2.0-beta.1 → 2.2.0-beta.3

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

@@ -163,6 +163,13 @@ export type FlowSurfaceReactionCapabilityBase<TKind extends FlowSurfaceReactionK
 };
 export type FlowSurfaceFieldValueCapability = FlowSurfaceReactionCapabilityBase<'fieldValue', FlowSurfaceFieldValueRule> & {
     targetFields: FlowSurfaceFieldOption[];
+    conditionMeta: {
+        operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
+    };
     valueExprMeta: {
         supportedSources: Array<'literal' | 'path' | 'runjs'>;
         runjsScene: 'fieldValue';
@@ -172,17 +179,29 @@ export type FlowSurfaceLinkageCapability = (FlowSurfaceReactionCapabilityBase<'b
     supportedActions: Array<Record<string, any>>;
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
 }) | (FlowSurfaceReactionCapabilityBase<'actionLinkage', FlowSurfaceActionLinkageRule> & {
     supportedActions: Array<Record<string, any>>;
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
 }) | (FlowSurfaceReactionCapabilityBase<'fieldLinkage', FlowSurfaceFieldLinkageRule> & {
     supportedActions: Array<Record<string, any>>;
     targetFields: FlowSurfaceFieldOption[];
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
     valueExprMeta?: {
         supportedSources: Array<'literal' | 'path' | 'runjs'>;

package/dist/server/flow-surfaces/relation-backing-foreign-key.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare function collectRelationBackingForeignKeyNames(collection: any): Set<string>;
+export declare function isRelationBackingForeignKeyField(collection: any, fieldOrFieldName: any): boolean;

package/dist/server/flow-surfaces/relation-backing-foreign-key.js

@@ -0,0 +1,79 @@
+/**
+ * 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 relation_backing_foreign_key_exports = {};
+__export(relation_backing_foreign_key_exports, {
+  collectRelationBackingForeignKeyNames: () => collectRelationBackingForeignKeyNames,
+  isRelationBackingForeignKeyField: () => isRelationBackingForeignKeyField
+});
+module.exports = __toCommonJS(relation_backing_foreign_key_exports);
+var import_service_helpers = require("./service-helpers");
+const CURRENT_COLLECTION_FOREIGN_KEY_RELATION_TYPES = /* @__PURE__ */ new Set(["belongsto"]);
+const CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES = /* @__PURE__ */ new Set(["m2o"]);
+const CONDITIONAL_CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES = /* @__PURE__ */ new Set(["o2o"]);
+const RELATION_INTERFACES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION = /* @__PURE__ */ new Set(["o2m", "m2m", "mbm"]);
+const RELATION_TYPES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION = /* @__PURE__ */ new Set(["hasone", "hasmany", "belongstomany"]);
+function collectRelationBackingForeignKeyNames(collection) {
+  const fields = (0, import_service_helpers.getCollectionFields)(collection);
+  const scalarFieldNames = new Set(
+    fields.filter((field) => !(0, import_service_helpers.isAssociationField)(field)).map((field) => String((0, import_service_helpers.getFieldName)(field) || "").trim()).filter(Boolean)
+  );
+  const names = /* @__PURE__ */ new Set();
+  fields.forEach((field) => {
+    const foreignKey = getCurrentCollectionRelationForeignKey(field);
+    if (foreignKey && scalarFieldNames.has(foreignKey)) {
+      names.add(foreignKey);
+    }
+  });
+  return names;
+}
+function isRelationBackingForeignKeyField(collection, fieldOrFieldName) {
+  const fieldName = typeof fieldOrFieldName === "string" ? fieldOrFieldName.trim() : String((0, import_service_helpers.getFieldName)(fieldOrFieldName) || "").trim();
+  return !!fieldName && collectRelationBackingForeignKeyNames(collection).has(fieldName);
+}
+function getCurrentCollectionRelationForeignKey(field) {
+  var _a;
+  if (!(0, import_service_helpers.isAssociationField)(field)) {
+    return "";
+  }
+  if (!relationCanStoreForeignKeyInCurrentCollection(field)) {
+    return "";
+  }
+  return String((field == null ? void 0 : field.foreignKey) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.foreignKey) || "").trim();
+}
+function relationCanStoreForeignKeyInCurrentCollection(field) {
+  const type = String((0, import_service_helpers.getFieldType)(field) || "").trim().toLowerCase();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim().toLowerCase();
+  if (RELATION_TYPES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION.has(type) || RELATION_INTERFACES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION.has(fieldInterface)) {
+    return false;
+  }
+  return CURRENT_COLLECTION_FOREIGN_KEY_RELATION_TYPES.has(type) || CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES.has(fieldInterface) || CONDITIONAL_CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES.has(fieldInterface);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectRelationBackingForeignKeyNames,
+  isRelationBackingForeignKeyField
+});

package/dist/server/flow-surfaces/runjs-authoring/ast/source.d.ts

@@ -23,6 +23,7 @@ export declare function getPreviousSignificantTokenInfo(sourceLike: string | str
 export declare function skipQuotedLiteral(source: string, start: number, quote: string): number;
 export declare function skipTemplateLiteral(source: string, start: number): number;
 export declare function findFunctionRanges(masked: string): SourceRange[];
+export declare function collectAstFunctionBodyRanges(ast: unknown): SourceRange[];
 export declare function collectFunctionRanges(masked: string, pattern: RegExp, ranges: SourceRange[]): void;
 export declare function collectArrowExpressionRanges(masked: string, ranges: SourceRange[]): void;
 export declare function collectMethodFunctionRanges(masked: string, ranges: SourceRange[]): void;

package/dist/server/flow-surfaces/runjs-authoring/ast/source.js

@@ -27,6 +27,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var source_exports = {};
 __export(source_exports, {
   collectArrowExpressionRanges: () => collectArrowExpressionRanges,
+  collectAstFunctionBodyRanges: () => collectAstFunctionBodyRanges,
   collectBraceRanges: () => collectBraceRanges,
   collectComputedMethodCandidates: () => collectComputedMethodCandidates,
   collectFunctionRanges: () => collectFunctionRanges,
@@ -69,6 +70,7 @@ __export(source_exports, {
 });
 module.exports = __toCommonJS(source_exports);
 var import_constants = require("../runtime/constants");
+var import_walk = require("./walk");
 function maskJavaScriptSource(source) {
   const chars = source.split("");
   const maskRange = (start, end) => {
@@ -406,6 +408,23 @@ function findFunctionRanges(masked) {
   collectMethodFunctionRanges(masked, ranges);
   return mergeRanges(ranges);
 }
+function collectAstFunctionBodyRanges(ast) {
+  const ranges = [];
+  const addBodyRange = (node) => {
+    var _a, _b;
+    const start = (_a = node.body) == null ? void 0 : _a.start;
+    const end = (_b = node.body) == null ? void 0 : _b.end;
+    if (typeof start === "number" && typeof end === "number" && end > start) {
+      ranges.push({ start, end });
+    }
+  };
+  (0, import_walk.walkAstSimple)(ast, {
+    FunctionDeclaration: addBodyRange,
+    FunctionExpression: addBodyRange,
+    ArrowFunctionExpression: addBodyRange
+  });
+  return mergeRanges(ranges);
+}
 function collectFunctionRanges(masked, pattern, ranges) {
   for (const match of masked.matchAll(pattern)) {
     const openBrace = masked.indexOf("{", match.index || 0);
@@ -853,6 +872,7 @@ function getAstSource(node, source) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   collectArrowExpressionRanges,
+  collectAstFunctionBodyRanges,
   collectBraceRanges,
   collectComputedMethodCandidates,
   collectFunctionRanges,

package/dist/server/flow-surfaces/runjs-authoring/scan/filter.js

@@ -900,7 +900,13 @@ function buildRunJsResourceFilterOperatorError(operator, index, input) {
   };
 }
 function buildRunJsResourceDateFilterValueError(operator, index, valueNode, input) {
-  if (!isRunJsDateFilterOperator(operator)) {
+  const fieldType = String((0, import_service_helpers.getFieldType)(input.field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(input.field) || "").trim();
+  const shouldValidateDateValue = isRunJsDateFilterOperator(operator) || (0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)({
+    type: fieldType,
+    interface: fieldInterface
+  });
+  if (!shouldValidateDateValue) {
     return null;
   }
   const valueObject = resolveRunJsStaticFilterObjectNode(
@@ -924,7 +930,11 @@ function buildRunJsResourceDateFilterValueError(operator, index, valueNode, inpu
     return null;
   }
   try {
-    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, resolvedValue.value, `${input.fieldPath}.${operator}`);
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, resolvedValue.value, `${input.fieldPath}.${operator}`, {
+      fieldPath: input.fieldPath,
+      fieldType,
+      fieldInterface
+    });
     return null;
   } catch (error) {
     return buildRunJsStrictDateFilterValueError(operator, index, resolvedValue.value, input, error);

package/dist/server/flow-surfaces/runjs-authoring/scan/index.js

@@ -43,7 +43,7 @@ var import_filter = require("./filter");
 var import_constants = require("../runtime/constants");
 function scanJavaScriptSource(source, ast, context = {}, modelUse = "") {
   const masked = (0, import_source.maskJavaScriptSource)(source);
-  const functionRanges = (0, import_source.findFunctionRanges)(masked);
+  const functionRanges = collectScanFunctionRanges(masked, ast);
   const blockRanges = (0, import_source.collectBraceRanges)(masked);
   const staticBlockRanges = (0, import_source.collectStaticBlockRanges)(masked);
   const sourceBindings = (0, import_bindings.collectSourceBindings)(masked, functionRanges, blockRanges, staticBlockRanges);
@@ -139,6 +139,14 @@ function scanJavaScriptSource(source, ast, context = {}, modelUse = "") {
     isTopLevelFunctionWrapper: (0, import_source_patterns.isTopLevelFunctionWrapper)(masked, functionRanges, topLevelReachableCtxRenderCalls)
   };
 }
+function collectScanFunctionRanges(masked, ast) {
+  if (!ast) {
+    return (0, import_source.findFunctionRanges)(masked);
+  }
+  const ranges = (0, import_source.collectAstFunctionBodyRanges)(ast);
+  (0, import_source.collectArrowExpressionRanges)(masked, ranges);
+  return (0, import_source.mergeRanges)(ranges);
+}
 function collectAstUnknownBareGlobalsFromAst(ast, identifierBindings, modelUse) {
   var _a;
   const allowedGlobals = new Set(import_constants.RUNJS_ALLOWED_BARE_GLOBALS);

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

@@ -160,6 +160,7 @@ export declare class FlowSurfacesService {
     private persistReactionSlot;
     private buildLinkageWriteResult;
     private getLiveLinkageCapability;
+    private getLiveFieldValueCapability;
     getReactionMeta(values: FlowSurfaceGetReactionMetaValues, options?: {
         transaction?: any;
     }): Promise<FlowSurfaceGetReactionMetaResult>;
@@ -182,6 +183,17 @@ export declare class FlowSurfacesService {
     private buildSurfaceReadPayload;
     private buildSurfaceContextFingerprint;
     get(input: Record<string, any>, options?: FlowSurfaceReadOptions): Promise<Record<string, any>>;
+    exportBlueprint(input: Record<string, unknown>, options?: FlowSurfaceReadOptions): Promise<{
+        document: FlowSurfaceApplyBlueprintDocument;
+        source: {
+            target: {
+                pageSchemaUid: string;
+            };
+            pageTitle?: string;
+        };
+        warnings: string[];
+        unsupported: import("./blueprint/export-document").FlowSurfaceExportBlueprintUnsupportedItem[];
+    }>;
     private getDeclaredKeyPersistenceDeps;
     private patchDeclaredKeyModel;
     private persistCreatedKeysForAction;
@@ -916,6 +928,12 @@ export declare class FlowSurfacesService {
     private normalizeRemoveNodeTarget;
     private assertRemoveNodeResolvedTarget;
     private normalizeGetTarget;
+    private normalizeExportBlueprintRequest;
+    private normalizeExportBlueprintUnsupportedPolicy;
+    private normalizeExportBlueprintLocatorValue;
+    private readRouteString;
+    private resolveExportBlueprintPageSchemaUid;
+    private assertExportBlueprintRootTarget;
     private normalizeContextPath;
     private normalizeContextMaxDepth;
     private buildReadTargetSummary;
@@ -1088,6 +1106,7 @@ export declare class FlowSurfacesService {
     private buildFieldCatalog;
     private getFieldMenuCatalogMode;
     private resolveRegisteredFieldBinding;
+    private isCollectionTitleField;
     private resolveAssociationLeafDisplaySemantics;
     private buildFieldMenuDirectCandidates;
     private collectFieldMenuAssociationLeafCandidates;

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,6 +231,7 @@ 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"]);
@@ -2621,6 +2624,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 +2691,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 +2900,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),
@@ -6679,11 +6741,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;
   }
@@ -11972,17 +12029,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));
@@ -13694,6 +13740,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;
@@ -18786,6 +18937,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 +18977,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 +18990,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 +19080,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 +19257,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 +19271,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),