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

package/dist/server/flow-surfaces/contract-guard.js

@@ -349,33 +349,67 @@ function collectSchemaValueErrors(value, schema, path) {
 function normalizeDomainValue(value, contract, context) {
   const normalized = import_lodash.default.cloneDeep(value);
   Object.entries(contract.pathSchemas || {}).forEach(([path, schema]) => {
-    if (!import_lodash.default.has(normalized, path) || !isFilterGroupSchema(schema)) {
+    if (!import_lodash.default.has(normalized, path)) {
       return;
     }
-    import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+    if (isFilterGroupSchema(schema)) {
+      import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+    } else if (isLinkageRulesSchema(schema)) {
+      import_lodash.default.set(normalized, path, normalizeLinkageRulesValue(import_lodash.default.get(normalized, path), context, path));
+    }
   });
   return normalized;
 }
 function normalizeGroupValue(value, groupContract, context) {
   const normalized = import_lodash.default.cloneDeep(value);
   Object.entries(groupContract.pathSchemas || {}).forEach(([path, schema]) => {
-    if (!import_lodash.default.has(normalized, path) || !isFilterGroupSchema(schema)) {
+    if (!import_lodash.default.has(normalized, path)) {
       return;
     }
-    import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+    if (isFilterGroupSchema(schema)) {
+      import_lodash.default.set(normalized, path, normalizeFilterGroupValue(import_lodash.default.get(normalized, path), context, path));
+    } else if (isLinkageRulesSchema(schema)) {
+      import_lodash.default.set(normalized, path, normalizeLinkageRulesValue(import_lodash.default.get(normalized, path), context, path));
+    }
   });
   return normalized;
 }
 function isFilterGroupSchema(schema) {
   return (schema == null ? void 0 : schema["x-flowSurfaceFormat"]) === "filter-group";
 }
+function isLinkageRulesSchema(schema) {
+  return (schema == null ? void 0 : schema["x-flowSurfaceFormat"]) === "linkage-rules";
+}
 function normalizeFilterGroupValue(value, context, path) {
   const domainPath = context.groupKey ? `${context.domain}.${context.groupKey}.${path}` : `${context.domain}.${path}`;
   return (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
     value,
-    `flowSurfaces updateSettings domain '${domainPath}' on '${context.use}' expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`
+    `flowSurfaces updateSettings domain '${domainPath}' on '${context.use}' expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+    { strictDateValues: true }
   );
 }
+function normalizeLinkageRulesValue(value, context, path) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  return value.map((rule, index) => {
+    if (!import_lodash.default.isPlainObject(rule) || !import_lodash.default.has(rule, "condition")) {
+      return rule;
+    }
+    const normalizedRule = import_lodash.default.cloneDeep(rule);
+    const domainPath = context.groupKey ? `${context.domain}.${context.groupKey}.${path}[${index}].condition` : `${context.domain}.${path}[${index}].condition`;
+    import_lodash.default.set(
+      normalizedRule,
+      "condition",
+      (0, import_filter_group.normalizeFlowSurfaceCompatibleFilterGroupValue)(
+        import_lodash.default.get(normalizedRule, "condition"),
+        `flowSurfaces updateSettings domain '${domainPath}' on '${context.use}' expects FilterGroup or backend query filter like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+        { strictDateValues: true }
+      )
+    );
+    return normalizedRule;
+  });
+}
 function isContractDefinedFlowGroup(groupContract) {
   if (!groupContract) {
     return false;

package/dist/server/flow-surfaces/default-block-actions.js

@@ -104,6 +104,8 @@ const FLOW_SURFACE_DEFAULT_BLOCK_ACTIONS = {
   ],
   calendar: [
     { type: "filter", scope: "actions" },
+    { type: "turnPages", scope: "actions" },
+    { type: "selectView", scope: "actions" },
     { type: "refresh", scope: "actions" },
     {
       type: "addNew",

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

@@ -8,6 +8,7 @@
  */
 export type FlowSurfaceErrorType = 'bad_request' | 'forbidden' | 'conflict' | 'internal_error';
 export interface FlowSurfaceErrorItem {
+    index?: number;
     message: string;
     type: FlowSurfaceErrorType;
     code: string;
@@ -48,6 +49,20 @@ export declare class FlowSurfaceAggregateError extends FlowSurfaceError {
     readonly errors: FlowSurfaceErrorItem[];
     constructor(errors: FlowSurfaceErrorItemInput[], message?: string);
     toResponseBody(): {
+        message: string;
+        errorCount: number;
+        details: {
+            requiredBlockPolicy?: {
+                requiredBlockTypes: string[];
+                fixStrategy: string;
+                doNotReplaceOrDrop: boolean;
+            };
+            errorCount: number;
+            mustFixAllErrorsBeforeRetry: boolean;
+            retryPolicy: string;
+            sameWriteRetryRequired: boolean;
+            agentInstruction: string;
+        };
         errors: FlowSurfaceErrorItem[];
     };
 }

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

@@ -88,14 +88,27 @@ class FlowSurfaceInternalError extends FlowSurfaceError {
 }
 class FlowSurfaceAggregateError extends FlowSurfaceError {
   errors;
-  constructor(errors, message = "flowSurfaces authoring validation failed") {
-    const normalizedErrors = errors.map((error) => normalizeFlowSurfaceErrorItemInput(error));
-    super(message, 400, "bad_request", "FLOW_SURFACE_AUTHORING_VALIDATION_FAILED");
+  constructor(errors, message) {
+    const normalizedErrors = errors.map(
+      (error, index) => normalizeFlowSurfaceErrorItemInput({
+        ...error,
+        index: index + 1
+      })
+    );
+    super(
+      message || buildAggregateBadRequestMessage(normalizedErrors.length),
+      400,
+      "bad_request",
+      "FLOW_SURFACE_AUTHORING_VALIDATION_FAILED"
+    );
     this.name = "FlowSurfaceAggregateError";
     this.errors = normalizedErrors;
   }
   toResponseBody() {
     return {
+      message: this.message,
+      errorCount: this.errors.length,
+      details: buildAggregateBadRequestDetails(this.errors),
       errors: this.errors
     };
   }
@@ -162,6 +175,9 @@ function buildDefinedErrorItem(input) {
     code: input.code,
     status: input.status
   };
+  if (typeof input.index !== "undefined") {
+    output.index = input.index;
+  }
   if (typeof input.path !== "undefined") {
     output.path = input.path;
   }
@@ -176,6 +192,7 @@ function buildDefinedErrorItem(input) {
 function normalizeFlowSurfaceErrorItemInput(input) {
   return buildDefinedErrorItem({
     message: input.message,
+    index: input.index,
     type: input.type || "bad_request",
     code: input.code || "FLOW_SURFACE_AUTHORING_VALIDATION_ERROR",
     status: input.status || 400,
@@ -184,6 +201,35 @@ function normalizeFlowSurfaceErrorItemInput(input) {
     details: input.details
   });
 }
+function buildAggregateBadRequestMessage(errorCount) {
+  return `flowSurfaces authoring validation failed with ${errorCount} error(s); fix all errors before retrying the same write`;
+}
+function buildAggregateBadRequestDetails(errors) {
+  const requiredBlockTypes = Array.from(
+    new Set(
+      errors.map((error) => {
+        var _a;
+        return (_a = error.details) == null ? void 0 : _a.requiredBlockType;
+      }).filter(
+        (requiredBlockType) => typeof requiredBlockType === "string" && !!requiredBlockType
+      )
+    )
+  );
+  return {
+    errorCount: errors.length,
+    mustFixAllErrorsBeforeRetry: true,
+    retryPolicy: "fix_all_errors_before_retry_same_write",
+    sameWriteRetryRequired: true,
+    agentInstruction: "Read the complete errors[] array. Fix every listed error in one payload revision before retrying the same write. Do not fix only the first error and immediately retry. Do not drop, defer, or replace required chart, jsBlock, or JS/RunJS work to bypass validation.",
+    ...requiredBlockTypes.length ? {
+      requiredBlockPolicy: {
+        requiredBlockTypes,
+        fixStrategy: "repair_same_block_type",
+        doNotReplaceOrDrop: true
+      }
+    } : {}
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FlowSurfaceAggregateError,

package/dist/server/flow-surfaces/filter-group.d.ts

@@ -13,5 +13,11 @@ export declare const FLOW_SURFACE_EMPTY_FILTER_GROUP: {
 export declare const FLOW_SURFACE_FILTER_GROUP_EXAMPLE: string;
 export declare function assertFlowSurfaceFilterOperator(operator: unknown, path: string): void;
 export declare function normalizeFlowSurfaceFilterDateValue(operator: unknown, value: unknown, path: string): unknown;
-export declare function normalizeFlowSurfaceFilterGroupValue(value: any, errorPrefix: string): any;
+export declare function normalizeFlowSurfaceStrictFilterDateValue(operator: unknown, value: unknown, path: string): unknown;
+export declare function normalizeFlowSurfaceFilterGroupValue(value: any, errorPrefix: string, options?: {
+    strictDateValues?: boolean;
+}): any;
+export declare function normalizeFlowSurfaceCompatibleFilterGroupValue(value: unknown, errorPrefix: string, options?: {
+    strictDateValues?: boolean;
+}): any;
 export declare function assertFlowSurfaceFilterGroupShape(filter: any): void;

package/dist/server/flow-surfaces/filter-group.js

@@ -40,8 +40,10 @@ __export(filter_group_exports, {
   FLOW_SURFACE_FILTER_GROUP_EXAMPLE: () => FLOW_SURFACE_FILTER_GROUP_EXAMPLE,
   assertFlowSurfaceFilterGroupShape: () => assertFlowSurfaceFilterGroupShape,
   assertFlowSurfaceFilterOperator: () => assertFlowSurfaceFilterOperator,
+  normalizeFlowSurfaceCompatibleFilterGroupValue: () => normalizeFlowSurfaceCompatibleFilterGroupValue,
   normalizeFlowSurfaceFilterDateValue: () => normalizeFlowSurfaceFilterDateValue,
-  normalizeFlowSurfaceFilterGroupValue: () => normalizeFlowSurfaceFilterGroupValue
+  normalizeFlowSurfaceFilterGroupValue: () => normalizeFlowSurfaceFilterGroupValue,
+  normalizeFlowSurfaceStrictFilterDateValue: () => normalizeFlowSurfaceStrictFilterDateValue
 });
 module.exports = __toCommonJS(filter_group_exports);
 var import_database = require("@nocobase/database");
@@ -94,7 +96,9 @@ const FLOW_SURFACE_DATE_RANGE_TYPES = /* @__PURE__ */ new Set([
   "next"
 ]);
 const FLOW_SURFACE_DATE_RANGE_UNITS = /* @__PURE__ */ new Set(["day", "week", "month", "year"]);
-const FLOW_SURFACE_DATE_VALUE_REPAIR_HINT = 'Date filter values must use NocoBase-supported date values such as "2026-05-17", ["2026-05-01","2026-05-31"], or UI relative date descriptors like {"type":"past","number":14,"unit":"day"}.';
+const FLOW_SURFACE_RELATIVE_DATE_DESCRIPTOR_KEYS = /* @__PURE__ */ new Set(["type", "number", "unit"]);
+const FLOW_SURFACE_EXACT_DATE_VALUE_FORMATS = ["YYYY-MM-DD", "YYYY-MM", "YYYY", "YYYY[Q]Q", "YYYY-[Q]Q"];
+const FLOW_SURFACE_DATE_VALUE_REPAIR_HINT = 'Date filter values must match the NocoBase filter UI contract: exact values like "2026-05-17", "2026-05", "2026", "2026-Q2", ranges like ["2026-05-01","2026-05-31"], or relative date descriptors like {"type":"past","number":14,"unit":"day"} and {"type":"thisWeek"}.';
 const FLOW_SURFACE_DATE_VALUE_REPAIR_EXAMPLE = {
   logic: "$and",
   items: [
@@ -158,12 +162,23 @@ function normalizeFlowSurfaceFilterDateValue(operator, value, path) {
   }
   return normalizeFlowSurfaceDateValue(value, path);
 }
-function normalizeFlowSurfaceFilterGroupValue(value, errorPrefix) {
+function normalizeFlowSurfaceStrictFilterDateValue(operator, value, path) {
+  if (typeof operator !== "string" || !FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator)) {
+    return value;
+  }
+  if (import_lodash.default.isNil(value) || value === "") {
+    throwInvalidFlowSurfaceDateValue(path, value, {
+      invalidReason: "date filter value is required"
+    });
+  }
+  return normalizeFlowSurfaceDateValue(value, path);
+}
+function normalizeFlowSurfaceFilterGroupValue(value, errorPrefix, options = {}) {
   const normalized = value === null || import_lodash.default.isPlainObject(value) && !Object.keys(value).length ? import_lodash.default.cloneDeep(FLOW_SURFACE_EMPTY_FILTER_GROUP) : import_lodash.default.cloneDeep(value);
   try {
     assertFlowSurfaceFilterGroupShape(normalized);
     assertFlowSurfaceFilterGroupOperators(normalized, errorPrefix);
-    normalizeFlowSurfaceFilterGroupDateValues(normalized, errorPrefix);
+    normalizeFlowSurfaceFilterGroupDateValues(normalized, errorPrefix, options);
     (0, import_utils.transformFilter)(normalized);
     return normalized;
   } catch (error) {
@@ -174,10 +189,30 @@ function normalizeFlowSurfaceFilterGroupValue(value, errorPrefix) {
     (0, import_errors.throwBadRequest)(`${errorPrefix}: ${reason}`);
   }
 }
+function normalizeFlowSurfaceCompatibleFilterGroupValue(value, errorPrefix, options = {}) {
+  const input = value === null || import_lodash.default.isPlainObject(value) && !Object.keys(value).length ? import_lodash.default.cloneDeep(FLOW_SURFACE_EMPTY_FILTER_GROUP) : import_lodash.default.cloneDeep(value);
+  if (isFlowSurfaceFilterGroupLike(input)) {
+    return normalizeFlowSurfaceFilterGroupValue(input, errorPrefix, options);
+  }
+  try {
+    const converted = convertBackendQueryFilterToFlowSurfaceFilterGroup(input, errorPrefix);
+    return normalizeFlowSurfaceFilterGroupValue(converted, errorPrefix, options);
+  } catch (error) {
+    if (error instanceof import_errors.FlowSurfaceBadRequestError) {
+      throw error;
+    }
+    const reason = error instanceof Error ? error.message : String(error);
+    (0, import_errors.throwBadRequest)(`${errorPrefix}: ${reason}`);
+  }
+}
 function assertFlowSurfaceFilterGroupShape(filter) {
   if (!import_lodash.default.isPlainObject(filter)) {
     throw new Error("Invalid filter: filter must be an object");
   }
+  const unsupportedKeys = Object.keys(filter).filter((key) => key !== "logic" && key !== "items");
+  if (unsupportedKeys.length) {
+    throw new Error(`Invalid filter: filter group does not support: ${unsupportedKeys.join(", ")}`);
+  }
   if (!("logic" in filter) || !("items" in filter)) {
     throw new Error("Invalid filter: filter must have logic and items properties");
   }
@@ -198,6 +233,88 @@ function assertFlowSurfaceFilterGroupShape(filter) {
     throw new Error("Invalid filter item type");
   });
 }
+function isFlowSurfaceFilterGroupLike(value) {
+  if (!import_lodash.default.isPlainObject(value)) {
+    return false;
+  }
+  const filter = value;
+  return "logic" in filter && "items" in filter;
+}
+function isBackendQueryLogicKey(key) {
+  return key === "$and" || key === "$or";
+}
+function convertBackendQueryFilterToFlowSurfaceFilterGroup(input, label) {
+  if (!import_lodash.default.isPlainObject(input)) {
+    throw new Error("Invalid filter: filter must be an object");
+  }
+  const keys = Object.keys(input);
+  const logicKeys = keys.filter(isBackendQueryLogicKey);
+  if (logicKeys.length > 1 || logicKeys.length === 1 && keys.length > 1) {
+    throw new Error("cannot convert backend query filter with mixed logical and field conditions");
+  }
+  if (logicKeys.length === 1) {
+    const logic = logicKeys[0];
+    const operands = input[logic];
+    if (!Array.isArray(operands)) {
+      throw new Error(`${logic}: backend query filter operands must be an array`);
+    }
+    return {
+      logic,
+      items: operands.map((operand, index) => convertBackendQueryOperandToFlowSurfaceFilterItem(operand, label, index))
+    };
+  }
+  if (keys.some((key) => key.startsWith("$"))) {
+    throw new Error("cannot convert backend query filter with unsupported logical operator");
+  }
+  return {
+    logic: "$and",
+    items: Object.entries(input).flatMap(
+      ([field, condition]) => convertBackendFieldConditionToFlowSurfaceFilterItems(field, condition, label)
+    )
+  };
+}
+function convertBackendQueryOperandToFlowSurfaceFilterItem(input, label, index) {
+  if (isFlowSurfaceFilterGroupLike(input)) {
+    throw new Error(`${label}.$operand[${index}]: cannot mix filter groups with backend query filters`);
+  }
+  const group = convertBackendQueryFilterToFlowSurfaceFilterGroup(input, `${label}.$operand[${index}]`);
+  if (group.logic === "$and" && group.items.length === 1) {
+    return group.items[0];
+  }
+  return group;
+}
+function convertBackendFieldConditionToFlowSurfaceFilterItems(field, condition, label) {
+  if (!field.trim() || field.startsWith("$")) {
+    throw new Error(`cannot convert backend query filter field "${field}"`);
+  }
+  if (!import_lodash.default.isPlainObject(condition)) {
+    throw new Error(`${field}: backend query filter condition must be an object`);
+  }
+  const keys = Object.keys(condition);
+  if (!keys.length) {
+    throw new Error(`${field}: backend query filter condition cannot be empty`);
+  }
+  const operatorKeys = keys.filter((key) => key.startsWith("$"));
+  if (operatorKeys.length) {
+    if (operatorKeys.length !== keys.length) {
+      throw new Error(`${field}: cannot mix backend query operators with nested field conditions`);
+    }
+    return operatorKeys.map((operator) => {
+      if (isBackendQueryLogicKey(operator)) {
+        throw new Error(`${field}: cannot convert backend query filter operator "${operator}"`);
+      }
+      assertFlowSurfaceFilterOperator(operator, `${label}.${field}.${operator}`);
+      return {
+        path: field,
+        operator,
+        value: import_lodash.default.cloneDeep(import_lodash.default.get(condition, operator))
+      };
+    });
+  }
+  return Object.entries(condition).flatMap(
+    ([nestedField, nestedCondition]) => convertBackendFieldConditionToFlowSurfaceFilterItems(`${field}.${nestedField}`, nestedCondition, label)
+  );
+}
 function assertFlowSurfaceFilterGroupOperators(filter, errorPrefix) {
   filter.items.forEach((item, index) => {
     const itemPath = `${errorPrefix}.items[${index}]`;
@@ -208,14 +325,14 @@ function assertFlowSurfaceFilterGroupOperators(filter, errorPrefix) {
     assertFlowSurfaceFilterOperator(item.operator, `${itemPath}.operator`);
   });
 }
-function normalizeFlowSurfaceFilterGroupDateValues(filter, errorPrefix) {
+function normalizeFlowSurfaceFilterGroupDateValues(filter, errorPrefix, options) {
   filter.items.forEach((item, index) => {
     const itemPath = `${errorPrefix}.items[${index}]`;
     if (import_lodash.default.isPlainObject(item) && "logic" in item && "items" in item) {
-      normalizeFlowSurfaceFilterGroupDateValues(item, itemPath);
+      normalizeFlowSurfaceFilterGroupDateValues(item, itemPath, options);
       return;
     }
-    item.value = normalizeFlowSurfaceFilterDateValue(item.operator, item.value, `${itemPath}.value`);
+    item.value = options.strictDateValues ? normalizeFlowSurfaceStrictFilterDateValue(item.operator, item.value, `${itemPath}.value`) : normalizeFlowSurfaceFilterDateValue(item.operator, item.value, `${itemPath}.value`);
   });
 }
 function normalizeFlowSurfaceDateValue(value, path) {
@@ -223,17 +340,9 @@ function normalizeFlowSurfaceDateValue(value, path) {
     return value;
   }
   if (Array.isArray(value)) {
-    const normalized2 = normalizeFlowSurfaceDateArrayValue(value, path);
-    if (!hasTemplateDateValue(normalized2)) {
-      assertFlowSurfaceDateValueParsable(normalized2, path);
-    }
-    return normalized2;
+    return normalizeFlowSurfaceDateArrayValue(value, path);
   }
-  const normalized = normalizeFlowSurfaceDateValuePart(value, path);
-  if (!hasTemplateDateValue(normalized)) {
-    assertFlowSurfaceDateValueParsable(normalized, path);
-  }
-  return normalized;
+  return normalizeFlowSurfaceDateValuePart(value, path);
 }
 function normalizeFlowSurfaceDateArrayValue(value, path) {
   if (value.length !== 2) {
@@ -241,41 +350,49 @@ function normalizeFlowSurfaceDateArrayValue(value, path) {
       invalidReason: "date range arrays must contain exactly start and end values"
     });
   }
-  return value.map((item, index) => normalizeFlowSurfaceDateValuePart(item, `${path}[${index}]`));
+  return value.map((item, index) => normalizeFlowSurfaceExactDateValuePart(item, `${path}[${index}]`));
 }
 function normalizeFlowSurfaceDateValuePart(value, path) {
-  if (import_lodash.default.isNil(value) || value === "" || isTemplateDateString(value) || value instanceof Date) {
+  if (import_lodash.default.isNil(value) || value === "" || isTemplateDateString(value)) {
     return value;
   }
   if (typeof value === "string") {
-    const relative = normalizeRelativeDateShorthand(value, path);
-    if (relative) {
-      return relative;
-    }
-    assertFlowSurfaceDateValueParsable(value, path);
-    return value;
+    return normalizeFlowSurfaceExactDateValuePart(value, path);
   }
   if (import_lodash.default.isPlainObject(value)) {
     return normalizeRelativeDateDescriptor(value, path);
   }
-  assertFlowSurfaceDateValueParsable(value, path);
-  return value;
+  throwInvalidFlowSurfaceDateValue(path, value, {
+    invalidReason: "date filter value must be an exact date string, date range array, or relative date descriptor"
+  });
 }
-function normalizeRelativeDateShorthand(value, path) {
-  const match = /^\s*([+-])(\d+)d\s*$/i.exec(value);
-  if (!match) {
-    return void 0;
+function normalizeFlowSurfaceExactDateValuePart(value, path) {
+  if (isTemplateDateString(value)) {
+    return value;
   }
-  return normalizeRelativeDateDescriptor(
-    {
-      type: match[1] === "-" ? "past" : "next",
-      number: Number(match[2]),
-      unit: "day"
-    },
-    path
-  );
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    if (isFlowSurfaceExactDateValue(normalized)) {
+      return normalized;
+    }
+  }
+  throwInvalidFlowSurfaceDateValue(path, value, {
+    invalidReason: "date filter strings must use UI exact date formats YYYY-MM-DD, YYYY-MM, YYYY, YYYYQn, or YYYY-Qn"
+  });
+}
+function isFlowSurfaceExactDateValue(value) {
+  return FLOW_SURFACE_EXACT_DATE_VALUE_FORMATS.some((format) => {
+    const parsed = (0, import_utils.dayjs)(value, format, true);
+    return parsed.isValid() && parsed.format(format) === value;
+  });
 }
 function normalizeRelativeDateDescriptor(value, path) {
+  const invalidKeys = Object.keys(value).filter((key) => !FLOW_SURFACE_RELATIVE_DATE_DESCRIPTOR_KEYS.has(key));
+  if (invalidKeys.length) {
+    throwInvalidFlowSurfaceDateValue(path, value, {
+      invalidReason: `relative date descriptor contains unsupported keys: ${invalidKeys.join(", ")}`
+    });
+  }
   const rawType = value.type;
   const type = typeof rawType === "string" ? rawType.trim() : "";
   if (!isTemplateDateString(rawType) && !FLOW_SURFACE_DATE_RANGE_TYPES.has(type)) {
@@ -289,18 +406,21 @@ function normalizeRelativeDateDescriptor(value, path) {
   };
   if (type === "past" || type === "next") {
     if (import_lodash.default.isUndefined(value.number)) {
-      normalized.number = 1;
+      throwInvalidFlowSurfaceDateValue(path, value, {
+        invalidReason: "past/next relative date descriptor must include number"
+      });
     } else if (!isTemplateDateString(value.number)) {
-      const number = Number(value.number);
-      if (!Number.isFinite(number) || number <= 0) {
+      if (typeof value.number !== "number" || !Number.isFinite(value.number) || value.number <= 0) {
         throwInvalidFlowSurfaceDateValue(path, value, {
           invalidReason: "past/next relative date descriptor number must be greater than 0"
         });
       }
-      normalized.number = number;
+      normalized.number = value.number;
     }
     if (import_lodash.default.isUndefined(value.unit)) {
-      normalized.unit = "day";
+      throwInvalidFlowSurfaceDateValue(path, value, {
+        invalidReason: "past/next relative date descriptor must include unit"
+      });
     } else if (!isTemplateDateString(value.unit)) {
       const unit = typeof value.unit === "string" ? value.unit.trim() : "";
       if (!FLOW_SURFACE_DATE_RANGE_UNITS.has(unit)) {
@@ -311,23 +431,15 @@ function normalizeRelativeDateDescriptor(value, path) {
       normalized.unit = unit;
     }
   } else {
-    if (!import_lodash.default.isUndefined(value.number) && !isTemplateDateString(value.number)) {
-      const number = Number(value.number);
-      if (!Number.isFinite(number) || number <= 0) {
-        throwInvalidFlowSurfaceDateValue(path, value, {
-          invalidReason: "relative date descriptor number must be greater than 0"
-        });
-      }
-      normalized.number = number;
+    if (!import_lodash.default.isUndefined(value.number)) {
+      throwInvalidFlowSurfaceDateValue(path, value, {
+        invalidReason: `relative date descriptor type "${type}" must not include number`
+      });
     }
-    if (!import_lodash.default.isUndefined(value.unit) && !isTemplateDateString(value.unit)) {
-      const unit = typeof value.unit === "string" ? value.unit.trim() : "";
-      if (!FLOW_SURFACE_DATE_RANGE_UNITS.has(unit)) {
-        throwInvalidFlowSurfaceDateValue(path, value, {
-          invalidReason: `unsupported relative date unit "${unit}"`
-        });
-      }
-      normalized.unit = unit;
+    if (!import_lodash.default.isUndefined(value.unit)) {
+      throwInvalidFlowSurfaceDateValue(path, value, {
+        invalidReason: `relative date descriptor type "${type}" must not include unit`
+      });
     }
   }
   if (!hasTemplateDateValue(normalized)) {
@@ -356,16 +468,6 @@ function hasTemplateDateValue(value) {
   }
   return false;
 }
-function assertFlowSurfaceDateValueParsable(value, path) {
-  try {
-    const parsed = (0, import_utils.parseDate)(value);
-    if (parsed) {
-      return;
-    }
-  } catch {
-  }
-  throwInvalidFlowSurfaceDateValue(path, value);
-}
 function throwInvalidFlowSurfaceDateValue(path, value, details = {}) {
   (0, import_errors.throwBadRequest)(`${path} must be a valid date filter value`, {
     path,
@@ -384,6 +486,8 @@ function throwInvalidFlowSurfaceDateValue(path, value, details = {}) {
   FLOW_SURFACE_FILTER_GROUP_EXAMPLE,
   assertFlowSurfaceFilterGroupShape,
   assertFlowSurfaceFilterOperator,
+  normalizeFlowSurfaceCompatibleFilterGroupValue,
   normalizeFlowSurfaceFilterDateValue,
-  normalizeFlowSurfaceFilterGroupValue
+  normalizeFlowSurfaceFilterGroupValue,
+  normalizeFlowSurfaceStrictFilterDateValue
 });

package/dist/server/flow-surfaces/public-data-surface-default-filter.js

@@ -263,7 +263,8 @@ function normalizeFlowSurfacePublicBlockDefaultFilter(actionName, defaultFilter,
   }
   const normalized = (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
     defaultFilter,
-    `flowSurfaces ${actionName} ${fieldPath} expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`
+    `flowSurfaces ${actionName} ${fieldPath} expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+    { strictDateValues: true }
   );
   return normalized;
 }

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

@@ -0,0 +1,66 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { SourceBinding, SourceRange, StringLiteralBinding } from '../internal-types';
+export declare function collectSourceBindings(masked: string, functionRanges: SourceRange[], blockRanges: SourceRange[], staticBlockRanges: SourceRange[]): SourceBinding[];
+export declare function collectStringLiteralBindings(source: string, masked: string, bindings: SourceBinding[]): StringLiteralBinding[];
+export declare function isNamedFunctionOrClassExpression(masked: string, keywordIndex: number, kind: string): boolean;
+export declare function isExpressionPrefixToken(token: string): boolean;
+export declare function findNamedFunctionOrClassExpressionRange(masked: string, keywordIndex: number, kind: string): {
+    start: number;
+    end: number;
+};
+export declare function addSourceBinding(bindings: SourceBinding[], functionRanges: SourceRange[], blockRanges: SourceRange[], staticBlockRanges: SourceRange[], masked: string, name: string, start: number, sourceEnd: number, kind: string): void;
+export declare function resolveBindingScope(masked: string, sourceEnd: number, start: number, kind: string, functionRanges: SourceRange[], blockRanges: SourceRange[], staticBlockRanges: SourceRange[]): SourceRange;
+export declare function findForScopeForDeclaration(masked: string, start: number, blockRanges: SourceRange[]): {
+    start: number;
+    end: number;
+};
+export declare function findForHeaderRangeContaining(masked: string, start: number): {
+    start: number;
+    end: number;
+};
+export declare function findFollowingBraceRange(masked: string, afterIndex: number, blockRanges: SourceRange[]): SourceRange;
+export declare function findFollowingStatementRange(masked: string, afterIndex: number, blockRanges: SourceRange[]): SourceRange;
+export declare function findSingleStatementEnd(masked: string, start: number): number;
+export declare function collectDestructuredVariableBindingNames(masked: string, functionRanges: SourceRange[], blockRanges: SourceRange[], staticBlockRanges: SourceRange[], bindings: SourceBinding[]): void;
+export declare function collectParameterBindingNames(masked: string, bindings: SourceBinding[]): void;
+export declare function collectArrowParameterBindingNames(masked: string, bindings: SourceBinding[]): void;
+export declare function collectMethodParameterBindingNames(masked: string, bindings: SourceBinding[]): void;
+export declare function findBraceBodyAfter(masked: string, afterIndex: number): SourceRange | undefined;
+export declare function findArrowBodyRange(masked: string, afterArrowIndex: number): SourceRange | undefined;
+export declare function addParameterBindings(bindings: SourceBinding[], params: string, range: SourceRange): void;
+export declare function extractBindingPatternNames(pattern: string): string[];
+export declare function collectBindingPatternNames(pattern: string, names: Set<string>): void;
+export declare function collectObjectBindingPatternNames(pattern: string, names: Set<string>): void;
+export declare function collectArrayBindingPatternNames(pattern: string, names: Set<string>): void;
+export declare function findInnermostRange(index: number, ranges: SourceRange[]): SourceRange;
+export declare function isNameBoundAtIndex(bindings: SourceBinding[], name: string, index: number): boolean;
+export declare function findSourceBindingByDeclaration(bindings: SourceBinding[], name: string, declarationStart: number): SourceBinding;
+export declare function isSameAstRange(left: SourceRange, right: SourceRange): boolean;
+export declare function isSourceAliasShadowedAtIndex(alias: SourceRange & {
+    declarationStart?: number;
+    name: string;
+}, bindings: SourceBinding[], index: number): boolean;
+export declare function isAstDefinitelyNonEmptyForInSource(node: any): any;
+export declare function isAstDefinitelyNonEmptyForOfSource(node: any): any;
+export declare function isAstDefinitelyNonEmptyArrayElement(element: any): boolean;
+export declare function isAstDefinitelyEnumerableObjectProperty(property: any): boolean;
+export declare function isAstDefinitelyEnumerableComputedObjectKey(key: any): boolean;
+export declare function findAstAncestor(ancestors: any[], type: string): any;
+export declare function getAstExecutionScopeRange(ancestors: any[], sourceLength: number): SourceRange;
+export declare function isAstAlwaysExecutedInCurrentExecutionScope(ancestors: any[]): boolean;
+export declare function getAstBindingScopeRange(ancestors: any[], sourceLength: number, functionScoped?: boolean): SourceRange;
+export declare function isAstFunctionLike(node: any): boolean;
+export declare function dedupeIndexedEntries<T extends {
+    index: number;
+    match?: string;
+    capability?: string;
+    component?: string;
+}>(entries: T[]): T[];
+export declare function unwrapAstChainExpression(node: any): any;