@nocobase/plugin-flow-engine 2.2.0-beta.9 → 2.2.0

package/dist/server/flow-surfaces/configure-options.js

@@ -578,6 +578,16 @@ const ACTION_ASSIGN_OPTIONS = {
   assignValues: objectOption("Bulk or single-record assigned values", { example: { status: "published" } }),
   updateMode: stringOption("Update mode", { example: "overwrite" })
 };
+const ACTION_AFTER_SUCCESS_OPTIONS = {
+  afterSuccess: objectOption("Action after a successful update", {
+    example: {
+      successMessage: "Saved successfully",
+      manualClose: false,
+      actionAfterSuccess: "stay",
+      redirectTo: "/admin/example"
+    }
+  })
+};
 const ACTION_TRIGGER_WORKFLOWS_OPTIONS = {
   triggerWorkflows: arrayOption("Workflow bindings for submit/update actions", {
     example: [{ workflowKey: "workflow-key", context: "department" }]
@@ -748,11 +758,17 @@ function getActionConfigureOptionsByUse(use) {
       return merged(
         ACTION_CONFIRM_OPTIONS,
         ACTION_ASSIGN_OPTIONS,
+        ACTION_AFTER_SUCCESS_OPTIONS,
         ACTION_TRIGGER_WORKFLOWS_OPTIONS,
         ACTION_LINKAGE_OPTIONS
       );
     case "BulkUpdateActionModel":
-      return merged(ACTION_CONFIRM_OPTIONS, ACTION_ASSIGN_OPTIONS, ACTION_LINKAGE_OPTIONS);
+      return merged(
+        ACTION_CONFIRM_OPTIONS,
+        ACTION_ASSIGN_OPTIONS,
+        ACTION_AFTER_SUCCESS_OPTIONS,
+        ACTION_LINKAGE_OPTIONS
+      );
     case "BulkEditActionModel":
       return merged(ACTION_EDIT_MODE_OPTIONS, ACTION_LINKAGE_OPTIONS);
     case "DuplicateActionModel":

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

@@ -52,6 +52,13 @@ export declare const FLOW_SURFACE_ACTION_DEFINITIONS: {
         readonly mutate: false;
         readonly valueSource: "default";
     };
+    readonly listNavigationTargets: {
+        readonly method: "post";
+        readonly read: true;
+        readonly transaction: false;
+        readonly mutate: false;
+        readonly valueSource: "default";
+    };
     readonly getReactionMeta: {
         readonly method: "post";
         readonly read: true;
@@ -380,7 +387,7 @@ type SelectFlowSurfaceActionNames<TFlag extends keyof FlowSurfaceActionDefinitio
     [K in FlowSurfacesActionName]: (typeof FLOW_SURFACE_ACTION_DEFINITIONS)[K][TFlag] extends true ? K : never;
 }[FlowSurfacesActionName];
 type FlowSurfaceMutateActionName = SelectFlowSurfaceActionNames<'mutate'>;
-export declare const FLOW_SURFACES_ACTION_NAMES: ("setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "context" | "get" | "configure" | "apply" | "createPage" | "addTab" | "addPopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "compose" | "createMenu" | "catalog" | "describeSurface" | "exportBlueprint" | "getReactionMeta" | "applyBlueprint" | "applyApprovalBlueprint" | "listTemplates" | "getTemplate" | "saveTemplate" | "updateTemplate" | "destroyTemplate" | "convertTemplateToCopy" | "updateMenu" | "destroyPage" | "updateTab" | "moveTab" | "removeTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlocks" | "addFields" | "addActions" | "addRecordActions" | "updateSettings" | "getEventFlowMeta" | "addEventFlow" | "setEventFlow" | "removeEventFlow" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode" | "mutate")[];
+export declare const FLOW_SURFACES_ACTION_NAMES: ("setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "context" | "get" | "configure" | "apply" | "createPage" | "addTab" | "addPopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "compose" | "createMenu" | "catalog" | "describeSurface" | "exportBlueprint" | "listNavigationTargets" | "getReactionMeta" | "applyBlueprint" | "applyApprovalBlueprint" | "listTemplates" | "getTemplate" | "saveTemplate" | "updateTemplate" | "destroyTemplate" | "convertTemplateToCopy" | "updateMenu" | "destroyPage" | "updateTab" | "moveTab" | "removeTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlocks" | "addFields" | "addActions" | "addRecordActions" | "updateSettings" | "getEventFlowMeta" | "addEventFlow" | "setEventFlow" | "removeEventFlow" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode" | "mutate")[];
 export declare const FLOW_SURFACES_READ_ACTION_NAMES: SelectFlowSurfaceActionNames<"read">[];
 export declare const FLOW_SURFACE_MUTATE_OP_TYPES: FlowSurfaceMutateActionName[];
-export declare const FLOW_SURFACES_ACTION_METHODS: Record<"setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "context" | "get" | "configure" | "apply" | "createPage" | "addTab" | "addPopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "compose" | "createMenu" | "catalog" | "describeSurface" | "exportBlueprint" | "getReactionMeta" | "applyBlueprint" | "applyApprovalBlueprint" | "listTemplates" | "getTemplate" | "saveTemplate" | "updateTemplate" | "destroyTemplate" | "convertTemplateToCopy" | "updateMenu" | "destroyPage" | "updateTab" | "moveTab" | "removeTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlocks" | "addFields" | "addActions" | "addRecordActions" | "updateSettings" | "getEventFlowMeta" | "addEventFlow" | "setEventFlow" | "removeEventFlow" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode" | "mutate", FlowSurfaceActionMethod>;
+export declare const FLOW_SURFACES_ACTION_METHODS: Record<"setFieldValueRules" | "setBlockLinkageRules" | "setFieldLinkageRules" | "setActionLinkageRules" | "context" | "get" | "configure" | "apply" | "createPage" | "addTab" | "addPopupTab" | "addBlock" | "addField" | "addAction" | "addRecordAction" | "compose" | "createMenu" | "catalog" | "describeSurface" | "exportBlueprint" | "listNavigationTargets" | "getReactionMeta" | "applyBlueprint" | "applyApprovalBlueprint" | "listTemplates" | "getTemplate" | "saveTemplate" | "updateTemplate" | "destroyTemplate" | "convertTemplateToCopy" | "updateMenu" | "destroyPage" | "updateTab" | "moveTab" | "removeTab" | "updatePopupTab" | "movePopupTab" | "removePopupTab" | "addBlocks" | "addFields" | "addActions" | "addRecordActions" | "updateSettings" | "getEventFlowMeta" | "addEventFlow" | "setEventFlow" | "removeEventFlow" | "setEventFlows" | "setLayout" | "moveNode" | "removeNode" | "mutate", FlowSurfaceActionMethod>;

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

@@ -41,6 +41,7 @@ const FLOW_SURFACE_ACTION_DEFINITIONS = {
   get: { method: "get", read: true, transaction: false, mutate: false, valueSource: "read" },
   describeSurface: { method: "post", read: true, transaction: false, mutate: false, valueSource: "default" },
   exportBlueprint: { method: "post", read: true, transaction: false, mutate: false, valueSource: "default" },
+  listNavigationTargets: { method: "post", read: true, transaction: false, mutate: false, valueSource: "default" },
   getReactionMeta: { method: "post", read: true, transaction: false, mutate: false, valueSource: "default" },
   setFieldValueRules: { method: "post", read: false, transaction: true, mutate: false, valueSource: "default" },
   setBlockLinkageRules: { method: "post", read: false, transaction: true, mutate: false, valueSource: "default" },

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

@@ -393,27 +393,35 @@ function normalizeLinkageRulesValue(value, context, path) {
     return value;
   }
   return value.map((rule, index) => {
-    if (!import_lodash.default.isPlainObject(rule) || !import_lodash.default.has(rule, "condition")) {
-      return rule;
+    if (!import_lodash.default.isPlainObject(rule)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces updateSettings domain '${getLinkageRuleDomainPath(context, path, index)}' on '${context.use}' expects each linkage rule to be an object`
+      );
     }
     const normalizedRule = import_lodash.default.cloneDeep(rule);
-    const conditionPath = getLinkageRuleDomainPath(context, path, index, "condition");
+    const hasCondition = import_lodash.default.has(normalizedRule, "condition");
+    const hasWhen = import_lodash.default.has(normalizedRule, "when");
+    const conditionLeaf = hasCondition ? "condition" : hasWhen ? "when" : "condition";
+    const conditionInput = hasCondition ? import_lodash.default.get(normalizedRule, "condition") : hasWhen ? import_lodash.default.get(normalizedRule, "when") : import_filter_group.FLOW_SURFACE_EMPTY_FILTER_GROUP;
     import_lodash.default.set(
       normalizedRule,
       "condition",
       (0, import_filter_group.normalizeFlowSurfaceCompatibleFilterGroupValue)(
-        import_lodash.default.get(normalizedRule, "condition"),
-        `flowSurfaces updateSettings domain '${conditionPath}' on '${context.use}' expects FilterGroup or backend query filter like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
+        conditionInput,
+        `flowSurfaces updateSettings domain '${getLinkageRuleDomainPath(context, path, index, conditionLeaf)}' on '${context.use}' expects FilterGroup or backend query filter like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`,
         { strictDateValues: true }
       )
     );
-    if (!import_lodash.default.has(normalizedRule, "actions")) {
-      import_lodash.default.set(normalizedRule, "actions", []);
-    } else if (!Array.isArray(import_lodash.default.get(normalizedRule, "actions"))) {
+    const hasActions = import_lodash.default.has(normalizedRule, "actions");
+    const hasThen = import_lodash.default.has(normalizedRule, "then");
+    const actionsLeaf = hasActions ? "actions" : hasThen ? "then" : "actions";
+    const actionsInput = hasActions ? import_lodash.default.get(normalizedRule, "actions") : hasThen ? import_lodash.default.get(normalizedRule, "then") : [];
+    if (!Array.isArray(actionsInput)) {
       (0, import_errors.throwBadRequest)(
-        `flowSurfaces updateSettings domain '${getLinkageRuleDomainPath(context, path, index, "actions")}' on '${context.use}' expects actions to be an array`
+        `flowSurfaces updateSettings domain '${getLinkageRuleDomainPath(context, path, index, actionsLeaf)}' on '${context.use}' expects actions/then to be an array`
       );
     }
+    import_lodash.default.set(normalizedRule, "actions", actionsInput);
     if (!import_lodash.default.has(normalizedRule, "key")) {
       import_lodash.default.set(normalizedRule, "key", `linkage-rule-${index + 1}`);
     }
@@ -425,12 +433,14 @@ function normalizeLinkageRulesValue(value, context, path) {
       import_lodash.default.set(normalizedRule, "enable", typeof enabled === "boolean" ? enabled : true);
     }
     import_lodash.default.unset(normalizedRule, "enabled");
+    import_lodash.default.unset(normalizedRule, "when");
+    import_lodash.default.unset(normalizedRule, "then");
     return normalizedRule;
   });
 }
 function getLinkageRuleDomainPath(context, path, index, leaf) {
   const basePath = context.groupKey ? `${context.domain}.${context.groupKey}.${path}[${index}]` : `${context.domain}.${path}[${index}]`;
-  return `${basePath}.${leaf}`;
+  return leaf ? `${basePath}.${leaf}` : basePath;
 }
 function isContractDefinedFlowGroup(groupContract) {
   if (!groupContract) {

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

@@ -37,7 +37,7 @@ export declare class FlowSurfaceBadRequestError extends FlowSurfaceError {
     constructor(message: string, code?: string, options?: FlowSurfaceErrorOptions);
 }
 export declare class FlowSurfaceForbiddenError extends FlowSurfaceError {
-    constructor(message: string, code?: string);
+    constructor(message: string, code?: string, options?: FlowSurfaceErrorOptions);
 }
 export declare class FlowSurfaceConflictError extends FlowSurfaceError {
     constructor(message: string, code?: string);
@@ -76,6 +76,6 @@ export declare function toFlowSurfaceErrorItem(error: FlowSurfaceError): FlowSur
 export declare function normalizeFlowSurfaceError(error: unknown): FlowSurfaceError;
 export declare function throwBadRequest(message: string, codeOrOptions?: string | FlowSurfaceErrorOptions, options?: FlowSurfaceErrorOptions): never;
 export declare function throwAggregateBadRequest(errors: FlowSurfaceErrorItemInput[]): never;
-export declare function throwForbidden(message: string, code?: string): never;
+export declare function throwForbidden(message: string, code?: string, options?: FlowSurfaceErrorOptions): never;
 export declare function throwConflict(message: string, code?: string): never;
 export declare function throwInternalError(message: string, code?: string): never;

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

@@ -69,8 +69,8 @@ class FlowSurfaceBadRequestError extends FlowSurfaceError {
   }
 }
 class FlowSurfaceForbiddenError extends FlowSurfaceError {
-  constructor(message, code = "FLOW_SURFACE_FORBIDDEN") {
-    super(message, 403, "forbidden", code);
+  constructor(message, code = "FLOW_SURFACE_FORBIDDEN", options = {}) {
+    super(message, 403, "forbidden", code, options);
     this.name = "FlowSurfaceForbiddenError";
   }
 }
@@ -159,8 +159,8 @@ function throwBadRequest(message, codeOrOptions, options = {}) {
 function throwAggregateBadRequest(errors) {
   throw new FlowSurfaceAggregateError(errors);
 }
-function throwForbidden(message, code) {
-  throw new FlowSurfaceForbiddenError(message, code);
+function throwForbidden(message, code, options = {}) {
+  throw new FlowSurfaceForbiddenError(message, code, options);
 }
 function throwConflict(message, code) {
   throw new FlowSurfaceConflictError(message, code);

package/dist/server/flow-surfaces/field-binding-registry.js

@@ -58,14 +58,7 @@ function isNumericFormulaDataType(dataType) {
   return ["integer", "bigInt", "double", "decimal", "number"].includes(String(dataType || "").trim());
 }
 function resolveTargetCollection(input) {
-  var _a;
-  if ((_a = input.field) == null ? void 0 : _a.targetCollection) {
-    return input.field.targetCollection;
-  }
-  if (!input.getCollection || !input.dataSourceKey) {
-    return null;
-  }
-  return (0, import_service_helpers.resolveFieldTargetCollection)(input.field, input.dataSourceKey, input.getCollection);
+  return (0, import_service_helpers.resolveFieldTargetCollection)(input.field, input.dataSourceKey || "main", input.getCollection || (() => null));
 }
 function normalizeBindingContainerUse(containerUse) {
   const normalized = String(containerUse || "").trim();
@@ -100,6 +93,14 @@ function selectPreferredDefaultRule(rules) {
   return rules.find((rule) => typeof rule.when === "function") || rules[0];
 }
 const FIELD_BINDING_RULE_DEFINITIONS = [
+  {
+    scope: "filter",
+    modelClassName: "CascadeSelectFieldModel",
+    interfaces: ["m2o", "o2o", "oho", "obo"],
+    isDefault: true,
+    order: 60,
+    when: ({ targetCollection }) => getCollectionTemplate(targetCollection) === "tree"
+  },
   {
     scope: "display",
     modelClassName: "DisplayPreviewFieldModel",

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 {};