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

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

@@ -39,24 +39,137 @@ __export(filter_group_exports, {
   FLOW_SURFACE_EMPTY_FILTER_GROUP: () => FLOW_SURFACE_EMPTY_FILTER_GROUP,
   FLOW_SURFACE_FILTER_GROUP_EXAMPLE: () => FLOW_SURFACE_FILTER_GROUP_EXAMPLE,
   assertFlowSurfaceFilterGroupShape: () => assertFlowSurfaceFilterGroupShape,
+  assertFlowSurfaceFilterOperator: () => assertFlowSurfaceFilterOperator,
+  normalizeFlowSurfaceFilterDateValue: () => normalizeFlowSurfaceFilterDateValue,
   normalizeFlowSurfaceFilterGroupValue: () => normalizeFlowSurfaceFilterGroupValue
 });
 module.exports = __toCommonJS(filter_group_exports);
+var import_database = require("@nocobase/database");
 var import_utils = require("@nocobase/utils");
 var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
 var import_errors = require("./errors");
 const FLOW_SURFACE_EMPTY_FILTER_GROUP = {
   logic: "$and",
   items: []
 };
 const FLOW_SURFACE_FILTER_GROUP_EXAMPLE = JSON.stringify(FLOW_SURFACE_EMPTY_FILTER_GROUP);
