[Bug] Side-nav applications (#12260)

* fix side nav

Signed-off-by: Adam Tackett <tackadam@amazon.com>

* address comment

Signed-off-by: Adam Tackett <tackadam@amazon.com>

---------

Signed-off-by: Adam Tackett <tackadam@amazon.com>
Co-authored-by: Adam Tackett <tackadam@amazon.com>

Author: TackAdam

src/plugins/workspace/public/components/workspace_creator/workspace_creator.tsx

@@ -28,7 +28,11 @@ import { WorkspaceClient } from '../../workspace_client';
 import { DataSourceManagementPluginSetup } from '../../../../../plugins/data_source_management/public';
 import { DataPublicPluginStart } from '../../../../data/public';
 import { WorkspaceUseCase } from '../../types';
-import { getFirstUseCaseOfFeatureConfigs } from '../../utils';
+import {
+  getApplicationsSnapshot,
+  getFirstUseCaseOfFeatureConfigs,
+  pickUseCaseLandingAppId,
+} from '../../utils';
 import { useFormAvailableUseCases } from '../workspace_form/use_form_available_use_cases';
 import { NavigationPublicPluginStart } from '../../../../../plugins/navigation/public';
 import { DataSourceConnectionType } from '../../../common/types';
@@ -144,8 +148,9 @@ export const WorkspaceCreator = (props: WorkspaceCreatorProps) => {
           if (application && http) {
             const newWorkspaceId = result.result.id;
             const useCaseId = getFirstUseCaseOfFeatureConfigs(attributes.features);
-            const useCaseLandingAppId = availableUseCases?.find(({ id }) => useCaseId === id)
-              ?.features[0].id;
+            const matchedUseCase = availableUseCases?.find(({ id }) => useCaseId === id);
+            const apps = getApplicationsSnapshot(application);
+            const useCaseLandingAppId = pickUseCaseLandingAppId(matchedUseCase?.features, apps);
 
             // For observability workspaces, run trace detection and create datasets if found
             const isObservabilityWorkspace = useCaseId === 'observability';

src/plugins/workspace/public/utils.test.ts

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { AppNavLinkStatus, NavGroupType, PublicAppInfo } from '../../../core/public';
+import { BehaviorSubject } from 'rxjs';
+import { AppNavLinkStatus, AppStatus, NavGroupType, PublicAppInfo } from '../../../core/public';
 import {
   featureMatchesConfig,
   filterWorkspaceConfigurableApps,
@@ -12,6 +13,7 @@ import {
   getDataSourcesList,
   convertNavGroupToWorkspaceUseCase,
   isEqualWorkspaceUseCase,
+  pickUseCaseLandingAppId,
   prependWorkspaceToBreadcrumbs,
   mergeDataSourcesWithConnections,
   fetchDataSourceConnections,
@@ -967,6 +969,81 @@ describe('workspace utils: mergeDataSourcesWithConnections', () => {
   });
 });
 
+describe('workspace utils: pickUseCaseLandingAppId', () => {
+  const accessibleVisible = ({
+    status: AppStatus.accessible,
+    navLinkStatus: AppNavLinkStatus.default,
+  } as Partial<PublicAppInfo>) as PublicAppInfo;
+  const featureFlagDisabled = ({
+    status: AppStatus.accessible,
+    navLinkStatus: AppNavLinkStatus.hidden,
+  } as Partial<PublicAppInfo>) as PublicAppInfo;
+  const outsideWorkspaceHidden = ({
+    // Mirrors the state read on the workspace creator page for an
+    // `insideWorkspace`-only app: workspace plugin pushed `inaccessible`,
+    // some other path pushed `navLinkStatus: hidden` — both flip back
+    // once the user enters the workspace, so the picker must keep them.
+    status: AppStatus.inaccessible,
+    navLinkStatus: AppNavLinkStatus.hidden,
+  } as Partial<PublicAppInfo>) as PublicAppInfo;
+
+  it('returns undefined when the use case has no features', () => {
+    expect(pickUseCaseLandingAppId(undefined, new Map())).toBeUndefined();
+    expect(pickUseCaseLandingAppId([], new Map())).toBeUndefined();
+  });
+
+  it('falls back to features[0] when no apps snapshot is provided', () => {
+    expect(pickUseCaseLandingAppId([{ id: 'first' }, { id: 'second' }], undefined)).toBe('first');
+  });
+
+  it('skips feature-flag-disabled apps (hidden + accessible)', () => {
+    const apps = new Map<string, PublicAppInfo>([
+      ['alerting', featureFlagDisabled],
+      ['dashboards', accessibleVisible],
+    ]);
+    expect(pickUseCaseLandingAppId([{ id: 'alerting' }, { id: 'dashboards' }], apps)).toBe(
+      'dashboards'
+    );
+  });
+
+  it('keeps apps that are transiently hidden outside a workspace (hidden + inaccessible)', () => {
+    // Repro of the bug we shipped this for: workspace creator runs outside
+    // any workspace, so `insideWorkspace` apps look hidden — but we must
+    // still pick the first one as the landing target, because it'll be
+    // accessible immediately after the redirect.
+    const apps = new Map<string, PublicAppInfo>([
+      ['dashboards', outsideWorkspaceHidden],
+      ['explore/logs', outsideWorkspaceHidden],
+    ]);
+    expect(pickUseCaseLandingAppId([{ id: 'dashboards' }, { id: 'explore/logs' }], apps)).toBe(
+      'dashboards'
+    );
+  });
+
+  it('falls back to features[0] when every feature is feature-flag-disabled', () => {
+    const apps = new Map<string, PublicAppInfo>([
+      ['a', featureFlagDisabled],
+      ['b', featureFlagDisabled],
+    ]);
+    expect(pickUseCaseLandingAppId([{ id: 'a' }, { id: 'b' }], apps)).toBe('a');
+  });
+
+  it('treats a feature id absent from the apps map as selectable', () => {
+    // Load-bearing for the transient-load case: feature ids come from
+    // `convertNavGroupToWorkspaceUseCase` over real nav links, so an
+    // absent lookup means the apps snapshot hasn't propagated yet, not
+    // that the app is missing. Skipping such features would silently
+    // skip the entire list during early page load.
+    const apps = new Map<string, PublicAppInfo>([['known-feature-flag-off', featureFlagDisabled]]);
+    expect(
+      pickUseCaseLandingAppId(
+        [{ id: 'known-feature-flag-off' }, { id: 'not-yet-in-apps-map' }],
+        apps
+      )
+    ).toBe('not-yet-in-apps-map');
+  });
+});
+
 describe('workspace utils: getUseCaseUrl', () => {
   it('should get use case url', () => {
     startMock.application.getUrlForApp.mockImplementation((id) => `http://localhost/${id}`);
@@ -979,6 +1056,32 @@ describe('workspace utils: getUseCaseUrl', () => {
     const url = getUseCaseUrl(undefined, 'foo', startMock.application, startMock.http);
     expect(url).toEqual('http://localhost/w/foo/workspace_detail');
   });
+
+  it('should skip feature-flag-disabled features when picking the landing app', () => {
+    startMock.application.getUrlForApp.mockImplementation((id) => `http://localhost/${id}`);
+    (startMock.application.applications$ as BehaviorSubject<Map<string, PublicAppInfo>>).next(
+      new Map<string, PublicAppInfo>([
+        // `bar` is the first feature of `useCaseMock`. Flag it off so the
+        // picker has to fall through to the next feature.
+        [
+          'bar',
+          ({
+            status: AppStatus.accessible,
+            navLinkStatus: AppNavLinkStatus.hidden,
+          } as Partial<PublicAppInfo>) as PublicAppInfo,
+        ],
+        [
+          'baz',
+          ({
+            status: AppStatus.accessible,
+            navLinkStatus: AppNavLinkStatus.default,
+          } as Partial<PublicAppInfo>) as PublicAppInfo,
+        ],
+      ])
+    );
+    const url = getUseCaseUrl(useCaseMock, 'foo', startMock.application, startMock.http);
+    expect(url).toEqual('http://localhost/w/foo/baz');
+  });
 });
 
 describe('workspace utils: fetchDataSourceConnections', () => {

src/plugins/workspace/public/utils.ts

@@ -11,6 +11,7 @@ import {
   AppCategory,
   ApplicationStart,
   AppNavLinkStatus,
+  AppStatus,
   ChromeBreadcrumb,
   CoreStart,
   DEFAULT_APP_CATEGORIES,
@@ -526,13 +527,71 @@ export function prependWorkspaceToBreadcrumbs(
   }
 }
 
+/**
+ * Read the current value of `application.applications$` synchronously.
+ *
+ * Load-bearing assumption: `applications$` is wrapped in `shareReplay(1)`
+ * upstream (see `application_service.tsx`), so subscribing then immediately
+ * unsubscribing emits the latest cached value without leaking the
+ * subscription. If a future refactor drops `shareReplay`, this returns
+ * `undefined` instead of throwing — callers that branch on snapshot
+ * presence (e.g. `pickUseCaseLandingAppId`) will silently regress to
+ * pre-fix behavior. Keep this helper as the single source of truth so the
+ * regression has one place to surface rather than many.
+ */
+export const getApplicationsSnapshot = (
+  application: ApplicationStart
+): ReadonlyMap<string, PublicAppInfo> | undefined => {
+  let apps: ReadonlyMap<string, PublicAppInfo> | undefined;
+  const sub = application.applications$.subscribe((value) => {
+    apps = value;
+  });
+  sub.unsubscribe();
+  return apps;
+};
+
+/**
+ * Pick the landing app for a use case. Skips features that are
+ * **feature-flag-disabled** — i.e. `navLinkStatus === hidden` *and*
+ * `status === accessible`. An app gated by a feature flag is still
+ * accessible in principle, the plugin just hides the nav link to suppress
+ * the UI; an app that's transiently inaccessible (e.g. an
+ * `insideWorkspace`-only app read from outside any workspace, which the
+ * workspace plugin marks `inaccessible` and which therefore renders as
+ * `hidden` too) will become available once the user enters the workspace
+ * and must not be filtered out here.
+ *
+ * Reading both fields lets us distinguish "hidden by config" (skip) from
+ * "hidden because of where we are" (keep — it'll come back). A feature id
+ * with no entry in `apps` is treated as selectable: feature ids come from
+ * `convertNavGroupToWorkspaceUseCase` over real registered nav links, so
+ * an absent lookup means the applications snapshot hasn't propagated yet,
+ * not that the app doesn't exist.
+ */
+export const pickUseCaseLandingAppId = (
+  features: WorkspaceUseCaseFeature[] | undefined,
+  apps: ReadonlyMap<string, PublicAppInfo> | undefined
+): string | undefined => {
+  if (!features?.length) {
+    return undefined;
+  }
+  if (!apps) {
+    return features[0].id;
+  }
+  const isFeatureFlagDisabled = (app: PublicAppInfo | undefined) =>
+    app?.navLinkStatus === AppNavLinkStatus.hidden && app?.status === AppStatus.accessible;
+  const firstSelectable = features.find((feature) => !isFeatureFlagDisabled(apps.get(feature.id)));
+  return (firstSelectable ?? features[0]).id;
+};
+
 export const getUseCaseUrl = (
   useCase: WorkspaceUseCase | undefined,
   workspaceId: string,
   application: ApplicationStart,
   http: HttpSetup
 ): string => {
-  const appId = useCase?.features?.[0]?.id || WORKSPACE_DETAIL_APP_ID;
+  const apps = getApplicationsSnapshot(application);
+  const appId = pickUseCaseLandingAppId(useCase?.features, apps) || WORKSPACE_DETAIL_APP_ID;
   const useCaseURL = formatUrlWithWorkspaceId(
     application.getUrlForApp(appId, {
       absolute: false,