@nocobase/plugin-flow-engine 2.1.0-beta.41 → 2.1.0-beta.43

package/dist/server/flow-surfaces/authoring-validation.js

@@ -60,6 +60,7 @@ var import_association_interfaces = require("./association-interfaces");
 var import_defaults = require("./blueprint/defaults");
 var import_runjs_authoring = require("./runjs-authoring");
 var import_configure_options = require("./configure-options");
+var import_filter_group = require("./filter-group");
 const MAIN_BLOCK_UNSUPPORTED_SECTIONS = {
   calendar: ["fields", "fieldGroups", "recordActions", "fieldsLayout"],
   kanban: ["fieldGroups", "recordActions", "fieldsLayout"],
@@ -83,6 +84,13 @@ const VISIBLE_FIELD_REQUIRED_DATA_BLOCK_TYPES = /* @__PURE__ */ new Set([
   "kanban"
 ]);
 const VISIBLE_FIELD_MINIMUM_DATA_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "list", "gridCard", "details"]);
+const IMPLICIT_RELATION_TITLE_FIELD_DISPLAY_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "list", "gridCard", "details"]);
+const IMPLICIT_RELATION_TITLE_FIELD_CONTAINER_USE_BY_BLOCK_TYPE = {
+  details: "DetailsItemModel",
+  gridCard: "GridCardItemModel",
+  list: "ListItemModel",
+  table: "TableColumnModel"
+};
 const RICH_COLLECTION_VISIBLE_FIELD_THRESHOLD = import_public_data_surface_default_filter.FLOW_SURFACE_DEFAULT_FILTER_REQUIRED_FIELD_COUNT * 2;
 const RICH_DATA_BLOCK_VISIBLE_FIELD_MINIMUM = 3;
 const NON_BUSINESS_VISIBLE_FIELD_NAMES = /* @__PURE__ */ new Set([
@@ -163,10 +171,31 @@ const JS_BLOCK_ALLOWED_SETTINGS_KEYS = /* @__PURE__ */ new Set(["title", "descri
 const JS_BLOCK_TOP_LEVEL_JS_KEYS = ["code", "version"];
 const JS_BLOCK_INTERNAL_AUTHORING_KEYS = ["props", "decoratorProps", "flowRegistry", "stepParams"];
 const JS_BLOCK_REPAIR_HINT = "This is a jsBlock payload shape problem. Repair this jsBlock using inline settings.code/settings.version, or applyBlueprint assets.scripts.<key>.code plus block.script. Do not change this block type to table, chart, actionPanel, gridCard, or another block type.";
-const CHART_REPAIR_HINT = "This is a chart payload shape problem. Repair this chart using assets.charts.<key>.query/visual plus block.chart, or localized settings.query/settings.visual. Do not change this block type to table, jsBlock, actionPanel, gridCard, or another block type, and do not drop or defer the chart. KPI / summary numbers should use jsBlock; charts are for trends, distributions, rankings, and visual analysis.";
+const CHART_REPAIR_HINT = "This is a chart payload shape problem. Keep using chart and repair this chart using assets.charts.<key>.query/visual plus block.chart, or localized settings.query/settings.visual. Do not change this block type to table, jsBlock, actionPanel, gridCard, or another block type, and do not drop or defer the chart. KPI / summary numbers should use jsBlock; charts are for trends, distributions, rankings, and visual analysis.";
+const JS_BLOCK_FORBIDDEN_FALLBACKS = [
+  "table",
+  "list",
+  "chart",
+  "actionPanel",
+  "gridCard",
+  "markdown",
+  "drop jsBlock",
+  "defer jsBlock"
+];
+const CHART_FORBIDDEN_FALLBACKS = [
+  "table",
+  "list",
+  "jsBlock",
+  "actionPanel",
+  "gridCard",
+  "markdown",
+  "drop chart",
+  "defer chart"
+];
 const CHART_QUERY_MODE_SET = new Set(import_chart_config.CHART_QUERY_MODES);
 const CHART_VISUAL_MODE_SET = new Set(import_chart_config.CHART_VISUAL_MODES);
 const CHART_BASIC_VISUAL_TYPE_SET = new Set(import_chart_config.CHART_BASIC_VISUAL_TYPES);
+const STRICT_LOCALIZED_CHART_ACTIONS = /* @__PURE__ */ new Set(["compose", "addBlocks"]);
 const CHART_VISUAL_LEGACY_BUILDER_KEYS = /* @__PURE__ */ new Set([
   "xField",
   "yField",
@@ -201,6 +230,7 @@ const CHART_SQL_QUERY_FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
   "offset"
 ]);
 const CHART_CUSTOM_VISUAL_FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["type", "mappings", "style"]);
+const CHART_DEFAULT_DATA_SOURCE_KEY = "main";
 const JS_ITEM_COLLECTION_ACTION_HOST_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "list", "gridCard", "calendar", "kanban"]);
 const JS_ITEM_RECORD_ACTION_HOST_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "details", "list", "gridCard"]);
 const JS_ITEM_FORM_ACTION_HOST_BLOCK_TYPES = /* @__PURE__ */ new Set(["createForm", "editForm"]);
