@nocobase/plugin-flow-engine 2.2.0-alpha.1 → 2.2.0-alpha.10

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

@@ -36,11 +36,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var filter_group_exports = {};
 __export(filter_group_exports, {
+  FLOW_SURFACE_DATE_FILTER_OPERATORS: () => FLOW_SURFACE_DATE_FILTER_OPERATORS,
   FLOW_SURFACE_EMPTY_FILTER_GROUP: () => FLOW_SURFACE_EMPTY_FILTER_GROUP,
   FLOW_SURFACE_FILTER_GROUP_EXAMPLE: () => FLOW_SURFACE_FILTER_GROUP_EXAMPLE,
   assertFlowSurfaceFilterGroupShape: () => assertFlowSurfaceFilterGroupShape,
   assertFlowSurfaceFilterOperator: () => assertFlowSurfaceFilterOperator,
+  isFlowSurfaceDateLikeFieldMeta: () => isFlowSurfaceDateLikeFieldMeta,
   normalizeFlowSurfaceCompatibleFilterGroupValue: () => normalizeFlowSurfaceCompatibleFilterGroupValue,
+  normalizeFlowSurfaceDateConditionValue: () => normalizeFlowSurfaceDateConditionValue,
   normalizeFlowSurfaceFilterDateValue: () => normalizeFlowSurfaceFilterDateValue,
   normalizeFlowSurfaceFilterGroupValue: () => normalizeFlowSurfaceFilterGroupValue,
   normalizeFlowSurfaceStrictFilterDateValue: () => normalizeFlowSurfaceStrictFilterDateValue
@@ -76,6 +79,17 @@ const FLOW_SURFACE_DATE_FILTER_OPERATORS = /* @__PURE__ */ new Set([
   "$dateNotAfter",
   "$dateBetween"
 ]);
+const FLOW_SURFACE_DATE_COMPARISON_OPERATORS = /* @__PURE__ */ new Set(["$eq", "$ne", "$lt", "$lte", "$gt", "$gte", "$in", "$notIn"]);
+const FLOW_SURFACE_EMPTY_FILTER_OPERATORS = /* @__PURE__ */ new Set(["$empty", "$notEmpty", "$exists", "$notExists"]);
+const FLOW_SURFACE_DATE_LIKE_TYPES = /* @__PURE__ */ new Set([
+  "date",
+  "datetime",
+  "dateonly",
+  "datetimenotz",
+  "unixtimestamp",
+  "createdat",
+  "updatedat"
+]);
 const FLOW_SURFACE_DATE_RANGE_TYPES = /* @__PURE__ */ new Set([
   "today",
   "yesterday",
@@ -109,6 +123,18 @@ const FLOW_SURFACE_DATE_VALUE_REPAIR_EXAMPLE = {
     }
   ]
 };
+const FLOW_SURFACE_DATE_CONDITION_REPAIR_HINT = "Date/DateTime condition values must be valid UI date values or safe context-path templates. Do not use template arithmetic such as {{$now - 14 * 24 * 60 * 60 * 1000}}; use date operators such as $dateBefore with a relative descriptor instead.";
+const FLOW_SURFACE_DATE_CONDITION_REPAIR_EXAMPLE = {
+  logic: "$and",
+  items: [
+    {
+      path: "lastFollowUpAt",
+      operator: "$dateBefore",
+      value: { type: "past", number: 14, unit: "day" }
+    }
+  ]
+};
+const FLOW_SURFACE_ISO_DATE_VALUE_RE = /^\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,6})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
 const FLOW_SURFACE_KNOWN_FILTER_OPERATORS = buildFlowSurfaceKnownFilterOperators();
 function buildFlowSurfaceKnownFilterOperators() {
   const operators = new Set(Object.keys(import_database.operators));
@@ -156,13 +182,16 @@ function assertFlowSurfaceFilterOperator(operator, path) {
     );
   }
 }
