commit 5cd5df3ee9e3ec96583c23d7a6cea620d1cb2095 · cduck.me/statusphere-example-app-fork

-1

package.json

···

       20
       20
        
           "@atproto/lexicon": "^0.4.11",

     

       21
       21
        
           "@atproto/oauth-client-node": "^0.3.1",

     

       22
       22
        
           "@atproto/sync": "^0.1.26",

     

       23
       23
       -
           "@atproto/syntax": "^0.4.0",

     

       24
       23
        
           "@atproto/xrpc-server": "^0.8.0",

     

       25
       24
        
           "better-sqlite3": "^11.1.2",

     

       26
       25
        
           "dotenv": "^16.4.5",

+2

src/auth/client.ts

···

       60
       60
        
           clientMetadata,

     

       61
       61
        
           stateStore: new StateStore(db),

     

       62
       62
        
           sessionStore: new SessionStore(db),

     

       63
       63
       +
           plcDirectoryUrl: env.PLC_URL,

     

       64
       64
       +
           handleResolver: env.PDS_URL,

     

       63
       65
        
         })

     

       64
       66
        
       }

+2 -1

src/context.ts

···

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

     

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

     

       7
       7
        
       import { createIngester } from '#/ingester'

     

       8
       8
       +
       import { env } from '#/env'

     

       8
       9
        
       

     

       9
       10
        
       /**

     

       10
       11
        
        * Application state passed to the router and elsewhere

     
···

       21
       22
        
         const db = await createDb()

     

       22
       23
        
         const oauthClient = await createOAuthClient(db)

     

       23
       24
        
         const ingester = createIngester(db)

     

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

     

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

     

       25
       26
        
       

     

       26
       27
        
         return {

     

       27
       28
        
           db,

+5

src/env.ts

···

       14
       14
        
         DB_PATH: str({ devDefault: ':memory:' }),

     

       15
       15
        
         COOKIE_SECRET: str({ devDefault: '00000000000000000000000000000000' }),

     

       16
       16
        
         PRIVATE_KEYS: envalidJsonWebKeys({ default: undefined }),

     

       17
       17
       +
         LOG_LEVEL: str({ default: 'info' }),

     

       18
       18
       +
         PDS_OWNER: str({ default: 'Bluesky' }),

     

       19
       19
       +
         PDS_URL: str({ default: 'https://bsky.social' }),

     

       20
       20
       +
         PLC_URL: str({ default: 'https://plc.directory' }),

     

       21
       21
       +
         FIREHOSE_URL: str({ default: 'wss://bsky.network' }),

     

       17
       22
        
       })

+14 -1

src/ingester.ts

···

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

     

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

     

       5
       5
        
       import pino from 'pino'

     

       6
       6
       +
       import { env } from './env'

     

       6
       7
        
       

     

       7
       8
        
       const HOUR = 60e3 * 60

     

       8
       9
        
       const DAY = HOUR * 24

     

       9
       10
        
       

     

       10
       11
        
       export function createIngester(db: Database) {

     

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

     

       12
       12
       +
         const logger = pino({ name: 'firehose', level: env.LOG_LEVEL })

     

       12
       13
        
         return new Firehose({

     

       14
       14
       +
           service: env.FIREHOSE_URL,

     

       13
       15
        
           idResolver: new IdResolver({

     

       16
       16
       +
             plcUrl: env.PLC_URL,

     

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

     

       15
       18
        
           }),

     

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

     
···

       25
       28
        
                 Status.isRecord(record) &&

     

       26
       29
        
                 Status.validateRecord(record).success

     

       27
       30
        
               ) {

     

       31
       31
       +
                 logger.debug(

     

       32
       32
       +
                   { uri: evt.uri.toString(), status: record.status },

     

       33
       33
       +
                   'ingesting status',

     

       34
       34
       +
                 )

     

       35
       35
       +
       

     

       28
       36
        
                 // Store the status in our SQLite

     

       29
       37
        
                 await db

     

       30
       38
        
                   .insertInto('status')

     
···

       47
       55
        
               evt.event === 'delete' &&

     

       48
       56
        
               evt.collection === 'xyz.statusphere.status'

     

       49
       57
        
             ) {

     

       58
       58
       +
               logger.debug(

     

       59
       59
       +
                 { uri: evt.uri.toString(), did: evt.did },

     

       60
       60
       +
                 'deleting status',

     

       61
       61
       +
               )

     

       62
       62
       +
       

     

       50
       63
        
               // Remove the status from our SQLite

     

       51
       64
        
               await db

     

       52
       65
        
                 .deleteFrom('status')

+8 -6

src/pages/login.ts

···

       1
       1
       +
       import { env } from '#/env'

     

       1
       2
        
       import { html } from '../lib/view'

     

       2
       3
        
       import { shell } from './shell'

     

       3
       4
        
       

     
···

       20
       21
        
             <form action="/login" method="post" class="login-form">

     

       21
       22
        
               <input

     

       22
       23
        
                 type="text"

     

       23
       23
       -
                 name="handle"

     

       24
       24
       +
                 name="input"

     

       24
       25
        
                 placeholder="Enter your handle (eg alice.bsky.social)"

     

       25
       26
        
                 required

     

       26
       27
        
               />

     

       27
       28
        
               <button type="submit">Log in</button>

     

       28
       28
       -
               ${error ? html`<p>Error: <i>${error}</i></p>` : undefined}

     

       29
       29
        
             </form>

     

       30
       30
       -
             <div class="signup-cta">

     

       31
       31
       -
               Don't have an account on the Atmosphere?

     

       32
       32
       -
               <a href="https://bsky.app">Sign up for Bluesky</a> to create one now!

     

       33
       33
       -
             </div>

     

       30
       30
       +
       

     

       31
       31
       +
             <a href="/signup" class="button signup-cta">

     

       32
       32
       +
               Login or Sign up with a ${env.PDS_OWNER} account

     

       33
       33
       +
             </a>

     

       34
       34
       +
       

     

       35
       35
       +
             ${error ? html`<p>Error: <i>${error}</i></p>` : undefined}

     

       34
       36
        
           </div>

     

       35
       37
        
         </div>`

     

       36
       38
        
       }

+3 -2

src/pages/public/styles.css

···

       207
       207
        
       

     

       208
       208
        
       .signup-cta {

     

       209
       209
        
         text-align: center;

     

       210
       210
       -
         text-wrap: balance;

     

       210
       210
       +
         width: 100%;

     

       211
       211
       +
         display: block;

     

       211
       212
        
         margin-top: 1rem;

     

       212
       212
       -
       }
     

       213
       213
       +
       }

+29 -5

src/routes.ts

···

       1
       1
        
       import { Agent } from '@atproto/api'

     

       2
       2
        
       import { TID } from '@atproto/common'

     

       3
       3
        
       import { OAuthResolverError } from '@atproto/oauth-client-node'

     

       4
       4
       -
       import { isValidHandle } from '@atproto/syntax'

     

       5
       4
        
       import express, { Request, Response } from 'express'

     

       6
       5
        
       import { getIronSession } from 'iron-session'

     

       7
       6
        
       import assert from 'node:assert'

     
···

       105
       104
        
           express.urlencoded({ extended: true }),

     

       106
       105
        
           handler(async (req: Request, res: Response) => {

     

       107
       106
        
             // Validate

     

       108
       108
       -
             const handle = req.body?.handle

     

       109
       109
       -
             if (typeof handle !== 'string' || !isValidHandle(handle)) {

     

       107
       107
       +
             const input = req.body?.input

     

       108
       108
       +
             if (typeof input !== 'string') {

     

       110
       109
        
               return void res

     

       111
       110
        
                 .type('html')

     

       112
       112
       -
                 .send(page(login({ error: 'invalid handle' })))

     

       111
       111
       +
                 .send(page(login({ error: 'invalid input' })))

     

       113
       112
        
             }

     

       114
       113
        
       

     

       115
       114
        
             // Initiate the OAuth flow

     

       116
       115
        
             try {

     

       117
       117
       -
               const url = await ctx.oauthClient.authorize(handle, {

     

       116
       116
       +
               const url = await ctx.oauthClient.authorize(input, {

     

       117
       117
       +
                 scope: 'atproto transition:generic',

     

       118
       118
       +
               })

     

       119
       119
       +
               res.redirect(url.toString())

     

       120
       120
       +
             } catch (err) {

     

       121
       121
       +
               ctx.logger.error({ err }, 'oauth authorize failed')

     

       122
       122
       +
               res.type('html').send(

     

       123
       123
       +
                 page(

     

       124
       124
       +
                   login({

     

       125
       125
       +
                     error:

     

       126
       126
       +
                       err instanceof OAuthResolverError

     

       127
       127
       +
                         ? err.message

     

       128
       128
       +
                         : "couldn't initiate login",

     

       129
       129
       +
                   }),

     

       130
       130
       +
                 ),

     

       131
       131
       +
               )

     

       132
       132
       +
             }

     

       133
       133
       +
           }),

     

       134
       134
       +
         )

     

       135
       135
       +
       

     

       136
       136
       +
         // Signup

     

       137
       137
       +
         app.get(

     

       138
       138
       +
           '/signup',

     

       139
       139
       +
           handler(async (req: Request, res: Response) => {

     

       140
       140
       +
             try {

     

       141
       141
       +
               const url = await ctx.oauthClient.authorize(env.PDS_URL, {

     

       118
       142
        
                 scope: 'atproto transition:generic',

     

       119
       143
        
               })

     

       120
       144
        
               res.redirect(url.toString())