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

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

@@ -3124,6 +3124,209 @@ class FlowSurfacesService {
       );
     }
   }
+  composeChartBlockHasInlineConfig(block) {
+    const settings = import_lodash.default.isPlainObject(block.settings) ? block.settings : {};
+    return ["configure", "query", "visual", "events"].some(
+      (key) => Object.prototype.hasOwnProperty.call(settings, key)
+    );
+  }
+  prepareComposeChartAssetNestedPopupBlocks(input, path, chartAssets) {
+    if (!import_lodash.default.isPlainObject(input)) {
+      return { value: input, didResolveChartAsset: false };
+    }
+    let didResolveChartAsset = false;
+    let nextInput = input;
+    const ensureNextInput = () => {
+      if (nextInput === input) {
+        nextInput = { ...input };
+      }
+      return nextInput;
+    };
+    const preparePopupBlocks = (key) => {
+      const popup = input[key];
+      if (!import_lodash.default.isPlainObject(popup) || !Array.isArray(popup.blocks)) {
+        return;
+      }
+      const prepared = this.prepareComposeChartAssetBlockList(popup.blocks, `${path}.${key}.blocks`, chartAssets);
+      if (!prepared.didResolveChartAsset) {
+        return;
+      }
+      ensureNextInput()[key] = {
+        ...popup,
+        blocks: prepared.blocks
+      };
+      didResolveChartAsset = true;
+    };
+    preparePopupBlocks("popup");
+    preparePopupBlocks("openView");
+    return {
+      value: nextInput,
+      didResolveChartAsset
+    };
+  }
+  prepareComposeChartAssetBlockList(blocks, path, chartAssets) {
+    const rawBlocks = import_lodash.default.castArray(blocks || []);
+    if (!rawBlocks.length) {
+      return { blocks: rawBlocks, didResolveChartAsset: false };
+    }
+    let didResolveChartAsset = false;
+    const hiddenPopupKeys = [
+      "quickCreatePopup",
+      "eventPopup",
+      "cardPopup",
+      "quickCreatePopupSettings",
+      "eventPopupSettings",
+      "cardPopupSettings"
+    ];
+    const nextBlocks = rawBlocks.map((block, index) => {
+      if (!import_lodash.default.isPlainObject(block)) {
+        return block;
+      }
+      const blockPath = `${path}[${index}]`;
+      let nextBlock = block;
+      const ensureNextBlock = () => {
+        if (nextBlock === block) {
+          nextBlock = { ...block };
+        }
+        return nextBlock;
+      };
+      if (Array.isArray(block.blocks)) {
+        const prepared = this.prepareComposeChartAssetBlockList(block.blocks, `${blockPath}.blocks`, chartAssets);
+        if (prepared.didResolveChartAsset) {
+          ensureNextBlock().blocks = prepared.blocks;
+          didResolveChartAsset = true;
+        }
+      }
+      for (const slot of ["actions", "recordActions", "fields"]) {
+        if (!Array.isArray(block[slot])) {
+          continue;
+        }
+        let didPrepareSlot = false;
+        const nextItems = block[slot].map((item, itemIndex) => {
+          const prepared = this.prepareComposeChartAssetNestedPopupBlocks(
+            item,
+            `${blockPath}.${slot}[${itemIndex}]`,
+            chartAssets
+          );
+          didPrepareSlot = didPrepareSlot || prepared.didResolveChartAsset;
+          return prepared.value;
+        });
+        if (didPrepareSlot) {
+          ensureNextBlock()[slot] = nextItems;
+          didResolveChartAsset = true;
+        }
+      }
+      if (Array.isArray(block.fieldGroups)) {
+        let didPrepareFieldGroups = false;
+        const nextFieldGroups = block.fieldGroups.map((group, groupIndex) => {
+          if (!import_lodash.default.isPlainObject(group) || !Array.isArray(group.fields)) {
+            return group;
+          }
+          let didPrepareGroupFields = false;
+          const nextFields = group.fields.map((field, fieldIndex) => {
+            const prepared = this.prepareComposeChartAssetNestedPopupBlocks(
+              field,
+              `${blockPath}.fieldGroups[${groupIndex}].fields[${fieldIndex}]`,
+              chartAssets
+            );
+            didPrepareGroupFields = didPrepareGroupFields || prepared.didResolveChartAsset;
+            return prepared.value;
+          });
+          if (!didPrepareGroupFields) {
+            return group;
+          }
+          didPrepareFieldGroups = true;
+          return {
+            ...group,
+            fields: nextFields
+          };
+        });
+        if (didPrepareFieldGroups) {
+          ensureNextBlock().fieldGroups = nextFieldGroups;
+          didResolveChartAsset = true;
+        }
+      }
+      if (import_lodash.default.isPlainObject(block.popup) && Array.isArray(block.popup.blocks)) {
+        const prepared = this.prepareComposeChartAssetBlockList(
+          block.popup.blocks,
+          `${blockPath}.popup.blocks`,
+          chartAssets
+        );
+        if (prepared.didResolveChartAsset) {
+          ensureNextBlock().popup = {
+            ...block.popup,
+            blocks: prepared.blocks
+          };
+          didResolveChartAsset = true;
+        }
+      }
+      if (import_lodash.default.isPlainObject(block.settings)) {
+        for (const key of hiddenPopupKeys) {
+          const popup = block.settings[key];
+          if (!import_lodash.default.isPlainObject(popup) || !Array.isArray(popup.blocks)) {
+            continue;
+          }
+          const prepared = this.prepareComposeChartAssetBlockList(
+            popup.blocks,
+            `${blockPath}.settings.${key}.blocks`,
+            chartAssets
+          );
+          if (!prepared.didResolveChartAsset) {
+            continue;
+          }
+          ensureNextBlock().settings = {
+            ...nextBlock.settings || {},
+            [key]: {
+              ...popup,
+              blocks: prepared.blocks
+            }
+          };
+          didResolveChartAsset = true;
+        }
+      }
+      if (String(nextBlock.type || "").trim() !== "chart" || !Object.prototype.hasOwnProperty.call(nextBlock, "chart") || this.composeChartBlockHasInlineConfig(nextBlock)) {
+        return nextBlock;
+      }
+      const chartKey = String(nextBlock.chart || "").trim();
+      if (!chartKey) {
+        throwChartRepairBadRequest(`${blockPath}.chart must reference one key from assets.charts`, {
+          path: `${blockPath}.chart`,
+          ruleId: "chart-block-asset-reference-required"
+        });
+      }
+      const chartAsset = chartAssets[chartKey];
+      if (!import_lodash.default.isPlainObject(chartAsset)) {
+        throwChartRepairBadRequest(`${blockPath}.chart references missing chart asset '${chartKey}'`, {
+          path: `${blockPath}.chart`,
+          ruleId: "chart-block-asset-reference-missing",
+          details: {
+            chartKey
+          }
+        });
+      }
+      if (!import_lodash.default.isUndefined(nextBlock.settings) && !import_lodash.default.isPlainObject(nextBlock.settings)) {
+        return nextBlock;
+      }
+      didResolveChartAsset = true;
+      return {
+        ...nextBlock,
+        settings: import_lodash.default.merge({}, import_lodash.default.cloneDeep(nextBlock.settings || {}), import_lodash.default.cloneDeep(chartAsset))
+      };
+    });
+    return {
+      blocks: nextBlocks,
+      didResolveChartAsset
+    };
+  }
+  prepareComposeChartAssetSettings(values) {
+    var _a;
+    const chartAssets = import_lodash.default.isPlainObject((_a = values == null ? void 0 : values.assets) == null ? void 0 : _a.charts) ? values.assets.charts : {};
+    const prepared = this.prepareComposeChartAssetBlockList(values == null ? void 0 : values.blocks, "$.blocks", chartAssets);
+    return prepared.didResolveChartAsset ? {
+      ...values,
+      blocks: prepared.blocks
+    } : values;
+  }
   getApplyBlueprintKanbanBlockResourceObject(block) {
     return import_lodash.default.isPlainObject(block == null ? void 0 : block.resource) ? block.resource : {};
   }
