fix: read World user count from the worlds endpoint on /jump cards (#621)

Author: braianj

src/features/places/places.client.spec.ts

@@ -92,6 +92,10 @@ describe('placesEndpoints', () => {
     })
 
     describe('and an ENS realm with an explicit position is provided', () => {
+      // The /places scene record carries a contaminated user_count (the Genesis
+      // City parcel's occupancy); /worlds carries the World's real count. The
+      // scene fetch is always the first call, so it's queued in the parent
+      // beforeEach; each child queues only its distinct /worlds response next.
       beforeEach(() => {
         mockGetEnv.mockImplementation(key => (key === 'PLACES_API_URL' ? 'https://places.test/api' : undefined))
         fetchSpy.mockResolvedValueOnce({
@@ -109,25 +113,118 @@ describe('placesEndpoints', () => {
                   description: '',
                   positions: ['10,20', '11,20'],
                   world: true,
-                  world_name: 'cool.dcl.eth'
+                  world_name: 'cool.dcl.eth',
+                  user_count: 99
                 }
               ]
             })
         } as unknown as Response)
       })
 
-      it('should query the World scene by name AND position so the API returns only the matching scene', async () => {
-        const store = createTestStore()
-        await store.dispatch(placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'Cool.DCL.eth', position: [10, 20] }))
+      describe('and the /worlds lookup resolves the World record', () => {
+        beforeEach(() => {
+          fetchSpy.mockResolvedValueOnce({
+            ok: true,
+            json: () =>
+              Promise.resolve({ ok: true, data: [{ id: 'cool.dcl.eth', world: true, world_name: 'cool.dcl.eth', user_count: 2 }] })
+          } as unknown as Response)
+        })
+
+        it('should query the World scene by name AND position so the API returns only the matching scene', async () => {
+          const store = createTestStore()
+          await store.dispatch(placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'Cool.DCL.eth', position: [10, 20] }))
 
-        expect(fetchSpy).toHaveBeenCalledWith('https://places.test/api/places?names=cool.dcl.eth&positions=10,20')
+          expect(fetchSpy).toHaveBeenCalledWith('https://places.test/api/places?names=cool.dcl.eth&positions=10,20')
+        })
+
+        it('should return the scene the server resolved for that position', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'cool.dcl.eth', position: [10, 20] })
+          )
+
+          expect(result.data?.[0]).toEqual(expect.objectContaining({ id: 'arena' }))
+        })
+
+        it('should also query /worlds with the lowercased name to read the reliable occupancy', async () => {
+          const store = createTestStore()
+          await store.dispatch(placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'Cool.DCL.eth', position: [10, 20] }))
+
+          expect(fetchSpy).toHaveBeenCalledWith('https://places.test/api/worlds?names=cool.dcl.eth')
+        })
+
+        it('should overlay the /worlds user_count so the card shows the World occupancy, not the Genesis City parcel count', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'cool.dcl.eth', position: [10, 20] })
+          )
+
+          expect(result.data?.[0].user_count).toBe(2)
+        })
       })
 
