@nocobase/plugin-flow-engine 2.1.0-alpha.45 → 2.1.0-alpha.46

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,36 @@ 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 REPAIR_ALL_ERRORS_AGENT_INSTRUCTION = "If this response contains errors[], fix every listed error in one payload revision before retrying the same write. Do not fix only this error and immediately retry.";
+const JS_BLOCK_AGENT_INSTRUCTION = `${REPAIR_ALL_ERRORS_AGENT_INSTRUCTION} Do not skip, drop, defer, or replace this required jsBlock. Repair it as jsBlock.`;
+const CHART_AGENT_INSTRUCTION = `${REPAIR_ALL_ERRORS_AGENT_INSTRUCTION} Do not skip, drop, defer, or replace this required chart. Repair it as chart.`;
+const VISIBLE_DATA_BLOCK_FIELDS_REPAIR_HINT = "Add direct visible collection fields to this block. Do not rely on defaults.collections.*.fieldGroups, action-only fields, dividers, or generated popup/form defaults as a substitute for visible block fields.";
+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 CHART_BASIC_VISUAL_TYPE_LIST = import_chart_config.CHART_BASIC_VISUAL_TYPES.join(", ");
+const STRICT_LOCALIZED_CHART_ACTIONS = /* @__PURE__ */ new Set(["compose", "addBlocks"]);
 const CHART_VISUAL_LEGACY_BUILDER_KEYS = /* @__PURE__ */ new Set([
   "xField",
   "yField",
@@ -201,6 +235,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 +431,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 +451,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 +472,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,13 +720,41 @@ 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,
+    agentInstruction: JS_BLOCK_AGENT_INSTRUCTION,
+    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,
+    agentInstruction: CHART_AGENT_INSTRUCTION,
     repairSteps: [
       "Keep the block type as chart.",
       "Define assets.charts.<key>.query and assets.charts.<key>.visual.",
@@ -658,6 +762,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 +827,245 @@ 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 withUnsupportedChartVisualTypeHint(details = {}) {
+  const jsBlockHint = `Supported basic chart visual types are: ${CHART_BASIC_VISUAL_TYPE_LIST}. If the required visualization cannot be represented by these chart types, use a jsBlock instead.`;
+  return {
+    ...details,
+    fixStrategy: "use_supported_chart_type_or_jsBlock",
+    repairHint: jsBlockHint,
+    agentInstruction: `${REPAIR_ALL_ERRORS_AGENT_INSTRUCTION} Use one of the supported chart visual types, or use a jsBlock when the requested visualization is outside the chart plugin capabilities.`,
+    supportedVisualTypes: [...import_chart_config.CHART_BASIC_VISUAL_TYPES],
+    alternativeBlockType: "jsBlock",
+    alternativeHint: jsBlockHint,
+    forbiddenFallbacks: CHART_FORBIDDEN_FALLBACKS.filter((item) => item !== "jsBlock")
+  };
+}
+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 +1173,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.normalizeFlowSurfaceStrictFilterDateValue)(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(".");
@@ -790,6 +1259,7 @@ function normalizeChartAssetFieldPath(input) {
   return String(input || "").trim();
 }
 function collectBuilderChartAssetFieldErrors(query, path, context, errors) {
+  var _a, _b, _c, _d, _e;
   const resource = _.isPlainObject(query.resource) ? query.resource : null;
   const collectionName = String((resource == null ? void 0 : resource.collectionName) || "").trim();
   if (!collectionName || typeof context.getCollection !== "function") {
@@ -803,10 +1273,12 @@ function collectBuilderChartAssetFieldErrors(query, path, context, errors) {
   const selections = [
     ..._.castArray(query.measures || []).map((selection, index) => ({
       selection,
+      kind: "measure",
       fieldPath: `${path}.query.measures[${index}].field`
     })),
     ..._.castArray(query.dimensions || []).map((selection, index) => ({
       selection,
+      kind: "dimension",
       fieldPath: `${path}.query.dimensions[${index}].field`
     }))
   ];
@@ -818,24 +1290,80 @@ function collectBuilderChartAssetFieldErrors(query, path, context, errors) {
     if (!fieldPath) {
       continue;
     }
+    const fieldPathParts = fieldPath.split(".").filter(Boolean);
+    const isCountMeasureSelection = item.kind === "measure" && String(((_a = item.selection) == null ? void 0 : _a.aggregation) || "").trim() === "count" && !((_b = item.selection) == null ? void 0 : _b.distinct);
+    if (fieldPathParts.length > 1 && !isCountMeasureSelection) {
+      const directAssociationPath = fieldPathParts[0];
+      const directAssociationField = (0, import_service_helpers.resolveFieldFromCollection)(collection, directAssociationPath);
+      const directAssociationTargetCollection = directAssociationField && (0, import_service_helpers.isAssociationField)(directAssociationField) ? (0, import_service_helpers.resolveFieldTargetCollection)(
+        directAssociationField,
+        dataSourceKey,
+        (resolvedDataSourceKey, targetCollection) => {
+          var _a2;
+          return (_a2 = context.getCollection) == null ? void 0 : _a2.call(context, resolvedDataSourceKey, targetCollection);
+        }
+      ) : null;
+      const invalidDirectSubfield = directAssociationTargetCollection ? (0, import_service_helpers.getInvalidChartBuilderRelationDirectSubfieldDetails)({
+        associationPathName: directAssociationPath,
+        selectedSubfieldPath: fieldPathParts.slice(1).join("."),
+        targetCollection: directAssociationTargetCollection
+      }) : null;
+      if (invalidDirectSubfield) {
+        pushAuthoringError(errors, {
+          path: item.fieldPath,
+          ruleId: "chart-builder-query-relation-direct-subfield-required",
+          message: `flowSurfaces authoring ${item.fieldPath} must reference a direct scalar child field under relation '${invalidDirectSubfield.associationPath}'. ${(0, import_service_helpers.formatChartBuilderSupportedRelationSubfields)(
+            invalidDirectSubfield.associationPath,
+            invalidDirectSubfield.supportedFields
+          )}`,
+          details: withChartRepairHint({
+            fieldPath,
+            dataSourceKey,
+            collectionName,
+            ...invalidDirectSubfield
+          })
+        });
+        continue;
+      }
+    }
     const field = (0, import_service_helpers.resolveFieldFromCollection)(collection, fieldPath);
+    const associationPath = fieldPath.includes(".") ? fieldPath.split(".").slice(0, -1).join(".") : "";
+    const leafFieldName = fieldPath.split(".").slice(-1)[0];
+    const associationField = associationPath ? (0, import_service_helpers.resolveFieldFromCollection)(collection, associationPath) : null;
+    const associationTargetCollection = associationField && (0, import_service_helpers.isAssociationField)(associationField) ? (0, import_service_helpers.resolveFieldTargetCollection)(
+      associationField,
+      dataSourceKey,
+      (resolvedDataSourceKey, targetCollection) => {
+        var _a2;
+        return (_a2 = context.getCollection) == null ? void 0 : _a2.call(context, resolvedDataSourceKey, targetCollection);
+      }
+    ) : null;
+    const leafModelAttributes = (0, import_service_helpers.getCollectionModelAttributes)(associationTargetCollection || collection);
+    const hasLeafModelAttribute = Object.prototype.hasOwnProperty.call(leafModelAttributes, leafFieldName);
+    const isCountMeasureRelationSubfield = item.kind === "measure" && String(((_c = item.selection) == null ? void 0 : _c.aggregation) || "").trim() === "count" && !((_d = item.selection) == null ? void 0 : _d.distinct) && associationField && (0, import_service_helpers.isAssociationField)(associationField);
+    const unsupportedRelationSubfield = associationTargetCollection ? (0, import_service_helpers.getUnsupportedChartBuilderRelationSubfieldDetails)({
+      associationPathName: associationPath,
+      leafFieldName,
+      leafField: field,
+      targetCollection: associationTargetCollection
+    }) : null;
     if (!field) {
-      if (collectionHasConcreteField(collection, fieldPath)) {
+      const hasConcreteField = associationTargetCollection ? hasLeafModelAttribute || collectionHasConcreteField(associationTargetCollection, leafFieldName) : collectionHasConcreteField(collection, fieldPath);
+      if (!hasConcreteField) {
+        pushAuthoringError(errors, {
+          path: item.fieldPath,
+          ruleId: "chart-builder-query-field-unknown",
+          message: `flowSurfaces authoring ${item.fieldPath} references unknown field '${fieldPath}' on collection '${dataSourceKey}.${collectionName}'`,
+          details: withChartRepairHint({
+            fieldPath,
+            dataSourceKey,
+            collectionName
+          })
+        });
         continue;
       }
-      pushAuthoringError(errors, {
-        path: item.fieldPath,
-        ruleId: "chart-builder-query-field-unknown",
-        message: `flowSurfaces authoring ${item.fieldPath} references unknown field '${fieldPath}' on collection '${dataSourceKey}.${collectionName}'`,
-        details: withChartRepairHint({
-          fieldPath,
-          dataSourceKey,
-          collectionName
-        })
-      });
-      continue;
     }
-    if (!fieldPath.includes(".") && (0, import_service_helpers.isAssociationField)(field)) {
+    if (!fieldPath.includes(".") && field && (0, import_service_helpers.isAssociationField)(field)) {
       const suggestion = resolveChartBuilderAssociationSubfieldSuggestion(
         fieldPath,
         field,
@@ -854,6 +1382,43 @@ function collectBuilderChartAssetFieldErrors(query, path, context, errors) {
         })
       });
     }
+    if (isCountMeasureRelationSubfield) {
+      pushAuthoringError(errors, {
+        path: item.fieldPath,
+        ruleId: "chart-builder-query-count-measure-relation-subfield",
+        message: `flowSurfaces authoring ${item.fieldPath} counts relation subfield '${fieldPath}'; count a scalar base field such as 'id' and keep '${fieldPath}' as a dimension`,
+        details: withChartRepairHint({
+          fieldPath,
+          dataSourceKey,
+          collectionName,
+          suggestedMeasure: {
+            field: "id",
+            aggregation: "count",
+            alias: String(((_e = item.selection) == null ? void 0 : _e.alias) || "").trim() || "recordCount"
+          },
+          suggestedDimension: {
+            field: fieldPath
+          }
+        })
+      });
+      continue;
+    }
+    if (unsupportedRelationSubfield) {
+      pushAuthoringError(errors, {
+        path: item.fieldPath,
+        ruleId: "chart-builder-query-relation-subfield-column-unsupported",
+        message: `flowSurfaces authoring ${item.fieldPath} references relation subfield '${fieldPath}', but current chart builder SQL generation cannot query relation subfield '${unsupportedRelationSubfield.leafFieldName}' because its database column is '${unsupportedRelationSubfield.columnName}'. ${(0, import_service_helpers.formatChartBuilderSupportedRelationSubfields)(
+          associationPath,
+          unsupportedRelationSubfield.supportedFields
+        )}`,
+        details: withChartRepairHint({
+          fieldPath,
+          dataSourceKey,
+          collectionName,
+          ...unsupportedRelationSubfield
+        })
+      });
+    }
   }
 }
 function resolveChartBuilderAssociationSubfieldSuggestion(fieldPath, field, dataSourceKey, getCollection) {
@@ -953,8 +1518,8 @@ function collectChartAssetVisualErrors(asset, path, errors) {
     pushAuthoringError(errors, {
       path: `${path}.visual.type`,
       ruleId: "chart-visual-type-unsupported",
-      message: `flowSurfaces authoring ${path}.visual.type '${type}' is not supported`,
-      details: withChartRepairHint({
+      message: `flowSurfaces authoring ${path}.visual.type '${type}' is not supported. Supported basic chart visual types: ${CHART_BASIC_VISUAL_TYPE_LIST}. If these types do not satisfy the requirement, use a jsBlock instead.`,
+      details: withUnsupportedChartVisualTypeHint({
         type
       })
     });
@@ -3385,10 +3950,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 +4214,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 +4264,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);
@@ -3783,6 +4353,23 @@ function collectUnsupportedDefaultFilterOperatorError(operator, path, errors) {
     }
   });
 }
+function collectDefaultFilterDateValueError(operator, value, path, errors) {
+  var _a, _b, _c;
+  try {
+    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, value, path);
+  } catch (error) {
+    if (!(error instanceof import_errors.FlowSurfaceBadRequestError)) {
+      throw error;
+    }
+    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 : path,
+      ruleId: typeof ((_c = error.options) == null ? void 0 : _c.ruleId) === "string" && error.options.ruleId ? error.options.ruleId : "filter-group-date-value-invalid",
+      message: error.message,
+      details
+    });
+  }
+}
 function collectTopLevelLayoutErrors(actionName, values, errors) {
   if (actionName !== "applyBlueprint") {
     return;
@@ -4377,6 +4964,8 @@ function collectVisibleDataBlockFieldErrors(block, blockType, path, errors, cont
         blockType,
         collection: getBlockCollectionName(block, context),
         fieldCount: fieldEntries.length,
+        repairHint: VISIBLE_DATA_BLOCK_FIELDS_REPAIR_HINT,
+        agentInstruction: REPAIR_ALL_ERRORS_AGENT_INSTRUCTION,
         ...suggestedFields.length ? { suggestion: { fields: suggestedFields } } : {}
       }
     });
@@ -4410,6 +4999,8 @@ function collectVisibleDataBlockFieldErrors(block, blockType, path, errors, cont
       fieldCount: validBusinessFieldNames.length,
       requiredFieldCount,
       eligibleBusinessFieldCount: eligibleBusinessFields.length,
+      repairHint: VISIBLE_DATA_BLOCK_FIELDS_REPAIR_HINT,
+      agentInstruction: REPAIR_ALL_ERRORS_AGENT_INSTRUCTION,
       suggestion: {
         fields: eligibleBusinessFields.slice(0, requiredFieldCount)
       }
@@ -4783,6 +5374,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));
@@ -4797,6 +5397,7 @@ function visitFilterItems(value, path, errors, block, context = {}) {
   }
   if (typeof value.operator === "string") {
     collectUnsupportedDefaultFilterOperatorError(value.operator, `${path}.operator`, errors);
+    collectDefaultFilterDateValueError(value.operator, value.value, `${path}.value`, errors);
   }
   const filterItems = value.items;
   if (Array.isArray(filterItems)) {
@@ -4820,8 +5421,9 @@ function visitFilterItems(value, path, errors, block, context = {}) {
     }
     collectDefaultFilterFieldPathError(key, `${path}.${key}`, block, context, errors);
     if (_.isPlainObject(child)) {
-      Object.keys(child).forEach((operator) => {
+      Object.entries(child).forEach(([operator, operatorValue]) => {
         collectUnsupportedDefaultFilterOperatorError(operator, `${path}.${key}.${operator}`, errors);
+        collectDefaultFilterDateValueError(operator, operatorValue, `${path}.${key}.${operator}`, errors);
       });
     }
   });
@@ -5198,6 +5800,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 +5816,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 +6497,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 +6818,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";
@@ -6204,18 +6951,18 @@ function getRecordHistoryDeclaredFilterTargetKey(collection) {
   return String(raw || "").trim();
 }
 function collectionHasConcreteField(collection, fieldName) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c;
   const normalized = String(fieldName || "").trim();
   if (!normalized) {
     return false;
   }
-  const modelAttributes = (typeof ((_a = collection == null ? void 0 : collection.model) == null ? void 0 : _a.getAttributes) === "function" ? collection.model.getAttributes() : null) || ((_b = collection == null ? void 0 : collection.model) == null ? void 0 : _b.rawAttributes) || ((_c = collection == null ? void 0 : collection.model) == null ? void 0 : _c.attributes) || {};
+  const modelAttributes = (0, import_service_helpers.getCollectionModelAttributes)(collection);
   const primaryKeyAttributes = _.castArray(
-    ((_d = collection == null ? void 0 : collection.model) == null ? void 0 : _d.primaryKeyAttributes) || ((_e = collection == null ? void 0 : collection.model) == null ? void 0 : _e.primaryKeyAttribute) || []
+    ((_a = collection == null ? void 0 : collection.model) == null ? void 0 : _a.primaryKeyAttributes) || ((_b = collection == null ? void 0 : collection.model) == null ? void 0 : _b.primaryKeyAttribute) || []
   );
   const modelAttribute = modelAttributes == null ? void 0 : modelAttributes[normalized];
   const isModelPrimaryKey = primaryKeyAttributes.includes(normalized) || !!(modelAttribute == null ? void 0 : modelAttribute.primaryKey);
-  return !!((0, import_service_helpers.resolveFieldFromCollection)(collection, normalized) || ((_f = collection == null ? void 0 : collection.getField) == null ? void 0 : _f.call(collection, normalized)) || (0, import_service_helpers.getCollectionFields)(collection).some((field) => (0, import_service_helpers.getFieldName)(field) === normalized) || isModelPrimaryKey);
+  return !!((0, import_service_helpers.resolveFieldFromCollection)(collection, normalized) || ((_c = collection == null ? void 0 : collection.getField) == null ? void 0 : _c.call(collection, normalized)) || (0, import_service_helpers.getCollectionFields)(collection).some((field) => (0, import_service_helpers.getFieldName)(field) === normalized) || isModelPrimaryKey);
 }
 function collectDefaultFilterFieldPathError(rawFieldPath, path, block, context, errors) {
   const fieldPath = String(rawFieldPath || "").trim();