the statusphere demo reworked into a vite/react app in a monorepo
Add comments
+44
-11
+13
-11
src/index.ts
+13
-11
src/index.ts
···
12
12
import { createResolver, Resolver } from '#/firehose/resolver'
13
13
import type { Database } from '#/db'
14
14
15
+
// Application state passed to the router and elsewhere
15
16
export type AppContext = {
16
17
db: Database
17
18
ingester: Ingester
···
29
30
30
31
static async create() {
31
32
const { NODE_ENV, HOST, PORT, DB_PATH } = env
33
+
const logger = pino({ name: 'server start' })
32
34
33
-
const logger = pino({ name: 'server start' })
35
+
// Set up the SQLite database
34
36
const db = createDb(DB_PATH)
35
37
await migrateToLatest(db)
36
-
const ingester = new Ingester(db)
38
+
39
+
// Create the atproto utilities
37
40
const oauthClient = await createClient(db)
41
+
const ingester = new Ingester(db)
38
42
const resolver = createResolver()
39
-
ingester.start()
40
43
const ctx = {
41
44
db,
42
45
ingester,
···
45
48
resolver,
46
49
}
47
50
48
-
const app: Express = express()
51
+
// Subscribe to events on the firehose
52
+
ingester.start()
49
53
50
-
// Set the application to trust the reverse proxy
54
+
// Create our server
55
+
const app: Express = express()
51
56
app.set('trust proxy', true)
52
57
53
-
// Middlewares
58
+
// Routes & middlewares
59
+
const router = createRouter(ctx)
54
60
app.use(express.json())
55
61
app.use(express.urlencoded({ extended: true }))
56
-
57
-
// Routes
58
-
const router = createRouter(ctx)
59
62
app.use(router)
60
-
61
-
// Error handlers
62
63
app.use((_req, res) => res.sendStatus(404))
63
64
65
+
// Bind our server to the port
64
66
const server = app.listen(env.PORT)
65
67
await events.once(server, 'listening')
66
68
logger.info(`Server (${NODE_ENV}) running on port http://${HOST}:${PORT}`)
+31
src/routes.ts
+31
src/routes.ts
···
9
9
import { page } from '#/lib/view'
10
10
import * as Status from '#/lexicon/types/com/example/status'
11
11
12
+
// Helper function for defining routes
12
13
const handler =
13
14
(fn: express.Handler) =>
14
15
async (
···
26
27
export const createRouter = (ctx: AppContext) => {
27
28
const router = express.Router()
28
29
30
+
// Static assets
29
31
router.use('/public', express.static(path.join(__dirname, 'pages', 'public')))
30
32
33
+
// OAuth metadata
31
34
router.get(
32
35
'/client-metadata.json',
33
36
handler((_req, res) => {
···
35
38
})
36
39
)
37
40
41
+
// OAuth callback to complete session creation
38
42
router.get(
39
43
'/oauth/callback',
40
44
handler(async (req, res) => {
···
50
54
})
51
55
)
52
56
57
+
// Login page
53
58
router.get(
54
59
'/login',
55
60
handler(async (_req, res) => {
···
57
62
})
58
63
)
59
64
65
+
// Login handler
60
66
router.post(
61
67
'/login',
62
68
handler(async (req, res) => {
69
+
// Validate
63
70
const handle = req.body?.handle
64
71
if (typeof handle !== 'string' || !isValidHandle(handle)) {
65
72
return res.type('html').send(page(login({ error: 'invalid handle' })))
66
73
}
74
+
75
+
// Initiate the OAuth flow
67
76
try {
68
77
const url = await ctx.oauthClient.authorize(handle)
69
78
return res.redirect(url.toString())
···
83
92
})
84
93
)
85
94
95
+
// Logout handler
86
96
router.post(
87
97
'/logout',
88
98
handler(async (req, res) => {
···
91
101
})
92
102
)
93
103
104
+
// Homepage
94
105
router.get(
95
106
'/',
96
107
handler(async (req, res) => {
108
+
// If the user is signed in, get an agent which communicates with their server
97
109
const agent = await getSessionAgent(req, res, ctx)
110
+
111
+
// Fetch data stored in our SQLite
98
112
const statuses = await ctx.db
99
113
.selectFrom('status')
100
114
.selectAll()
···
108
122
.where('authorDid', '=', agent.accountDid)
109
123
.executeTakeFirst()
110
124
: undefined
125
+
126
+
// Map user DIDs to their domain-name handles
111
127
const didHandleMap = await ctx.resolver.resolveDidsToHandles(
112
128
statuses.map((s) => s.authorDid)
113
129
)
130
+
114
131
if (!agent) {
132
+
// Serve the logged-out view
115
133
return res.type('html').send(page(home({ statuses, didHandleMap })))
116
134
}
135
+
136
+
// Fetch additional information about the logged-in user
117
137
const { data: profile } = await agent.getProfile({
118
138
actor: agent.accountDid,
119
139
})
140
+
didHandleMap[profile.handle] = agent.accountDid
141
+
142
+
// Serve the logged-in view
120
143
return res
121
144
.type('html')
122
145
.send(page(home({ statuses, didHandleMap, profile, myStatus })))
123
146
})
124
147
)
125
148
149
+
// "Set status" handler
126
150
router.post(
127
151
'/status',
128
152
handler(async (req, res) => {
153
+
// If the user is signed in, get an agent which communicates with their server
129
154
const agent = await getSessionAgent(req, res, ctx)
130
155
if (!agent) {
131
156
return res.status(401).json({ error: 'Session required' })
132
157
}
133
158
159
+
// Construct & validate their status record
134
160
const record = {
135
161
$type: 'com.example.status',
136
162
status: req.body?.status,
···
141
167
}
142
168
143
169
try {
170
+
// Write the status record to the user's repository
144
171
await agent.com.atproto.repo.putRecord({
145
172
repo: agent.accountDid,
146
173
collection: 'com.example.status',
···
154
181
}
155
182
156
183
try {
184
+
// Optimistically update our SQLite
185
+
// This isn't strictly necessary because the write event will be
186
+
// handled in #/firehose/ingestor.ts, but it ensures that future reads
187
+
// will be up-to-date after this method finishes.
157
188
await ctx.db
158
189
.insertInto('status')
159
190
.values({