= ({
91 | name,
92 | username,
93 | handle,
94 | following,
95 | followers,
96 | }) => (
97 | <>
98 |
99 |
102 |
103 | {handle} ·{" "}
104 | {following} following{" "}
105 | ·{" "}
106 |
107 | {followers === 1 ? "1 follower" : `${followers} followers`}
108 |
109 |
110 |
111 |
112 | );
113 |
114 | export interface FollowingListProps {
115 | following: Actor[];
116 | }
117 |
118 | export const FollowingList: FC = ({ following }) => (
119 | <>
120 | Following
121 |
122 | {following.map((actor) => (
123 | -
124 |
125 |
126 | ))}
127 |
128 |
129 | );
130 |
131 | export interface FollowerListProps {
132 | followers: Actor[];
133 | }
134 |
135 | export const FollowerList: FC = ({ followers }) => (
136 | <>
137 | Followers
138 |
139 | {followers.map((follower) => (
140 | -
141 |
142 |
143 | ))}
144 |
145 |
146 | );
147 |
148 | export interface ActorLinkProps {
149 | actor: Actor;
150 | }
151 |
152 | export const ActorLink: FC = ({ actor }) => {
153 | const href = actor.url ?? actor.uri;
154 | return actor.name == null ? (
155 |
156 | {actor.handle}
157 |
158 | ) : (
159 | <>
160 | {actor.name}{" "}
161 |
162 | (
163 |
164 | {actor.handle}
165 |
166 | )
167 |
168 |
169 | );
170 | };
171 |
172 | export interface PostPageProps extends ProfileProps, PostViewProps {}
173 |
174 | export const PostPage: FC = (props) => (
175 | <>
176 |
183 |
184 |
185 | );
186 |
187 | export interface PostViewProps {
188 | post: Post & Actor;
189 | }
190 |
191 | export const PostView: FC = ({ post }) => (
192 |
193 |
196 | {/* biome-ignore lint/security/noDangerouslySetInnerHtml: */}
197 |
198 |
205 |
206 | );
207 |
208 | export interface PostListProps {
209 | posts: (Post & Actor)[];
210 | }
211 |
212 | export const PostList: FC = ({ posts }) => (
213 | <>
214 | {posts.map((post) => (
215 |
218 | ))}
219 |
220 | );
221 |
--------------------------------------------------------------------------------
/src/app.tsx:
--------------------------------------------------------------------------------
1 | import { federation } from "@fedify/fedify/x/hono";
2 | import { getLogger } from "@logtape/logtape";
3 | import { Hono } from "hono";
4 | import { stringifyEntities } from "stringify-entities";
5 | import db from "./db.ts";
6 | import fedi from "./federation.ts";
7 | import type { Actor, Post, User } from "./schema.ts";
8 | import {
9 | FollowerList,
10 | FollowingList,
11 | Home,
12 | Layout,
13 | PostList,
14 | PostPage,
15 | Profile,
16 | SetupForm,
17 | } from "./views.tsx";
18 | import { Create, Follow, isActor, lookupObject, Note } from "@fedify/fedify";
19 |
20 | const logger = getLogger("microblog");
21 |
22 | const app = new Hono();
23 | app.use(federation(fedi, () => undefined));
24 |
25 | app.get("/", (c) => {
26 | const user = db
27 | .prepare(
28 | `
29 | SELECT users.*, actors.*
30 | FROM users
31 | JOIN actors ON users.id = actors.user_id
32 | LIMIT 1
33 | `,
34 | )
35 | .get();
36 | if (user == null) return c.redirect("/setup");
37 |
38 | const posts = db
39 | .prepare(
40 | `
41 | SELECT actors.*, posts.*
42 | FROM posts
43 | JOIN actors ON posts.actor_id = actors.id
44 | WHERE posts.actor_id = ? OR posts.actor_id IN (
45 | SELECT following_id
46 | FROM follows
47 | WHERE follower_id = ?
48 | )
49 | ORDER BY posts.created DESC
50 | `,
51 | )
52 | .all(user.id, user.id);
53 | return c.html(
54 |
55 |
56 | ,
57 | );
58 | });
59 |
60 | app.get("/setup", (c) => {
61 | // Check if the user already exists
62 | const user = db
63 | .prepare(
64 | `
65 | SELECT * FROM users
66 | JOIN actors ON (users.id = actors.user_id)
67 | LIMIT 1
68 | `,
69 | )
70 | .get();
71 | if (user != null) return c.redirect("/");
72 |
73 | return c.html(
74 |
75 |
76 | ,
77 | );
78 | });
79 |
80 | app.post("/setup", async (c) => {
81 | // Check if the user already exists
82 | const user = db
83 | .prepare(
84 | `
85 | SELECT * FROM users
86 | JOIN actors ON (users.id = actors.user_id)
87 | LIMIT 1
88 | `,
89 | )
90 | .get();
91 | if (user != null) return c.redirect("/");
92 |
93 | const form = await c.req.formData();
94 | const username = form.get("username");
95 | if (typeof username !== "string" || !username.match(/^[a-z0-9_-]{1,50}$/)) {
96 | return c.redirect("/setup");
97 | }
98 | const name = form.get("name");
99 | if (typeof name !== "string" || name.trim() === "") {
100 | return c.redirect("/setup");
101 | }
102 | const url = new URL(c.req.url);
103 | const handle = `@${username}@${url.host}`;
104 | const ctx = fedi.createContext(c.req.raw, undefined);
105 | db.transaction(() => {
106 | db.prepare("INSERT OR REPLACE INTO users (id, username) VALUES (1, ?)").run(
107 | username,
108 | );
109 | db.prepare(
110 | `
111 | INSERT OR REPLACE INTO actors
112 | (user_id, uri, handle, name, inbox_url, shared_inbox_url, url)
113 | VALUES (1, ?, ?, ?, ?, ?, ?)
114 | `,
115 | ).run(
116 | ctx.getActorUri(username).href,
117 | handle,
118 | name,
119 | ctx.getInboxUri(username).href,
120 | ctx.getInboxUri().href,
121 | ctx.getActorUri(username).href,
122 | );
123 | })();
124 | return c.redirect("/");
125 | });
126 |
127 | app.get("/users/:username", async (c) => {
128 | const user = db
129 | .prepare(
130 | `
131 | SELECT * FROM users
132 | JOIN actors ON (users.id = actors.user_id)
133 | WHERE username = ?
134 | `,
135 | )
136 | .get(c.req.param("username"));
137 | if (user == null) return c.notFound();
138 |
139 | // biome-ignore lint/style/noNonNullAssertion: always returns a row
140 | const { following } = db
141 | .prepare(
142 | `
143 | SELECT count(*) AS following
144 | FROM follows
145 | JOIN actors ON follows.follower_id = actors.id
146 | WHERE actors.user_id = ?
147 | `,
148 | )
149 | .get(user.id)!;
150 | // biome-ignore lint/style/noNonNullAssertion: always returns a row
151 | const { followers } = db
152 | .prepare(
153 | `
154 | SELECT count(*) AS followers
155 | FROM follows
156 | JOIN actors ON follows.following_id = actors.id
157 | WHERE actors.user_id = ?
158 | `,
159 | )
160 | .get(user.id)!;
161 | const posts = db
162 | .prepare(
163 | `
164 | SELECT actors.*, posts.*
165 | FROM posts
166 | JOIN actors ON posts.actor_id = actors.id
167 | WHERE actors.user_id = ?
168 | ORDER BY posts.created DESC
169 | `,
170 | )
171 | .all(user.user_id);
172 | const url = new URL(c.req.url);
173 | const handle = `@${user.username}@${url.host}`;
174 | return c.html(
175 |
176 |
183 |
184 | ,
185 | );
186 | });
187 |
188 | app.post("/users/:username/following", async (c) => {
189 | const username = c.req.param("username");
190 | const form = await c.req.formData();
191 | const handle = form.get("actor");
192 | if (typeof handle !== "string") {
193 | return c.text("Invalid actor handle or URL", 400);
194 | }
195 | const actor = await lookupObject(handle);
196 | if (!isActor(actor)) {
197 | return c.text("Invalid actor handle or URL", 400);
198 | }
199 | const ctx = fedi.createContext(c.req.raw, undefined);
200 | await ctx.sendActivity(
201 | { identifier: username },
202 | actor,
203 | new Follow({
204 | actor: ctx.getActorUri(username),
205 | object: actor.id,
206 | to: actor.id,
207 | }),
208 | );
209 | return c.text("Successfully sent a follow request");
210 | });
211 |
212 | app.get("/users/:username/following", async (c) => {
213 | const following = db
214 | .prepare(
215 | `
216 | SELECT following.*
217 | FROM follows
218 | JOIN actors AS followers ON follows.follower_id = followers.id
219 | JOIN actors AS following ON follows.following_id = following.id
220 | JOIN users ON users.id = followers.user_id
221 | WHERE users.username = ?
222 | ORDER BY follows.created DESC
223 | `,
224 | )
225 | .all(c.req.param("username"));
226 | return c.html(
227 |
228 |
229 | ,
230 | );
231 | });
232 |
233 | app.get("/users/:username/followers", async (c) => {
234 | const followers = db
235 | .prepare(
236 | `
237 | SELECT followers.*
238 | FROM follows
239 | JOIN actors AS followers ON follows.follower_id = followers.id
240 | JOIN actors AS following ON follows.following_id = following.id
241 | JOIN users ON users.id = following.user_id
242 | WHERE users.username = ?
243 | ORDER BY follows.created DESC
244 | `,
245 | )
246 | .all(c.req.param("username"));
247 | return c.html(
248 |
249 |
250 | ,
251 | );
252 | });
253 |
254 | app.post("/users/:username/posts", async (c) => {
255 | const username = c.req.param("username");
256 | const actor = db
257 | .prepare(
258 | `
259 | SELECT actors.*
260 | FROM actors
261 | JOIN users ON users.id = actors.user_id
262 | WHERE users.username = ?
263 | `,
264 | )
265 | .get(username);
266 | if (actor == null) return c.redirect("/setup");
267 | const form = await c.req.formData();
268 | const content = form.get("content")?.toString();
269 | if (content == null || content.trim() === "") {
270 | return c.text("Content is required", 400);
271 | }
272 | const ctx = fedi.createContext(c.req.raw, undefined);
273 | const post: Post | null = db.transaction(() => {
274 | const post = db
275 | .prepare(
276 | `
277 | INSERT INTO posts (uri, actor_id, content)
278 | VALUES ('https://localhost/', ?, ?)
279 | RETURNING *
280 | `,
281 | )
282 | .get(actor.id, stringifyEntities(content, { escapeOnly: true }));
283 | if (post == null) return null;
284 | const url = ctx.getObjectUri(Note, {
285 | identifier: username,
286 | id: post.id.toString(),
287 | }).href;
288 | db.prepare("UPDATE posts SET uri = ?, url = ? WHERE id = ?").run(
289 | url,
290 | url,
291 | post.id,
292 | );
293 | return post;
294 | })();
295 | if (post == null) return c.text("Failed to create post", 500);
296 | const noteArgs = { identifier: username, id: post.id.toString() };
297 | const note = await ctx.getObject(Note, noteArgs);
298 | await ctx.sendActivity(
299 | { identifier: username },
300 | "followers",
301 | new Create({
302 | id: new URL("#activity", note?.id ?? undefined),
303 | object: note,
304 | actors: note?.attributionIds,
305 | tos: note?.toIds,
306 | ccs: note?.ccIds,
307 | }),
308 | );
309 | return c.redirect(ctx.getObjectUri(Note, noteArgs).href);
310 | });
311 |
312 | app.get("/users/:username/posts/:id", (c) => {
313 | const post = db
314 | .prepare(
315 | `
316 | SELECT users.*, actors.*, posts.*
317 | FROM posts
318 | JOIN actors ON actors.id = posts.actor_id
319 | JOIN users ON users.id = actors.user_id
320 | WHERE users.username = ? AND posts.id = ?
321 | `,
322 | )
323 | .get(c.req.param("username"), c.req.param("id"));
324 | if (post == null) return c.notFound();
325 |
326 | // biome-ignore lint/style/noNonNullAssertion: always returns a row
327 | const { following, followers } = db
328 | .prepare(
329 | `
330 | SELECT sum(follows.follower_id = ?) AS following,
331 | sum(follows.following_id = ?) AS followers
332 | FROM follows
333 | `,
334 | )
335 | .get(post.actor_id, post.actor_id)!;
336 | return c.html(
337 |
338 |
346 | ,
347 | );
348 | });
349 |
350 | export default app;
351 |
--------------------------------------------------------------------------------
/src/federation.ts:
--------------------------------------------------------------------------------
1 | import {
2 | Accept,
3 | Create,
4 | Endpoints,
5 | Follow,
6 | Note,
7 | PUBLIC_COLLECTION,
8 | Person,
9 | Undo,
10 | createFederation,
11 | exportJwk,
12 | generateCryptoKeyPair,
13 | getActorHandle,
14 | importJwk,
15 | isActor,
16 | type Actor as APActor,
17 | type Recipient,
18 | } from "@fedify/fedify";
19 | import { InProcessMessageQueue, MemoryKvStore } from "@fedify/fedify";
20 | import { Temporal } from "@js-temporal/polyfill";
21 | import { getLogger } from "@logtape/logtape";
22 | import db from "./db.ts";
23 | import type { Actor, Key, Post, User } from "./schema.ts";
24 |
25 | const logger = getLogger("microblog");
26 |
27 | const federation = createFederation({
28 | kv: new MemoryKvStore(),
29 | queue: new InProcessMessageQueue(),
30 | });
31 |
32 | federation
33 | .setActorDispatcher("/users/{identifier}", async (ctx, identifier) => {
34 | const user = db
35 | .prepare(
36 | `
37 | SELECT * FROM users
38 | JOIN actors ON (users.id = actors.user_id)
39 | WHERE users.username = ?
40 | `,
41 | )
42 | .get(identifier);
43 | if (user == null) return null;
44 |
45 | const keys = await ctx.getActorKeyPairs(identifier);
46 | return new Person({
47 | id: ctx.getActorUri(identifier),
48 | preferredUsername: identifier,
49 | name: user.name,
50 | inbox: ctx.getInboxUri(identifier),
51 | endpoints: new Endpoints({
52 | sharedInbox: ctx.getInboxUri(),
53 | }),
54 | followers: ctx.getFollowersUri(identifier),
55 | url: ctx.getActorUri(identifier),
56 | publicKey: keys[0].cryptographicKey,
57 | assertionMethods: keys.map((k) => k.multikey),
58 | });
59 | })
60 | .setKeyPairsDispatcher(async (ctx, identifier) => {
61 | const user = db
62 | .prepare("SELECT * FROM users WHERE username = ?")
63 | .get(identifier);
64 | if (user == null) return [];
65 | const rows = db
66 | .prepare("SELECT * FROM keys WHERE keys.user_id = ?")
67 | .all(user.id);
68 | const keys = Object.fromEntries(
69 | rows.map((row) => [row.type, row]),
70 | ) as Record;
71 | const pairs: CryptoKeyPair[] = [];
72 | // Ensure that the user has a key pair for each supported key type
73 | // (RSASSA-PKCS1-v1_5 and Ed25519); if not, generate one
74 | // and store it in the database:
75 | for (const keyType of ["RSASSA-PKCS1-v1_5", "Ed25519"] as const) {
76 | if (keys[keyType] == null) {
77 | logger.debug(
78 | "The user {identifier} does not have an {keyType} key; creating one...",
79 | { identifier, keyType },
80 | );
81 | const { privateKey, publicKey } = await generateCryptoKeyPair(keyType);
82 | db.prepare(
83 | `
84 | INSERT INTO keys (user_id, type, private_key, public_key)
85 | VALUES (?, ?, ?, ?)
86 | `,
87 | ).run(
88 | user.id,
89 | keyType,
90 | JSON.stringify(await exportJwk(privateKey)),
91 | JSON.stringify(await exportJwk(publicKey)),
92 | );
93 | pairs.push({ privateKey, publicKey });
94 | } else {
95 | pairs.push({
96 | privateKey: await importJwk(
97 | JSON.parse(keys[keyType].private_key),
98 | "private",
99 | ),
100 | publicKey: await importJwk(
101 | JSON.parse(keys[keyType].public_key),
102 | "public",
103 | ),
104 | });
105 | }
106 | }
107 | return pairs;
108 | });
109 |
110 | federation
111 | .setInboxListeners("/users/{identifier}/inbox", "/inbox")
112 | .on(Follow, async (ctx, follow) => {
113 | if (follow.objectId == null) {
114 | logger.debug("The Follow object does not have an object: {follow}", {
115 | follow,
116 | });
117 | return;
118 | }
119 | const object = ctx.parseUri(follow.objectId);
120 | if (object == null || object.type !== "actor") {
121 | logger.debug("The Follow object's object is not an actor: {follow}", {
122 | follow,
123 | });
124 | return;
125 | }
126 | const follower = await follow.getActor();
127 | if (follower == null) {
128 | logger.debug("The Follow object does not have an actor: {follow}", {
129 | follow,
130 | });
131 | return;
132 | }
133 | const following_id = db
134 | .prepare(
135 | `
136 | SELECT * FROM actors
137 | JOIN users ON users.id = actors.user_id
138 | WHERE users.username = ?
139 | `,
140 | )
141 | .get(object.identifier)?.id;
142 | if (following_id == null) {
143 | logger.debug(
144 | "Failed to find the actor to follow in the database: {object}",
145 | { object },
146 | );
147 | }
148 | const followerId = (await persistActor(follower))?.id;
149 | db.prepare(
150 | "INSERT INTO follows (following_id, follower_id) VALUES (?, ?)",
151 | ).run(following_id, followerId);
152 | const accept = new Accept({
153 | actor: follow.objectId,
154 | to: follow.actorId,
155 | object: follow,
156 | });
157 | await ctx.sendActivity(object, follower, accept);
158 | })
159 | .on(Undo, async (ctx, undo) => {
160 | const object = await undo.getObject();
161 | if (!(object instanceof Follow)) return;
162 | if (undo.actorId == null || object.objectId == null) return;
163 | const parsed = ctx.parseUri(object.objectId);
164 | if (parsed == null || parsed.type !== "actor") return;
165 | db.prepare(
166 | `
167 | DELETE FROM follows
168 | WHERE following_id = (
169 | SELECT actors.id
170 | FROM actors
171 | JOIN users ON actors.user_id = users.id
172 | WHERE users.username = ?
173 | ) AND follower_id = (SELECT id FROM actors WHERE uri = ?)
174 | `,
175 | ).run(parsed.identifier, undo.actorId.href);
176 | })
177 | .on(Accept, async (ctx, accept) => {
178 | const follow = await accept.getObject();
179 | if (!(follow instanceof Follow)) return;
180 | const following = await accept.getActor();
181 | if (!isActor(following)) return;
182 | const follower = follow.actorId;
183 | if (follower == null) return;
184 | const parsed = ctx.parseUri(follower);
185 | if (parsed == null || parsed.type !== "actor") return;
186 | const followingId = (await persistActor(following))?.id;
187 | if (followingId == null) return;
188 | db.prepare(
189 | `
190 | INSERT INTO follows (following_id, follower_id)
191 | VALUES (
192 | ?,
193 | (
194 | SELECT actors.id
195 | FROM actors
196 | JOIN users ON actors.user_id = users.id
197 | WHERE users.username = ?
198 | )
199 | )
200 | `,
201 | ).run(followingId, parsed.identifier);
202 | })
203 | .on(Create, async (ctx, create) => {
204 | const object = await create.getObject();
205 | if (!(object instanceof Note)) return;
206 | const actor = create.actorId;
207 | if (actor == null) return;
208 | const author = await object.getAttribution();
209 | if (!isActor(author) || author.id?.href !== actor.href) return;
210 | const actorId = (await persistActor(author))?.id;
211 | if (actorId == null) return;
212 | if (object.id == null) return;
213 | const content = object.content?.toString();
214 | db.prepare(
215 | "INSERT INTO posts (uri, actor_id, content, url) VALUES (?, ?, ?, ?)",
216 | ).run(object.id.href, actorId, content, object.url?.href);
217 | });
218 |
219 | federation
220 | .setFollowersDispatcher(
221 | "/users/{identifier}/followers",
222 | (ctx, identifier, cursor) => {
223 | const followers = db
224 | .prepare(
225 | `
226 | SELECT followers.*
227 | FROM follows
228 | JOIN actors AS followers ON follows.follower_id = followers.id
229 | JOIN actors AS following ON follows.following_id = following.id
230 | JOIN users ON users.id = following.user_id
231 | WHERE users.username = ?
232 | ORDER BY follows.created DESC
233 | `,
234 | )
235 | .all(identifier);
236 | const items: Recipient[] = followers.map((f) => ({
237 | id: new URL(f.uri),
238 | inboxId: new URL(f.inbox_url),
239 | endpoints:
240 | f.shared_inbox_url == null
241 | ? null
242 | : { sharedInbox: new URL(f.shared_inbox_url) },
243 | }));
244 | return { items };
245 | },
246 | )
247 | .setCounter((ctx, identifier) => {
248 | const result = db
249 | .prepare(
250 | `
251 | SELECT count(*) AS cnt
252 | FROM follows
253 | JOIN actors ON actors.id = follows.following_id
254 | JOIN users ON users.id = actors.user_id
255 | WHERE users.username = ?
256 | `,
257 | )
258 | .get(identifier);
259 | return result == null ? 0 : result.cnt;
260 | });
261 |
262 | federation.setObjectDispatcher(
263 | Note,
264 | "/users/{identifier}/posts/{id}",
265 | (ctx, values) => {
266 | const post = db
267 | .prepare(
268 | `
269 | SELECT posts.*
270 | FROM posts
271 | JOIN actors ON actors.id = posts.actor_id
272 | JOIN users ON users.id = actors.user_id
273 | WHERE users.username = ? AND posts.id = ?
274 | `,
275 | )
276 | .get(values.identifier, values.id);
277 | if (post == null) return null;
278 | return new Note({
279 | id: ctx.getObjectUri(Note, values),
280 | attribution: ctx.getActorUri(values.identifier),
281 | to: PUBLIC_COLLECTION,
282 | cc: ctx.getFollowersUri(values.identifier),
283 | content: post.content,
284 | mediaType: "text/html",
285 | published: Temporal.Instant.from(`${post.created.replace(" ", "T")}Z`),
286 | url: ctx.getObjectUri(Note, values),
287 | });
288 | },
289 | );
290 |
291 | async function persistActor(actor: APActor): Promise {
292 | if (actor.id == null || actor.inboxId == null) {
293 | logger.debug("Actor is missing required fields: {actor}", { actor });
294 | return null;
295 | }
296 | return (
297 | db
298 | .prepare(
299 | `
300 | -- Insert or update the actor
301 | INSERT INTO actors (uri, handle, name, inbox_url, shared_inbox_url, url)
302 | VALUES (?, ?, ?, ?, ?, ?)
303 | ON CONFLICT (uri) DO UPDATE SET
304 | handle = excluded.handle,
305 | name = excluded.name,
306 | inbox_url = excluded.inbox_url,
307 | shared_inbox_url = excluded.shared_inbox_url,
308 | url = excluded.url
309 | WHERE
310 | actors.uri = excluded.uri
311 | RETURNING *
312 | `,
313 | )
314 | .get(
315 | actor.id.href,
316 | await getActorHandle(actor),
317 | actor.name?.toString(),
318 | actor.inboxId.href,
319 | actor.endpoints?.sharedInbox?.href,
320 | actor.url?.href,
321 | ) ?? null
322 | );
323 | }
324 |
325 | export default federation;
326 |
--------------------------------------------------------------------------------