@@ -5198,12 +5401,13 @@ class FlowSurfacesService {
   async compose(values, options = {}) {
     var _a, _b, _c;
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
-    const target = await this.prepareWriteTarget("compose", values == null ? void 0 : values.target, values, options);
+    const composeValues = this.prepareComposeChartAssetSettings(values);
+    const target = await this.prepareWriteTarget("compose", composeValues == null ? void 0 : composeValues.target, composeValues, options);
     const authoringContext = await this.buildTargetAuthoringContext({
       target,
       transaction: options.transaction
     });
-    await (0, import_authoring_validation.assertFlowSurfaceAuthoringPayload)("compose", values, {
+    await (0, import_authoring_validation.assertFlowSurfaceAuthoringPayload)("compose", composeValues, {
       transaction: options.transaction,
       enabledPackages,
       skipGeneratedLayoutSingleColumnErrors: options.skipGeneratedLayoutSingleColumnErrors === true,
@@ -5216,12 +5420,17 @@ class FlowSurfacesService {
       ...options,
       popupTemplateTreeCache
     };
-    const mode = this.assertComposeMode(values == null ? void 0 : values.mode);
-    const popupDefaultsMetadata = this.buildPopupDefaultsMetadata(values == null ? void 0 : values.defaults);
-    const normalizedBlocks = this.normalizeComposeBlocks(values == null ? void 0 : values.blocks, enabledPackages, popupDefaultsMetadata, {
-      dataSourceKey: authoringContext.currentDataSourceKey,
-      collectionName: authoringContext.currentCollectionName
-    });
+    const mode = this.assertComposeMode(composeValues == null ? void 0 : composeValues.mode);
+    const popupDefaultsMetadata = this.buildPopupDefaultsMetadata(composeValues == null ? void 0 : composeValues.defaults);
+    const normalizedBlocks = this.normalizeComposeBlocks(
+      composeValues == null ? void 0 : composeValues.blocks,
+      enabledPackages,
+      popupDefaultsMetadata,
+      {
+        dataSourceKey: authoringContext.currentDataSourceKey,
+        collectionName: authoringContext.currentCollectionName
+      }
+    );
     this.validateComposePopupTemplateAliases(normalizedBlocks, popupTemplateAliasSession);
     const blockParent = await this.surfaceContext.resolveBlockParent(target, options.transaction);
     const gridUid = blockParent.parentUid;
@@ -5247,7 +5456,7 @@ class FlowSurfacesService {
       mode,
       normalizedBlocks,
       existingItemUids: existingItems.map((item) => item.uid),
-      layout: values.layout
+      layout: composeValues.layout
     });
     const generatedDefaultFilterByComposeBlockUid = /* @__PURE__ */ new Map();
     const result = await (0, import_compose_runtime.executeComposeRuntime)(plan, {
@@ -5282,7 +5491,7 @@ class FlowSurfacesService {
           {
             ...payload,
             ...Object.keys(hiddenPopupSettings).length ? { settings: hiddenPopupSettings } : {},
-            ...values.defaults ? { defaults: values.defaults } : {}
+            ...composeValues.defaults ? { defaults: composeValues.defaults } : {}
           },
           {
             ...runtimeOptions,
@@ -6449,7 +6658,8 @@ class FlowSurfacesService {
     if ((0, import_service_utils.hasOwnDefined)(normalizedSettings, "defaultFilter")) {
       normalizedSettings.defaultFilter = (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
         normalizedSettings.defaultFilter,
-        `flowSurfaces ${actionName} defaultActionSettings.filter.defaultFilter expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`
+        `flowSurfaces ${actionName} defaultActionSettings.filter.defaultFilter expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+        { strictDateValues: true }
       );
       normalizedSettings.defaultFilter = this.normalizeEffectivePublicDataSurfaceDefaultFilter(
         normalizedSettings.defaultFilter,
@@ -11738,12 +11948,12 @@ class FlowSurfacesService {
           "flowSurfaces updateSettings filter action values 'props.defaultFilterValue/filterValue' and 'stepParams.filterSettings.defaultFilter.defaultFilter' must match"
         );
       }
-      const filterValue = this.normalizeEffectivePublicDataSurfaceDefaultFilter(
-        hasStepDefaultFilter ? nextStepFilter : nextPropFilter,
-        {
-          requiredFieldCount: options.requiredFieldCount
-        }
+      const normalizedFilterValue = this.normalizeFilterActionDefaultFilterValue(
+        hasStepDefaultFilter ? nextStepFilter : nextPropFilter
       );
+      const filterValue = this.normalizeEffectivePublicDataSurfaceDefaultFilter(normalizedFilterValue, {
+        requiredFieldCount: options.requiredFieldCount
+      });
       if (!hasPropsFilterableFieldNames && !hasStepFilterableFieldNames) {
         const filterableFieldNames = (0, import_public_data_surface_default_filter.resolveFlowSurfaceDefaultFilterFieldNames)(filterValue);
         if (filterableFieldNames.length) {
@@ -12187,7 +12397,7 @@ class FlowSurfacesService {
     return String(input || "").trim();
   }
   validateBuilderChartFieldsForRuntime(actionName, configure) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e, _f, _g;
     const resourceInit = (0, import_chart_config.getChartBuilderResourceInit)(configure);
     if (!(resourceInit == null ? void 0 : resourceInit.collectionName)) {
       return;
@@ -12205,10 +12415,12 @@ class FlowSurfacesService {
     const selections = [
       ...import_lodash.default.castArray(state.query.measures || []).map((selection, index) => ({
         selection,
+        kind: "measure",
         path: `chart query.measures[${index}].field`
       })),
       ...import_lodash.default.castArray(state.query.dimensions || []).map((selection, index) => ({
         selection,
+        kind: "dimension",
         path: `chart query.dimensions[${index}].field`
       }))
     ];
@@ -12217,37 +12429,151 @@ class FlowSurfacesService {
       if (!fieldPath) {
         continue;
       }
+      const fieldPathParts = fieldPath.split(".").filter(Boolean);
+      const isCountMeasureSelection = item.kind === "measure" && String(((_c = item.selection) == null ? void 0 : _c.aggregation) || "").trim() === "count" && !((_d = item.selection) == null ? void 0 : _d.distinct);
+      if (fieldPathParts.length > 1 && !isCountMeasureSelection) {
+        const directAssociationPath = fieldPathParts[0];
+        const directAssociationField = (0, import_service_helpers.resolveFieldFromCollection)(collection, directAssociationPath);
+        const directAssociationTargetCollection = directAssociationField && (0, import_service_helpers.isAssociationField)(directAssociationField) ? (0, import_service_helpers.resolveFieldTargetCollection)(
+          directAssociationField,
+          dataSourceKey,
+          (resolvedDataSourceKey, targetCollection) => this.getCollection(resolvedDataSourceKey, targetCollection)
+        ) : null;
+        const invalidDirectSubfield = directAssociationTargetCollection ? (0, import_service_helpers.getInvalidChartBuilderRelationDirectSubfieldDetails)({
+          associationPathName: directAssociationPath,
+          selectedSubfieldPath: fieldPathParts.slice(1).join("."),
+          targetCollection: directAssociationTargetCollection
+        }) : null;
+        if (invalidDirectSubfield) {
+          (0, import_errors.throwBadRequest)(
+            withChartRepairMessage(
+              `flowSurfaces ${actionName} ${item.path} '${fieldPath}' must reference a direct scalar child field under relation '${invalidDirectSubfield.associationPath}'. ${(0, import_service_helpers.formatChartBuilderSupportedRelationSubfields)(
+                invalidDirectSubfield.associationPath,
+                invalidDirectSubfield.supportedFields
+              )}`
+            ),
+            {
+              path: item.path,
+              ruleId: "chart-builder-query-relation-direct-subfield-required",
+              details: withFlowSurfaceChartRepairDetails({
+                fieldPath,
+                dataSourceKey,
+                collectionName,
+                ...invalidDirectSubfield
+              })
+            }
+          );
+        }
+      }
       const parsed = this.parseFieldPath(collection, fieldPath, void 0, dataSourceKey, collectionName);
+      if (parsed.associationPathName) {
+        const associationField = parsed.associationField;
+        const associationTargetCollection = associationField && (0, import_service_helpers.isAssociationField)(associationField) ? (0, import_service_helpers.resolveFieldTargetCollection)(
+          associationField,
+          dataSourceKey,
+          (resolvedDataSourceKey, targetCollection) => this.getCollection(resolvedDataSourceKey, targetCollection)
+        ) : null;
+        if (!associationField || !(0, import_service_helpers.isAssociationField)(associationField) || !associationTargetCollection) {
+          (0, import_errors.throwBadRequest)(
+            withChartRepairMessage(
+              `flowSurfaces ${actionName} ${item.path} '${fieldPath}' uses invalid association path '${parsed.associationPathName}' for builder charts`
+            ),
+            {
+              path: item.path,
+              ruleId: "chart-builder-query-association-path-invalid",
+              details: withFlowSurfaceChartRepairDetails({
+                fieldPath,
+                associationPath: parsed.associationPathName,
+                dataSourceKey,
+                collectionName
+              })
+            }
+          );
+        }
+      }
       const field = (0, import_service_helpers.resolveFieldFromCollection)(parsed.leafCollection, parsed.leafFieldPath);
+      const leafModelAttributes = (0, import_service_helpers.getCollectionModelAttributes)(parsed.leafCollection);
+      const hasLeafModelAttribute = Object.prototype.hasOwnProperty.call(leafModelAttributes, parsed.leafFieldPath);
+      const isCountMeasureRelationSubfield = item.kind === "measure" && String(((_e = item.selection) == null ? void 0 : _e.aggregation) || "").trim() === "count" && !((_f = item.selection) == null ? void 0 : _f.distinct) && parsed.associationField && (0, import_service_helpers.isAssociationField)(parsed.associationField);
+      const unsupportedRelationSubfield = parsed.associationField && (0, import_service_helpers.isAssociationField)(parsed.associationField) ? (0, import_service_helpers.getUnsupportedChartBuilderRelationSubfieldDetails)({
+        associationPathName: parsed.associationPathName,
+        leafFieldName: parsed.leafFieldPath,
+        leafField: field,
+        targetCollection: parsed.leafCollection
+      }) : null;
       if (!field) {
-        if (this.collectionHasConcreteField(parsed.leafCollection, parsed.leafFieldPath)) {
-          continue;
+        const hasConcreteField = hasLeafModelAttribute || this.collectionHasConcreteField(parsed.leafCollection, parsed.leafFieldPath);
+        if (!hasConcreteField) {
+          (0, import_errors.throwBadRequest)(
+            withChartRepairMessage(
+              `flowSurfaces ${actionName} ${item.path} '${fieldPath}' does not exist on collection '${dataSourceKey}.${collectionName}'`
+            ),
+            {
+              details: withFlowSurfaceChartRepairDetails({
+                fieldPath,
+                dataSourceKey,
+                collectionName
+              })
+            }
+          );
         }
+      }
+      if (!fieldPath.includes(".") && field && (0, import_service_helpers.isAssociationField)(field)) {
+        const suggestion = this.resolveBuilderChartAssociationSubfieldSuggestion(fieldPath, field, dataSourceKey);
         (0, import_errors.throwBadRequest)(
           withChartRepairMessage(
-            `flowSurfaces ${actionName} ${item.path} '${fieldPath}' does not exist on collection '${dataSourceKey}.${collectionName}'`
+            `flowSurfaces ${actionName} ${item.path} '${fieldPath}' references an association field directly; use scalar subfield '${suggestion.suggestedFieldPath}' for builder charts`
           ),
           {
             details: withFlowSurfaceChartRepairDetails({
               fieldPath,
               dataSourceKey,
-              collectionName
+              collectionName,
+              ...suggestion
             })
           }
         );
       }
-      if (!fieldPath.includes(".") && (0, import_service_helpers.isAssociationField)(field)) {
-        const suggestion = this.resolveBuilderChartAssociationSubfieldSuggestion(fieldPath, field, dataSourceKey);
+      if (isCountMeasureRelationSubfield) {
         (0, import_errors.throwBadRequest)(
           withChartRepairMessage(
-            `flowSurfaces ${actionName} ${item.path} '${fieldPath}' references an association field directly; use scalar subfield '${suggestion.suggestedFieldPath}' for builder charts`
+            `flowSurfaces ${actionName} ${item.path} '${fieldPath}' counts a relation subfield; count a scalar base field such as 'id' and keep '${fieldPath}' as a dimension`
           ),
           {
+            path: item.path,
+            ruleId: "chart-builder-query-count-measure-relation-subfield",
             details: withFlowSurfaceChartRepairDetails({
               fieldPath,
               dataSourceKey,
               collectionName,
-              ...suggestion
+              suggestedMeasure: {
+                field: "id",
+                aggregation: "count",
+                alias: String(((_g = item.selection) == null ? void 0 : _g.alias) || "").trim() || "recordCount"
+              },
+              suggestedDimension: {
+                field: fieldPath
+              }
+            })
+          }
+        );
+      }
+      if (unsupportedRelationSubfield) {
+        (0, import_errors.throwBadRequest)(
+          withChartRepairMessage(
+            `flowSurfaces ${actionName} ${item.path} '${fieldPath}' references relation subfield '${fieldPath}', but current chart builder SQL generation cannot query relation subfield '${unsupportedRelationSubfield.leafFieldName}' because its database column is '${unsupportedRelationSubfield.columnName}'. ${(0, import_service_helpers.formatChartBuilderSupportedRelationSubfields)(
+              unsupportedRelationSubfield.associationPath,
+              unsupportedRelationSubfield.supportedFields
+            )}`
+          ),
+          {
+            path: item.path,
+            ruleId: "chart-builder-query-relation-subfield-column-unsupported",
+            details: withFlowSurfaceChartRepairDetails({
+              fieldPath,
+              dataSourceKey,
+              collectionName,
+              ...unsupportedRelationSubfield
             })
           }
         );
@@ -16229,18 +16555,18 @@ class FlowSurfacesService {
     return String(raw || "").trim();
   }
   collectionHasConcreteField(collection, fieldName) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c;
     const normalized = String(fieldName || "").trim();
     if (!normalized) {
       return false;
     }
-    const modelAttributes = (typeof ((_a = collection == null ? void 0 : collection.model) == null ? void 0 : _a.getAttributes) === "function" ? collection.model.getAttributes() : null) || ((_b = collection == null ? void 0 : collection.model) == null ? void 0 : _b.rawAttributes) || ((_c = collection == null ? void 0 : collection.model) == null ? void 0 : _c.attributes) || {};
+    const modelAttributes = (0, import_service_helpers.getCollectionModelAttributes)(collection);
     const primaryKeyAttributes = import_lodash.default.castArray(
-      ((_d = collection == null ? void 0 : collection.model) == null ? void 0 : _d.primaryKeyAttributes) || ((_e = collection == null ? void 0 : collection.model) == null ? void 0 : _e.primaryKeyAttribute) || []
+      ((_a = collection == null ? void 0 : collection.model) == null ? void 0 : _a.primaryKeyAttributes) || ((_b = collection == null ? void 0 : collection.model) == null ? void 0 : _b.primaryKeyAttribute) || []
     );
     const modelAttribute = modelAttributes == null ? void 0 : modelAttributes[normalized];
     const isModelPrimaryKey = primaryKeyAttributes.includes(normalized) || !!(modelAttribute == null ? void 0 : modelAttribute.primaryKey);
-    return !!((0, import_service_helpers.resolveFieldFromCollection)(collection, normalized) || ((_f = collection == null ? void 0 : collection.getField) == null ? void 0 : _f.call(collection, normalized)) || (0, import_service_helpers.getCollectionFields)(collection).some((field) => (0, import_service_helpers.getFieldName)(field) === normalized) || isModelPrimaryKey);
+    return !!((0, import_service_helpers.resolveFieldFromCollection)(collection, normalized) || ((_c = collection == null ? void 0 : collection.getField) == null ? void 0 : _c.call(collection, normalized)) || (0, import_service_helpers.getCollectionFields)(collection).some((field) => (0, import_service_helpers.getFieldName)(field) === normalized) || isModelPrimaryKey);
   }
   assertInitialBlockResourceCompatible(actionName, blockUse, resourceInit, popupProfile) {
     if (blockUse === "CommentsBlockModel") {
@@ -17051,7 +17377,11 @@ class FlowSurfacesService {
         items: []
       };
     }
-    return import_lodash.default.cloneDeep(value);
+    return (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
+      value,
+      `flowSurfaces configure action defaultFilter expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+      { strictDateValues: true }
+    );
   }
   normalizeActionAssignValues(actionName, value) {
     if (!import_lodash.default.isPlainObject(value)) {

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

@@ -229,6 +229,9 @@ export type FlowSurfaceComposeValues = {
     target: FlowSurfaceWriteTarget;
     mode?: FlowSurfaceComposeMode;
     blocks?: Array<Record<string, any>>;
+    assets?: {
+        charts?: Record<string, any>;
+    };
     layout?: Record<string, any>;
     defaults?: FlowSurfaceApplyBlueprintDefaults;
 };

package/dist/server/repository.d.ts

@@ -25,6 +25,12 @@ export interface FlowModelAttachOptions {
     subType: 'array' | 'object';
     position?: FlowModelAttachPosition;
 }
+type FlowModelMovePosition = 'before' | 'after';
+interface FlowModelMoveOptions {
+    sourceId: string;
+    targetId: string;
+    position?: FlowModelMovePosition;
+}
 type BreakRemoveOnType = {
     [key: string]: any;
 };
@@ -59,6 +65,8 @@ export declare class FlowModelRepository extends Repository {
     getParentProperty(uid: string, options?: GetPropertiesOptions): Promise<any>;
     getJsonSchema(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
     static optionsToJson(options: any): any;
+    private static getSortNumber;
+    private static compareBySortAndUid;
     nodesToSchema(nodes: any, rootUid: any): {
         uid: any;
         "x-async": boolean;
@@ -90,6 +98,12 @@ export declare class FlowModelRepository extends Repository {
     protected childrenCount(uid: any, transaction: any): Promise<number>;
     protected isLeafNode(uid: any, transaction: any): Promise<boolean>;
     protected findParentUid(uid: any, transaction?: any): Promise<string>;
+    private findSiblingInfo;
+    private findSiblingSortRows;
+    private writeSiblingSorts;
+    private normalizeSiblingSorts;
+    private isAncestorOf;
+    private updateModelParentOptions;
     protected findNodeSchemaWithParent(uid: any, transaction: any): Promise<{
         parentUid: string;
         schema: any;
@@ -122,6 +136,6 @@ export declare class FlowModelRepository extends Repository {
         subKey?: string;
     }): Promise<any>;
     attach(uid: string, attachOptions: FlowModelAttachOptions, options?: Transactionable): Promise<any>;
-    move(options: any): Promise<any>;
+    move(options: FlowModelMoveOptions, transactionOptions?: Transactionable): Promise<any>;
 }
 export default FlowModelRepository;