@@ -396,6 +426,14 @@ async function collectFlowSurfaceAuthoringErrors(actionName, values, context = {
   if (!_.isPlainObject(values)) {
     return errors;
   }
+  validationContext.getDefaultFieldGroups = validationContext.getDefaultFieldGroups || ((dataSourceKey, collectionName) => {
+    var _a2;
+    return (_a2 = (0, import_defaults.resolveFlowSurfaceApplyBlueprintDefaultCollection)({
+      metadata: values == null ? void 0 : values.defaults,
+      dataSourceKey,
+      collectionName
+    }).collectionDefaults) == null ? void 0 : _a2.fieldGroups;
+  });
   if (actionName === "applyBlueprint" && _.isPlainObject((_a = values == null ? void 0 : values.assets) == null ? void 0 : _a.scripts)) {
     validationContext.applyBlueprintScriptAssets = values.assets.scripts;
   }
@@ -408,7 +446,7 @@ async function collectFlowSurfaceAuthoringErrors(actionName, values, context = {
   collectApplyBlueprintChartAssetErrors(actionName, values, validationContext, errors);
   if (actionName === "configure") {
     await collectConfigureErrors(values, errors, validationContext);
-    errors.push(...(0, import_runjs_authoring.collectRunJsAuthoringErrors)(actionName, values, validationContext));
+    appendRunJsAuthoringErrors(actionName, values, validationContext, errors);
     if (!validationContext.skipGeneratedPopupDefaultFieldGroups) {
       collectGeneratedPopupDefaultFieldGroupErrors(actionName, values, validationContext, errors);
     }
@@ -429,9 +467,42 @@ async function collectFlowSurfaceAuthoringErrors(actionName, values, context = {
   if (!validationContext.skipGeneratedPopupDefaultFieldGroups) {
     collectGeneratedPopupDefaultFieldGroupErrors(actionName, values, validationContext, errors);
   }
-  errors.push(...(0, import_runjs_authoring.collectRunJsAuthoringErrors)(actionName, values, validationContext));
+  appendRunJsAuthoringErrors(actionName, values, validationContext, errors);
   return errors;
 }
+function appendRunJsAuthoringErrors(actionName, values, context, errors) {
+  try {
+    errors.push(...(0, import_runjs_authoring.collectRunJsAuthoringErrors)(actionName, values, context));
+  } catch (error) {
+    if (shouldKeepExistingChartAuthoringErrors(error, errors)) {
+      return;
+    }
+    if (isChartBadRequestError(error)) {
+      pushChartBadRequestAuthoringError(errors, error, actionName === "configure" ? "$.changes" : "$");
+      return;
+    }
+    throw error;
+  }
+}
+function isChartBadRequestError(error) {
+  return error instanceof import_errors.FlowSurfaceBadRequestError && String(error.message || "").startsWith("chart ");
+}
+function shouldKeepExistingChartAuthoringErrors(error, errors) {
+  return isChartBadRequestError(error) && errors.some((item) => {
+    var _a;
+    return ((_a = item.details) == null ? void 0 : _a.repairHint) === CHART_REPAIR_HINT;
+  });
+}
+function pushChartBadRequestAuthoringError(errors, error, fallbackPath) {
+  var _a, _b, _c;
+  const details = _.isPlainObject((_a = error.options) == null ? void 0 : _a.details) ? error.options.details : {};
+  pushAuthoringError(errors, {
+    path: typeof ((_b = error.options) == null ? void 0 : _b.path) === "string" && error.options.path ? error.options.path : fallbackPath,
+    ruleId: typeof ((_c = error.options) == null ? void 0 : _c.ruleId) === "string" && error.options.ruleId ? error.options.ruleId : "chart-configure-invalid",
+    message: error.message,
+    details: withChartRepairHint(details)
+  });
+}
 async function collectNavigationGroupErrors(actionName, values, context, errors) {
   var _a;
   if (actionName !== "applyBlueprint" || (values == null ? void 0 : values.mode) !== "create" || !_.isPlainObject((_a = values == null ? void 0 : values.navigation) == null ? void 0 : _a.group)) {
@@ -644,12 +715,38 @@ function collectChartAssetBlockTreeErrors(block, path, chartAssets, errors) {
 function withJsBlockRepairHint(details = {}) {
   return {
     ...details,
-    repairHint: JS_BLOCK_REPAIR_HINT
+    requiredBlockType: "jsBlock",
+    fixStrategy: "repair_same_block_type",
+    repairHint: JS_BLOCK_REPAIR_HINT,
+    repairExample: {
+      inlineBlock: {
+        type: "jsBlock",
+        settings: {
+          code: 'ctx.render("Replace this with the required rendered UI");'
+        }
+      },
+      assetBlock: {
+        assets: {
+          scripts: {
+            scriptKey: {
+              code: 'ctx.render("Replace this with the required rendered UI");'
+            }
+          }
+        },
+        block: {
+          type: "jsBlock",
+          script: "scriptKey"
+        }
+      }
+    },
+    forbiddenFallbacks: JS_BLOCK_FORBIDDEN_FALLBACKS
   };
 }
 function withChartRepairHint(details = {}) {
   return {
     ...details,
+    requiredBlockType: "chart",
+    fixStrategy: "repair_same_block_type",
     repairHint: CHART_REPAIR_HINT,
     repairSteps: [
       "Keep the block type as chart.",
@@ -658,6 +755,58 @@ function withChartRepairHint(details = {}) {
       "Retry the chart payload instead of replacing the chart with another block type or omitting it."
     ],
     expectedShape: {
+      settings: {
+        query: {
+          mode: "builder",
+          resource: {
+            dataSourceKey: "main",
+            collectionName: "employees"
+          },
+          measures: [
+            {
+              field: "id",
+              aggregation: "count",
+              alias: "employeeCount"
+            }
+          ]
+        },
+        visual: {
+          mode: "basic",
+          type: "bar",
+          mappings: {
+            x: "status",
+            y: "employeeCount"
+          }
+        }
+      },
+      legacySettings: {
+        configure: {
+          query: {
+            mode: "builder",
+            resource: {
+              dataSourceKey: "main",
+              collectionName: "employees"
+            },
+            measures: [
+              {
+                field: "id",
+                aggregation: "count",
+                alias: "employeeCount"
+              }
+            ]
+          },
+          chart: {
+            option: {
+              mode: "basic",
+              builder: {
+                type: "bar",
+                xField: "status",
+                yField: "employeeCount"
+              }
+            }
+          }
+        }
+      },
       assets: {
         charts: {
           chartKey: {
@@ -671,9 +820,232 @@ function withChartRepairHint(details = {}) {
         chart: "chartKey"
       }
     },
-    forbiddenFallbacks: ["table", "jsBlock", "actionPanel", "gridCard", "drop chart", "defer chart"]
+    repairExample: {
+      settings: {
+        query: {
+          mode: "builder",
+          resource: {
+            dataSourceKey: "main",
+            collectionName: "<collectionName>"
+          },
+          measures: [
+            {
+              field: "id",
+              aggregation: "count",
+              alias: "recordCount"
+            }
+          ],
+          dimensions: [
+            {
+              field: "<dimensionField>"
+            }
+          ]
+        },
+        visual: {
+          mode: "basic",
+          type: "bar",
+          mappings: {
+            x: "<dimensionField>",
+            y: "recordCount"
+          }
+        }
+      },
+      assets: {
+        charts: {
+          chartKey: {
+            query: {
+              mode: "builder",
+              resource: {
+                dataSourceKey: "main",
+                collectionName: "<collectionName>"
+              },
+              measures: [
+                {
+                  field: "id",
+                  aggregation: "count",
+                  alias: "recordCount"
+                }
+              ],
+              dimensions: [
+                {
+                  field: "<dimensionField>"
+                }
+              ]
+            },
+            visual: {
+              mode: "basic",
+              type: "bar",
+              mappings: {
+                x: "<dimensionField>",
+                y: "recordCount"
+              }
+            }
+          }
+        }
+      },
+      block: {
+        type: "chart",
+        chart: "chartKey"
+      }
+    },
+    forbiddenFallbacks: CHART_FORBIDDEN_FALLBACKS
+  };
+}
+function collectLocalizedChartSettingsErrors(block, blockType, path, errors, context) {
+  if (blockType !== "chart" || !STRICT_LOCALIZED_CHART_ACTIONS.has(context.authoringActionName)) {
+    return;
+  }
+  const settingsPath = `${path}.settings`;
+  if (!_.isUndefined(block.settings) && !_.isPlainObject(block.settings)) {
+    pushAuthoringError(errors, {
+      path: settingsPath,
+      ruleId: "chart-localized-settings-invalid",
+      message: `flowSurfaces authoring ${settingsPath} must be an object for compose/addBlocks chart blocks`,
+      details: withChartRepairHint()
+    });
+    return;
+  }
+  const settings = _.isPlainObject(block.settings) ? block.settings : {};
+  if (hasOwn(settings, "configure")) {
+    if (["query", "visual", "events"].some((key) => hasOwn(settings, key))) {
+      pushAuthoringError(errors, {
+        path: settingsPath,
+        ruleId: "chart-localized-settings-mixed-configure",
+        message: `flowSurfaces authoring ${settingsPath} cannot mix legacy configure with query/visual/events`,
+        details: withChartRepairHint()
+      });
+      return;
+    }
+    collectLocalizedLegacyChartConfigureErrors(settings.configure, `${settingsPath}.configure`, errors);
+    return;
+  }
+  if (!hasOwn(settings, "query") && !hasOwn(settings, "visual")) {
+    return;
+  }
+  collectChartAssetQueryErrors(settings, settingsPath, context, errors);
+  collectChartAssetVisualErrors(settings, settingsPath, errors);
+}
+function collectLocalizedLegacyChartConfigureErrors(configure, path, errors) {
+  if (!_.isPlainObject(configure)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "chart-configure-invalid",
+      message: `flowSurfaces authoring ${path} must be an object`,
+      details: withChartRepairHint()
+    });
+    return;
+  }
+  collectLegacyChartQueryCompatibilityErrors(configure.query, `${path}.query`, errors);
+}
+function collectLegacyChartQueryCompatibilityErrors(query, path, errors) {
+  if (!_.isPlainObject(query)) {
+    return;
+  }
+  collectChartQueryFilterOperatorErrors(query, path, errors);
+  const hasResource = hasOwn(query, "resource");
+  const hasCollectionPath = hasOwn(query, "collectionPath");
+  if (!hasResource && !hasCollectionPath) {
+    return;
+  }
+  const resource = hasResource ? normalizeLegacyChartResourceForValidation(query.resource, `${path}.resource`, errors) : void 0;
+  const collectionPathResource = hasCollectionPath ? normalizeLegacyChartCollectionPathResourceForValidation(query.collectionPath, `${path}.collectionPath`, errors) : void 0;
+  if (hasResource && hasCollectionPath && resource && collectionPathResource && !_.isEqual(resource, collectionPathResource)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "chart-legacy-query-resource-conflict",
+      message: `flowSurfaces authoring ${path}.resource and ${path}.collectionPath must reference the same collection`,
+      details: withChartRepairHint({
+        resource,
+        collectionPathResource
+      })
+    });
+  }
+}
+function normalizeLegacyChartCollectionPathResource(collectionPath) {
+  if (!Array.isArray(collectionPath)) {
+    return void 0;
+  }
+  const collectionName = normalizeLegacyChartRequiredString(collectionPath[1]);
+  if (!collectionName) {
+    return void 0;
+  }
+  const dataSourceKey = normalizeLegacyChartCollectionPathDataSourceKey(collectionPath[0]);
+  if (!dataSourceKey) {
+    return void 0;
+  }
+  return {
+    dataSourceKey,
+    collectionName
   };
 }
+function normalizeLegacyChartResourceForValidation(resource, path, errors) {
+  if (!_.isPlainObject(resource)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "chart-legacy-query-resource-invalid",
+      message: `flowSurfaces authoring ${path} must be an object with string collectionName`,
+      details: withChartRepairHint()
+    });
+    return void 0;
+  }
+  const collectionName = normalizeLegacyChartRequiredString(resource.collectionName);
+  if (!collectionName) {
+    pushAuthoringError(errors, {
+      path: `${path}.collectionName`,
+      ruleId: "chart-legacy-query-resource-invalid",
+      message: `flowSurfaces authoring ${path}.collectionName must be a non-empty string`,
+      details: withChartRepairHint()
+    });
+    return void 0;
+  }
+  const dataSourceKey = normalizeLegacyChartResourceDataSourceKey(resource.dataSourceKey);
+  if (!dataSourceKey) {
+    pushAuthoringError(errors, {
+      path: `${path}.dataSourceKey`,
+      ruleId: "chart-legacy-query-resource-invalid",
+      message: `flowSurfaces authoring ${path}.dataSourceKey must be a non-empty string when provided`,
+      details: withChartRepairHint()
+    });
+    return void 0;
+  }
+  return {
+    dataSourceKey,
+    collectionName
+  };
+}
+function normalizeLegacyChartCollectionPathResourceForValidation(collectionPath, path, errors) {
+  const resource = normalizeLegacyChartCollectionPathResource(collectionPath);
+  if (!resource) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "chart-legacy-query-collection-path-invalid",
+      message: `flowSurfaces authoring ${path} must be [dataSourceKey, collectionName] with string values and a non-empty collectionName`,
+      details: withChartRepairHint()
+    });
+  }
+  return resource;
+}
+function normalizeLegacyChartRequiredString(input) {
+  if (typeof input !== "string") {
+    return void 0;
+  }
+  return input.trim() || void 0;
+}
+function normalizeLegacyChartResourceDataSourceKey(input) {
+  if (_.isUndefined(input) || _.isNull(input)) {
+    return CHART_DEFAULT_DATA_SOURCE_KEY;
+  }
+  return normalizeLegacyChartRequiredString(input);
+}
+function normalizeLegacyChartCollectionPathDataSourceKey(input) {
+  if (_.isUndefined(input) || _.isNull(input)) {
+    return CHART_DEFAULT_DATA_SOURCE_KEY;
+  }
+  if (typeof input === "string" && !input.trim()) {
+    return CHART_DEFAULT_DATA_SOURCE_KEY;
+  }
+  return normalizeLegacyChartRequiredString(input);
+}
 function collectChartBlockAssetReferenceErrors(block, path, chartAssets, errors) {
   if (!CHART_BLOCK_TYPES.has(String((block == null ? void 0 : block.type) || "").trim())) {
     return;
@@ -781,8 +1153,85 @@ function collectBuilderChartAssetQueryErrors(query, path, context, errors) {
     errors,
     withChartRepairHint()
   );
+  collectChartQueryFilterOperatorErrors(query, `${path}.query`, errors);
   collectBuilderChartAssetFieldErrors(query, path, context, errors);
 }
+function collectChartQueryFilterOperatorErrors(query, path, errors) {
+  if (!_.isPlainObject(query) || !hasOwn(query, "filter")) {
+    return;
+  }
+  collectChartFilterOperatorErrors(query.filter, `${path}.filter`, errors);
+}
+function collectChartFilterOperatorErrors(filter, path, errors) {
+  if (_.isUndefined(filter) || _.isNull(filter) || !_.isPlainObject(filter)) {
+    return;
+  }
+  if (Array.isArray(filter.items)) {
+    collectChartFilterGroupOperatorErrors(filter.items, `${path}.items`, errors);
+    return;
+  }
+  collectBackendQueryFilterOperatorErrors(filter, path, errors);
+}
+function collectChartFilterGroupOperatorErrors(items, path, errors) {
+  items.forEach((item, index) => {
+    const itemPath = `${path}[${index}]`;
+    if (!_.isPlainObject(item)) {
+      return;
+    }
+    if (Array.isArray(item.items)) {
+      collectChartFilterGroupOperatorErrors(item.items, `${itemPath}.items`, errors);
+      return;
+    }
+    if (hasOwn(item, "operator")) {
+      collectChartFilterOperatorError(item.operator, `${itemPath}.operator`, errors);
+      collectChartFilterDateValueError(item.operator, item.value, `${itemPath}.value`, errors);
+    }
+  });
+}
+function collectBackendQueryFilterOperatorErrors(filter, path, errors) {
+  Object.entries(filter).forEach(([field, condition]) => {
+    const fieldPath = `${path}.${field}`;
+    if ((field === "$and" || field === "$or") && Array.isArray(condition)) {
+      condition.forEach(
+        (operand, index) => collectChartFilterOperatorErrors(operand, `${fieldPath}[${index}]`, errors)
+      );
+      return;
+    }
+    if (!_.isPlainObject(condition)) {
+      return;
+    }
+    Object.keys(condition).forEach((operator) => {
+      if (operator === "$and" || operator === "$or") {
+        collectChartFilterOperatorErrors({ [operator]: condition[operator] }, fieldPath, errors);
+        return;
+      }
+      collectChartFilterOperatorError(operator, `${fieldPath}.${operator}`, errors);
+      collectChartFilterDateValueError(operator, condition[operator], `${fieldPath}.${operator}`, errors);
+    });
+  });
+}
+function collectChartFilterOperatorError(operator, path, errors) {
+  try {
+    (0, import_filter_group.assertFlowSurfaceFilterOperator)(operator, path);
+  } catch (error) {
+    if (error instanceof import_errors.FlowSurfaceBadRequestError) {
+      pushChartBadRequestAuthoringError(errors, error, path);
+      return;
+    }
+    throw error;
+  }
+}
+function collectChartFilterDateValueError(operator, value, path, errors) {
+  try {
+    (0, import_filter_group.normalizeFlowSurfaceFilterDateValue)(operator, value, path);
+  } catch (error) {
+    if (error instanceof import_errors.FlowSurfaceBadRequestError) {
+      pushChartBadRequestAuthoringError(errors, error, path);
+      return;
+    }
+    throw error;
+  }
+}
 function normalizeChartAssetFieldPath(input) {
   if (Array.isArray(input)) {
     return input.map((item) => String(item || "").trim()).filter(Boolean).join(".");
@@ -3385,10 +3834,13 @@ function collectBlockErrors(block, path, errors, localKeys, context) {
   collectVisibleDataBlockFieldErrors(block, blockType, path, errors, context);
   collectCommentsBlockErrors(block, blockType, path, errors, context);
   collectRecordHistoryBlockErrors(block, blockType, path, errors, context);
+  collectLocalizedChartSettingsErrors(block, blockType, path, errors, context);
   collectChartDisplayTitleErrors(block, blockType, path, errors);
   collectTreeTableExplicitFieldsErrors(block, blockType, path, errors, context);
   collectTreeConnectFieldsErrors((_a = block.settings) == null ? void 0 : _a.connectFields, `${path}.settings.connectFields`, errors);
-  collectTableSettingsErrors(block, blockType, path, errors);
+  collectTableSettingsErrors(block, blockType, path, errors, {
+    deferPublicDataScopeErrors: context.authoringActionName === "addBlocks"
+  });
   collectGridCardSettingsErrors(block, blockType, path, errors);
   const descendantContext = getBlockDescendantValidationContext(block, context);
   collectActionListErrors(block.actions, `${path}.actions`, errors, block, descendantContext, "actions");
@@ -3646,6 +4098,7 @@ function collectFieldGroupsShapeErrors(fieldGroups, blockPath, errors, block, co
         if (fieldPath) {
           collectUnknownFieldPathError(fieldPath, itemPath, block, context, errors);
         }
+        collectImplicitRelationTitleFieldErrors(field, itemPath, block, context, errors);
         if (!_.isPlainObject(field)) {
           return;
         }
@@ -3695,6 +4148,7 @@ async function collectConfigureErrors(values, errors, context) {
   collectCommentsBlockErrors(changesBlock, hostBlockType, "$.changes", errors, context);
   collectRecordHistoryBlockErrors(changesBlock, hostBlockType, "$.changes", errors, context);
   collectChartDisplayTitleErrors(changes, hostBlockType, "$.changes", errors);
+  collectChartConfigureFilterOperatorErrors(changes, hostBlockType, "$.changes", errors);
   collectTableSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true });
   collectGridCardSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true });
   collectAssignValuesErrors(changes.assignValues, "$.changes.assignValues", errors, changesBlock, context);
@@ -4783,6 +5237,15 @@ function collectChartDisplayTitleErrors(block, blockType, blockPath, errors) {
     message: "Chart block settings do not support displayTitle in the current flowSurfaces runtime; keep settings.title and omit displayTitle."
   });
 }
+function collectChartConfigureFilterOperatorErrors(changes, hostBlockType, path, errors) {
+  if (hostBlockType !== "chart" || !_.isPlainObject(changes)) {
+    return;
+  }
+  collectChartQueryFilterOperatorErrors(changes.query, `${path}.query`, errors);
+  if (_.isPlainObject(changes.configure)) {
+    collectChartQueryFilterOperatorErrors(changes.configure.query, `${path}.configure.query`, errors);
+  }
+}
 function visitFilterItems(value, path, errors, block, context = {}) {
   if (Array.isArray(value)) {
     value.forEach((item, index) => visitFilterItems(item, `${path}[${index}]`, errors, block, context));
@@ -5198,6 +5661,9 @@ function collectTableSettingsErrors(block, blockType, blockPath, errors, options
     }
     pushTableSettingsUnsupportedError(errors, `${settingsPath}.${key}`, key);
   });
+  if (!shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options)) {
+    collectPublicDataScopeErrors(settings.dataScope, `${settingsPath}.dataScope`, errors);
+  }
 }
 function pushTableSettingsUnsupportedError(errors, path, key) {
   pushAuthoringError(errors, {
@@ -5211,6 +5677,47 @@ function pushTableSettingsUnsupportedError(errors, path, key) {
     }
   });
 }
+function collectPublicDataScopeErrors(value, path, errors) {
+  if (_.isUndefined(value)) {
+    return;
+  }
+  if (value === null || _.isPlainObject(value) && !Object.keys(value).length) {
+    return;
+  }
+  const validationValue = normalizePublicDataScopeValueForValidation(value);
+  try {
+    (0, import_filter_group.assertFlowSurfaceFilterGroupShape)(validationValue);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "dataScope-filter-group-invalid-shape",
+      message: `flowSurfaces authoring ${path} expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}: ${reason}`,
+      details: {
+        repairHint: 'Use settings.dataScope with logic/items, for example {"logic":"$and","items":[{"path":"status","operator":"$eq","value":"Active"}]}; do not use a field-name map.'
+      }
+    });
+  }
+}
+function shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options) {
+  if (options.deferPublicDataScopeErrors !== true) {
+    return false;
+  }
+  if (!/^\$\.blocks\[\d+\]$/.test(blockPath)) {
+    return false;
+  }
+  return !errors.some((error) => error.path === `${blockPath}.settings.dataScope`);
+}
+function normalizePublicDataScopeValueForValidation(value) {
+  if (!_.isPlainObject(value)) {
+    return value;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 1 && keys[0] === "filter") {
+    return value.filter;
+  }
+  return value;
+}
 function collectGridCardSettingsErrors(block, blockType, blockPath, errors, options = {}) {
   const hasSettings = _.isPlainObject(block == null ? void 0 : block.settings);
   if (!hasSettings && options.directSettings !== true) {
@@ -5851,6 +6358,7 @@ function collectFieldListErrors(fields, path, errors, localKeys, context, block)
     if (fieldPath) {
       collectUnknownFieldPathError(fieldPath, `${path}[${index}]`, block, context, errors);
     }
+    collectImplicitRelationTitleFieldErrors(field, `${path}[${index}]`, block, context, errors);
     if (!_.isPlainObject(field)) {
       return;
     }
@@ -6171,6 +6679,106 @@ function collectRelationTitleFieldErrors(fieldSpec, path, block, context, errors
     })
   });
 }
