react-native-audio-browser 0.2.0-next.17 → 0.2.0-next.19

package/src/web/browser/SearchManager.ts

@@ -15,7 +15,9 @@ export class SearchManager {
    * Matches Android's BrowserManager.search(params: SearchParams) behavior.
    *
    * @param params Search parameters (query is required, other fields optional)
-   * @returns Array of matching tracks
+   * @returns Array of matching tracks — empty only when the source found none
+   * @throws The failure itself: an `Error` carrying a `NavigationErrorType`
+   *   `code` from `HttpClient`, or whatever a `searchCallback` rejected with
    */
   async search(params: SearchParams): Promise<Track[]> {
     // Find __search__ route entry
@@ -48,36 +50,31 @@ export class SearchManager {
 
       // Delegate to the shared layered fetch (request → search) on BrowserManager
       // so the ladder lives in one place.
-      try {
-        results = await this.browserManager.fetchSearchResults(
-          searchRoute.searchConfig,
-          searchQueryParams
-        )
-      } catch (error) {
-        console.error('Search failed:', error)
-        return []
-      }
+      results = await this.browserManager.fetchSearchResults(
+        searchRoute.searchConfig,
+        searchQueryParams
+      )
     }
 
     // Transform artwork URLs on search results using async method with full Track access
+    // Gated per track inside the resolver, as on Android — a result carrying a
+    // plain `artwork` URL resolves even with no `artwork` config.
     const { request: requestConfig, artwork: artworkConfig } =
       this.browserManager.configuration
-    if (artworkConfig) {
-      results = await Promise.all(
-        results.map(async (track) => {
-          const artworkSource =
-            await RequestConfigBuilder.resolveArtworkSourceAsync(
-              track,
-              requestConfig,
-              artworkConfig
-            )
-          if (artworkSource && !track.artworkSource) {
-            return { ...track, artworkSource }
-          }
-          return track
-        })
-      )
-    }
+    results = await Promise.all(
+      results.map(async (track) => {
+        const artworkSource =
+          await RequestConfigBuilder.resolveArtworkSourceAsync(
+            track,
+            requestConfig,
+            artworkConfig
+          )
+        if (artworkSource && !track.artworkSource) {
+          return { ...track, artworkSource }
+        }
+        return track
+      })
+    )
 
     return results
   }

package/src/web/browser/__tests__/artwork-resolution.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { HttpClient } from '../../http/HttpClient'
+import { BrowserManager } from '../BrowserManager'
+import { FavoriteManager } from '../FavoriteManager'
+import { NavigationErrorManager } from '../NavigationErrorManager'
+
+function makeManager(): BrowserManager {
+  const httpClient = {
+    executeRequest: vi.fn().mockRejectedValue(new Error('no network in test'))
+  } as unknown as HttpClient
+  return new BrowserManager(
+    httpClient,
+    new FavoriteManager(),
+    new NavigationErrorManager()
+  )
+}
+
+/**
+ * Who gets an `artworkSource`, and on whose say-so.
+ *
+ * Android gates this per *track* — `resolveArtworkUrl` returns early only when
+ * `artworkConfig == null && track.artwork == null`, so a track carrying a plain
+ * URL resolves to `{ uri }` with no `artwork` block configured at all. Web used
+ * to gate a level up, bailing out of the whole page when `configuration.artwork`
+ * was unset, which left every child's `artworkSource` undefined in any app that
+ * never declared one — the example app among them.
+ */
+describe('artwork resolution without an artwork config', () => {
+  it('populates artworkSource for a child carrying a plain artwork url', async () => {
+    const manager = makeManager()
+    manager.configuration = {
+      path: '/',
+      routes: [
+        {
+          path: '/library',
+          browseStatic: {
+            path: '/library',
+            title: 'Library',
+            sections: [
+              {
+                title: 'Collections',
+                children: [
+                  {
+                    title: 'Cratediggers',
+                    path: '/collection/cratediggers',
+                    artwork: 'https://cdn.example.com/cratediggers.jpg'
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+    }
+
+    await manager.navigatePath('/library')
+
+    const tile = manager.content?.sections?.[0]?.children[0]
+    expect(tile?.artworkSource?.uri).toBe(
+      'https://cdn.example.com/cratediggers.jpg'
+    )
+  })
+
+  it('leaves artworkSource undefined for a child with no artwork', async () => {
+    const manager = makeManager()
+    manager.configuration = {
+      path: '/',
+      routes: [
+        {
+          path: '/library',
+          browseStatic: {
+            path: '/library',
+            title: 'Library',
+            sections: [
+              {
+                title: 'Collections',
+                children: [{ title: 'Bare', path: '/collection/bare' }]
+              }
+            ]
+          }
+        }
+      ]
+    }
+
+    await manager.navigatePath('/library')
+
+    const tile = manager.content?.sections?.[0]?.children[0]
+    expect(tile?.artworkSource).toBeUndefined()
+  })
+
+  it('treats an empty artwork string as no artwork, as Android does', async () => {
+    const manager = makeManager()
+    manager.configuration = {
+      path: '/',
+      routes: [
+        {
+          path: '/library',
+          browseStatic: {
+            path: '/library',
+            title: 'Library',
+            sections: [
+              {
+                title: 'Collections',
+                children: [{ title: 'Empty', path: '/x', artwork: '' }]
+              }
+            ]
+          }
+        }
+      ]
+    }
+
+    await manager.navigatePath('/library')
+
+    const tile = manager.content?.sections?.[0]?.children[0]
+    expect(tile?.artworkSource).toBeUndefined()
+  })
+})

package/src/web/browser/__tests__/layer-resolver.test.ts

@@ -66,4 +66,39 @@ describe('BrowserManager layer resolver', () => {
     await expect(manager.navigatePath('/a')).resolves.not.toThrow()
     expect(calls).toBe(1)
   })
+
+  /**
+   * The media and artwork paths sit outside browse and so must reach the
+   * request layer through this accessor. Reading `configuration.request`
+   * instead hands a resolver-only config no baseUrl and no headers — on
+   * exactly the requests that carry a credential. Android's
+   * `resolvedRequestConfig()` exists for the same reason.
+   */
+  it('exposes the resolver result to consumers outside the browse path', async () => {
+    const manager = makeManager()
+    manager.configuration = {
+      path: '/',
+      requestResolver: async () => ({
+        baseUrl: 'https://api.example.com',
+        headers: { Authorization: 'Bearer token' }
+      })
+    }
+
+    expect(await manager.resolvedRequestConfig()).toEqual({
+      baseUrl: 'https://api.example.com',
+      headers: { Authorization: 'Bearer token' }
+    })
+  })
+
+  it('falls back to the static request config when no resolver is set', async () => {
+    const manager = makeManager()
+    manager.configuration = {
+      path: '/',
+      request: { baseUrl: 'https://static.example.com' }
+    }
+
+    expect(await manager.resolvedRequestConfig()).toEqual({
+      baseUrl: 'https://static.example.com'
+    })
+  })
 })

package/src/web/browser/__tests__/search-navigation.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { FormattedNavigationError } from '../../../features'
+import type { HttpClient } from '../../http/HttpClient'
+import { BrowserManager } from '../BrowserManager'
+import { FavoriteManager } from '../FavoriteManager'
+import { NavigationErrorManager } from '../NavigationErrorManager'
+
+/**
+ * A BrowserManager whose only route is a `searchConfig`, with its HTTP client
+ * answering every request with `respond`.
+ */
+function makeManager(respond: () => Promise<unknown>): {
+  manager: BrowserManager
+  errors: NavigationErrorManager
+  formattedPaths: string[]
+} {
+  const httpClient = {
+    executeRequest: vi.fn().mockImplementation(respond)
+  } as unknown as HttpClient
+  const errors = new NavigationErrorManager()
+  const manager = new BrowserManager(httpClient, new FavoriteManager(), errors)
+  const formattedPaths: string[] = []
+  manager.configuration = {
+    routes: [
+      {
+        path: '__search__',
+        searchConfig: { baseUrl: 'https://api.example.com' }
+      }
+    ],
+    formatNavigationError: ({ path }): FormattedNavigationError => {
+      formattedPaths.push(path)
+      return { title: 'Search unavailable' }
+    }
+  }
+  return { manager, errors, formattedPaths }
+}
+
+const httpError = (): Error => {
+  const error = new Error('HTTP 500: Internal Server Error') as Error & {
+    code: string
+    statusCode: number
+  }
+  error.code = 'http-error'
+  error.statusCode = 500
+  return error
+}
+
+describe('navigating to a search path', () => {
+  it('surfaces a navigation error when the search fails', async () => {
+    const { manager, errors, formattedPaths } = makeManager(() =>
+      Promise.reject(httpError())
+    )
+
+    await manager.navigatePath('/__search?q=jazz')
+
+    expect(errors.getNavigationError()).toEqual({
+      code: 'http-error',
+      message: 'HTTP 500: Internal Server Error',
+      statusCode: 500,
+      statusCodeSuccess: undefined
+    })
+    expect(formattedPaths).toEqual(['/__search?q=jazz'])
+    expect(manager.content).toBeUndefined()
+  })
+
+  it('resolves an empty page without an error when the search found nothing', async () => {
+    const { manager, errors } = makeManager(() =>
+      Promise.resolve({ children: [] })
+    )
+
+    await manager.navigatePath('/__search?q=jazz')
+
+    expect(errors.getNavigationError()).toBeUndefined()
+    expect(manager.content?.sections).toEqual([{ children: [] }])
+  })
+})

package/src/web/http/RequestConfigBuilder.test.ts

@@ -1,5 +1,9 @@
 import { describe, it, expect } from 'vitest'
-import type { RequestConfig, TransformableRequestConfig } from '../../types'
+import type {
+  RequestConfig,
+  Track,
+  TransformableRequestConfig
+} from '../../types'
 import { RequestConfigBuilder } from './RequestConfigBuilder'
 
 /**
@@ -48,6 +52,29 @@ describe('RequestConfigBuilder.applyLayer — sync/async transform composition',
     expect(out.query).toEqual({ stage: 'sync' })
   })
 
+  it('falls back to the base when a transform throws', async () => {
+    const layer: TransformableRequestConfig = {
+      transform: async () => {
+        throw new Error('boom')
+      }
+    }
+    const out = await RequestConfigBuilder.applyLayer(base, layer)
+    expect(out).toEqual(base)
+  })
+
+  it('falls back to the base when the sync stage throws after the async one', async () => {
+    const layer: TransformableRequestConfig = {
+      transform: async (req) => ({ ...req, headers: { a: '1' } }),
+      transformSync: () => {
+        throw new Error('boom')
+      }
+    }
+    const out = await RequestConfigBuilder.applyLayer(base, layer)
+    // the layer's input, not the half-applied config — matches native's single
+    // catch around the pair
+    expect(out).toEqual(base)
+  })
+
   it('falls back to a static field merge when no transform is set', async () => {
     const layer: TransformableRequestConfig = {
       baseUrl: 'https://override.example.com'
@@ -57,3 +84,216 @@ describe('RequestConfigBuilder.applyLayer — sync/async transform composition',
     expect(out.path).toBe('/p')
   })
 })
+
+/**
+ * A media request needs more than its URL. The layers resolve headers (and a
+ * user agent) alongside it, and native applies them to the AVURLAsset /
+ * ExoPlayer DataSpec — so a resolver that returned only the URL left web unable
+ * to play media that authenticated fine on iOS and Android.
+ */
+describe('RequestConfigBuilder.resolveMediaRequest', () => {
+  const src = 'https://cdn.example.com/track.m3u8'
+
+  it('keeps the headers a media transform resolves', async () => {
+    const media = {
+      transform: async (req: RequestConfig) => ({
+        ...req,
+        headers: { ...req.headers, Authorization: 'Bearer token' }
+      })
+    }
+
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      src,
+      undefined,
+      media
+    )
+
+    expect(out.path).toBe(src)
+    expect(out.headers).toEqual({ Authorization: 'Bearer token' })
+  })
+
+  it('keeps the headers of a static media config', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(src, undefined, {
+      headers: { 'X-Api-Key': 'k' }
+    })
+
+    expect(out.headers).toEqual({ 'X-Api-Key': 'k' })
+  })
+
+  it('merges the shared request layer under the media layer', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      src,
+      { headers: { 'User-Agent': 'shared', 'X-Shared': 'yes' } },
+      { headers: { 'User-Agent': 'media' } }
+    )
+
+    expect(out.headers).toEqual({
+      'User-Agent': 'media',
+      'X-Shared': 'yes'
+    })
+  })
+
+  it('folds baseUrl into the resolved path', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      '/track.m3u8',
+      undefined,
+      { baseUrl: 'https://cdn.example.com' }
+    )
+
+    expect(out.path).toBe('https://cdn.example.com/track.m3u8')
+    expect(out.baseUrl).toBeUndefined()
+  })
+
+  it('carries the media config query onto the resolved url', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(src, undefined, {
+      query: { token: 'abc' }
+    })
+
+    expect(out.path).toBe(`${src}?token=abc`)
+    // cleared so the resolved url can't be rebuilt and double-append it
+    expect(out.query).toBeUndefined()
+  })
+
+  it('appends query to a url that already has one', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      'https://cdn.example.com/track.m3u8?v=2',
+      undefined,
+      { query: { token: 'abc' } }
+    )
+
+    expect(out.path).toBe('https://cdn.example.com/track.m3u8?v=2&token=abc')
+  })
+
+  it('falls back to the original src when a transform throws', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(src, undefined, {
+      transform: async () => {
+        throw new Error('boom')
+      }
+    })
+
+    expect(out.path).toBe(src)
+    expect(out.headers).toBeUndefined()
+  })
+
+  it('keeps the shared layer when the media transform throws', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      '/track.mp3',
+      {
+        baseUrl: 'https://api.example.com',
+        headers: { Authorization: 'Bearer token' }
+      },
+      {
+        transform: async () => {
+          throw new Error('boom')
+        }
+      }
+    )
+
+    // the media layer is skipped, the ladder under it stands — dropping it too
+    // would play a relative url with no credential
+    expect(out.path).toBe('https://api.example.com/track.mp3')
+    expect(out.headers).toEqual({ Authorization: 'Bearer token' })
+  })
+})
+
+/**
+ * `media.resolve(track)` is the final, most-specific layer — the shape native
+ * runs (Android `applyMediaResolve`, iOS `applyMediaResolveLayer`) and the one
+ * the public docs promise. Web ignored it entirely until these landed, so a
+ * config minting per-track signed URLs played on both native platforms and
+ * silently played the unsigned src on web.
+ */
+describe('RequestConfigBuilder.resolveMediaRequest — media.resolve', () => {
+  const src = '/track.mp3'
+  const track: Track = { id: '7', title: 'Track 7', src }
+
+  it('lets the resolver replace the url', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      src,
+      undefined,
+      { resolve: async (t) => ({ path: `/signed/${t.id}.mp3` }) },
+      track
+    )
+
+    expect(out.path).toBe('/signed/7.mp3')
+  })
+
+  it('runs after the media transform, and wins over it', async () => {
+    const order: string[] = []
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      src,
+      undefined,
+      {
+        transform: async (req) => {
+          order.push('transform')
+          return { ...req, path: '/unsigned.mp3', headers: { A: 'transform' } }
+        },
+        resolve: async () => {
+          order.push('resolve')
+          return { path: '/signed.mp3', headers: { A: 'resolve' } }
+        }
+      },
+      track
+    )
+
+    expect(order).toEqual(['transform', 'resolve'])
+    expect(out.path).toBe('/signed.mp3')
+    expect(out.headers).toEqual({ A: 'resolve' })
+  })
+
+  it('merges resolveSync over resolve, and both over the layers', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      src,
+      { headers: { 'X-Shared': 'yes' } },
+      {
+        headers: { 'X-Media': 'yes' },
+        resolve: async () => ({ headers: { Authorization: 'async' } }),
+        resolveSync: () => ({ headers: { Authorization: 'sync' } })
+      },
+      track
+    )
+
+    expect(out.headers).toEqual({
+      'X-Shared': 'yes',
+      'X-Media': 'yes',
+      'Authorization': 'sync'
+    })
+  })
+
+  it('reports the resolver contribution as a media-layer header', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      src,
+      { headers: { 'X-Client-Version': '1.2.3' } },
+      { resolve: async () => ({ headers: { 'X-Api-Key': 'k' } }) },
+      track
+    )
+
+    // per-track and media-specific, so the web redirect probe should run
+    expect(out.mediaLayerHeaders).toBe(true)
+  })
+
+  it('keeps the layers when the resolver throws', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(
+      src,
+      { baseUrl: 'https://api.example.com', headers: { 'X-Shared': 'yes' } },
+      {
+        resolve: async () => {
+          throw new Error('boom')
+        }
+      },
+      track
+    )
+
+    // native loses the per-track shaping, not the layers under it
+    expect(out.path).toBe('https://api.example.com/track.mp3')
+    expect(out.headers).toEqual({ 'X-Shared': 'yes' })
+  })
+
+  it('skips the resolver when there is no track', async () => {
+    const out = await RequestConfigBuilder.resolveMediaRequest(src, undefined, {
+      resolve: async () => ({ path: '/signed.mp3' })
+    })
+
+    expect(out.path).toBe(src)
+  })
+})