@nocobase/plugin-flow-engine 2.1.0-alpha.45 → 2.1.0-alpha.47

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

@@ -26,6 +26,35 @@ export declare function getCollectionName(collection: any): any;
 export declare function getCollectionTitleFieldName(collection: any): any;
 export declare function getFieldName(field: any): any;
 export declare function getFieldTitle(field: any): any;
+export declare function getCollectionModelAttributes(collection: any): any;
+export type FlowSurfaceChartBuilderSupportedSubfield = {
+    field: string;
+    title?: string;
+    interface?: string;
+};
+export declare function getChartBuilderSupportedRelationSubfields(associationPathName: string, targetCollection: any): FlowSurfaceChartBuilderSupportedSubfield[];
+export declare function formatChartBuilderSupportedRelationSubfields(associationPath: string, supportedFields?: FlowSurfaceChartBuilderSupportedSubfield[]): string;
+export declare function getInvalidChartBuilderRelationDirectSubfieldDetails(input: {
+    associationPathName: string;
+    selectedSubfieldPath: string;
+    targetCollection: any;
+}): {
+    associationPath: string;
+    leafFieldName: string;
+    selectedSubfieldPath: string;
+    supportedFields: FlowSurfaceChartBuilderSupportedSubfield[];
+};
+export declare function getUnsupportedChartBuilderRelationSubfieldDetails(input: {
+    associationPathName: string;
+    leafFieldName: string;
+    leafField?: any;
+    targetCollection: any;
+}): {
+    associationPath: string;
+    leafFieldName: string;
+    columnName: string;
+    supportedFields: FlowSurfaceChartBuilderSupportedSubfield[];
+};
 export declare function resolveAssociationNameFromField(field: any, fallbackCollection?: any): any;
 export declare function getFieldInterface(field: any): any;
 export declare function getFieldType(field: any): any;

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

