commit 50bb430c5886097ae75f32651b563e656718ad78 · cduck.me/statusphere-example-app-fork

+7 -2

src/context.ts

···

       6
        
       import { createDb, Database, migrateToLatest } from '#/db'

     

       7
        
       import { createIngester } from '#/ingester'

     

       8
        
       import { env } from '#/env'

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
       

     

       10
        
       /**

     

       11
        
        * Application state passed to the router and elsewhere

     
···

       15
        
         ingester: Firehose

     

       16
        
         logger: pino.Logger

     

       17
        
         oauthClient: NodeOAuthClient

     

       18
       -
         identityResolver: NodeOAuthClient['identityResolver']

     

       19
        
       }

     

       20
        
       

     

       21
        
       export async function createAppContext(): Promise<AppContext> {

     
···

       24
        
         const oauthClient = await createOAuthClient(db)

     

       25
        
         const ingester = createIngester(db)

     

       26
        
         const logger = pino({ name: 'server', level: env.LOG_LEVEL })

     

       0
        
       
     

       27
        
       

     

       28
        
         return {

     

       29
        
           db,

     

       30
        
           ingester,

     

       31
        
           logger,

     

       32
        
           oauthClient,

     

       33
       -
           identityResolver: oauthClient.identityResolver,

     

       34
        
         }

     

       35
        
       }

···

       6
        
       import { createDb, Database, migrateToLatest } from '#/db'

     

       7
        
       import { createIngester } from '#/ingester'

     

       8
        
       import { env } from '#/env'

     

       9
       +
       import {

     

       10
       +
         BidirectionalResolver,

     

       11
       +
         createBidirectionalResolver,

     

       12
       +
       } from '#/id-resolver'

     

       13
        
       

     

       14
        
       /**

     

       15
        
        * Application state passed to the router and elsewhere

     
···

       19
        
         ingester: Firehose

     

       20
        
         logger: pino.Logger

     

       21
        
         oauthClient: NodeOAuthClient

     

       22
       +
         resolver: BidirectionalResolver

     

       23
        
       }

     

       24
        
       

     

       25
        
       export async function createAppContext(): Promise<AppContext> {

     
···

       28
        
         const oauthClient = await createOAuthClient(db)

     

       29
        
         const ingester = createIngester(db)

     

       30
        
         const logger = pino({ name: 'server', level: env.LOG_LEVEL })

     

       31
       +
         const resolver = createBidirectionalResolver(oauthClient)

     

       32
        
       

     

       33
        
         return {

     

       34
        
           db,

     

       35
        
           ingester,

     

       36
        
           logger,

     

       37
        
           oauthClient,

     

       38
       +
           resolver,

     

       39
        
         }

     

       40
        
       }

+38

src/id-resolver.ts

···

       1
       +
       import { OAuthClient } from '@atproto/oauth-client-node'

     

       2
       +
       

     

       3
       +
       export interface BidirectionalResolver {

     

       4
       +
         resolveDidToHandle(did: string): Promise<string>

     

       5
       +
         resolveDidsToHandles(

     

       6
       +
           dids: string[],

     

       7
       +
         ): Promise<Record<string, string | undefined>>

     

       8
       +
       }

     

       9
       +
       

     

       10
       +
       export function createBidirectionalResolver({

     

       11
       +
         identityResolver,

     

       12
       +
       }: OAuthClient): BidirectionalResolver {

     

       13
       +
         return {

     

       14
       +
           async resolveDidToHandle(did: string): Promise<string> {

     

       15
       +
             try {

     

       16
       +
               const { handle } = await identityResolver.resolve(did)

     

       17
       +
               if (handle) return handle

     

       18
       +
             } catch {

     

       19
       +
               // Ignore

     

       20
       +
             }

     

       21
       +
             return did

     

       22
       +
           },

     

       23
       +
       

     

       24
       +
           async resolveDidsToHandles(

     

       25
       +
             dids: string[],

     

       26
       +
           ): Promise<Record<string, string | undefined>> {

     

       27
       +
             const uniqueDids = [...new Set(dids)]

     

       28
       +
       

     

       29
       +
             return Object.fromEntries(

     

       30
       +
               await Promise.all(

     

       31
       +
                 uniqueDids.map((did) =>

     

       32
       +
                   this.resolveDidToHandle(did).then((handle) => [did, handle]),

     

       33
       +
                 ),

     

       34
       +
               ),

     

       35
       +
             )

     

       36
       +
           },

     

       37
       +
         }

     

       38
       +
       }

+4 -14

src/routes.ts

···

       221
        
                   .executeTakeFirst()

     

       222
        
               : undefined

     

       223
        
       

     

       224
       -
             // Map (unique) user DIDs to their domain-name handles

     

       225
       -
             const uniqueDids = [...new Set(statuses.map((s) => s.authorDid))]

     

       226
       -
       

     

       227
       -
             const didHandleMap: Record<string, string | undefined> =

     

       228
       -
               Object.fromEntries(

     

       229
       -
                 await Promise.all(

     

       230
       -
                   uniqueDids.map((did) =>

     

       231
       -
                     ctx.identityResolver.resolve(did).then(

     

       232
       -
                       (r) => [did, r.handle],

     

       233
       -
                       () => [did, undefined],

     

       234
       -
                     ),

     

       235
       -
                   ),

     

       236
       -
                 ),

     

       237
       -
               )

     

       238
        
       

     

       239
        
             if (!agent) {

     

       240
        
               // Serve the logged-out view

···

       221
        
                   .executeTakeFirst()

     

       222
        
               : undefined

     

       223
        
       

     

       224
       +
             // Map user DIDs to their domain-name handles

     

       225
       +
             const didHandleMap = await ctx.resolver.resolveDidsToHandles(

     

       226
       +
               statuses.map((s) => s.authorDid),

     

       227
       +
             )

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       228
        
       

     

       229
        
             if (!agent) {

     

       230
        
               // Serve the logged-out view