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

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

@@ -45,6 +45,7 @@ var import_lodash = __toESM(require("lodash"));
 var import_service_utils = require("../service-utils");
 var import_errors = require("../errors");
 var import_blueprint = require("./blueprint");
+var import_authoring_validation = require("./authoring-validation");
 var import_builder = require("./builder");
 class FlowSurfaceApprovalBlueprintService {
   constructor(deps) {
@@ -541,6 +542,7 @@ class FlowSurfaceApprovalBlueprintService {
     }
   }
   async applyApprovalBlueprint(values, options = {}) {
+    (0, import_authoring_validation.assertFlowSurfaceApprovalBlueprintAuthoringPayload)(values);
     const document = (0, import_blueprint.prepareFlowSurfaceApplyApprovalBlueprintDocument)(values);
     const bindingContext = await this.resolveApprovalBlueprintBindingContext(document, options.transaction);
     const surfaceRoot = await this.ensureApprovalBlueprintSurfaceRoot(bindingContext, options.transaction);

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

@@ -51,6 +51,7 @@ var import_association_title_field = require("./association-title-field");
 var import_chart_config = require("./chart-config");
 var import_public_data_surface_default_filter = require("./public-data-surface-default-filter");
 var import_default_action_popup = require("./default-action-popup");
+var import_relation_backing_foreign_key = require("./relation-backing-foreign-key");
 var import_default_block_actions = require("./default-block-actions");
 var import_hidden_popup_contract = require("./hidden-popup-contract");
 var import_node_use_sets = require("./node-use-sets");
@@ -60,6 +61,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_context = require("./context");
 var import_filter_group = require("./filter-group");
 const MAIN_BLOCK_UNSUPPORTED_SECTIONS = {
   calendar: ["fields", "fieldGroups", "recordActions", "fieldsLayout"],
@@ -472,7 +474,10 @@ async function collectFlowSurfaceAuthoringErrors(actionName, values, context = {
     blocks.forEach(({ block }) => collectLocalKeys(block, localKeys));
   }
   blocks.forEach(({ block, path }) => collectBlockErrors(block, path, errors, localKeys, validationContext));
-  collectReactionErrors(values == null ? void 0 : values.reaction, "$.reaction", localKeys, errors);
+  collectReactionErrors(values == null ? void 0 : values.reaction, "$.reaction", localKeys, errors, {
+    values,
+    context: validationContext
+  });
   if (!validationContext.skipGeneratedPopupDefaultFieldGroups) {
     collectGeneratedPopupDefaultFieldGroupErrors(actionName, values, validationContext, errors);
   }
@@ -1177,47 +1182,69 @@ function collectBuilderChartAssetQueryErrors(query, path, context, errors) {
     errors,
     withChartRepairHint()
   );
-  collectChartQueryFilterOperatorErrors(query, `${path}.query`, errors);
+  collectChartQueryFilterOperatorErrors(query, `${path}.query`, errors, context);
   collectBuilderChartAssetFieldErrors(query, path, context, errors);
 }
-function collectChartQueryFilterOperatorErrors(query, path, errors) {
+const AUTHORABLE_REACTION_SCALAR_CONTEXT_PATHS = /* @__PURE__ */ new Set(["role", "locale", "token", "deviceType"]);
+const AUTHORABLE_REACTION_CONTEXT_ROOTS = /* @__PURE__ */ new Set([
+  "user",
+  "collection",
+  "formValues",
+  "record",
+  "item",
+  "popup",
+  "urlSearchParams"
+]);
+function collectChartQueryFilterOperatorErrors(query, path, errors, context) {
   if (!_.isPlainObject(query) || !hasOwn(query, "filter")) {
     return;
   }
-  collectChartFilterOperatorErrors(query.filter, `${path}.filter`, errors);
+  collectChartFilterOperatorErrors(
+    query.filter,
+    `${path}.filter`,
+    errors,
+    createChartQueryDateConditionFieldResolver(query, context)
+  );
 }
-function collectChartFilterOperatorErrors(filter, path, errors) {
+function collectChartFilterOperatorErrors(filter, path, errors, resolveField) {
   if (_.isUndefined(filter) || _.isNull(filter) || !_.isPlainObject(filter)) {
     return;
   }
   if (Array.isArray(filter.items)) {
-    collectChartFilterGroupOperatorErrors(filter.items, `${path}.items`, errors);
+    collectChartFilterGroupOperatorErrors(filter.items, `${path}.items`, errors, resolveField);
     return;
   }
-  collectBackendQueryFilterOperatorErrors(filter, path, errors);
+  collectBackendQueryFilterOperatorErrors(filter, path, errors, resolveField);
 }
-function collectChartFilterGroupOperatorErrors(items, path, errors) {
+function collectChartFilterGroupOperatorErrors(items, path, errors, resolveField) {
   items.forEach((item, index) => {
     const itemPath = `${path}[${index}]`;
     if (!_.isPlainObject(item)) {
       return;
     }
     if (Array.isArray(item.items)) {
-      collectChartFilterGroupOperatorErrors(item.items, `${itemPath}.items`, errors);
+      collectChartFilterGroupOperatorErrors(item.items, `${itemPath}.items`, errors, resolveField);
       return;
     }
     if (hasOwn(item, "operator")) {
       collectChartFilterOperatorError(item.operator, `${itemPath}.operator`, errors);
-      collectChartFilterDateValueError(item.operator, item.value, `${itemPath}.value`, errors);
+      const fieldPath = String(item.path || item.field || "").trim();
+      collectChartFilterDateValueError(
+        item.operator,
+        item.value,
+        `${itemPath}.value`,
+        errors,
+        fieldPath ? (resolveField == null ? void 0 : resolveField(fieldPath)) || { fieldPath } : void 0
+      );
     }
   });
 }
-function collectBackendQueryFilterOperatorErrors(filter, path, errors) {
+function collectBackendQueryFilterOperatorErrors(filter, path, errors, resolveField) {
   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)
+        (operand, index) => collectChartFilterOperatorErrors(operand, `${fieldPath}[${index}]`, errors, resolveField)
       );
       return;
     }
@@ -1226,11 +1253,17 @@ function collectBackendQueryFilterOperatorErrors(filter, path, errors) {
     }
     Object.keys(condition).forEach((operator) => {
       if (operator === "$and" || operator === "$or") {
-        collectChartFilterOperatorErrors({ [operator]: condition[operator] }, fieldPath, errors);
+        collectChartFilterOperatorErrors({ [operator]: condition[operator] }, fieldPath, errors, resolveField);
         return;
       }
       collectChartFilterOperatorError(operator, `${fieldPath}.${operator}`, errors);
-      collectChartFilterDateValueError(operator, condition[operator], `${fieldPath}.${operator}`, errors);
+      collectChartFilterDateValueError(
+        operator,
+        condition[operator],
+        `${fieldPath}.${operator}`,
+        errors,
+        (resolveField == null ? void 0 : resolveField(field)) || { fieldPath: field }
+      );
     });
   });
 }
@@ -1245,9 +1278,18 @@ function collectChartFilterOperatorError(operator, path, errors) {
     throw error;
   }
 }
-function collectChartFilterDateValueError(operator, value, path, errors) {
+function collectChartFilterDateValueError(operator, value, path, errors, fieldContext) {
+  const fieldMeta = getDateConditionFieldContextMeta(fieldContext);
+  const normalizedOperator = typeof operator === "string" ? operator.trim() : "";
+  if (!import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS.has(normalizedOperator) && !(0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+    return;
+  }
   try {
-    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, value, path);
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, value, path, {
+      fieldPath: fieldContext == null ? void 0 : fieldContext.fieldPath,
+      fieldType: fieldMeta.type,
+      fieldInterface: fieldMeta.interface
+    });
   } catch (error) {
     if (error instanceof import_errors.FlowSurfaceBadRequestError) {
       pushChartBadRequestAuthoringError(errors, error, path);
@@ -1256,6 +1298,38 @@ function collectChartFilterDateValueError(operator, value, path, errors) {
     throw error;
   }
 }
+function createChartQueryDateConditionFieldResolver(query, context) {
+  const resource = _.isPlainObject(query == null ? void 0 : query.resource) ? query.resource : null;
+  const collectionName = String((resource == null ? void 0 : resource.collectionName) || "").trim();
+  if (!collectionName || typeof (context == null ? void 0 : context.getCollection) !== "function") {
+    return null;
+  }
+  const dataSourceKey = String((resource == null ? void 0 : resource.dataSourceKey) || "main").trim() || "main";
+  const collection = context.getCollection(dataSourceKey, collectionName);
+  if (!collection) {
+    return null;
+  }
+  return (fieldPath) => {
+    const normalizedFieldPath = (0, import_service_helpers.normalizeFieldPath)(fieldPath);
+    const resolved = resolveDefaultFilterFieldPath(collection, normalizedFieldPath, dataSourceKey, context);
+    return {
+      fieldPath,
+      field: resolved.field
+    };
+  };
+}
+function getDateConditionFieldMeta(field) {
+  return {
+    type: (0, import_service_helpers.getFieldType)(field),
+    interface: (0, import_service_helpers.getFieldInterface)(field)
+  };
+}
+function getDateConditionFieldContextMeta(fieldContext) {
+  return {
+    ...getDateConditionFieldMeta(fieldContext == null ? void 0 : fieldContext.field),
+    ...(fieldContext == null ? void 0 : fieldContext.fieldMeta) || {}
+  };
+}
 function normalizeChartAssetFieldPath(input) {
   if (Array.isArray(input)) {
     return input.map((item) => String(item || "").trim()).filter(Boolean).join(".");
@@ -3616,6 +3690,9 @@ function getGeneratedPopupBusinessFieldCandidates(collection) {
     if (!fieldName || !(0, import_default_action_popup.isFlowSurfaceDefaultActionPopupBusinessField)(field)) {
       return [];
     }
+    if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(collection, field)) {
+      return [];
+    }
     return [
       {
         field,
@@ -3730,11 +3807,15 @@ function getGeneratedPopupDefaultFormFieldPaths(candidates, fieldGroups) {
 }
 function getGeneratedPopupRuntimeFieldCandidates(input) {
   const candidateContext = DEFAULT_ACTION_POPUP_FIELD_CONTEXT_BY_TYPE[input.actionType];
+  const explicitDefaultFieldPaths = (0, import_default_action_popup.collectFlowSurfaceDefaultActionPopupFieldGroupFieldPaths)(input.fieldGroups);
   return (0, import_service_helpers.getCollectionFields)(input.collection).flatMap((field) => {
     const fieldName = (0, import_service_helpers.getFieldName)(field);
     if (!fieldName || !(0, import_default_action_popup.isFlowSurfaceDefaultActionPopupBusinessField)(field)) {
       return [];
     }
+    if ((0, import_relation_backing_foreign_key.isRelationBackingForeignKeyField)(input.collection, field) && !explicitDefaultFieldPaths.has(fieldName)) {
+      return [];
+    }
     const fieldInterface = (0, import_service_helpers.getFieldInterface)(field);
     const registeredBinding = (0, import_field_binding_registry.resolveRegisteredFieldBinding)({
       containerUse: candidateContext.ownerUse,
@@ -3958,9 +4039,16 @@ function collectBlockErrors(block, path, errors, localKeys, 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, {
-    deferPublicDataScopeErrors: context.authoringActionName === "addBlocks"
-  });
+  collectTableSettingsErrors(
+    block,
+    blockType,
+    path,
+    errors,
+    {
+      deferPublicDataScopeErrors: context.authoringActionName === "addBlocks"
+    },
+    context
+  );
   collectGridCardSettingsErrors(block, blockType, path, errors);
   const descendantContext = getBlockDescendantValidationContext(block, context);
   collectActionListErrors(block.actions, `${path}.actions`, errors, block, descendantContext, "actions");
@@ -4268,8 +4356,8 @@ 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 });
+  collectChartConfigureFilterOperatorErrors(changes, hostBlockType, "$.changes", errors, context);
+  collectTableSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true }, context);
   collectGridCardSettingsErrors(changes, hostBlockType, "$.changes", errors, { directSettings: true });
   collectAssignValuesErrors(changes.assignValues, "$.changes.assignValues", errors, changesBlock, context);
   collectTriggerWorkflowsErrors(changes.triggerWorkflows, "$.changes.triggerWorkflows", errors);
@@ -4357,10 +4445,20 @@ function collectUnsupportedDefaultFilterOperatorError(operator, path, errors) {
     }
   });
 }
-function collectDefaultFilterDateValueError(operator, value, path, errors) {
+function collectDefaultFilterDateValueError(operator, value, path, errors, fieldContext, options = {}) {
   var _a, _b, _c;
+  const fieldMeta = getDateConditionFieldContextMeta(fieldContext);
+  const normalizedOperator = typeof operator === "string" ? operator.trim() : "";
+  if (!import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS.has(normalizedOperator) && !(0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+    return;
+  }
   try {
-    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, value, path);
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, value, path, {
+      fieldPath: fieldContext == null ? void 0 : fieldContext.fieldPath,
+      fieldType: fieldMeta.type,
+      fieldInterface: fieldMeta.interface,
+      allowContextPathValue: options.allowContextPathValue
+    });
   } catch (error) {
     if (!(error instanceof import_errors.FlowSurfaceBadRequestError)) {
       throw error;
@@ -5423,13 +5521,13 @@ 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) {
+function collectChartConfigureFilterOperatorErrors(changes, hostBlockType, path, errors, context) {
   if (hostBlockType !== "chart" || !_.isPlainObject(changes)) {
     return;
   }
-  collectChartQueryFilterOperatorErrors(changes.query, `${path}.query`, errors);
+  collectChartQueryFilterOperatorErrors(changes.query, `${path}.query`, errors, context);
   if (_.isPlainObject(changes.configure)) {
-    collectChartQueryFilterOperatorErrors(changes.configure.query, `${path}.configure.query`, errors);
+    collectChartQueryFilterOperatorErrors(changes.configure.query, `${path}.configure.query`, errors, context);
   }
 }
 function visitFilterItems(value, path, errors, block, context = {}) {
@@ -5446,7 +5544,13 @@ 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);
+    collectDefaultFilterDateValueError(
+      value.operator,
+      value.value,
+      `${path}.value`,
+      errors,
+      fieldRef ? resolveDefaultFilterDateConditionField(fieldRef.value, block, context) : void 0
+    );
   }
   const filterItems = value.items;
   if (Array.isArray(filterItems)) {
@@ -5472,11 +5576,33 @@ function visitFilterItems(value, path, errors, block, context = {}) {
     if (_.isPlainObject(child)) {
       Object.entries(child).forEach(([operator, operatorValue]) => {
         collectUnsupportedDefaultFilterOperatorError(operator, `${path}.${key}.${operator}`, errors);
-        collectDefaultFilterDateValueError(operator, operatorValue, `${path}.${key}.${operator}`, errors);
+        collectDefaultFilterDateValueError(
+          operator,
+          operatorValue,
+          `${path}.${key}.${operator}`,
+          errors,
+          resolveDefaultFilterDateConditionField(key, block, context)
+        );
       });
     }
   });
 }
+function resolveDefaultFilterDateConditionField(rawFieldPath, block, context) {
+  const fieldPath = String(rawFieldPath || "").trim();
+  if (!fieldPath || fieldPath.startsWith("$") || fieldPath.startsWith("{{")) {
+    return null;
+  }
+  const collection = getBlockCollection(block, context);
+  if (!collection) {
+    return null;
+  }
+  const dataSourceKey = getBlockDataSourceKey(block, context);
+  const resolved = resolveDefaultFilterFieldPath(collection, (0, import_service_helpers.normalizeFieldPath)(fieldPath), dataSourceKey, context);
+  return {
+    fieldPath,
+    field: resolved.field
+  };
+}
 function collectTreeConnectFieldsErrors(value, path, errors) {
   if (_.isUndefined(value)) {
     return [];
@@ -5825,7 +5951,7 @@ function getCollectionFilterTargetKey(collection) {
 function normalizeDataSourceKey(value) {
   return String(value || "main").trim() || "main";
 }
-function collectTableSettingsErrors(block, blockType, blockPath, errors, options = {}) {
+function collectTableSettingsErrors(block, blockType, blockPath, errors, options = {}, context = {}) {
   if (blockType !== "table" || !_.isPlainObject(block)) {
     return;
   }
@@ -5836,6 +5962,9 @@ function collectTableSettingsErrors(block, blockType, blockPath, errors, options
   });
   const hasSettings = _.isPlainObject(block == null ? void 0 : block.settings);
   if (!hasSettings) {
+    if (options.directSettings === true && !shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options)) {
+      collectPublicDataScopeErrors(block.dataScope, `${blockPath}.dataScope`, errors, block, context);
+    }
     return;
   }
   const settings = block.settings;
@@ -5850,7 +5979,7 @@ function collectTableSettingsErrors(block, blockType, blockPath, errors, options
     pushTableSettingsUnsupportedError(errors, `${settingsPath}.${key}`, key);
   });
   if (!shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options)) {
-    collectPublicDataScopeErrors(settings.dataScope, `${settingsPath}.dataScope`, errors);
+    collectPublicDataScopeErrors(settings.dataScope, `${settingsPath}.dataScope`, errors, block, context);
   }
 }
 function pushTableSettingsUnsupportedError(errors, path, key) {
@@ -5865,7 +5994,7 @@ function pushTableSettingsUnsupportedError(errors, path, key) {
     }
   });
 }
-function collectPublicDataScopeErrors(value, path, errors) {
+function collectPublicDataScopeErrors(value, path, errors, block, context) {
   if (_.isUndefined(value)) {
     return;
   }
@@ -5885,6 +6014,62 @@ function collectPublicDataScopeErrors(value, path, errors) {
         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.'
       }
     });
+    return;
+  }
+  collectPublicDataScopeFieldPathErrors(validationValue, path, errors, block, context);
+  collectFilterGroupDateConditionErrors(validationValue, path, errors, block, context);
+}
+function collectPublicDataScopeFieldPathErrors(value, path, errors, block, context) {
+  if (!_.isPlainObject(value)) {
+    return;
+  }
+  if (hasOwn(value, "operator")) {
+    collectPublicDataScopeFieldPathError(value.path, `${path}.path`, block, context, errors);
+  }
+  if (Array.isArray(value.items)) {
+    value.items.forEach(
+      (item, index) => collectPublicDataScopeFieldPathErrors(item, `${path}.items[${index}]`, errors, block, context)
+    );
+  }
+}
+function collectPublicDataScopeFieldPathError(rawFieldPath, path, block, context, errors) {
+  const fieldPath = String(rawFieldPath || "").trim();
+  if (!fieldPath || fieldPath.startsWith("$") || fieldPath.startsWith("{{")) {
+    return;
+  }
+  const collection = getBlockCollection(block, context);
+  if (!collection) {
+    return;
+  }
+  const resolved = resolveDefaultFilterFieldPath(
+    collection,
+    (0, import_service_helpers.normalizeFieldPath)(fieldPath),
+    getBlockDataSourceKey(block, context),
+    context
+  );
+  if (!resolved.field) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "field-path-unknown",
+      message: `flowSurfaces authoring ${path} references unknown field '${fieldPath}'`,
+      details: {
+        fieldPath,
+        collection: (0, import_service_helpers.getCollectionName)(resolved.collection || collection),
+        availableFields: (0, import_service_helpers.getCollectionFields)(resolved.collection || collection).map((field) => String((0, import_service_helpers.getFieldName)(field) || "").trim()).filter(Boolean)
+      }
+    });
+    return;
+  }
+  if ((0, import_service_helpers.isAssociationField)(resolved.field)) {
+    pushAuthoringError(errors, {
+      path,
+      ruleId: "defaultFilter-relation-field-unsupported",
+      message: `flowSurfaces authoring ${path} cannot use relation field '${fieldPath}' itself; use a scalar subfield instead`,
+      details: {
+        fieldPath,
+        fieldName: (0, import_service_helpers.getFieldName)(resolved.field)
+      }
+    });
   }
 }
 function shouldDeferPublicDataScopeErrorsToBatchItem(blockPath, errors, options) {
@@ -5906,6 +6091,28 @@ function normalizePublicDataScopeValueForValidation(value) {
   }
   return value;
 }