-function normalizeFlowSurfaceFilterDateValue(operator, value, path) {
+function normalizeFlowSurfaceFilterDateValue(operator, value, path, options = {}) {
   if (typeof operator !== "string" || !FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator)) {
     return value;
   }
+  if (options.allowContextPathValue && isFlowSurfaceContextPathValueObject(value)) {
+    return value;
+  }
   return normalizeFlowSurfaceDateValue(value, path);
 }
-function normalizeFlowSurfaceStrictFilterDateValue(operator, value, path) {
+function normalizeFlowSurfaceStrictFilterDateValue(operator, value, path, options = {}) {
   if (typeof operator !== "string" || !FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator)) {
     return value;
   }
@@ -171,8 +200,33 @@ function normalizeFlowSurfaceStrictFilterDateValue(operator, value, path) {
       invalidReason: "date filter value is required"
     });
   }
+  if (options.allowContextPathValue && isFlowSurfaceContextPathValueObject(value)) {
+    return value;
+  }
   return normalizeFlowSurfaceDateValue(value, path);
 }
+function isFlowSurfaceDateLikeFieldMeta(value) {
+  const fieldType = String((value == null ? void 0 : value.type) || "").trim().toLowerCase();
+  const fieldInterface = String((value == null ? void 0 : value.interface) || "").trim().toLowerCase();
+  return FLOW_SURFACE_DATE_LIKE_TYPES.has(fieldType) || FLOW_SURFACE_DATE_LIKE_TYPES.has(fieldInterface);
+}
+function normalizeFlowSurfaceDateConditionValue(operator, value, path, options = {}) {
+  const normalizedOperator = typeof operator === "string" ? operator.trim() : "";
+  if (!normalizedOperator || FLOW_SURFACE_EMPTY_FILTER_OPERATORS.has(normalizedOperator)) {
+    return value;
+  }
+  if (options.allowContextPathValue && isFlowSurfaceContextPathValueObject(value)) {
+    return value;
+  }
+  if (FLOW_SURFACE_DATE_FILTER_OPERATORS.has(normalizedOperator)) {
+    assertNoUnsafeFlowSurfaceDateTemplateValues(value, path, options);
+    return normalizeFlowSurfaceStrictFilterDateValue(normalizedOperator, value, path);
+  }
+  if (!FLOW_SURFACE_DATE_COMPARISON_OPERATORS.has(normalizedOperator)) {
+    return value;
+  }
+  return normalizeFlowSurfaceDateComparisonValue(normalizedOperator, value, path, options);
+}
 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 {
@@ -332,7 +386,11 @@ function normalizeFlowSurfaceFilterGroupDateValues(filter, errorPrefix, options)
       normalizeFlowSurfaceFilterGroupDateValues(item, itemPath, options);
       return;
     }
-    item.value = options.strictDateValues ? normalizeFlowSurfaceStrictFilterDateValue(item.operator, item.value, `${itemPath}.value`) : normalizeFlowSurfaceFilterDateValue(item.operator, item.value, `${itemPath}.value`);
+    item.value = options.strictDateValues ? normalizeFlowSurfaceStrictFilterDateValue(item.operator, item.value, `${itemPath}.value`, {
+      allowContextPathValue: options.allowContextPathValue
+    }) : normalizeFlowSurfaceFilterDateValue(item.operator, item.value, `${itemPath}.value`, {
+      allowContextPathValue: options.allowContextPathValue
+    });
   });
 }
 function normalizeFlowSurfaceDateValue(value, path) {
@@ -344,6 +402,82 @@ function normalizeFlowSurfaceDateValue(value, path) {
   }
   return normalizeFlowSurfaceDateValuePart(value, path);
 }
