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

package/dist/server/flow-surfaces/blueprint/normalize-document.js

@@ -588,12 +588,16 @@ function prepareFlowSurfaceApplyBlueprintDocument(input) {
   if (tabs.length > 1 && (page == null ? void 0 : page.enableTabs) === false) {
     (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint page.enableTabs cannot be false when tabs.length > 1`);
   }
+  const normalizedPage = tabs.length === 1 ? {
+    ...page || {},
+    enableTabs: false
+  } : page;
   return {
     version: "1",
     mode,
     ...target ? { target } : {},
     ...navigation ? { navigation } : {},
-    ...page ? { page } : {},
+    ...normalizedPage ? { page: normalizedPage } : {},
     ...defaults ? { defaults } : {},
     tabs,
     assets,

package/dist/server/flow-surfaces/chart-config.js

@@ -64,7 +64,91 @@ __export(chart_config_exports, {
 module.exports = __toCommonJS(chart_config_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_errors = require("./errors");
+var import_filter_group = require("./filter-group");
 const CHART_REPAIR_HINT = "This is a chart payload shape problem. Repair the current chart query/visual mappings and keep the chart block type. Do not change this block type to table, jsBlock, actionPanel, gridCard, or another block type. KPI / summary numbers should use jsBlock; charts are for trends, distributions, rankings, and visual analysis.";
+const CHART_FORBIDDEN_FALLBACKS = [
+  "table",
+  "list",
+  "jsBlock",
+  "actionPanel",
+  "gridCard",
+  "markdown",
+  "drop chart",
+  "defer chart"
+];
+const CHART_REPAIR_STEPS = [
+  "Keep the block type as chart.",
+  "Repair the chart query and visual mappings on the current chart payload.",
+  "Retry the chart payload instead of replacing the chart with another block type, omitting it, or deferring it."
+];
+const CHART_EXPECTED_SHAPE = {
+  settings: {
+    query: {
+      mode: "builder",
+      resource: {
+        dataSourceKey: "main",
+        collectionName: "employees"
+      },
+      measures: [
+        {
+          field: "id",
+          aggregation: "count",
+          alias: "employeeCount"
+        }
+      ]
+    },
+    visual: {
+      mode: "basic",
+      type: "bar",
+      mappings: {
+        x: "status",
+        y: "employeeCount"
+      }
+    }
+  }
+};
+function withChartRepairDetails(details = {}) {
+  return {
+    ...details,
+    requiredBlockType: "chart",
+    fixStrategy: "repair_same_block_type",
+    repairHint: CHART_REPAIR_HINT,
+    repairSteps: CHART_REPAIR_STEPS,
+    expectedShape: CHART_EXPECTED_SHAPE,
+    repairExample: {
+      settings: {
+        query: {
+          mode: "builder",
+          resource: {
+            dataSourceKey: "main",
+            collectionName: "<collectionName>"
+          },
+          measures: [
+            {
+              field: "id",
+              aggregation: "count",
+              alias: "recordCount"
+            }
+          ],
+          dimensions: [
+            {
+              field: "<dimensionField>"
+            }
+          ]
+        },
+        visual: {
+          mode: "basic",
+          type: "bar",
+          mappings: {
+            x: "<dimensionField>",
+            y: "recordCount"
+          }
+        }
+      }
+    },
+    forbiddenFallbacks: CHART_FORBIDDEN_FALLBACKS
+  };
+}
 function withChartRepairMessage(message) {
   return `${message}. ${CHART_REPAIR_HINT}`;
 }
@@ -86,10 +170,6 @@ const CHART_SORT_DIRECTIONS = ["asc", "desc"];
 const CHART_SORT_NULLS = ["default", "first", "last"];
 const CHART_LABEL_TYPES = ["value", "percent"];
 const CHART_FUNNEL_SORTS = ["descending", "ascending"];
-const EMPTY_FILTER_GROUP = {
-  logic: "$and",
-  items: []
-};
 const CHART_SAFE_DEFAULT_HINTS = [
   {
     key: "builder_basic_minimal",
@@ -406,7 +486,7 @@ function fromPersistedOrder(input) {
   return CHART_SORT_DIRECTION_SET.has(normalized) ? normalized : void 0;
 }
 function createEmptyFilterGroup() {
-  return import_lodash.default.cloneDeep(EMPTY_FILTER_GROUP);
+  return import_lodash.default.cloneDeep(import_filter_group.FLOW_SURFACE_EMPTY_FILTER_GROUP);
 }
 function assertAllowedKeys(input, allowed, label) {
   const unknownKeys = Object.keys(input).filter((key) => !allowed.has(key));
@@ -530,13 +610,106 @@ function normalizeChartSortingItem(input, index) {
     nulls: normalizeOptionalEnumValue(normalized.nulls, CHART_SORT_NULLS_SET, `${label}.nulls`)
   });
 }
+function isFilterGroupLike(input) {
+  return import_lodash.default.isPlainObject(input) && isBackendQueryLogicKey(input.logic) && Array.isArray(input.items);
+}
+function assertFilterGroupKeys(input, label) {
+  if (!isFilterGroupLike(input)) {
+    return;
+  }
+  const unsupportedKeys = Object.keys(input).filter((key) => key !== "logic" && key !== "items");
+  if (unsupportedKeys.length) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label} does not support: ${unsupportedKeys.join(", ")}`);
+  }
+  if (Array.isArray(input.items)) {
+    input.items.forEach((item, index) => {
+      assertFilterGroupKeys(item, `${label}.items[${index}]`);
+    });
+  }
+}
+function isBackendQueryLogicKey(key) {
+  return key === "$and" || key === "$or";
+}
+function getBackendQueryLogicKey(input, label) {
+  const keys = Object.keys(input);
+  const logicKeys = keys.filter(isBackendQueryLogicKey);
+  if (!logicKeys.length) {
+    return void 0;
+  }
+  if (logicKeys.length > 1 || keys.length > 1) {
+    throw new import_errors.FlowSurfaceBadRequestError(
+      `${label}: cannot convert backend query filter with mixed logical and field conditions`
+    );
+  }
+  return logicKeys[0];
+}
+function convertBackendFieldConditionToFilterItems(field, condition, label) {
+  if (!field.trim() || field.startsWith("$")) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label}: cannot convert backend query filter field "${field}"`);
+  }
+  if (!import_lodash.default.isPlainObject(condition)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label}.${field}: backend query filter condition must be an object`);
+  }
+  const operators = Object.keys(condition);
+  if (!operators.length) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label}.${field}: backend query filter condition cannot be empty`);
+  }
+  return operators.map((operator) => {
+    if (!operator.startsWith("$")) {
+      (0, import_filter_group.assertFlowSurfaceFilterOperator)(operator, `${label}.${field}.${operator}`);
+    }
+    if (!operator.startsWith("$") || isBackendQueryLogicKey(operator)) {
+      throw new import_errors.FlowSurfaceBadRequestError(
+        `${label}.${field}: cannot convert backend query filter operator "${operator}"`
+      );
+    }
+    return {
+      path: field,
+      operator,
+      value: import_lodash.default.cloneDeep(condition[operator])
+    };
+  });
+}
+function convertBackendQueryFilterToFilterGroup(input, label) {
+  const logicKey = getBackendQueryLogicKey(input, label);
+  if (logicKey) {
+    const operands = input[logicKey];
+    if (!Array.isArray(operands)) {
+      throw new import_errors.FlowSurfaceBadRequestError(`${label}.${logicKey}: backend query filter operands must be an array`);
+    }
+    return {
+      logic: logicKey,
+      items: operands.map(
+        (operand, index) => convertBackendQueryOperandToFilterItem(operand, `${label}.${logicKey}[${index}]`)
+      )
+    };
+  }
+  return {
+    logic: "$and",
+    items: Object.entries(input).flatMap(
+      ([field, condition]) => convertBackendFieldConditionToFilterItems(field, condition, label)
+    )
+  };
+}
+function convertBackendQueryOperandToFilterItem(input, label) {
+  if (isFilterGroupLike(input)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`${label}: cannot mix filter groups with backend query filters`);
+  }
+  const group = convertBackendQueryFilterToFilterGroup(ensurePlainObject(input, label), label);
+  if (group.logic === "$and" && group.items.length === 1) {
+    return group.items[0];
+  }
+  return group;
+}
 function normalizeFilterGroupValue(input, label) {
   if (import_lodash.default.isUndefined(input) || import_lodash.default.isNull(input)) {
     return void 0;
   }
   const normalized = ensurePlainObject(input, label);
-  validateFilterGroupPaths(normalized, label);
-  return import_lodash.default.cloneDeep(normalized);
+  assertFilterGroupKeys(normalized, label);
+  const filterGroup = !Object.keys(normalized).length || isFilterGroupLike(normalized) ? (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(normalized, label) : (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(convertBackendQueryFilterToFilterGroup(normalized, label), label);
+  validateFilterGroupPaths(filterGroup, label);
+  return filterGroup;
 }
 function validateFilterGroupPaths(input, label) {
   const items = Array.isArray(input == null ? void 0 : input.items) ? input.items : [];
@@ -568,6 +741,7 @@ function inferQueryMode(query) {
 }
 function validateLooseChartQuery(query) {
   inferQueryMode(query);
+  validateChartQueryFilterOperators(query);
   if (!hasOwn(query, "resource") || !hasOwn(query, "collectionPath")) {
     return;
   }
@@ -582,6 +756,11 @@ function validateLooseChartQuery(query) {
     );
   }
 }
+function validateChartQueryFilterOperators(query) {
+  if (hasOwn(query, "filter")) {
+    normalizeFilterGroupValue(query.filter, "chart query.filter");
+  }
+}
 function canStrictNormalizeChartQuery(query) {
   validateLooseChartQuery(query);
   const mode = inferQueryMode(query);
@@ -605,7 +784,10 @@ function mergeChartQuerySection(current, patch) {
   const nextMode = inferQueryMode(normalizedPatch);
   const modeChanged = currentMode && currentMode !== nextMode;
   const base = modeChanged ? {} : current || {};
-  const merged = mergeReplaceArrays(base, normalizedPatch);
+  const merged = mergeReplaceArrays(base, import_lodash.default.omit(normalizedPatch, ["filter"]));
+  if (hasOwn(normalizedPatch, "filter")) {
+    merged.filter = import_lodash.default.cloneDeep(normalizedPatch.filter);
+  }
   if (nextMode !== "builder") {
     return merged;
   }
@@ -1092,10 +1274,9 @@ function assertBasicVisualMappingsAgainstBuilderQuery(builderVisual, query) {
         ),
         void 0,
         {
-          details: {
-            repairHint: CHART_REPAIR_HINT,
+          details: withChartRepairDetails({
             allowedOutputs: Array.from(allowedOutputs)
-          }
+          })
         }
       );
     }

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

@@ -165,7 +165,7 @@ class FlowSurfaceContractGuard {
       if (typeof on === "string" && !allowedDirectEvents.has(eventName)) {
         (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' event '${eventName}' is not allowed on '${node == null ? void 0 : node.use}'`);
       }