+function collectFilterGroupDateConditionErrors(value, path, errors, block, context) {
+  if (!_.isPlainObject(value)) {
+    return;
+  }
+  if (Array.isArray(value.items)) {
+    value.items.forEach(
+      (item, index) => collectFilterGroupDateConditionErrors(item, `${path}.items[${index}]`, errors, block, context)
+    );
+    return;
+  }
+  if (!hasOwn(value, "operator")) {
+    return;
+  }
+  const fieldPath = String(value.path || value.field || "").trim();
+  collectDefaultFilterDateValueError(
+    value.operator,
+    value.value,
+    `${path}.value`,
+    errors,
+    fieldPath ? resolveDefaultFilterDateConditionField(fieldPath, block, context) : void 0
+  );
+}
 function collectGridCardSettingsErrors(block, blockType, blockPath, errors, options = {}) {
   const hasSettings = _.isPlainObject(block == null ? void 0 : block.settings);
   if (!hasSettings && options.directSettings !== true) {
@@ -6516,7 +6723,7 @@ function collectNestedBlockErrors(blocks, path, errors, localKeys, context) {
   }
   blocks.forEach((block, index) => collectBlockErrors(block, `${path}[${index}]`, errors, localKeys, context));
 }
-function collectReactionErrors(reaction, path, localKeys, errors) {
+function collectReactionErrors(reaction, path, localKeys, errors, options = {}) {
   const items = Array.isArray(reaction == null ? void 0 : reaction.items) ? reaction.items : [];
   items.forEach((item, index) => {
     const rawTarget = (item == null ? void 0 : item.target) ?? (item == null ? void 0 : item.targetKey) ?? (item == null ? void 0 : item.targetBlock);
@@ -6534,8 +6741,198 @@ function collectReactionErrors(reaction, path, localKeys, errors) {
         message: `flowSurfaces authoring ${path}.items[${index}].target references unknown local target '${target}'`
       });
     }
+    collectReactionItemDateConditionErrors(item, `${path}.items[${index}]`, target, errors, options);
+  });
+}
+function collectReactionItemDateConditionErrors(item, path, target, errors, options) {
+  if (!_.isPlainObject(item) || !_.isPlainObject(options.values) || !options.context) {
+    return;
+  }
+  const targetMatch = findApplyBlueprintReactionTargetBlock(options.values, target, options.context);
+  if (!targetMatch) {
+    return;
+  }
+  const type = String(item.type || "").trim();
+  const conditionFieldMetaByPath = buildApplyBlueprintReactionConditionFieldMetaByPath(
+    targetMatch.block,
+    targetMatch.context
+  );
+  _.castArray(item.rules || []).forEach((rule, ruleIndex) => {
+    collectReactionFilterDateConditionErrors(
+      (rule == null ? void 0 : rule.when) ?? (rule == null ? void 0 : rule.condition),
+      `${path}.rules[${ruleIndex}].when`,
+      errors,
+      targetMatch.block,
+      targetMatch.context,
+      conditionFieldMetaByPath
+    );
+    if (type !== "setFieldLinkageRules") {
+      return;
+    }
+    _.castArray((rule == null ? void 0 : rule.then) || (rule == null ? void 0 : rule.actions) || []).forEach((action, actionIndex) => {
+      _.castArray((action == null ? void 0 : action.items) || []).forEach((assignItem, itemIndex) => {
+        collectReactionFilterDateConditionErrors(
+          (assignItem == null ? void 0 : assignItem.when) ?? (assignItem == null ? void 0 : assignItem.condition),
+          `${path}.rules[${ruleIndex}].then[${actionIndex}].items[${itemIndex}].when`,
+          errors,
+          targetMatch.block,
+          targetMatch.context,
+          conditionFieldMetaByPath
+        );
+      });
+    });
   });
 }
