🐞 Fix journey version filtering: remove "Untitled Guide" and correct progress counts (#60675)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Kevin Heis <heiskr@users.noreply.github.com>
Co-authored-by: hubwriter <hubwriter@github.com>

Author: 4 people

src/journeys/lib/journey-path-resolver.ts

@@ -233,38 +233,47 @@ export async function resolveJourneyContext(
           }
         }
 
+        // Build the list of guides available for the current version.
+        // fetchGuideData returns null for guides that don't exist in the current version,
+        // so this filters out unavailable guides for correct counts and navigation.
+        const availableGuides = (
+          await Promise.all(
+            track.guides.map(async (guide, i) => {
+              const guideData = await fetchGuideData(guide.href, context)
+              return guideData ? { rawIndex: i, ...guideData } : null
+            }),
+          )
+        ).filter((g): g is { rawIndex: number; href: string; title: string } => g !== null)
+
+        const filteredIndex = availableGuides.findIndex((g) => g.rawIndex === guideIndex)
+        const filteredCount = availableGuides.length
+
         result = {
           trackId: track.id,
           trackName: track.id,
           trackTitle: track.title,
           journeyTitle: journeyPage.title || '',
           journeyPath:
             journeyPage.permalink || Permalink.relativePathToSuffix(journeyPage.relativePath || ''),
-          currentGuideIndex: guideIndex,
-          numberOfGuides: track.guides.length,
+          currentGuideIndex: filteredIndex >= 0 ? filteredIndex : guideIndex,
+          numberOfGuides: filteredCount,
           alternativeNextStep: renderedAlternativeNextStep,
         }
 
