commit d5b45a1f725bb866fe31e4d1d39c910273360728 · cduck.me/statusphere-example-app-fork

+5 -14

src/context.ts

···

       3
        
       import { pino } from 'pino'

     

       4
        
       

     

       5
        
       import { createOAuthClient } from '#/auth/client'

     

       6
       -
       import { Database } from '#/db'

     

       7
       -
       import { createDb } from '#/db'

     

       8
       -
       import {

     

       9
       -
         BidirectionalResolver,

     

       10
       -
         createBidirectionalResolver,

     

       11
       -
         createIdResolver,

     

       12
       -
       } from '#/id-resolver'

     

       13
        
       import { createIngester } from '#/ingester'

     

       14
        
       

     

       15
        
       /**

     
···

       20
        
         ingester: Firehose

     

       21
        
         logger: pino.Logger

     

       22
        
         oauthClient: NodeOAuthClient

     

       23
       -
         resolver: BidirectionalResolver

     

       24
        
       }

     

       25
        
       

     

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

     

       27
       -
         const logger = pino({ name: 'server start' })

     

       28
       -
       

     

       29
        
         const db = await createDb()

     

       30
        
         const oauthClient = await createOAuthClient(db)

     

       31
       -
         const baseIdResolver = createIdResolver()

     

       32
       -
         const ingester = createIngester(db, baseIdResolver)

     

       33
       -
         const resolver = createBidirectionalResolver(baseIdResolver)

     

       34
        
       

     

       35
        
         return {

     

       36
        
           db,

     

       37
        
           ingester,

     

       38
        
           logger,

     

       39
        
           oauthClient,

     

       40
       -
           resolver,

     

       41
        
         }

     

       42
        
       }

···

       3
        
       import { pino } from 'pino'

     

       4
        
       

     

       5
        
       import { createOAuthClient } from '#/auth/client'

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
       import { createIngester } from '#/ingester'

     

       8
        
       

     

       9
        
       /**

     
···

       14
        
         ingester: Firehose

     

       15
        
         logger: pino.Logger

     

       16
        
         oauthClient: NodeOAuthClient

     

       17
       +
         identityResolver: NodeOAuthClient['identityResolver']

     

       18
        
       }

     

       19
        
       

     

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

     

       0
        
       
     

       0
        
       
     

       21
        
         const db = await createDb()

     

       22
        
         const oauthClient = await createOAuthClient(db)

     

       23
       +
         const ingester = createIngester(db)

     

       24
       +
         const logger = pino({ name: 'server' })

     

       0
        
       
     

       25
        
       

     

       26
        
         return {

     

       27
        
           db,

     

       28
        
           ingester,

     

       29
        
           logger,

     

       30
        
           oauthClient,

     

       31
       +
           identityResolver: oauthClient.identityResolver,

     

       32
        
         }

     

       33
        
       }

-41

src/id-resolver.ts

···

       1
       -
       import { IdResolver, MemoryCache } from '@atproto/identity'

     

       2
       -
       

     

       3
       -
       const HOUR = 60e3 * 60

     

       4
       -
       const DAY = HOUR * 24

     

       5
       -
       

     

       6
       -
       export function createIdResolver() {

     

       7
       -
         return new IdResolver({

     

       8
       -
           didCache: new MemoryCache(HOUR, DAY),

     

       9
       -
         })

     

       10
       -
       }

     

       11
       -
       

     

       12
       -
       export interface BidirectionalResolver {

     

       13
       -
         resolveDidToHandle(did: string): Promise<string>

     

       14
       -
         resolveDidsToHandles(dids: string[]): Promise<Record<string, string>>

     

       15
       -
       }

     

       16
       -
       

     

       17
       -
       export function createBidirectionalResolver(resolver: IdResolver) {

     

       18
       -
         return {

     

       19
       -
           async resolveDidToHandle(did: string): Promise<string> {

     

       20
       -
             const didDoc = await resolver.did.resolveAtprotoData(did)

     

       21
       -
             const resolvedHandle = await resolver.handle.resolve(didDoc.handle)

     

       22
       -
             if (resolvedHandle === did) {

     

       23
       -
               return didDoc.handle

     

       24
       -
             }

     

       25
       -
             return did

     

       26
       -
           },

     

       27
       -
       

     

       28
       -
           async resolveDidsToHandles(

     

       29
       -
             dids: string[]

     

       30
       -
           ): Promise<Record<string, string>> {

     

       31
       -
             const didHandleMap: Record<string, string> = {}

     

       32
       -
             const resolves = await Promise.all(

     

       33
       -
               dids.map((did) => this.resolveDidToHandle(did).catch((_) => did))

     

       34
       -
             )

     

       35
       -
             for (let i = 0; i < dids.length; i++) {

     

       36
       -
               didHandleMap[dids[i]] = resolves[i]

     

       37
       -
             }

     

       38
       -
             return didHandleMap

     

       39
       -
           },

     

       40
       -
         }

     

       41
       -
       }

+11 -6

src/ingester.ts

···

       1
       -
       import pino from 'pino'

     

       2
       -
       import { IdResolver } from '@atproto/identity'

     

       3
       -
       import { Event, Firehose } from '@atproto/sync'

     

       4
        
       import type { Database } from '#/db'

     

       5
        
       import * as Status from '#/lexicon/types/xyz/statusphere/status'

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
       -
       export function createIngester(db: Database, idResolver: IdResolver) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       8
        
         const logger = pino({ name: 'firehose ingestion' })

     

       9
        
         return new Firehose({

     

       10
       -
           idResolver,

     

       0
        
       
     

       0
        
       
     

       11
        
           handleEvent: async (evt: Event) => {

     

       12
        
             // Watch for write events

     

       13
        
             if (evt.event === 'create' || evt.event === 'update') {

     
···

       34
        
                     oc.column('uri').doUpdateSet({

     

       35
        
                       status: record.status,

     

       36
        
                       indexedAt: now.toISOString(),

     

       37
       -
                     })

     

       38
        
                   )

     

       39
        
                   .execute()

     

       40
        
               }

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1
        
       import type { Database } from '#/db'

     

       2
        
       import * as Status from '#/lexicon/types/xyz/statusphere/status'

     

       3
       +
       import { IdResolver, MemoryCache } from '@atproto/identity'

     

       4
       +
       import { Event, Firehose } from '@atproto/sync'

     

       5
       +
       import pino from 'pino'

     

       6
        
       

     

       7
       +
       const HOUR = 60e3 * 60

     

       8
       +
       const DAY = HOUR * 24

     

       9
       +
       

     

       10
       +
       export function createIngester(db: Database) {

     

       11
        
         const logger = pino({ name: 'firehose ingestion' })

     

       12
        
         return new Firehose({

     

       13
       +
           idResolver: new IdResolver({

     

       14
       +
             didCache: new MemoryCache(HOUR, DAY),

     

       15
       +
           }),

     

       16
        
           handleEvent: async (evt: Event) => {

     

       17
        
             // Watch for write events

     

       18
        
             if (evt.event === 'create' || evt.event === 'update') {

     
···

       39
        
                     oc.column('uri').doUpdateSet({

     

       40
        
                       status: record.status,

     

       41
        
                       indexedAt: now.toISOString(),

     

       42
       +
                     }),

     

       43
        
                   )

     

       44
        
                   .execute()

     

       45
        
               }

+14 -4

src/routes.ts

···

       162
        
                   .executeTakeFirst()

     

       163
        
               : undefined

     

       164
        
       

     

       165
       -
             // Map user DIDs to their domain-name handles

     

       166
       -
             const didHandleMap = await ctx.resolver.resolveDidsToHandles(

     

       167
       -
               statuses.map((s) => s.authorDid),

     

       168
       -
             )

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       169
        
       

     

       170
        
             if (!agent) {

     

       171
        
               // Serve the logged-out view

···

       162
        
                   .executeTakeFirst()

     

       163
        
               : undefined

     

       164
        
       

     

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

     

       166
       +
             const uniqueDids = [...new Set(statuses.map((s) => s.authorDid))]

     

       167
       +
       

     

       168
       +
             const didHandleMap: Record<string, string | undefined> =

     

       169
       +
               Object.fromEntries(

     

       170
       +
                 await Promise.all(

     

       171
       +
                   uniqueDids.map((did) =>

     

       172
       +
                     ctx.identityResolver.resolve(did).then(

     

       173
       +
                       (r) => [did, r.handle],

     

       174
       +
                       () => [did, undefined],

     

       175
       +
                     ),

     

       176
       +
                   ),

     

       177
       +
                 ),

     

       178
       +
               )

     

       179
        
       

     

       180
        
             if (!agent) {

     

       181
        
               // Serve the logged-out view