+function collectImplicitRelationTitleFieldErrors(fieldSpec, path, block, context, errors) {
+  var _a;
+  if (context.authoringActionName !== "applyBlueprint") {
+    return;
+  }
+  const hostBlockType = String((block == null ? void 0 : block.type) || "").trim();
+  if (!IMPLICIT_RELATION_TITLE_FIELD_DISPLAY_BLOCK_TYPES.has(hostBlockType)) {
+    return;
+  }
+  if (_.isPlainObject(fieldSpec) && fieldSpec.__autoPopupForRelationField === true) {
+    return;
+  }
+  if (_.isPlainObject(fieldSpec) && Object.prototype.hasOwnProperty.call(fieldSpec, "titleField")) {
+    return;
+  }
+  const fieldPath = getFieldPathInput(fieldSpec);
+  if (!fieldPath || fieldPath.includes(".")) {
+    return;
+  }
+  const collection = getBlockCollection(block, context);
+  if (!collection || !context.getCollection) {
+    return;
+  }
+  const resolvedField = (0, import_service_helpers.resolveFieldFromCollection)(collection, (0, import_service_helpers.normalizeFieldPath)(fieldPath));
+  if (!resolvedField || !(0, import_service_helpers.isAssociationField)(resolvedField)) {
+    return;
+  }
+  const dataSourceKey = getBlockDataSourceKey(block, context);
+  if (hasUsableDefaultFieldGroupRelationTitleField({
+    fieldGroups: (_a = context.getDefaultFieldGroups) == null ? void 0 : _a.call(context, dataSourceKey, getBlockCollectionName(block, context)),
+    fieldPath,
+    field: resolvedField,
+    dataSourceKey,
+    context
+  })) {
+    return;
+  }
+  const registeredBinding = (0, import_field_binding_registry.resolveRegisteredFieldBinding)({
+    containerUse: IMPLICIT_RELATION_TITLE_FIELD_CONTAINER_USE_BY_BLOCK_TYPE[hostBlockType],
+    field: resolvedField,
+    dataSourceKey,
+    enabledPackages: context.enabledPackages,
+    getCollection: (resolvedDataSourceKey, targetCollectionName) => {
+      var _a2;
+      return (_a2 = context.getCollection) == null ? void 0 : _a2.call(context, resolvedDataSourceKey, targetCollectionName);
+    },
+    useStrictOnly: true
+  });
+  if (registeredBinding == null ? void 0 : registeredBinding.modelClassName) {
+    return;
+  }
+  try {
+    const resolvedTitleField = (0, import_association_title_field.resolveAssociationSafeTitleField)(resolvedField, dataSourceKey, context.getCollection, {
+      action: context.authoringActionName,
+      path: `${path}.titleField`,
+      fieldPath
+    });
+    if (!(resolvedTitleField == null ? void 0 : resolvedTitleField.fieldName)) {
+      pushAuthoringError(errors, {
+        path: `${path}.titleField`,
+        ruleId: "relation-titleField-unavailable",
+        message: `flowSurfaces authoring ${path} relation field '${fieldPath}' requires an explicit readable titleField`,
+        details: {
+          fieldPath,
+          repairHint: `Use object field form such as {"field":"${fieldPath}","titleField":"<readable target field>"}.`
+        }
+      });
+    }
+  } catch (error) {
+    if (!(error instanceof import_errors.FlowSurfaceBadRequestError)) {
+      throw error;
+    }
+    pushAuthoringError(errors, {
+      path: `${path}.titleField`,
+      ruleId: error.options.ruleId || "relation-titleField-unavailable",
+      message: `flowSurfaces authoring ${path} relation field '${fieldPath}' requires an explicit readable titleField`,
+      details: {
+        ...error.options.details || {},
+        fieldPath,
+        repairHint: `Use object field form such as {"field":"${fieldPath}","titleField":"<readable target field>"}.`
+      }
+    });
+  }
+}
+function hasUsableDefaultFieldGroupRelationTitleField(input) {
+  const titleField = (0, import_defaults.getFlowSurfaceDefaultFieldGroupRelationTitleFieldOverride)(input.fieldGroups, input.fieldPath);
+  if (!titleField || titleField === "id" || !input.context.getCollection) {
+    return false;
+  }
+  const targetCollection = (0, import_service_helpers.resolveFieldTargetCollection)(
+    input.field,
+    input.dataSourceKey,
+    (dataSourceKey, collectionName) => {
+      var _a, _b;
+      return (_b = (_a = input.context).getCollection) == null ? void 0 : _b.call(_a, dataSourceKey, collectionName);
+    }
+  );
+  const targetField = targetCollection ? (0, import_service_helpers.resolveFieldFromCollection)(targetCollection, titleField) : void 0;
+  return !!targetField && !(0, import_service_helpers.isAssociationField)(targetField);
+}
 function getRelationTitleFieldInvalidReason(titleField, targetField) {
   if (titleField === "id") {
     return "id";