-      if (typeof on !== "string" && !allowedObjectEvents.has(eventName)) {
+      if (typeof on !== "string" && !allowedObjectEvents.has(eventName) && !allowedDirectEvents.has(eventName)) {
         (0, import_errors.throwBadRequest)(`flowSurfaces flow '${key}' event '${eventName}' is not allowed on '${node == null ? void 0 : node.use}'`);
       }
       const phase = onObj == null ? void 0 : onObj.phase;

package/dist/server/flow-surfaces/event-flow-normalizer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+export type FlowSurfaceEventFlowRecord = Record<string, unknown>;
+export type FlowSurfaceEventFlowRegistry = Record<string, FlowSurfaceEventFlowRecord>;
+export declare function buildFlowSurfaceEmptyEventCondition(): {
+    logic: string;
+    items: any[];
+};
+export declare function normalizeFlowSurfaceEventFlowOn(on: unknown): unknown;
+export declare function normalizeFlowSurfaceEventFlow(actionName: string, key: string, flowInput: unknown): FlowSurfaceEventFlowRecord;
+export declare function normalizeFlowSurfaceEventFlowRegistry(actionName: string, flowRegistry: Record<string, unknown>): FlowSurfaceEventFlowRegistry;
+export declare function normalizeFlowSurfaceEventFlowRegistry<T>(actionName: string, flowRegistry: T): T;
+export declare function isFlowSurfaceBeforeAllEventFlow(flow: unknown): boolean;

package/dist/server/flow-surfaces/event-flow-normalizer.js

@@ -0,0 +1,128 @@
+/**
+ * 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.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_flow_normalizer_exports = {};
+__export(event_flow_normalizer_exports, {
+  buildFlowSurfaceEmptyEventCondition: () => buildFlowSurfaceEmptyEventCondition,
+  isFlowSurfaceBeforeAllEventFlow: () => isFlowSurfaceBeforeAllEventFlow,
+  normalizeFlowSurfaceEventFlow: () => normalizeFlowSurfaceEventFlow,
+  normalizeFlowSurfaceEventFlowOn: () => normalizeFlowSurfaceEventFlowOn,
+  normalizeFlowSurfaceEventFlowRegistry: () => normalizeFlowSurfaceEventFlowRegistry
+});
+module.exports = __toCommonJS(event_flow_normalizer_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+function asPlainRecord(value) {
+  return import_lodash.default.isPlainObject(value) ? value : null;
+}
+function buildFlowSurfaceEmptyEventCondition() {
+  return { logic: "$and", items: [] };
+}
+function normalizeFlowSurfaceEventFlowOn(on) {
+  if (typeof on === "string") {
+    const eventName2 = on.trim();
+    if (!eventName2) {
+      return on;
+    }
+    return {
+      eventName: eventName2,
+      defaultParams: {
+        condition: buildFlowSurfaceEmptyEventCondition()
+      }
+    };
+  }
+  const onRecord = asPlainRecord(on);
+  if (!onRecord) {
+    return on;
+  }
+  const next = import_lodash.default.cloneDeep(onRecord);
+  const eventName = String(next.eventName || "").trim();
+  if (eventName) {
+    next.eventName = eventName;
+  }
+  const phase = String(next.phase || "").trim();
+  if (!phase || phase === "beforeAllFlows") {
+    delete next.phase;
+  } else {
+    next.phase = phase;
+  }
+  const defaultParams = asPlainRecord(next.defaultParams) || {};
+  if (!asPlainRecord(defaultParams.condition)) {
+    defaultParams.condition = buildFlowSurfaceEmptyEventCondition();
+  }
+  next.defaultParams = defaultParams;
+  return next;
+}
+function normalizeFlowSurfaceEventFlow(actionName, key, flowInput) {
+  const flowRecord = asPlainRecord(flowInput);
+  if (!flowRecord) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} flow '${key}' must be an object`);
+  }
+  const flow = import_lodash.default.cloneDeep(flowRecord);
+  flow.key = key;
+  if (asPlainRecord(flow.on) || typeof flow.on === "string") {
+    flow.on = normalizeFlowSurfaceEventFlowOn(flow.on);
+  }
+  if (import_lodash.default.isUndefined(flow.steps)) {
+    flow.steps = {};
+  }
+  return flow;
+}
+function normalizeFlowSurfaceEventFlowRegistry(actionName, flowRegistry) {
+  const registryRecord = asPlainRecord(flowRegistry);
+  if (!registryRecord) {
+    return flowRegistry;
+  }
+  return Object.fromEntries(
+    Object.entries(registryRecord).map(([key, flow]) => [key, normalizeFlowSurfaceEventFlow(actionName, key, flow)])
+  );
+}
+function isFlowSurfaceBeforeAllEventFlow(flow) {
+  const flowRecord = asPlainRecord(flow);
+  if (!flowRecord) {
+    return false;
+  }
+  const onRecord = asPlainRecord(normalizeFlowSurfaceEventFlowOn(flowRecord.on));
+  return Boolean(onRecord) && typeof (onRecord == null ? void 0 : onRecord.eventName) === "string" && (typeof onRecord.phase === "undefined" || onRecord.phase === "beforeAllFlows");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFlowSurfaceEmptyEventCondition,
+  isFlowSurfaceBeforeAllEventFlow,
+  normalizeFlowSurfaceEventFlow,
+  normalizeFlowSurfaceEventFlowOn,
+  normalizeFlowSurfaceEventFlowRegistry
+});

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

@@ -11,5 +11,7 @@ export declare const FLOW_SURFACE_EMPTY_FILTER_GROUP: {
     items: any[];
 };
 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 assertFlowSurfaceFilterGroupShape(filter: any): void;