+const FLOW_SURFACE_FILTER_OPERATOR_REPAIR_HINT = "FilterGroup operators must use NocoBase operator names such as $notIn and $dateBefore.";
+const FLOW_SURFACE_FILTER_OPERATOR_REPAIR_EXAMPLE = {
+  logic: "$and",
+  items: [
+    {
+      path: "stage",
+      operator: "$notIn",
+      value: ["won", "lost"]
+    }
+  ]
+};
+const FLOW_SURFACE_DATE_FILTER_OPERATORS = /* @__PURE__ */ new Set([
+  "$dateOn",
+  "$dateNotOn",
+  "$dateBefore",
+  "$dateAfter",
+  "$dateNotBefore",
+  "$dateNotAfter",
+  "$dateBetween"
+]);
+const FLOW_SURFACE_DATE_RANGE_TYPES = /* @__PURE__ */ new Set([
+  "today",
+  "yesterday",
+  "tomorrow",
+  "thisWeek",
+  "lastWeek",
+  "nextWeek",
+  "thisMonth",
+  "lastMonth",
+  "nextMonth",
+  "thisQuarter",
+  "lastQuarter",
+  "nextQuarter",
+  "thisYear",
+  "lastYear",
+  "nextYear",
+  "past",
+  "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_DATE_VALUE_REPAIR_EXAMPLE = {
+  logic: "$and",
+  items: [
+    {
+      path: "lastFollowUpAt",
+      operator: "$dateBefore",
+      value: { type: "past", number: 14, unit: "day" }
+    }
+  ]
+};
+const FLOW_SURFACE_KNOWN_FILTER_OPERATORS = buildFlowSurfaceKnownFilterOperators();
+function buildFlowSurfaceKnownFilterOperators() {
+  const operators = new Set(Object.keys(import_database.operators));
+  for (const key in import_sequelize.Op) {
+    operators.add(`$${key}`);
+    const underscored = import_sequelize.Utils.underscoredIf(key, true);
+    operators.add(`$${underscored}`);
+    operators.add(`$${underscored.replace(/_/g, "")}`);
+  }
+  return operators;
+}
+function getSuggestedFlowSurfaceFilterOperator(operator) {
+  if (operator.startsWith("$")) {
+    return void 0;
+  }
+  const suggestedOperator = `$${operator}`;
+  return FLOW_SURFACE_KNOWN_FILTER_OPERATORS.has(suggestedOperator) ? suggestedOperator : void 0;
+}
+function assertFlowSurfaceFilterOperator(operator, path) {
+  if (typeof operator !== "string" || !operator.trim()) {
+    (0, import_errors.throwBadRequest)(`${path} must be a non-empty operator string`, {
+      path,
+      ruleId: "filter-group-operator-invalid",
+      details: {
+        invalidOperator: operator,
+        repairHint: FLOW_SURFACE_FILTER_OPERATOR_REPAIR_HINT,
+        repairExample: FLOW_SURFACE_FILTER_OPERATOR_REPAIR_EXAMPLE
+      }
+    });
+  }
+  if (!operator.startsWith("$")) {
+    const suggestedOperator = getSuggestedFlowSurfaceFilterOperator(operator);
+    (0, import_errors.throwBadRequest)(
+      suggestedOperator ? `${path} must start with "$"; use "${suggestedOperator}" instead of "${operator}"` : `${path} must start with "$"`,
+      {
+        path,
+        ruleId: "filter-group-operator-missing-dollar",
+        details: {
+          invalidOperator: operator,
+          ...suggestedOperator ? { suggestedOperator } : {},
+          repairHint: FLOW_SURFACE_FILTER_OPERATOR_REPAIR_HINT,
+          repairExample: FLOW_SURFACE_FILTER_OPERATOR_REPAIR_EXAMPLE
+        }
+      }
+    );
+  }
+}
+function normalizeFlowSurfaceFilterDateValue(operator, value, path) {
+  if (typeof operator !== "string" || !FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator)) {
+    return value;
+  }
+  return normalizeFlowSurfaceDateValue(value, path);
+}
 function normalizeFlowSurfaceFilterGroupValue(value, errorPrefix) {
   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);
     (0, import_utils.transformFilter)(normalized);
     return normalized;
   } 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}`);
   }
@@ -85,10 +198,192 @@ function assertFlowSurfaceFilterGroupShape(filter) {
     throw new Error("Invalid filter item type");
   });
 }
+function assertFlowSurfaceFilterGroupOperators(filter, errorPrefix) {
+  filter.items.forEach((item, index) => {
+    const itemPath = `${errorPrefix}.items[${index}]`;
+    if (import_lodash.default.isPlainObject(item) && "logic" in item && "items" in item) {
+      assertFlowSurfaceFilterGroupOperators(item, itemPath);
+      return;
+    }
+    assertFlowSurfaceFilterOperator(item.operator, `${itemPath}.operator`);
+  });
+}
+function normalizeFlowSurfaceFilterGroupDateValues(filter, errorPrefix) {
+  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);
+      return;
+    }
+    item.value = normalizeFlowSurfaceFilterDateValue(item.operator, item.value, `${itemPath}.value`);
+  });
+}
+function normalizeFlowSurfaceDateValue(value, path) {
+  if (import_lodash.default.isNil(value) || value === "") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const normalized2 = normalizeFlowSurfaceDateArrayValue(value, path);
+    if (!hasTemplateDateValue(normalized2)) {
+      assertFlowSurfaceDateValueParsable(normalized2, path);
+    }
+    return normalized2;
+  }
+  const normalized = normalizeFlowSurfaceDateValuePart(value, path);
+  if (!hasTemplateDateValue(normalized)) {
+    assertFlowSurfaceDateValueParsable(normalized, path);
+  }
+  return normalized;
+}
+function normalizeFlowSurfaceDateArrayValue(value, path) {
+  if (value.length !== 2) {
+    throwInvalidFlowSurfaceDateValue(path, value, {
+      invalidReason: "date range arrays must contain exactly start and end values"
+    });
+  }
+  return value.map((item, index) => normalizeFlowSurfaceDateValuePart(item, `${path}[${index}]`));
+}
+function normalizeFlowSurfaceDateValuePart(value, path) {
+  if (import_lodash.default.isNil(value) || value === "" || isTemplateDateString(value) || value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const relative = normalizeRelativeDateShorthand(value, path);
+    if (relative) {
+      return relative;
+    }
+    assertFlowSurfaceDateValueParsable(value, path);
+    return value;
+  }
+  if (import_lodash.default.isPlainObject(value)) {
+    return normalizeRelativeDateDescriptor(value, path);
+  }
+  assertFlowSurfaceDateValueParsable(value, path);
+  return value;
+}
+function normalizeRelativeDateShorthand(value, path) {
+  const match = /^\s*([+-])(\d+)d\s*$/i.exec(value);
+  if (!match) {
+    return void 0;
+  }
+  return normalizeRelativeDateDescriptor(
+    {
+      type: match[1] === "-" ? "past" : "next",
+      number: Number(match[2]),
+      unit: "day"
+    },
+    path
+  );
+}
+function normalizeRelativeDateDescriptor(value, path) {
+  const rawType = value.type;
+  const type = typeof rawType === "string" ? rawType.trim() : "";
+  if (!isTemplateDateString(rawType) && !FLOW_SURFACE_DATE_RANGE_TYPES.has(type)) {
+    throwInvalidFlowSurfaceDateValue(path, value, {
+      invalidReason: type ? `unsupported relative date type "${type}"` : "relative date descriptor must include type"
+    });
+  }
+  const normalized = {
+    ...value,
+    type: isTemplateDateString(rawType) ? rawType : type
+  };
+  if (type === "past" || type === "next") {
+    if (import_lodash.default.isUndefined(value.number)) {
+      normalized.number = 1;
+    } else if (!isTemplateDateString(value.number)) {
+      const number = Number(value.number);
+      if (!Number.isFinite(number) || number <= 0) {
+        throwInvalidFlowSurfaceDateValue(path, value, {
+          invalidReason: "past/next relative date descriptor number must be greater than 0"
+        });
+      }
+      normalized.number = number;
+    }
+    if (import_lodash.default.isUndefined(value.unit)) {
+      normalized.unit = "day";
+    } else if (!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;
+    }
+  } 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.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 (!hasTemplateDateValue(normalized)) {
+    try {
+      (0, import_utils.getDayRangeByParams)(normalized);
+    } catch (error) {
+      throwInvalidFlowSurfaceDateValue(path, value, {
+        invalidReason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return normalized;
+}
+function isTemplateDateString(value) {
+  return typeof value === "string" && /^\s*\{\{[\s\S]*\}\}\s*$/.test(value);
+}
+function hasTemplateDateValue(value) {
+  if (isTemplateDateString(value)) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.some((item) => hasTemplateDateValue(item));
+  }
+  if (import_lodash.default.isPlainObject(value)) {
+    return Object.values(value).some((item) => hasTemplateDateValue(item));
+  }
+  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,
+    ruleId: "filter-group-date-value-invalid",
+    details: {
+      invalidValue: value,
+      ...details,
+      repairHint: FLOW_SURFACE_DATE_VALUE_REPAIR_HINT,
+      repairExample: FLOW_SURFACE_DATE_VALUE_REPAIR_EXAMPLE
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FLOW_SURFACE_EMPTY_FILTER_GROUP,
   FLOW_SURFACE_FILTER_GROUP_EXAMPLE,
   assertFlowSurfaceFilterGroupShape,
+  assertFlowSurfaceFilterOperator,
+  normalizeFlowSurfaceFilterDateValue,
   normalizeFlowSurfaceFilterGroupValue
 });

package/dist/server/flow-surfaces/route-sync.js

@@ -166,7 +166,7 @@ class FlowSurfaceRouteSync {
     await this.removeRouteAnchorChildren(schemaUid, transaction);
   }
   async persistPageSettings(target, current, nextPayload, transaction) {
-    var _a;
+    var _a, _b;
     const route = await this.hydrateRoute(target.pageRoute, transaction);
     const routeValues = this.buildPageRoutePatch(current, nextPayload, route);
     if (Object.keys(routeValues).length) {
@@ -175,8 +175,25 @@ class FlowSurfaceRouteSync {
         values: routeValues,
         transaction
       });
+      if (Object.prototype.hasOwnProperty.call(routeValues, "enableTabs")) {
+        const tabRouteHidden = !routeValues.enableTabs;
+        await Promise.all(
+          import_lodash.default.castArray(((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "children")) || (route == null ? void 0 : route.children) || []).map((tabRoute) => {
+            var _a2;
+            return ((_a2 = tabRoute == null ? void 0 : tabRoute.get) == null ? void 0 : _a2.call(tabRoute, "id")) ?? (tabRoute == null ? void 0 : tabRoute.id);
+          }).filter((routeId) => !import_lodash.default.isNil(routeId) && routeId !== "").map(
+            (routeId) => this.db.getRepository("desktopRoutes").update({
+              filterByTk: String(routeId),
+              values: {
+                hidden: tabRouteHidden
+              },
+              transaction
+            })
+          )
+        );
+      }
     }
-    const pageSchemaUid = ((_a = route == null ? void 0 : route.get) == null ? void 0 : _a.call(route, "schemaUid")) || (route == null ? void 0 : route.schemaUid);
+    const pageSchemaUid = ((_b = route == null ? void 0 : route.get) == null ? void 0 : _b.call(route, "schemaUid")) || (route == null ? void 0 : route.schemaUid);
     const pageModel = target.pageModel || (pageSchemaUid ? await this.repository.findModelByParentId(pageSchemaUid, {
       transaction,
       subKey: "page",

package/dist/server/flow-surfaces/service-utils.js

@@ -625,7 +625,7 @@ function rethrowInlineConfigurationError(error, prefix) {
   if ((0, import_errors.isFlowSurfaceError)(error)) {
     const normalized = (0, import_errors.normalizeFlowSurfaceError)(error);
     if (normalized.type === "bad_request") {
-      (0, import_errors.throwBadRequest)(message, normalized.code);
+      (0, import_errors.throwBadRequest)(message, normalized.code, normalized.options);
     }
     if (normalized.type === "conflict") {
       (0, import_errors.throwConflict)(message, normalized.code);

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

@@ -11,6 +11,7 @@ import _ from 'lodash';
 import FlowModelRepository from '../repository';
 import type { FlowSurfaceApplyBlueprintDocument } from './blueprint';
 import { SurfaceLocator } from './locator';
+import { type FlowSurfaceEventFlowRegistry } from './event-flow-normalizer';
 import type { TemplateTranslate } from './template-display';
 import type { FlowSurfaceActionLinkageRule, FlowSurfaceBlockLinkageRule, FlowSurfaceFieldLinkageRule, FlowSurfaceFieldValueRule, FlowSurfaceGetReactionMetaResult, FlowSurfaceGetReactionMetaValues, FlowSurfaceReactionWriteResult, FlowSurfaceReactionWriteValues } from './reaction/types';
 import type { FlowSurfaceTemplateListPopupActionContext, FlowSurfaceTemplateListValues, FlowSurfaceTemplateRow } from './template-service-utils';
@@ -768,7 +769,7 @@ export declare class FlowSurfacesService {
             kind: import("./types").FlowSurfaceContainerKind;
             use: any;
         };
-        flowRegistry: any;
+        flowRegistry: FlowSurfaceEventFlowRegistry;
         events: {
             direct: string[];
             object: string[];
@@ -839,6 +840,7 @@ export declare class FlowSurfacesService {
     }>;
     private resolveEventFlowTarget;
     private getEventFlowRegistry;
+    private normalizeEventFlowRegistry;
     private buildEventFlowFingerprint;
     private assertEventFlowFingerprint;
     private normalizeEventFlowKey;