-      it('should return the scene the server resolved for that position', async () => {
-        const store = createTestStore()
-        const result = await store.dispatch(placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'cool.dcl.eth', position: [10, 20] }))
+      describe('and the /worlds lookup reports zero users (the user is alone)', () => {
+        beforeEach(() => {
+          fetchSpy.mockResolvedValueOnce({
+            ok: true,
+            json: () =>
+              Promise.resolve({ ok: true, data: [{ id: 'cool.dcl.eth', world: true, world_name: 'cool.dcl.eth', user_count: 0 }] })
+          } as unknown as Response)
+        })
 
-        expect(result.data?.[0]).toEqual(expect.objectContaining({ id: 'arena' }))
+        it('should overlay the zero count instead of leaving the contaminated value', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'cool.dcl.eth', position: [10, 20] })
+          )
+
+          expect(result.data?.[0].user_count).toBe(0)
+        })
+      })
+
+      describe('and the /worlds lookup fails', () => {
+        beforeEach(() => {
+          fetchSpy.mockRejectedValueOnce(new Error('worlds down'))
+        })
+
+        it('should keep the scene record and not crash the query', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'cool.dcl.eth', position: [10, 20] })
+          )
+
+          expect(result.data?.[0]).toEqual(expect.objectContaining({ id: 'arena', user_count: 99 }))
+        })
+      })
+
+      describe('and the /worlds lookup returns a non-OK response', () => {
+        beforeEach(() => {
+          fetchSpy.mockResolvedValueOnce({ ok: false, status: 503 } as unknown as Response)
+        })
+
+        it('should fall back to the scene record value rather than overriding with undefined', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'cool.dcl.eth', position: [10, 20] })
+          )
+
+          expect(result.data?.[0].user_count).toBe(99)
+        })
+      })
+
+      describe('and the /worlds lookup returns no record', () => {
+        beforeEach(() => {
+          fetchSpy.mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ok: true, data: [] }) } as unknown as Response)
+        })
+
+        it('should keep the scene record value', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getJumpPlaces.initiate({ realm: 'cool.dcl.eth', position: [10, 20] })
+          )
+
+          expect(result.data?.[0].user_count).toBe(99)
+        })
       })
     })
 

src/features/places/places.client.ts

@@ -66,6 +66,25 @@ function buildPlacesUrl(baseUrl: string, { position, realm }: GetPlacesArgs): st
   return `${baseUrl}/places`
 }
 
+// The Places API's `/places` endpoint reports a contaminated `user_count` for
+// World records reached via `?names=&positions=`: it returns the live occupancy
+// of the Genesis City parcel at that position (e.g. Genesis Plaza at 0,0), not
+// the World's own occupancy. The `/worlds` endpoint reports the correct count.
+// Launcher deep-links always carry `position=0,0` for Worlds, so without this
+// overlay every World card shows the busy Genesis Plaza count instead of the
+// real one. A `undefined` return (network error, non-OK, or missing record)
+// leaves the `/places` value untouched — never worse than today's behaviour.
+async function fetchWorldUserCount(worldsUrl: string): Promise<number | undefined> {
+  try {
+    const response = await fetch(worldsUrl)
+    if (!response.ok) return undefined
+    const envelope: JumpPlacesResponse = await response.json()
+    return envelope.data?.[0]?.user_count
+  } catch {
+    return undefined
+  }
+}
+
 function buildEventsUrl(baseUrl: string, { position, realm }: GetEventsArgs): string {
   const params = new URLSearchParams()
   if (position) params.set('position', `${position[0]},${position[1]}`)
@@ -167,7 +186,22 @@ const placesEndpoints = placesClient.injectEndpoints({
             return { error: { status: response.status, data: await response.text().catch(() => null) } }
           }
           const envelope: JumpPlacesResponse = await response.json()
-          return { data: envelope.data ?? [] }
+          const places = envelope.data ?? []
+          // A World jump WITH a position resolves the scene via
+          // `/places?names=&positions=`, but that endpoint's `user_count`
+          // reflects the Genesis City parcel at the position, not the World.
+          // Overlay the reliable count from `/worlds` so the card shows the
+          // World's real occupancy (see fetchWorldUserCount).
+          if (places.length > 0 && args.realm && isEns(args.realm) && args.position) {
+            // NOTE: buildPlacesUrl with no position resolves an ENS realm to the
+            // `/worlds?names=` record, whose user_count is the reliable one. This
+            // depends on buildPlacesUrl's no-position branch staying `/worlds`.
+            const worldUserCount = await fetchWorldUserCount(buildPlacesUrl(baseUrl, { realm: args.realm }))
+            if (worldUserCount !== undefined) {
+              return { data: [{ ...places[0], user_count: worldUserCount }, ...places.slice(1)] }
+            }
+          }
+          return { data: places }
         } catch (error) {
           return { error: { status: 'FETCH_ERROR', error: error instanceof Error ? error.message : 'Unknown error' } }
         }