+function normalizeFlowSurfaceDateComparisonValue(operator, value, path, options) {
+  if (operator === "$in" || operator === "$notIn") {
+    if (!Array.isArray(value)) {
+      throwInvalidFlowSurfaceDateConditionValue(path, value, {
+        ...options,
+        operator,
+        invalidReason: "date comparison array operators require an array value"
+      });
+    }
+    return value.map(
+      (item, index) => normalizeFlowSurfaceDateComparisonValuePart(item, `${path}[${index}]`, {
+        ...options,
+        operator
+      })
+    );
+  }
+  return normalizeFlowSurfaceDateComparisonValuePart(value, path, {
+    ...options,
+    operator
+  });
+}
+function normalizeFlowSurfaceDateComparisonValuePart(value, path, options) {
+  if (import_lodash.default.isNil(value) || value === "") {
+    throwInvalidFlowSurfaceDateConditionValue(path, value, {
+      ...options,
+      invalidReason: "date comparison value is required; use $empty or $notEmpty for empty checks"
+    });
+  }
+  if (options.allowContextPathValue && isFlowSurfaceContextPathValueObject(value)) {
+    return value;
+  }
+  if (isTemplateDateString(value)) {
+    if (isUnsafeFlowSurfaceDateTemplateString(value)) {
+      throwInvalidFlowSurfaceDateConditionValue(path, value, {
+        ...options,
+        invalidReason: "date condition template strings must be simple context-path references; template arithmetic, $now, Date/dayjs/moment calls, and Invalid date are not supported"
+      });
+    }
+    return value;
+  }
+  if (import_lodash.default.isDate(value)) {
+    if (!Number.isNaN(value.getTime())) {
+      return value;
+    }
+    throwInvalidFlowSurfaceDateConditionValue(path, value, {
+      ...options,
+      invalidReason: "date condition value must be a valid Date"
+    });
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    if (/invalid\s+date/i.test(normalized)) {
+      throwInvalidFlowSurfaceDateConditionValue(path, value, {
+        ...options,
+        invalidReason: "date condition value cannot be Invalid date"
+      });
+    }
+    if (isFlowSurfaceIsoLikeDateValue(normalized)) {
+      return normalized;
+    }
+    throwInvalidFlowSurfaceDateConditionValue(path, value, {
+      ...options,
+      invalidReason: "date comparison strings must use concrete YYYY-MM-DD or ISO-like date/datetime strings"
+    });
+  }
+  if (import_lodash.default.isPlainObject(value)) {
+    throwInvalidFlowSurfaceDateConditionValue(path, value, {
+      ...options,
+      invalidReason: "relative date descriptors require date operators such as $dateBefore or $dateBetween instead of comparison operators"
+    });
+  }
+  throwInvalidFlowSurfaceDateConditionValue(path, value, {
+    ...options,
+    invalidReason: "date condition value must be an exact date string, ISO datetime string, or safe context path template"
+  });
+}
 function normalizeFlowSurfaceDateArrayValue(value, path) {
   if (value.length !== 2) {
     throwInvalidFlowSurfaceDateValue(path, value, {
@@ -386,6 +520,25 @@ function isFlowSurfaceExactDateValue(value) {
     return parsed.isValid() && parsed.format(format) === value;
   });
 }
+function isFlowSurfaceIsoLikeDateValue(value) {
+  const match = FLOW_SURFACE_ISO_DATE_VALUE_RE.exec(value);
+  if (!match) {
+    return false;
+  }
+  const [year, month, day] = value.slice(0, 10).split("-").map((item) => Number(item));
+  const date = new Date(Date.UTC(year, month - 1, day));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+    return false;
+  }
+  const timeMatch = /[T\s](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,6}))?)?/.exec(value);
+  if (!timeMatch) {
+    return true;
+  }
+  const hour = Number(timeMatch[1]);
+  const minute = Number(timeMatch[2]);
+  const second = Number(timeMatch[3] || 0);
+  return hour <= 23 && minute <= 59 && second <= 59 && (0, import_utils.dayjs)(value).isValid();
+}
 function normalizeRelativeDateDescriptor(value, path) {
   const invalidKeys = Object.keys(value).filter((key) => !FLOW_SURFACE_RELATIVE_DATE_DESCRIPTOR_KEYS.has(key));
   if (invalidKeys.length) {
@@ -456,6 +609,67 @@ function normalizeRelativeDateDescriptor(value, path) {
 function isTemplateDateString(value) {
   return typeof value === "string" && /^\s*\{\{[\s\S]*\}\}\s*$/.test(value);
 }
+function isFlowSurfaceContextPathValueObject(value) {
+  if (!import_lodash.default.isPlainObject(value) || value.source !== "path") {
+    return false;
+  }
+  const path = value.path;
+  if (typeof path !== "string") {
+    return false;
+  }
+  const normalizedPath = path.trim();
+  if (isTemplateDateString(normalizedPath)) {
+    return !isUnsafeFlowSurfaceDateTemplateString(normalizedPath);
+  }
+  return isSimpleFlowSurfaceTemplateReference(normalizedPath);
+}
+function extractTemplateDateExpression(value) {
+  return value.replace(/^\s*\{\{\s*/, "").replace(/\s*\}\}\s*$/, "").trim();
+}
+function isSimpleFlowSurfaceTemplateReference(expression) {
+  const identifier = "[A-Za-z_$][A-Za-z0-9_$-]*";
+  const segment = `(?:\\.${identifier}|\\[(?:\\d+|"[^"\\]]+"|'[^'\\]]+')\\])`;
+  return new RegExp(`^${identifier}(?:${segment})*$`).test(expression.replace(/\s+/g, ""));
+}
+function isUnsafeFlowSurfaceDateTemplateString(value) {
+  const expression = extractTemplateDateExpression(value);
+  if (!expression) {
+    return true;
+  }
+  if (/\$now\b/i.test(expression)) {
+    return true;
+  }
+  if (/invalid\s+date/i.test(expression)) {
+    return true;
+  }
+  if (/\bnew\s+Date\b|\bDate\s*\(|\bdayjs\s*\(|\bmoment\s*\(/.test(expression)) {
+    return true;
+  }
+  if (isSimpleFlowSurfaceTemplateReference(expression)) {
+    return false;
+  }
+  return /[+\-*/%()]|=>/.test(expression);
+}
+function assertNoUnsafeFlowSurfaceDateTemplateValues(value, path, options = {}) {
+  if (isTemplateDateString(value)) {
+    if (isUnsafeFlowSurfaceDateTemplateString(value)) {
+      throwInvalidFlowSurfaceDateConditionValue(path, value, {
+        ...options,
+        invalidReason: "date filter template strings must be simple context-path references; template arithmetic, $now, Date/dayjs/moment calls, and Invalid date are not supported"
+      });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertNoUnsafeFlowSurfaceDateTemplateValues(item, `${path}[${index}]`, options));
+    return;
+  }
+  if (import_lodash.default.isPlainObject(value)) {
+    Object.entries(value).forEach(
+      ([key, item]) => assertNoUnsafeFlowSurfaceDateTemplateValues(item, `${path}.${key}`, options)
+    );
+  }
+}
 function hasTemplateDateValue(value) {
   if (isTemplateDateString(value)) {
     return true;
@@ -468,6 +682,18 @@ function hasTemplateDateValue(value) {
   }
   return false;
 }
+function throwInvalidFlowSurfaceDateConditionValue(path, value, details = {}) {
+  (0, import_errors.throwBadRequest)(`${path} must be a valid Date/DateTime condition value`, {
+    path,
+    ruleId: "date-condition-value-invalid",
+    details: {
+      invalidValue: value,
+      ...details,
+      repairHint: FLOW_SURFACE_DATE_CONDITION_REPAIR_HINT,
+      repairExample: FLOW_SURFACE_DATE_CONDITION_REPAIR_EXAMPLE
+    }
+  });
+}
 function throwInvalidFlowSurfaceDateValue(path, value, details = {}) {
   (0, import_errors.throwBadRequest)(`${path} must be a valid date filter value`, {
     path,
@@ -482,11 +708,14 @@ function throwInvalidFlowSurfaceDateValue(path, value, details = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FLOW_SURFACE_DATE_FILTER_OPERATORS,
   FLOW_SURFACE_EMPTY_FILTER_GROUP,
   FLOW_SURFACE_FILTER_GROUP_EXAMPLE,
   assertFlowSurfaceFilterGroupShape,
   assertFlowSurfaceFilterOperator,
+  isFlowSurfaceDateLikeFieldMeta,
   normalizeFlowSurfaceCompatibleFilterGroupValue,
+  normalizeFlowSurfaceDateConditionValue,
   normalizeFlowSurfaceFilterDateValue,
   normalizeFlowSurfaceFilterGroupValue,
   normalizeFlowSurfaceStrictFilterDateValue

package/dist/server/flow-surfaces/navigation-targets.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 { Database, Transaction } from '@nocobase/database';
+export declare const DEFAULT_ADMIN_UI_LAYOUT_UID = "admin-layout-model";
+export declare const DEFAULT_MOBILE_UI_LAYOUT_UID = "mobile-layout-model";
+export declare const DEFAULT_ADMIN_MULTI_PORTAL_UID = "__default_admin__";
+export declare const DEFAULT_MOBILE_MULTI_PORTAL_UID = "__default_mobile__";
+export type FlowSurfaceNavigationRequestRoles = readonly string[] | string;
+export type FlowSurfaceResolvedMultiPortal = {
+    uid: string;
+    title: string;
+    icon?: string | null;
+    routeName?: string;
+    routePath?: string;
+    authCheck?: boolean;
+    enabled: true;
+    layoutUid: string;
+    layoutType?: string;
+};
+export type FlowSurfaceNavigationTarget = {
+    kind: 'layout' | 'portal';
+    uid: string;
+    title: string;
+    icon?: string | null;
+    layoutUid: string;
+    layoutType?: string;
+    routeName?: string;
+    routePath?: string;
+    authCheck?: boolean;
+    default?: boolean;
+    portalUid?: string;
+};
+export type FlowSurfaceNavigationTargetsResult = {
+    version: '1';
+    capabilities: {
+        multiPortal: boolean;
+    };
+    targets: FlowSurfaceNavigationTarget[];
+};
+type PortalResolveOptions = {
+    actionName: string;
+    path: string;
+    currentRoles?: FlowSurfaceNavigationRequestRoles;
+    transaction?: Transaction;
+};
+export declare class FlowSurfaceNavigationTargetsService {
+    private readonly db;
+    constructor(db: Database);
+    hasMultiPortalCapability(): boolean;
+    hasUiLayoutCapability(): boolean;
+    normalizePortalUid(value: unknown): string;
+    listNavigationTargets(currentRoles?: FlowSurfaceNavigationRequestRoles, transaction?: Transaction): Promise<FlowSurfaceNavigationTargetsResult>;
+    resolvePortal(portalUidValue: unknown, options: PortalResolveOptions): Promise<FlowSurfaceResolvedMultiPortal>;
+    readRoutePortalUids(routeId: unknown, transaction?: Transaction): Promise<string[]>;
+    assertRouteBelongsToPortal(actionName: string, routeId: unknown, portalUid: string, path: string, transaction?: Transaction): Promise<void>;
+    attachRouteTreeToPortals(routeId: unknown, portalUids: string[], options: {
+        portalOnly: boolean;
+        transaction?: Transaction;
+    }): Promise<void>;
+    private listLayoutTargets;
+    private listAccessiblePortalTargets;
+    private canAccessPortal;
+    private collectRouteTreeIds;
+    private removeDefaultLayoutRoutePermissions;
+    private grantDefaultPortalRouteAccess;
+}
+export {};