-        // Set up previous guide
-        if (guideIndex > 0) {
-          const prevGuidePath = track.guides[guideIndex - 1].href
-          const guideData = await fetchGuideData(prevGuidePath, context)
-          if (guideData) {
-            result.prevGuide = guideData
-          }
+        // Set up previous guide using the version-filtered list
+        if (filteredIndex > 0) {
+          const prev = availableGuides[filteredIndex - 1]
+          result.prevGuide = { href: prev.href, title: prev.title }
         }
 
-        // Set up next guide
-        if (guideIndex < track.guides.length - 1) {
-          const nextGuidePath = track.guides[guideIndex + 1].href
-          const guideData = await fetchGuideData(nextGuidePath, context)
-          if (guideData) {
-            result.nextGuide = guideData
-          }
+        // Set up next guide using the version-filtered list
+        if (filteredIndex >= 0 && filteredIndex < filteredCount - 1) {
+          const next = availableGuides[filteredIndex + 1]
+          result.nextGuide = { href: next.href, title: next.title }
         }
 
-        // Only populate nextTrackFirstGuide when on the last guide of the track
-        if (guideIndex === track.guides.length - 1) {
+        // Only populate nextTrackFirstGuide when on the last guide of the filtered track
+        if (filteredIndex === filteredCount - 1) {
           foundTrackIndex = trackIndex
 
           if (
@@ -320,16 +329,18 @@ export async function resolveJourneyTracks(
           ? await renderContent(track.description, context, { textOnly: true })
           : track.description
 
-      const guides = await Promise.all(
-        track.guides.map(async (guide: { href: string; alternativeNextStep?: string }) => {
-          const linkData = await getLinkData(guide.href, context, { title: true })
-          const baseHref = linkData?.[0]?.href || guide.href
-          return {
-            href: baseHref,
-            title: linkData?.[0]?.title || 'Untitled Guide',
-          }
-        }),
-      )
+      const guides = (
+        await Promise.all(
+          track.guides.map(async (guide: { href: string; alternativeNextStep?: string }) => {
+            const linkData = await getLinkData(guide.href, context, { title: true })
+            if (!linkData?.[0]) return null
+            return {
+              href: linkData[0].href,
+              title: linkData[0].title || '',
+            }
+          }),
+        )
+      ).filter((g): g is { href: string; title: string } => g !== null)
 
       return {
         id: track.id,

src/journeys/tests/journey-path-resolver.ts

@@ -1,19 +1,27 @@
-import { describe, expect, test, vi } from 'vitest'
+import { afterEach, describe, expect, test, vi } from 'vitest'
 
 import { resolveJourneyContext, resolveJourneyTracks } from '../lib/journey-path-resolver'
+import getLinkData from '@/journeys/lib/get-link-data'
 import type { Page } from '@/types'
 
 // Mock modules since we just want to test journey functions, not their dependencies or
 // against real content files
 vi.mock('@/journeys/lib/get-link-data', () => ({
-  default: async (path: string) => [
-    {
-      href: `/en/enterprise-cloud@latest${path}`,
-      title: `Mock Title for ${path}`,
-    },
-  ],
+  default: vi.fn(async (rawLinks: string | string[] | undefined) => {
+    const path = Array.isArray(rawLinks) ? rawLinks[0] : rawLinks
+    if (!path) return undefined
+    return [
+      {
+        href: `/en/enterprise-cloud@latest${path}`,
+        title: `Mock Title for ${path}`,
+        page: {} as unknown as Page,
+      },
+    ]
+  }),
 }))
 
+const mockGetLinkData = vi.mocked(getLinkData)
+
 vi.mock('@/content-render/index', () => ({
   renderContent: async (content: string) => content,
 }))
@@ -269,4 +277,156 @@ describe('journey-path-resolver', () => {
       expect(result[0].description).toBeUndefined()
     })
   })
+
+  describe('resolveJourneyContext with version-filtered guides', () => {
+    afterEach(() => {
+      // Restore the default implementation after each test in this block
+      mockGetLinkData.mockImplementation(async (rawLinks: string | string[] | undefined) => {
+        const path = Array.isArray(rawLinks) ? rawLinks[0] : rawLinks
+        if (!path) return undefined
+        return [
+          {
+            href: `/en/enterprise-cloud@latest${path}`,
+            title: `Mock Title for ${path}`,
+            page: {} as unknown as Page,
+          },
+        ]
+      })
+    })
+
+    const mockContext = {
+      currentProduct: 'github',
+      currentLanguage: 'en',
+      currentVersion: 'enterprise-cloud@latest',
+    }
+
+    // Track with 4 guides where the 2nd guide is unavailable in the current version:
+    // raw indices: 0=setup, 1=unavailable, 2=config, 3=deploy
+    // filtered:    0=setup,                1=config,  2=deploy
+    const mockPages = {
+      'enterprise-onboarding/index': {
+        layout: 'journey-landing',
+        title: 'Enterprise onboarding',
+        permalink: '/enterprise-onboarding',
+        journeyTracks: [
+          {
+            id: 'getting_started',
+            title: 'Getting started',
+            guides: [
+              { href: '/enterprise-onboarding/setup' },
+              { href: '/enterprise-onboarding/unavailable' },
+              { href: '/enterprise-onboarding/config' },
+              { href: '/enterprise-onboarding/deploy' },
+            ],
+          },
+        ],
+      },
+    } as unknown as Record<string, Page>
+
+    test('resolveJourneyTracks filters out guides unavailable for the current version', async () => {
+      mockGetLinkData.mockImplementation(async (rawLinks: string | string[] | undefined) => {
+        const path = Array.isArray(rawLinks) ? rawLinks[0] : rawLinks
+        if (path === '/enterprise-onboarding/config') return undefined
+        if (!path) return undefined
+        return [
+          {
+            href: `/en/enterprise-cloud@latest${path}`,
+            title: `Mock Title for ${path}`,
+            page: {} as unknown as Page,
+          },
+        ]
+      })
+
+      const tracks = [
+        {
+          id: 'getting_started',
+          title: 'Getting started',
+          guides: [
+            { href: '/enterprise-onboarding/setup' },
+            { href: '/enterprise-onboarding/config' },
+          ],
+        },
+      ]
+      const result = await resolveJourneyTracks(tracks, mockContext)
+
+      // /enterprise-onboarding/config is unavailable, so only /enterprise-onboarding/setup remains
+      expect(result[0].guides).toHaveLength(1)
+      expect(result[0].guides[0].href).toBe(
+        '/en/enterprise-cloud@latest/enterprise-onboarding/setup',
+      )
+    })
+
+    test('numberOfGuides reflects only version-available guides', async () => {
+      mockGetLinkData.mockImplementation(async (rawLinks: string | string[] | undefined) => {
+        const path = Array.isArray(rawLinks) ? rawLinks[0] : rawLinks
+        if (path === '/enterprise-onboarding/unavailable') return undefined
+        if (!path) return undefined
+        return [
+          {
+            href: `/en/enterprise-cloud@latest${path}`,
+            title: `Mock Title for ${path}`,
+            page: {} as unknown as Page,
+          },
+        ]
+      })
+
+      const result = await resolveJourneyContext(
+        '/enterprise-onboarding/config',
+        mockPages,
+        mockContext,
+      )
+
+      expect(result?.numberOfGuides).toBe(3) // 3 available, not 4 raw
+    })
+
+    test('currentGuideIndex reflects position in version-filtered list', async () => {
+      mockGetLinkData.mockImplementation(async (rawLinks: string | string[] | undefined) => {
+        const path = Array.isArray(rawLinks) ? rawLinks[0] : rawLinks
+        if (path === '/enterprise-onboarding/unavailable') return undefined
+        if (!path) return undefined
+        return [
+          {
+            href: `/en/enterprise-cloud@latest${path}`,
+            title: `Mock Title for ${path}`,
+            page: {} as unknown as Page,
+          },
+        ]
+      })
+
+      const result = await resolveJourneyContext(
+        '/enterprise-onboarding/config',
+        mockPages,
+        mockContext,
+      )
+
+      // config is at raw index 2, but filtered index 1 (setup=0, config=1, deploy=2)
+      expect(result?.currentGuideIndex).toBe(1)
+    })
+
+    test('prevGuide skips unavailable guides', async () => {
+      mockGetLinkData.mockImplementation(async (rawLinks: string | string[] | undefined) => {
+        const path = Array.isArray(rawLinks) ? rawLinks[0] : rawLinks
+        if (path === '/enterprise-onboarding/unavailable') return undefined
+        if (!path) return undefined
+        return [
+          {
+            href: `/en/enterprise-cloud@latest${path}`,
+            title: `Mock Title for ${path}`,
+            page: {} as unknown as Page,
+          },
+        ]
+      })
+
+      // config's predecessor in the raw list is "unavailable", but in filtered list it's "setup"
+      const result = await resolveJourneyContext(
+        '/enterprise-onboarding/config',
+        mockPages,
+        mockContext,
+      )
+
+      expect(result?.prevGuide?.href).toBe(
+        '/en/enterprise-cloud@latest/enterprise-onboarding/setup',
+      )
+    })
+  })
 })