@nocobase/plugin-flow-engine 2.3.0-alpha.1 → 3.0.0-alpha.1

package/dist/server/flow-surfaces/navigation-targets.js

@@ -38,7 +38,6 @@ const DEFAULT_ADMIN_UI_LAYOUT_UID = "admin-layout-model";
 const DEFAULT_MOBILE_UI_LAYOUT_UID = "mobile-layout-model";
 const DEFAULT_ADMIN_MULTI_PORTAL_UID = "__default_admin__";
 const DEFAULT_MOBILE_MULTI_PORTAL_UID = "__default_mobile__";
-const RESERVED_MULTI_PORTAL_UIDS = /* @__PURE__ */ new Set([DEFAULT_ADMIN_MULTI_PORTAL_UID, DEFAULT_MOBILE_MULTI_PORTAL_UID]);
 function readRecordField(record, field) {
   if (!record || typeof record !== "object") {
     return void 0;
@@ -60,6 +59,9 @@ function normalizeRoles(currentRoles) {
 function normalizeRelationRouteId(routeId) {
   return routeId === null || typeof routeId === "undefined" ? void 0 : routeId;
 }
+function isDefaultLayoutMultiPortalUid(uid) {
+  return uid === DEFAULT_ADMIN_MULTI_PORTAL_UID || uid === DEFAULT_MOBILE_MULTI_PORTAL_UID;
+}
 class FlowSurfaceNavigationTargetsService {
   constructor(db) {
     this.db = db;
@@ -85,9 +87,17 @@ class FlowSurfaceNavigationTargetsService {
     return portalUid || void 0;
   }
   async listNavigationTargets(currentRoles, transaction) {
-    const layoutTargets = await this.listLayoutTargets(transaction);
+    var _a;
+    let layoutTargets = await this.listLayoutTargets(transaction);
     const multiPortal = this.hasMultiPortalCapability();
-    const portalTargets = multiPortal ? await this.listAccessiblePortalTargets(currentRoles, transaction) : [];
+    const portalInventory = multiPortal ? await this.getEnabledPortalInventory(currentRoles, transaction) : { accessible: [] };
+    const portalTargets = multiPortal ? await this.listAccessiblePortalTargets(portalInventory.accessible, transaction) : [];
+    if (multiPortal) {
+      layoutTargets = layoutTargets.map(({ default: _default, ...target }) => target);
+      if (portalInventory.accessible.length === 1 && ((_a = portalTargets[0]) == null ? void 0 : _a.uid) === readStringField(portalInventory.accessible[0], "uid")) {
+        portalTargets[0] = { ...portalTargets[0], default: true };
+      }
+    }
     return {
       version: "1",
       capabilities: {
@@ -96,6 +106,60 @@ class FlowSurfaceNavigationTargetsService {
       targets: [...layoutTargets, ...portalTargets]
     };
   }
+  async resolveDefaultPortal(options) {
+    if (!this.hasMultiPortalCapability()) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${options.actionName} requires the Multi-portal capability`, {
+        ruleId: "navigation-portal-unsupported",
+        path: "navigation"
+      });
+    }
+    const inventory = await this.getEnabledPortalInventory(options.currentRoles, options.transaction);
+    if (!inventory.enabled.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${options.actionName} requires an enabled portal`, {
+        ruleId: "navigation-portal-not-found",
+        path: "navigation",
+        details: {
+          uiBuilderAllowed: false,
+          adminLayoutFallbackAllowed: false,
+          agentInstruction: "Stop this Flow Surfaces write. Ask the user to create and enable a Portal before retrying; do not fall back to the Admin layout."
+        }
+      });
+    }
+    if (!inventory.accessible.length) {
+      (0, import_errors.throwForbidden)(
+        `flowSurfaces ${options.actionName} current roles cannot access an enabled portal`,
+        "FLOW_SURFACE_NAVIGATION_PORTAL_FORBIDDEN",
+        {
+          ruleId: "navigation-portal-forbidden",
+          path: "navigation"
+        }
+      );
+    }
+    if (inventory.accessible.length > 1) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${options.actionName} requires an explicit portal selection`, {
+        ruleId: "navigation-portal-selection-required",
+        path: "navigation",
+        details: {
+          candidates: inventory.accessible.map((portal) => {
+            const uid = readStringField(portal, "uid");
+            return {
+              uid,
+              portalName: readStringField(portal, "portalName") || null,
+              title: readStringField(portal, "title") || uid,
+              portalType: readStringField(portal, "portalType") || null
+            };
+          }),
+          uiBuilderAllowed: false,
+          adminLayoutFallbackAllowed: false,
+          agentInstruction: "Stop this Flow Surfaces write and ask the user to select one candidate before retrying; do not choose by Portal type or fall back to the Admin layout."
+        }
+      });
+    }
+    return this.resolvePortal(readStringField(inventory.accessible[0], "uid"), {
+      ...options,
+      path: "navigation"
+    });
+  }
   async resolvePortal(portalUidValue, options) {
     const portalUid = this.normalizePortalUid(portalUidValue);
     if (!portalUid) {
@@ -111,19 +175,9 @@ class FlowSurfaceNavigationTargetsService {
         details: { portalUid }
       });
     }
-    if (RESERVED_MULTI_PORTAL_UIDS.has(portalUid)) {
-      (0, import_errors.throwBadRequest)(
-        `flowSurfaces ${options.actionName} ${options.path} cannot use reserved default portal uid '${portalUid}'; use layoutUid semantics instead`,
-        {
-          ruleId: "navigation-portal-reserved",
-          path: options.path,
-          details: { portalUid }
-        }
-      );
-    }
     const portal = await this.db.getRepository("multiPortals").findOne({
       filter: { uid: portalUid },
-      fields: ["uid", "title", "icon", "routeName", "routePath", "authCheck", "enabled", "uiLayoutUid"],
+      fields: ["uid", "title", "icon", "portalType", "portalName", "routePath", "authCheck", "enabled", "uiLayoutUid"],
       transaction: options.transaction
     });
     if (!portal) {
@@ -133,6 +187,18 @@ class FlowSurfaceNavigationTargetsService {
         details: { portalUid }
       });
     }
+    const routeScopeKind = isDefaultLayoutMultiPortalUid(portalUid) ? "layout" : "portal";
+    if (routeScopeKind === "portal" && !await this.canAccessPortal(portalUid, options.currentRoles, options.transaction)) {
+      (0, import_errors.throwForbidden)(
+        `flowSurfaces ${options.actionName} current roles cannot access portal '${portalUid}'`,
+        "FLOW_SURFACE_NAVIGATION_PORTAL_FORBIDDEN",
+        {
+          ruleId: "navigation-portal-forbidden",
+          path: options.path,
+          details: { portalUid }
+        }
+      );
+    }
     if (readRecordField(portal, "enabled") !== true) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${options.actionName} portal '${portalUid}' is disabled`, {
         ruleId: "navigation-portal-disabled",
@@ -140,6 +206,33 @@ class FlowSurfaceNavigationTargetsService {
         details: { portalUid }
       });
     }
+    const portalType = readStringField(portal, "portalType");
+    if (portalType !== "no-code") {
+      if (portalType === "ai") {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces ${options.actionName} cannot use UI Builder or Flow Surfaces for AI Portal '${portalUid}'; stop and implement the request in the Portal source code`,
+          {
+            ruleId: "navigation-portal-type-unsupported",
+            path: options.path,
+            details: {
+              portalUid,
+              portalType,
+              portalName: readStringField(portal, "portalName") || null,
+              expectedPortalType: "no-code",
+              uiBuilderAllowed: false,
+              adminLayoutFallbackAllowed: false,
+              implementationPath: "ai-portal-source",
+              agentInstruction: "Stop this Flow Surfaces write. Run nb portal info <portalName> -j to resolve localPath, then implement the request in that AI Portal source code. Do not retry with an Admin layout."
+            }
+          }
+        );
+      }
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${options.actionName} portal '${portalUid}' does not support no-code routes`, {
+        ruleId: "navigation-portal-type-unsupported",
+        path: options.path,
+        details: { portalUid, portalType: portalType || null }
+      });
+    }
     const layoutUid = readStringField(portal, "uiLayoutUid");
     if (!layoutUid || !this.db.getCollection("uiLayouts")) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${options.actionName} portal '${portalUid}' has no available backing UI layout`, {
@@ -173,27 +266,18 @@ class FlowSurfaceNavigationTargetsService {
         }
       );
     }
-    if (!await this.canAccessPortal(portalUid, options.currentRoles, options.transaction)) {
-      (0, import_errors.throwForbidden)(
-        `flowSurfaces ${options.actionName} current roles cannot access portal '${portalUid}'`,
-        "FLOW_SURFACE_NAVIGATION_PORTAL_FORBIDDEN",
-        {
-          ruleId: "navigation-portal-forbidden",
-          path: options.path,
-          details: { portalUid }
-        }
-      );
-    }
     return {
       uid: portalUid,
       title: readStringField(portal, "title") || portalUid,
       icon: readStringField(portal, "icon") || null,
-      routeName: readStringField(portal, "routeName"),
+      routeName: readStringField(portal, "portalName"),
       routePath: readStringField(portal, "routePath"),
       authCheck: readRecordField(portal, "authCheck") === true,
       enabled: true,
       layoutUid,
-      layoutType: readStringField(layout, "layoutType")
+      layoutType: readStringField(layout, "layoutType"),
+      portalType,
+      routeScopeKind
     };
   }
   async readRoutePortalUids(routeId, transaction) {
@@ -293,43 +377,48 @@ class FlowSurfaceNavigationTargetsService {
       return left.uid.localeCompare(right.uid);
     });
   }
-  async listAccessiblePortalTargets(currentRoles, transaction) {
+  async getEnabledPortalInventory(currentRoles, transaction) {
+    const enabled = await this.db.getRepository("multiPortals").find({
+      filter: { enabled: true },
+      fields: ["uid", "title", "icon", "portalType", "portalName", "routePath", "authCheck", "enabled", "uiLayoutUid"],
+      sort: ["uid"],
+      transaction
+    });
+    enabled.sort(
+      (left, right) => String(readStringField(left, "uid") || "").localeCompare(String(readStringField(right, "uid") || ""))
+    );
     const roles = normalizeRoles(currentRoles);
-    let accessiblePortalUids;
-    if (!roles.includes("root")) {
-      if (!roles.length || !this.db.getCollection("rolesMultiPortals")) {
-        return [];
-      }
+    const isRoot = roles.includes("root");
+    const accessiblePortalUids = /* @__PURE__ */ new Set();
+    if (!isRoot && roles.length && this.db.getCollection("rolesMultiPortals")) {
       const grants = await this.db.getRepository("rolesMultiPortals").find({
-        fields: ["multiPortalUid"],
         filter: { roleName: roles },
+        fields: ["multiPortalUid"],
         transaction
       });
-      accessiblePortalUids = Array.from(
-        new Set(
-          grants.map((grant) => readStringField(grant, "multiPortalUid")).filter((portalUid) => !!portalUid)
-        )
-      );
-      if (!accessiblePortalUids.length) {
-        return [];
+      for (const grant of grants) {
+        const portalUid = readStringField(grant, "multiPortalUid");
+        if (portalUid) {
+          accessiblePortalUids.add(portalUid);
+        }
       }
     }
-    const accessiblePortalUidSet = accessiblePortalUids ? new Set(accessiblePortalUids) : void 0;
-    const filter = {
-      enabled: true,
-      "uid.$notIn": Array.from(RESERVED_MULTI_PORTAL_UIDS)
-    };
-    const portals = await this.db.getRepository("multiPortals").find({
-      filter,
-      fields: ["uid", "title", "icon", "routeName", "routePath", "authCheck", "enabled", "uiLayoutUid"],
-      sort: ["uid"],
-      transaction
+    const accessible = enabled.filter((portal) => {
+      const portalUid = readStringField(portal, "uid");
+      return !!portalUid && (isRoot || isDefaultLayoutMultiPortalUid(portalUid) || accessiblePortalUids.has(portalUid));
     });
+    return { enabled, accessible };
+  }
+  async listAccessiblePortalTargets(portals, transaction) {
     const targets = [];
     for (const portal of portals) {
       const portalUid = readStringField(portal, "uid");
       const layoutUid = readStringField(portal, "uiLayoutUid");
-      if (!portalUid || accessiblePortalUidSet && !accessiblePortalUidSet.has(portalUid) || !layoutUid || !this.db.getCollection("uiLayouts")) {
+      const portalType = readStringField(portal, "portalType");
+      if (!portalUid || portalType !== "no-code") {
+        continue;
+      }
+      if (!layoutUid || !this.db.getCollection("uiLayouts")) {
         continue;
       }
       const layout = await this.db.getRepository("uiLayouts").findOne({
@@ -348,12 +437,30 @@ class FlowSurfaceNavigationTargetsService {
         icon: readStringField(portal, "icon") || null,
         layoutUid,
         layoutType: readStringField(layout, "layoutType"),
-        routeName: readStringField(portal, "routeName"),
+        routeName: readStringField(portal, "portalName"),
         routePath: readStringField(portal, "routePath"),
         authCheck: readRecordField(portal, "authCheck") === true
       });
     }
-    return targets;
+    return targets.sort((left, right) => this.comparePortalPriority(left, right));
+  }
+  comparePortalPriority(left, right) {
+    const priorityDelta = this.getPortalPriority(left) - this.getPortalPriority(right);
+    if (priorityDelta) {
+      return priorityDelta;
+    }
+    return String(readStringField(left, "uid") || "").localeCompare(String(readStringField(right, "uid") || ""));
+  }
+  getPortalPriority(portal) {
+    const uiLayout = readRecordField(portal, "uiLayout");
+    const layoutType = readStringField(portal, "layoutType") || readStringField(uiLayout, "layoutType");
+    if (readStringField(portal, "uid") === DEFAULT_ADMIN_MULTI_PORTAL_UID) {
+      return 0;
+    }
+    if (layoutType !== "mobile") {
+      return 1;
+    }
+    return 2;
   }
   async canAccessPortal(portalUid, currentRoles, transaction) {
     const roles = normalizeRoles(currentRoles);

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

@@ -96,6 +96,12 @@ export declare class FlowSurfacesService {
     private resolveDesktopRouteLayoutUidFilter;
     private assertNavigationTargetIsExclusive;
     private readDesktopRouteScope;
+    private buildDesktopRouteScopeForPortal;
+    private assertAdminLayoutCreateScope;
+    private getPortalRouteFilterUid;
+    private assertRouteBelongsToResolvedPortal;
+    private resolveDefaultDesktopRouteScope;
+    private resolveDesktopRouteMatchScope;
     private resolveRequestedDesktopRouteScope;
     private resolveExistingDesktopRouteScope;
     private attachDesktopRouteScopeToRouteAndChildren;
@@ -227,6 +233,7 @@ export declare class FlowSurfacesService {
     private dispatchPlanOnlyAction;
     private resolveApplyBlueprintReplaceTargetInfo;
     private resolveApplyBlueprintCreateNavigationGroup;
+    private resolveApplyBlueprintDefaultNavigationTarget;
     private normalizeApplyBlueprintCreateMobileNavigation;
     private assertApplyBlueprintCreateNavigationTarget;
     private resolveApplyBlueprintCreatePageIdentity;