brand functionality enhancements (#125)

Author: rishibalakrishnan

.gitignore

@@ -19,6 +19,8 @@ xcuserdata
 DerivedData
 *.hmap
 *.xcuserstate
+.worktrees
+.worktree
 
 # Android/IntelliJ
 #

src/App.native.tsx

@@ -14,6 +14,7 @@ import {useLingui} from '@lingui/react/macro'
 import * as Sentry from '@sentry/react-native'
 
 import {BrandProvider, useBrand} from '#/lib/community/BrandContext'
+import {CommunityBrandSync} from '#/lib/community/useCommunityBrandSync'
 import {Provider as HideBottomBarBorderProvider} from '#/lib/hooks/useHideBottomBarBorder'
 import {QueryProvider} from '#/lib/react-query'
 import {ThemeProvider} from '#/lib/ThemeContext'
@@ -155,6 +156,7 @@ function InnerApp() {
                           <LabelDefsProvider>
                             <ModerationOptsProvider>
                               <LoggedOutViewProvider>
+                                <CommunityBrandSync />
                                 <SelectedFeedProvider>
                                   <HiddenRepliesProvider>
                                     <HomeBadgeProvider>

src/env/common.ts

@@ -155,6 +155,16 @@ export const LIVE_EVENTS_URL = IS_DEV
   ? (LIVE_EVENTS_DEV_URL ?? LIVE_EVENTS_PROD_URL)
   : LIVE_EVENTS_PROD_URL
 
+/**
+ * Base URL of the Acorn brand service. Used on native to resolve a community's
+ * brand config from the active account's PDS (`/brands/resolve?pds=` / `?slug=`).
+ * On web the config is injected by bskyweb (`window.__BRAND_CONFIG__`), so this
+ * is only consulted on native.
+ */
+export const BRAND_SERVICE_URL: string =
+  process.env.EXPO_PUBLIC_BRAND_SERVICE_URL ||
+  'https://brand.acorn.blacksky.community'
+
 /**
  * Stripe publishable key for embedded checkout
  */

src/lib/community/BrandContext.tsx

@@ -1,4 +1,10 @@
-import {createContext, type PropsWithChildren, useContext} from 'react'
+import {
+  createContext,
+  type PropsWithChildren,
+  useCallback,
+  useContext,
+  useState,
+} from 'react'
 
 import {generateComputedConfig} from '#/lib/community/configGenerator'
 import {
@@ -9,6 +15,8 @@ import {
 import {DISCOVER_FEED_URI, VIDEO_FEED_URI} from '#/lib/constants'
 import {DEFAULT_BLUE_HUE} from '#/alf/util/colorGeneration'
 
+const BLACKSKY_MODERATION_DID = 'did:plc:d2mkddsbmnrgr3domzg5qexf'
+
 // Blacksky defaults used as the dev-mode fallback when no brand config is
 // injected by bskyweb (i.e. when running `yarn web` locally).
 const BLACKSKY_CONFIG: RawCommunityConfig = {
@@ -39,6 +47,7 @@ const BLACKSKY_CONFIG: RawCommunityConfig = {
     pds: {
       url: 'https://blacksky.app',
     },
+    moderation: [BLACKSKY_MODERATION_DID],
   },
   feeds: {
     defaultPinned: [
@@ -103,15 +112,48 @@ const BLACKSKY_PRIMARY_SCALE = {
   primary_975: '#13133B',
 }
 
+type Pin = {type: string; value: string; pinned: boolean}
+
+// The Following timeline is a protocol-level home invariant, not per-community
+// configurable data. Guarantee exactly one entry (appended if missing) and drop
+// any following entry mis-typed as a feed. Backstops a served config that omits
+// Following (stale cache, service-down fallback, or upstream serialization bug).
+export function ensureFollowingPinned(pins: Pin[]): Pin[] {
+  let hasFollowing = false
+  const out = pins.filter(p => {
+    if (p.type === 'feed' && p.value === 'following') return false // drop corruption
+    if (p.type === 'timeline' && p.value === 'following') {
+      if (hasFollowing) return false // dedupe
+      hasFollowing = true
+    }
+    return true
+  })
+  if (!hasFollowing)
+    out.push({type: 'timeline', value: 'following', pinned: true})
+  return out
+}
+
+function normalizeBrandConfig(
+  config: ComputedBrandConfig,
+): ComputedBrandConfig {
+  return {
+    ...config,
+    feeds: {
+      ...config.feeds,
+      defaultPinned: ensureFollowingPinned(config.feeds?.defaultPinned ?? []),
+    },
+  }
+}
+
 // In multi-brand mode, bskyweb injects the config into the HTML before React loads.
 // In dev mode (yarn web), fall back to the Blacksky defaults above.
 function resolveBrandConfig(): ComputedBrandConfig {
   if (typeof window !== 'undefined' && window.__BRAND_CONFIG__) {
-    return window.__BRAND_CONFIG__
+    return normalizeBrandConfig(window.__BRAND_CONFIG__)
   }
 
   const config = generateComputedConfig(BLACKSKY_CONFIG)
-  return {
+  return normalizeBrandConfig({
     ...config,
     theme: {
       ...config.theme,
@@ -125,7 +167,7 @@ function resolveBrandConfig(): ComputedBrandConfig {
         selectionDark: '#464985',
       },
     },
-  }
+  })
 }
 
 export const DEFAULT_BRAND_CONFIG = resolveBrandConfig()
@@ -181,18 +223,41 @@ if (typeof document !== 'undefined') {
 }
 
 const BrandContext = createContext<ComputedBrandConfig>(DEFAULT_BRAND_CONFIG)
+const SetBrandContext = createContext<(config: ComputedBrandConfig) => void>(
+  () => {},
+)
 
 export function BrandProvider({
   children,
   config,
 }: PropsWithChildren<{config?: ComputedBrandConfig}>) {
+  // On web the active config is fixed at page load (bskyweb injects it by
+  // hostname), so this state never changes. On native it starts at the bundled
+  // Blacksky default and is updated to follow the active account's community —
+  // see useCommunityBrandSync. Account switches don't remount this provider
+  // (it sits above the account-keyed subtree), so re-theming rides this state.
+  const [current, setCurrent] = useState<ComputedBrandConfig>(
+    config || DEFAULT_BRAND_CONFIG,
+  )
+  const setBrandConfig = useCallback((next: ComputedBrandConfig) => {
+    setCurrent(normalizeBrandConfig(next))
+  }, [])
   return (
-    <BrandContext.Provider value={config || DEFAULT_BRAND_CONFIG}>
-      {children}
-    </BrandContext.Provider>
+    <SetBrandContext.Provider value={setBrandConfig}>
+      <BrandContext.Provider value={current}>{children}</BrandContext.Provider>
+    </SetBrandContext.Provider>
   )
 }
 
 export function useBrand(): ComputedBrandConfig {
   return useContext(BrandContext)
 }
+
+/**
+ * Setter for the active brand config. Used by useCommunityBrandSync (native) to
+ * re-theme when the active account resolves to a different community. The value
+ * is normalized (following-pinned) before it is applied.
+ */
+export function useSetBrandConfig(): (config: ComputedBrandConfig) => void {
+  return useContext(SetBrandContext)
+}

src/lib/community/__tests__/BrandContext.test.ts

@@ -1,7 +1,11 @@
 import {describe, expect, it} from '@jest/globals'
 
 import {DISCOVER_FEED_URI, VIDEO_FEED_URI} from '#/lib/constants'
-import {BRAND_DOMAIN, DEFAULT_BRAND_CONFIG} from '../BrandContext'
+import {
+  BRAND_DOMAIN,
+  DEFAULT_BRAND_CONFIG,
+  ensureFollowingPinned,
+} from '../BrandContext'
 
 describe('BrandContext defaults', () => {
   it('preserves Blacksky defaults when no brand config is injected', () => {
@@ -22,6 +26,9 @@ describe('BrandContext defaults', () => {
     expect(DEFAULT_BRAND_CONFIG.messages.postButtonLabel).toBe('Post')
 
     expect(DEFAULT_BRAND_CONFIG.services.pds.url).toBe('https://blacksky.app')
+    expect(DEFAULT_BRAND_CONFIG.services.moderation).toEqual([
+      'did:plc:d2mkddsbmnrgr3domzg5qexf',
+    ])
     expect(DEFAULT_BRAND_CONFIG.web.domains.main).toBe(
       'https://blacksky.community',
     )
@@ -70,3 +77,39 @@ describe('BrandContext defaults', () => {
     expect(DEFAULT_BRAND_CONFIG.theme.css.selectionDark).toBe('#464985')
   })
 })
+
+describe('ensureFollowingPinned', () => {
+  it('appends Following when missing, preserving order', () => {
+    const out = ensureFollowingPinned([
+      {type: 'feed', value: 'at://x/medsky', pinned: true},
+    ])
+    expect(out[0]).toEqual({type: 'feed', value: 'at://x/medsky', pinned: true})
+    expect(out[out.length - 1]).toEqual({
+      type: 'timeline',
+      value: 'following',
+      pinned: true,
+    })
+  })
+
+  it('does not duplicate an existing Following entry', () => {
+    const out = ensureFollowingPinned([
+      {type: 'timeline', value: 'following', pinned: true},
+      {type: 'feed', value: 'at://x/medsky', pinned: true},
+    ])
+    expect(
+      out.filter(f => f.type === 'timeline' && f.value === 'following'),
+    ).toHaveLength(1)
+  })
+
+  it('strips a malformed feed-typed following entry', () => {
+    const out = ensureFollowingPinned([
+      {type: 'feed', value: 'following', pinned: true},
+    ])
+    expect(out.some(f => f.type === 'feed' && f.value === 'following')).toBe(
+      false,
+    )
+    expect(
+      out.filter(f => f.type === 'timeline' && f.value === 'following'),
+    ).toHaveLength(1)
+  })
+})

src/lib/community/__tests__/configGenerator.test.ts

@@ -423,6 +423,24 @@ describe('generateComputedConfig', () => {
     expect(config.services.pds.availableHandles).toEqual([])
   })
 
+  it('passes through moderation service DIDs from raw config', () => {
+    const moderation = ['did:plc:mod1', 'did:plc:mod2']
+    const withModeration: RawCommunityConfig = {
+      ...theinviteConfig,
+      services: {
+        ...theinviteConfig.services,
+        moderation,
+      },
+    }
+    const config = generateComputedConfig(withModeration)
+    expect(config.services.moderation).toEqual(moderation)
+  })
+
+  it('defaults moderation service DIDs to empty array when omitted', () => {
+    const config = generateComputedConfig(theinviteConfig)
+    expect(config.services.moderation).toEqual([])
+  })
+
   it('produces default onboarding config when omitted', () => {
     const config = generateComputedConfig(theinviteConfig)
     expect(config.onboarding.starterPack).toBe('')

src/lib/community/__tests__/resolveBrand.test.ts

@@ -0,0 +1,113 @@
+import {afterEach, beforeEach, describe, expect, it, jest} from '@jest/globals'
+
+import {
+  fetchBrandBySlug,
+  normalizeHost,
+  resolveBrandForAccount,
+  resolveBrandForPds,
+} from '../resolveBrand'
+
+describe('normalizeHost', () => {
+  it('strips scheme, port, path, and lowercases', () => {
+    expect(normalizeHost('https://Blacksky.app')).toBe('blacksky.app')
+    expect(normalizeHost('blacksky.app')).toBe('blacksky.app')
+    expect(normalizeHost('https://blacksky.app:443/xrpc')).toBe('blacksky.app')
+    expect(normalizeHost('http://pds.example.com/')).toBe('pds.example.com')
+    expect(normalizeHost('  https://blacksky.app/  ')).toBe('blacksky.app')
+    expect(normalizeHost('blacksky.app.')).toBe('blacksky.app')
+  })
+})
+
+describe('brand resolution', () => {
+  const makeResponse = (body: unknown, ok = true): Response =>
+    ({ok, json: () => Promise.resolve(body)}) as unknown as Response
+  let fetchMock: jest.MockedFunction<typeof fetch>
+
+  beforeEach(() => {
+    fetchMock = jest
+      .fn<typeof fetch>()
+      .mockResolvedValue(
+        makeResponse({slug: 'x', status: 'published', computed: {slug: 'x'}}),
+      )
+    global.fetch = fetchMock
+  })
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  function calledUrl(): string {
+    const arg = fetchMock.mock.calls[0]?.[0]
+    return typeof arg === 'string' ? arg : ''
+  }
+
+  it('fetchBrandBySlug hits ?slug=', async () => {
+    await fetchBrandBySlug('latinsky')
+    expect(calledUrl()).toContain('/brands/resolve?slug=latinsky')
+  })
+
+  it('resolveBrandForPds normalizes the host into ?pds=', async () => {
+    await resolveBrandForPds('https://blacksky.app:443/')
+    expect(calledUrl()).toContain('/brands/resolve?pds=blacksky.app')
+  })
+
+  it('returns null (falls back to default) on non-ok responses', async () => {
+    fetchMock.mockResolvedValueOnce(makeResponse({}, false))
+    expect(await resolveBrandForPds('https://blacksky.app')).toBeNull()
+  })
+
+  it('returns null when fetch throws', async () => {
+    fetchMock.mockRejectedValueOnce(new Error('offline'))
+    expect(await resolveBrandForPds('https://blacksky.app')).toBeNull()
+  })
+
+  describe('resolveBrandForAccount precedence', () => {
+    it('1. stamped communitySlug wins over everything', async () => {
+      await resolveBrandForAccount({
+        communitySlug: 'medsky',
+        pdsUrl: 'https://blacksky.app',
+        handle: 'a.latinsky.app',
+      })
+      expect(calledUrl()).toContain('slug=medsky')
+    })
+
+    it('2. Latinsky carveout: Blacksky PDS + latinsky handle → latinsky slug', async () => {
+      await resolveBrandForAccount({
+        pdsUrl: 'https://blacksky.app',
+        handle: 'alice.latinsky.app',
+      })
+      expect(calledUrl()).toContain('slug=latinsky')
+    })
+
+    it('2b. afrolatinsky handle also triggers the carveout', async () => {
+      await resolveBrandForAccount({
+        pdsUrl: 'https://blacksky.app',
+        handle: 'bob.afrolatinsky.app',
+      })
+      expect(calledUrl()).toContain('slug=latinsky')
+    })
+
+    it('3. plain Blacksky account → null (bundled default), never PDS-resolved', async () => {
+      const result = await resolveBrandForAccount({
+        pdsUrl: 'https://blacksky.app',
+        handle: 'alice.blacksky.app',
+      })
+      expect(result).toBeNull()
+      expect(fetchMock).not.toHaveBeenCalled()
+    })
+
+    it('3b. a latinsky-looking handle on a different PDS is NOT the carveout', async () => {
+      await resolveBrandForAccount({
+        pdsUrl: 'https://pds.example.com',
+        handle: 'evil.latinsky.app',
+      })
+      expect(calledUrl()).toContain('pds=pds.example.com')
+    })
+
+    it('returns null when there is no pdsUrl and no slug', async () => {
+      expect(
+        await resolveBrandForAccount({handle: 'a.blacksky.app'}),
+      ).toBeNull()
+      expect(fetchMock).not.toHaveBeenCalled()
+    })
+  })
+})

src/lib/community/configGenerator.ts

@@ -387,6 +387,7 @@ export function generateComputedConfig(
         url: raw.services.pds.url,
         availableHandles: raw.services.pds.availableHandles || [],
       },
+      moderation: raw.services.moderation || [],
     },
     web: {
       themeColor: raw.web?.themeColor || primary,