@@ -40,8 +40,11 @@ __export(service_helpers_exports, {
   buildFilterFieldMeta: () => buildFilterFieldMeta,
   buildFlowTemplateSearchFilter: () => buildFlowTemplateSearchFilter,
   dedupeVisibleFieldCandidates: () => dedupeVisibleFieldCandidates,
+  formatChartBuilderSupportedRelationSubfields: () => formatChartBuilderSupportedRelationSubfields,
   getAssociationFilterTargetKey: () => getAssociationFilterTargetKey,
+  getChartBuilderSupportedRelationSubfields: () => getChartBuilderSupportedRelationSubfields,
   getCollectionFields: () => getCollectionFields,
+  getCollectionModelAttributes: () => getCollectionModelAttributes,
   getCollectionName: () => getCollectionName,
   getCollectionTitle: () => getCollectionTitle,
   getCollectionTitleFieldName: () => getCollectionTitleFieldName,
@@ -51,6 +54,8 @@ __export(service_helpers_exports, {
   getFieldTarget: () => getFieldTarget,
   getFieldTitle: () => getFieldTitle,
   getFieldType: () => getFieldType,
+  getInvalidChartBuilderRelationDirectSubfieldDetails: () => getInvalidChartBuilderRelationDirectSubfieldDetails,
+  getUnsupportedChartBuilderRelationSubfieldDetails: () => getUnsupportedChartBuilderRelationSubfieldDetails,
   hasConfiguredFlowContextValue: () => hasConfiguredFlowContextValue,
   inferAssociationLeafDisplayFieldUse: () => inferAssociationLeafDisplayFieldUse,
   inferFieldMenuEditableFieldUse: () => inferFieldMenuEditableFieldUse,
@@ -178,6 +183,101 @@ function getFieldTitle(field) {
   var _a, _b, _c, _d;
   return ((_a = field == null ? void 0 : field.uiSchema) == null ? void 0 : _a.title) || ((_c = (_b = field == null ? void 0 : field.options) == null ? void 0 : _b.uiSchema) == null ? void 0 : _c.title) || (field == null ? void 0 : field.title) || ((_d = field == null ? void 0 : field.options) == null ? void 0 : _d.title) || getFieldName(field);
 }
+function getCollectionModelAttributes(collection) {
+  var _a, _b, _c;
+  return (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) || {};
+}
+function getCollectionFieldColumnName(collection, fieldName) {
+  var _a;
+  const normalized = String(fieldName || "").trim();
+  if (!normalized) {
+    return "";
+  }
+  const attribute = (_a = getCollectionModelAttributes(collection)) == null ? void 0 : _a[normalized];
+  return String((attribute == null ? void 0 : attribute.field) || normalized).trim();
+}
+function getChartBuilderSupportedRelationSubfields(associationPathName, targetCollection) {
+  const normalizedAssociationPath = String(associationPathName || "").trim();
+  if (!normalizedAssociationPath || !targetCollection) {
+    return [];
+  }
+  return getCollectionFields(targetCollection).reduce((result, field) => {
+    const fieldName = getFieldName(field);
+    if (!fieldName || isAssociationField(field)) {
+      return result;
+    }
+    if (getCollectionFieldColumnName(targetCollection, fieldName) !== fieldName) {
+      return result;
+    }
+    result.push(
+      import_lodash.default.pickBy(
+        {
+          field: `${normalizedAssociationPath}.${fieldName}`,
+          title: getFieldTitle(field),
+          interface: getFieldInterface(field)
+        },
+        (value) => !import_lodash.default.isUndefined(value)
+      )
+    );
+    return result;
+  }, []);
+}
+function formatChartBuilderSupportedRelationSubfields(associationPath, supportedFields = []) {
+  const fields = supportedFields.map((item) => String((item == null ? void 0 : item.field) || "").trim()).filter(Boolean);
+  if (!fields.length) {
+    return `No chart-builder-compatible fields are available under '${associationPath}'.`;
+  }
+  return `Supported fields under '${associationPath}': ${fields.join(", ")}.`;
+}
+function getInvalidChartBuilderRelationDirectSubfieldDetails(input) {
+  const associationPath = String(input.associationPathName || "").trim();
+  const selectedSubfieldPath = String(input.selectedSubfieldPath || "").trim();
+  const selectedParts = selectedSubfieldPath.split(".").filter(Boolean);
+  if (!associationPath || !input.targetCollection || !selectedParts.length) {
+    return null;
+  }
+  const leafFieldName = selectedParts[0];
+  const leafField = resolveFieldFromCollection(input.targetCollection, leafFieldName);
+  const modelAttributes = getCollectionModelAttributes(input.targetCollection);
+  const modelAttribute = modelAttributes == null ? void 0 : modelAttributes[leafFieldName];
+  const hasModelAttribute = Object.prototype.hasOwnProperty.call(modelAttributes, leafFieldName);
+  const hasNestedSubfieldPath = selectedParts.length > 1;
+  if (leafField && !hasNestedSubfieldPath && !isAssociationField(leafField)) {
+    return null;
+  }
+  if (!leafField && hasModelAttribute && !hasNestedSubfieldPath) {
+    const columnName = String((modelAttribute == null ? void 0 : modelAttribute.field) || leafFieldName).trim();
+    if (columnName && columnName !== leafFieldName) {
+      return null;
+    }
+  }
+  return {
+    associationPath,
+    leafFieldName,
+    selectedSubfieldPath: selectedParts.join("."),
+    supportedFields: getChartBuilderSupportedRelationSubfields(associationPath, input.targetCollection)
+  };
+}
+function getUnsupportedChartBuilderRelationSubfieldDetails(input) {
+  const leafFieldName = String(input.leafFieldName || "").trim();
+  if (!input.targetCollection || !leafFieldName || input.leafField && isAssociationField(input.leafField)) {
+    return null;
+  }
+  const modelAttributes = getCollectionModelAttributes(input.targetCollection);
+  if (!input.leafField && !Object.prototype.hasOwnProperty.call(modelAttributes, leafFieldName)) {
+    return null;
+  }
+  const columnName = getCollectionFieldColumnName(input.targetCollection, leafFieldName);
+  if (!columnName || columnName === leafFieldName) {
+    return null;
+  }
+  return {
+    associationPath: String(input.associationPathName || "").trim(),
+    leafFieldName,
+    columnName,
+    supportedFields: getChartBuilderSupportedRelationSubfields(input.associationPathName, input.targetCollection)
+  };
+}
 function resolveAssociationNameFromField(field, fallbackCollection) {
   const resourceName = typeof (field == null ? void 0 : field.resourceName) === "string" ? field.resourceName.trim() : "";
   if (resourceName) {
@@ -309,8 +409,11 @@ function getAssociationFilterTargetKey(field, targetCollection) {
   buildFilterFieldMeta,
   buildFlowTemplateSearchFilter,
   dedupeVisibleFieldCandidates,
+  formatChartBuilderSupportedRelationSubfields,
   getAssociationFilterTargetKey,
+  getChartBuilderSupportedRelationSubfields,
   getCollectionFields,
+  getCollectionModelAttributes,
   getCollectionName,
   getCollectionTitle,
   getCollectionTitleFieldName,
@@ -320,6 +423,8 @@ function getAssociationFilterTargetKey(field, targetCollection) {
   getFieldTarget,
   getFieldTitle,
   getFieldType,
+  getInvalidChartBuilderRelationDirectSubfieldDetails,
+  getUnsupportedChartBuilderRelationSubfieldDetails,
   hasConfiguredFlowContextValue,
   inferAssociationLeafDisplayFieldUse,
   inferFieldMenuEditableFieldUse,

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

@@ -104,17 +104,29 @@ export declare function hasLegacyLocatorFields(input: any, options?: {
 }): boolean;
 export declare function rethrowInlineConfigurationError(error: any, prefix: string): never;
 export declare function toFlowSurfaceBatchItemError(error: any): {
-    code: string;
     message: string;
+    errorCount: number;
+    details: {
+        requiredBlockPolicy?: {
+            requiredBlockTypes: string[];
+            fixStrategy: string;
+            doNotReplaceOrDrop: boolean;
+        };
+        errorCount: number;
+        mustFixAllErrorsBeforeRetry: boolean;
+        retryPolicy: string;
+        sameWriteRetryRequired: boolean;
+        agentInstruction: string;
+    };
+    errors: import("./errors").FlowSurfaceErrorItem[];
+    code: string;
     status: number;
     type: import("./errors").FlowSurfaceErrorType;
-    errors: import("./errors").FlowSurfaceErrorItem[];
 } | {
     code: string;
     message: string;
     status: number;
     type: import("./errors").FlowSurfaceErrorType;
-    errors?: undefined;
 };
 export declare function splitComposeFieldChanges(changes: Record<string, any>, wrapperUse?: string): {
     wrapperChanges: _.Dictionary<any>;

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

@@ -620,12 +620,14 @@ function hasLegacyLocatorFields(input, options = {}) {
   return keys.some((key) => Object.prototype.hasOwnProperty.call(input, key));
 }
 function rethrowInlineConfigurationError(error, prefix) {
-  const childMessages = (0, import_errors.isFlowSurfaceAggregateError)(error) ? error.errors.map((item) => item.message).filter(Boolean) : [];
-  const message = `${prefix}: ${[(error == null ? void 0 : error.message) || String(error), ...childMessages].join("; ")}`;
+  if ((0, import_errors.isFlowSurfaceAggregateError)(error)) {
+    throw new import_errors.FlowSurfaceAggregateError(error.errors, `${prefix}: ${error.message}`);
+  }
+  const message = `${prefix}: ${(error == null ? void 0 : error.message) || String(error)}`;
   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);
@@ -641,10 +643,9 @@ function toFlowSurfaceBatchItemError(error) {
   if ((0, import_errors.isFlowSurfaceAggregateError)(error)) {
     return {
       code: error.code,
-      message: error.message,
       status: error.status,
       type: error.type,
-      errors: error.errors
+      ...error.toResponseBody()
     };
   }
   const normalized = (0, import_errors.normalizeFlowSurfaceError)(error);

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';
@@ -193,6 +194,10 @@ export declare class FlowSurfacesService {
     private resolveApplyBlueprintCreatePageIdentity;
     private prepareApplyBlueprintRequest;
     private prevalidateApplyBlueprintChartAssets;
+    private composeChartBlockHasInlineConfig;
+    private prepareComposeChartAssetNestedPopupBlocks;
+    private prepareComposeChartAssetBlockList;
+    private prepareComposeChartAssetSettings;
     private getApplyBlueprintKanbanBlockResourceObject;
     private normalizeApplyBlueprintKanbanResourceText;
     private getApplyBlueprintKanbanBlockBinding;
@@ -768,7 +773,7 @@ export declare class FlowSurfacesService {
             kind: import("./types").FlowSurfaceContainerKind;
             use: any;
         };
-        flowRegistry: any;
+        flowRegistry: FlowSurfaceEventFlowRegistry;
         events: {
             direct: string[];
             object: string[];
@@ -839,6 +844,7 @@ export declare class FlowSurfacesService {
     }>;
     private resolveEventFlowTarget;
     private getEventFlowRegistry;
+    private normalizeEventFlowRegistry;
     private buildEventFlowFingerprint;
     private assertEventFlowFingerprint;
     private normalizeEventFlowKey;