+function collectReactionFilterDateConditionErrors(filter, path, errors, block, context, fieldMetaByPath = {}) {
+  if (!_.isPlainObject(filter)) {
+    return;
+  }
+  if (Array.isArray(filter.items)) {
+    filter.items.forEach(
+      (item, index) => collectReactionFilterDateConditionErrors(
+        item,
+        `${path}.items[${index}]`,
+        errors,
+        block,
+        context,
+        fieldMetaByPath
+      )
+    );
+    return;
+  }
+  if (!hasOwn(filter, "operator")) {
+    return;
+  }
+  const conditionPath = normalizeReactionConditionPath(filter.path);
+  const fieldContext = resolveReactionConditionFieldContext(conditionPath, block, context, fieldMetaByPath);
+  collectDefaultFilterDateValueError(filter.operator, filter.value, `${path}.value`, errors, fieldContext, {
+    allowContextPathValue: true
+  });
+}
+function normalizeReactionConditionPath(rawPath) {
+  const value = String(rawPath || "").trim();
+  const templateMatch = /^\{\{\s*ctx(?:\.([^}]+?))?\s*\}\}$/.exec(value);
+  const path = templateMatch ? String(templateMatch[1] || "").trim() : value.replace(/^ctx\./, "");
+  return path.split(".").map((segment) => segment.trim()).filter(Boolean).join(".");
+}
+function buildApplyBlueprintReactionConditionFieldMetaByPath(block, context) {
+  var _a, _b;
+  const collection = getBlockCollection(block, context);
+  const dataSourceKey = getBlockDataSourceKey(block, context);
+  const userCollection = ((_a = context.getCollection) == null ? void 0 : _a.call(context, "main", "users")) || ((_b = context.getCollection) == null ? void 0 : _b.call(context, dataSourceKey, "users")) || null;
+  const response = (0, import_context.buildFlowSurfaceContextResponse)({
+    semantic: {
+      collection,
+      userCollection,
+      recordCollection: collection,
+      formValuesCollection: collection,
+      itemCollections: collection ? [collection] : [],
+      itemRootCollection: collection || void 0,
+      popupLevels: context.isPopupSurface || context.popupHasCurrentRecord ? [
+        {
+          recordCollection: collection,
+          sourceRecordCollection: collection
+        }
+      ] : []
+    },
+    maxDepth: 4
+  });
+  const fieldMetaByPath = collectAuthorableReactionContextFieldMetaByPath(response);
+  addCollectionFieldMetaAliases(fieldMetaByPath, collection, ["collection", "record", "formValues"]);
+  addCollectionFieldMetaAliases(fieldMetaByPath, collection, ["item"], {
+    preserveExisting: true,
+    reservedKeys: /* @__PURE__ */ new Set(["index", "length", "value", "parentItem"])
+  });
+  if (userCollection) {
+    addCollectionFieldMetaAliases(fieldMetaByPath, userCollection, ["user"]);
+  }
+  return fieldMetaByPath;
+}
+function collectAuthorableReactionContextFieldMetaByPath(context) {
+  const fieldMetaByPath = {};
+  const visit = (prefix, info) => {
+    if (!prefix || !info) {
+      return;
+    }
+    if (isAuthorableReactionContextPath(prefix)) {
+      fieldMetaByPath[prefix] = {
+        ...info.type ? { type: info.type } : {},
+        ...info.interface ? { interface: info.interface } : {}
+      };
+    }
+    if (info.dynamicProperties) {
+      visit(`${prefix}.*`, info.dynamicProperties);
+    }
+    Object.entries(info.properties || {}).forEach(([key, child]) => visit(`${prefix}.${key}`, child));
+  };
+  Object.entries((context == null ? void 0 : context.vars) || {}).forEach(([key, info]) => visit(key, info));
+  return fieldMetaByPath;
+}
+function isAuthorableReactionContextPath(path) {
+  const segments = String(path || "").split(".").filter(Boolean);
+  const root = segments[0];
+  if (!root) {
+    return false;
+  }
+  if (AUTHORABLE_REACTION_SCALAR_CONTEXT_PATHS.has(root)) {
+    return segments.length === 1;
+  }
+  return AUTHORABLE_REACTION_CONTEXT_ROOTS.has(root);
+}
+function addCollectionFieldMetaAliases(fieldMetaByPath, collection, roots, options = {}) {
+  var _a;
+  for (const field of (0, import_service_helpers.getCollectionFields)(collection)) {
+    const fieldName = (0, import_service_helpers.getFieldName)(field);
+    if (!fieldName) {
+      continue;
+    }
+    const fieldMeta = {
+      ...(0, import_service_helpers.getFieldType)(field) ? { type: (0, import_service_helpers.getFieldType)(field) } : {},
+      ...(0, import_service_helpers.getFieldInterface)(field) ? { interface: (0, import_service_helpers.getFieldInterface)(field) } : {}
+    };
+    for (const root of roots) {
+      if ((_a = options.reservedKeys) == null ? void 0 : _a.has(fieldName)) {
+        continue;
+      }
+      const aliasPath = `${root}.${fieldName}`;
+      if (options.preserveExisting && fieldMetaByPath[aliasPath]) {
+        continue;
+      }
+      fieldMetaByPath[aliasPath] = {
+        ...fieldMetaByPath[aliasPath],
+        ...fieldMeta
+      };
+    }
+  }
+}
+function resolveReactionConditionFieldContext(path, block, context, fieldMetaByPath) {
+  const normalized = String(path || "").trim();
+  const contextMeta = resolveReactionConditionFieldMeta(normalized, fieldMetaByPath);
+  if (contextMeta) {
+    return {
+      fieldPath: normalized,
+      fieldMeta: contextMeta
+    };
+  }
+  const fieldPath = resolveReactionConditionFieldPath(normalized);
+  return fieldPath ? resolveDefaultFilterDateConditionField(fieldPath, block, context) || void 0 : void 0;
+}
+function resolveReactionConditionFieldMeta(path, fieldMetaByPath) {
+  if (fieldMetaByPath[path]) {
+    return fieldMetaByPath[path];
+  }
+  const wildcardPath = Object.keys(fieldMetaByPath).filter((candidate) => candidate.endsWith(".*")).sort((a, b) => b.length - a.length).find((candidate) => {
+    const prefix = candidate.slice(0, -2);
+    return path.startsWith(`${prefix}.`) && path.length > prefix.length + 1;
+  });
+  return wildcardPath ? fieldMetaByPath[wildcardPath] : void 0;
+}
+function resolveReactionConditionFieldPath(path) {
+  const normalized = String(path || "").trim();
+  const prefixes = ["formValues.", "record.", "item.value.", "item.", "popup.record.", "collection.", "user."];
+  const prefix = prefixes.find((candidate) => normalized.startsWith(candidate));
+  return prefix ? normalized.slice(prefix.length) : "";
+}
 function collectFieldListErrors(fields, path, errors, localKeys, context, block) {
   if (!Array.isArray(fields)) {
     return;