+2

src/index.ts

reviewed

··· 2 2 import { createApp } from "./app.js"; 3 3 import { loadConfig } from "./config.js"; 4 4 import { initDatabase } from "./db.js"; 5 5 + import { createRepoRoutes } from "./repo.js"; 5 6 import { createSyncRoutes } from "./sync.js"; 6 7 7 8 const config = loadConfig(); 8 9 const db = initDatabase(config.dbPath); 9 10 const app = createApp(config, db); 10 11 app.route("/", createSyncRoutes(db)); 12 12 + app.route("/", createRepoRoutes(db, config)); 11 13 12 14 serve({ fetch: app.fetch, port: config.port }, (info) => { 13 15 console.log(`rookery listening on port ${info.port}`);

+198

src/repo.ts

reviewed

··· 1 1 + import { Hono, type Context } from "hono"; 2 2 + import { CID } from "@atproto/lex-data"; 3 3 + import { ReadableRepo } from "@atproto/repo/dist/readable-repo.js"; 4 4 + import type Database from "better-sqlite3"; 5 5 + import type { Config } from "./config.js"; 6 6 + import { SqliteRepoStorage } from "./storage.js"; 7 7 + 8 8 + type AccountRow = { 9 9 + id: number; 10 10 + did: string; 11 11 + handle: string | null; 12 12 + root_cid: string | null; 13 13 + rev: string | null; 14 14 + active: number; 15 15 + }; 16 16 + 17 17 + function xrpcError( 18 18 + c: Context, 19 19 + status: 400 | 404, 20 20 + error: string, 21 21 + message: string, 22 22 + ) { 23 23 + return c.json({ error, message }, status); 24 24 + } 25 25 + 26 26 + function resolveRepo( 27 27 + db: Database.Database, 28 28 + repo: string, 29 29 + ): AccountRow | undefined { 30 30 + if (repo.startsWith("did:")) { 31 31 + return db 32 32 + .prepare("SELECT id, did, handle, root_cid, rev, active FROM accounts WHERE did = ?") 33 33 + .get(repo) as AccountRow | undefined; 34 34 + } 35 35 + return db 36 36 + .prepare("SELECT id, did, handle, root_cid, rev, active FROM accounts WHERE handle = ?") 37 37 + .get(repo) as AccountRow | undefined; 38 38 + } 39 39 + 40 40 + export function createRepoRoutes( 41 41 + db: Database.Database, 42 42 + config: Config, 43 43 + ): Hono { 44 44 + const app = new Hono(); 45 45 + 46 46 + app.get("/xrpc/com.atproto.repo.getRecord", async (c) => { 47 47 + const repo = c.req.query("repo"); 48 48 + if (!repo) { 49 49 + return xrpcError(c, 400, "InvalidRequest", "missing repo parameter"); 50 50 + } 51 51 + 52 52 + const collection = c.req.query("collection"); 53 53 + if (!collection) { 54 54 + return xrpcError(c, 400, "InvalidRequest", "missing collection parameter"); 55 55 + } 56 56 + 57 57 + const rkey = c.req.query("rkey"); 58 58 + if (!rkey) { 59 59 + return xrpcError(c, 400, "InvalidRequest", "missing rkey parameter"); 60 60 + } 61 61 + 62 62 + const account = resolveRepo(db, repo); 63 63 + if (!account) { 64 64 + return xrpcError(c, 400, "RepoNotFound", "repo not found"); 65 65 + } 66 66 + if (!account.root_cid) { 67 67 + return xrpcError(c, 400, "RepoNotFound", "repo not initialized"); 68 68 + } 69 69 + 70 70 + const storage = new SqliteRepoStorage(db, account.id); 71 71 + const rootCid = CID.parse(account.root_cid); 72 72 + const readableRepo = await ReadableRepo.load(storage, rootCid); 73 73 + const cid = await readableRepo.data.get(`${collection}/${rkey}`); 74 74 + if (!cid) { 75 75 + return xrpcError(c, 404, "RecordNotFound", "record not found"); 76 76 + } 77 77 + 78 78 + const record = await storage.readRecord(cid); 79 79 + return c.json({ 80 80 + uri: `at://${account.did}/${collection}/${rkey}`, 81 81 + cid: cid.toString(), 82 82 + value: record, 83 83 + }); 84 84 + }); 85 85 + 86 86 + app.get("/xrpc/com.atproto.repo.listRecords", async (c) => { 87 87 + const repo = c.req.query("repo"); 88 88 + if (!repo) { 89 89 + return xrpcError(c, 400, "InvalidRequest", "missing repo parameter"); 90 90 + } 91 91 + 92 92 + const collection = c.req.query("collection"); 93 93 + if (!collection) { 94 94 + return xrpcError(c, 400, "InvalidRequest", "missing collection parameter"); 95 95 + } 96 96 + 97 97 + const limit = Math.min( 98 98 + Math.max(Number.parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 99 99 + 100, 100 100 + ); 101 101 + const cursor = c.req.query("cursor"); 102 102 + const reverse = c.req.query("reverse") === "true"; 103 103 + 104 104 + const account = resolveRepo(db, repo); 105 105 + if (!account) { 106 106 + return xrpcError(c, 400, "RepoNotFound", "repo not found"); 107 107 + } 108 108 + if (!account.root_cid) { 109 109 + return c.json({ records: [] }); 110 110 + } 111 111 + 112 112 + const storage = new SqliteRepoStorage(db, account.id); 113 113 + const rootCid = CID.parse(account.root_cid); 114 114 + const readableRepo = await ReadableRepo.load(storage, rootCid); 115 115 + 116 116 + let leaves; 117 117 + if (reverse) { 118 118 + const allLeaves = await readableRepo.data.listWithPrefix(`${collection}/`); 119 119 + allLeaves.reverse(); 120 120 + let startIdx = 0; 121 121 + if (cursor) { 122 122 + const cursorKey = `${collection}/${cursor}`; 123 123 + startIdx = allLeaves.findIndex((leaf) => leaf.key < cursorKey); 124 124 + if (startIdx === -1) { 125 125 + startIdx = allLeaves.length; 126 126 + } 127 127 + } 128 128 + leaves = allLeaves.slice(startIdx, startIdx + limit + 1); 129 129 + } else { 130 130 + const after = cursor ? `${collection}/${cursor}` : `${collection}/`; 131 131 + const before = `${collection}0`; 132 132 + leaves = await readableRepo.data.list(limit + 1, after, before); 133 133 + } 134 134 + 135 135 + let nextCursor: string | undefined; 136 136 + if (leaves.length > limit) { 137 137 + leaves.pop(); 138 138 + const lastLeaf = leaves[leaves.length - 1]; 139 139 + if (lastLeaf) { 140 140 + nextCursor = lastLeaf.key.slice(collection.length + 1); 141 141 + } 142 142 + } 143 143 + 144 144 + const records = await Promise.all( 145 145 + leaves.map(async (leaf) => { 146 146 + const record = await storage.readRecord(leaf.value); 147 147 + const rkey = leaf.key.slice(collection.length + 1); 148 148 + return { 149 149 + uri: `at://${account.did}/${collection}/${rkey}`, 150 150 + cid: leaf.value.toString(), 151 151 + value: record, 152 152 + }; 153 153 + }), 154 154 + ); 155 155 + 156 156 + return c.json(nextCursor ? { cursor: nextCursor, records } : { records }); 157 157 + }); 158 158 + 159 159 + app.get("/xrpc/com.atproto.repo.describeRepo", async (c) => { 160 160 + const repo = c.req.query("repo"); 161 161 + if (!repo) { 162 162 + return xrpcError(c, 400, "InvalidRequest", "missing repo parameter"); 163 163 + } 164 164 + 165 165 + const account = resolveRepo(db, repo); 166 166 + if (!account) { 167 167 + return xrpcError(c, 400, "RepoNotFound", "repo not found"); 168 168 + } 169 169 + 170 170 + const storage = new SqliteRepoStorage(db, account.id); 171 171 + const collections = storage.getCollections(); 172 172 + 173 173 + let didDoc: unknown = {}; 174 174 + try { 175 175 + const res = await fetch(`${config.plcUrl}/${account.did}`); 176 176 + if (res.ok) { 177 177 + didDoc = await res.json(); 178 178 + } 179 179 + } catch {} 180 180 + 181 181 + return c.json({ 182 182 + handle: account.handle ?? "", 183 183 + did: account.did, 184 184 + didDoc, 185 185 + collections, 186 186 + handleIsCorrect: account.handle !== null, 187 187 + }); 188 188 + }); 189 189 + 190 190 + app.get("/xrpc/com.atproto.server.describeServer", (c) => { 191 191 + return c.json({ 192 192 + did: `did:web:${config.hostname}`, 193 193 + availableUserDomains: [config.handleDomain], 194 194 + }); 195 195 + }); 196 196 + 197 197 + return app; 198 198 + }

+481

test/repo.test.ts

reviewed

··· 1 1 + import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; 2 2 + import Database from "better-sqlite3"; 3 3 + import { Hono } from "hono"; 4 4 + import { Repo, WriteOpAction } from "@atproto/repo"; 5 5 + import { Secp256k1Keypair } from "@atproto/crypto"; 6 6 + import { initDatabase } from "../src/db.js"; 7 7 + import { SqliteRepoStorage } from "../src/storage.js"; 8 8 + import { createRepoRoutes } from "../src/repo.js"; 9 9 + import type { Config } from "../src/config.js"; 10 10 + 11 11 + const testConfig: Config = { 12 12 + hostname: "pds.test.example", 13 13 + handleDomain: "test.example", 14 14 + plcUrl: "https://plc.test", 15 15 + dbPath: ":memory:", 16 16 + port: 3000, 17 17 + tosText: "test tos", 18 18 + }; 19 19 + 20 20 + function createAccount( 21 21 + db: Database.Database, 22 22 + did: string, 23 23 + ): { id: number; storage: SqliteRepoStorage } { 24 24 + const info = db.prepare("INSERT INTO accounts (did) VALUES (?)").run(did); 25 25 + const id = Number(info.lastInsertRowid); 26 26 + return { id, storage: new SqliteRepoStorage(db, id) }; 27 27 + } 28 28 + 29 29 + async function createRepoWithPost(db: Database.Database, did: string) { 30 30 + const { id, storage } = createAccount(db, did); 31 31 + const keypair = await Secp256k1Keypair.create(); 32 32 + const created = await Repo.create(storage, did, keypair); 33 33 + const repo = await created.applyWrites( 34 34 + { 35 35 + action: WriteOpAction.Create, 36 36 + collection: "app.bsky.feed.post", 37 37 + rkey: "test1", 38 38 + record: { 39 39 + text: "hello world", 40 40 + createdAt: new Date().toISOString(), 41 41 + $type: "app.bsky.feed.post", 42 42 + }, 43 43 + }, 44 44 + keypair, 45 45 + ); 46 46 + 47 47 + return { id, storage, repo, keypair }; 48 48 + } 49 49 + 50 50 + async function createRepoWithPosts( 51 51 + db: Database.Database, 52 52 + did: string, 53 53 + rkeys: string[], 54 54 + ) { 55 55 + const { id, storage } = createAccount(db, did); 56 56 + const keypair = await Secp256k1Keypair.create(); 57 57 + let repo = await Repo.create(storage, did, keypair); 58 58 + for (const rkey of rkeys) { 59 59 + repo = await repo.applyWrites( 60 60 + { 61 61 + action: WriteOpAction.Create, 62 62 + collection: "app.bsky.feed.post", 63 63 + rkey, 64 64 + record: { 65 65 + text: `post ${rkey}`, 66 66 + createdAt: new Date().toISOString(), 67 67 + $type: "app.bsky.feed.post", 68 68 + }, 69 69 + }, 70 70 + keypair, 71 71 + ); 72 72 + } 73 73 + return { id, storage, repo, keypair }; 74 74 + } 75 75 + 76 76 + function setHandle(db: Database.Database, did: string, handle: string) { 77 77 + db.prepare("UPDATE accounts SET handle = ? WHERE did = ?").run(handle, did); 78 78 + } 79 79 + 80 80 + describe("createRepoRoutes", () => { 81 81 + let db: Database.Database; 82 82 + let app: Hono; 83 83 + 84 84 + beforeEach(() => { 85 85 + db = initDatabase(":memory:"); 86 86 + app = createRepoRoutes(db, testConfig); 87 87 + }); 88 88 + 89 89 + afterEach(() => { 90 90 + vi.restoreAllMocks(); 91 91 + }); 92 92 + 93 93 + describe("getRecord", () => { 94 94 + it("returns uri, cid, and value for an existing record", async () => { 95 95 + const did = "did:plc:alice"; 96 96 + await createRepoWithPost(db, did); 97 97 + 98 98 + const res = await app.request( 99 99 + `/xrpc/com.atproto.repo.getRecord?repo=${did}&collection=app.bsky.feed.post&rkey=test1`, 100 100 + ); 101 101 + const body = await res.json(); 102 102 + 103 103 + expect(res.status).toBe(200); 104 104 + expect(body.uri).toBe(`at://${did}/app.bsky.feed.post/test1`); 105 105 + expect(typeof body.cid).toBe("string"); 106 106 + expect(body.value.text).toBe("hello world"); 107 107 + }); 108 108 + 109 109 + it("returns 404 for a missing record in an existing repo", async () => { 110 110 + const did = "did:plc:alice"; 111 111 + await createRepoWithPost(db, did); 112 112 + 113 113 + const res = await app.request( 114 114 + `/xrpc/com.atproto.repo.getRecord?repo=${did}&collection=app.bsky.feed.post&rkey=nonexistent`, 115 115 + ); 116 116 + const body = await res.json(); 117 117 + 118 118 + expect(res.status).toBe(404); 119 119 + expect(body.error).toBe("RecordNotFound"); 120 120 + }); 121 121 + 122 122 + it("returns 400 when the repo does not exist", async () => { 123 123 + const res = await app.request( 124 124 + "/xrpc/com.atproto.repo.getRecord?repo=did:plc:missing&collection=app.bsky.feed.post&rkey=test1", 125 125 + ); 126 126 + const body = await res.json(); 127 127 + 128 128 + expect(res.status).toBe(400); 129 129 + expect(body.error).toBe("RepoNotFound"); 130 130 + }); 131 131 + 132 132 + it("works with a handle as the repo param", async () => { 133 133 + const did = "did:plc:alice"; 134 134 + await createRepoWithPost(db, did); 135 135 + setHandle(db, did, "alice.test.example"); 136 136 + 137 137 + const res = await app.request( 138 138 + "/xrpc/com.atproto.repo.getRecord?repo=alice.test.example&collection=app.bsky.feed.post&rkey=test1", 139 139 + ); 140 140 + 141 141 + expect(res.status).toBe(200); 142 142 + }); 143 143 + 144 144 + it("returns 400 when repo is missing", async () => { 145 145 + const res = await app.request( 146 146 + "/xrpc/com.atproto.repo.getRecord?collection=app.bsky.feed.post&rkey=test1", 147 147 + ); 148 148 + const body = await res.json(); 149 149 + 150 150 + expect(res.status).toBe(400); 151 151 + expect(body).toEqual({ 152 152 + error: "InvalidRequest", 153 153 + message: "missing repo parameter", 154 154 + }); 155 155 + }); 156 156 + 157 157 + it("returns 400 when collection is missing", async () => { 158 158 + const res = await app.request( 159 159 + "/xrpc/com.atproto.repo.getRecord?repo=did:plc:alice&rkey=test1", 160 160 + ); 161 161 + const body = await res.json(); 162 162 + 163 163 + expect(res.status).toBe(400); 164 164 + expect(body).toEqual({ 165 165 + error: "InvalidRequest", 166 166 + message: "missing collection parameter", 167 167 + }); 168 168 + }); 169 169 + 170 170 + it("returns 400 when rkey is missing", async () => { 171 171 + const res = await app.request( 172 172 + "/xrpc/com.atproto.repo.getRecord?repo=did:plc:alice&collection=app.bsky.feed.post", 173 173 + ); 174 174 + const body = await res.json(); 175 175 + 176 176 + expect(res.status).toBe(400); 177 177 + expect(body).toEqual({ 178 178 + error: "InvalidRequest", 179 179 + message: "missing rkey parameter", 180 180 + }); 181 181 + }); 182 182 + }); 183 183 + 184 184 + describe("listRecords", () => { 185 185 + it("returns records with the expected structure", async () => { 186 186 + const did = "did:plc:alice"; 187 187 + await createRepoWithPost(db, did); 188 188 + 189 189 + const res = await app.request( 190 190 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post`, 191 191 + ); 192 192 + const body = await res.json(); 193 193 + 194 194 + expect(res.status).toBe(200); 195 195 + expect(body.records).toHaveLength(1); 196 196 + expect(body.records[0].uri).toBe(`at://${did}/app.bsky.feed.post/test1`); 197 197 + expect(typeof body.records[0].cid).toBe("string"); 198 198 + expect(body.records[0].value.text).toBe("hello world"); 199 199 + }); 200 200 + 201 201 + it("returns empty records for a collection with no records", async () => { 202 202 + const did = "did:plc:alice"; 203 203 + await createRepoWithPost(db, did); 204 204 + 205 205 + const res = await app.request( 206 206 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.graph.follow`, 207 207 + ); 208 208 + const body = await res.json(); 209 209 + 210 210 + expect(res.status).toBe(200); 211 211 + expect(body).toEqual({ records: [] }); 212 212 + }); 213 213 + 214 214 + it("respects limit and returns a cursor", async () => { 215 215 + const did = "did:plc:alice"; 216 216 + await createRepoWithPosts(db, did, ["test1", "test2"]); 217 217 + 218 218 + const res = await app.request( 219 219 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&limit=1`, 220 220 + ); 221 221 + const body = await res.json(); 222 222 + 223 223 + expect(res.status).toBe(200); 224 224 + expect(body.records).toHaveLength(1); 225 225 + expect(body.cursor).toBe("test1"); 226 226 + }); 227 227 + 228 228 + it("uses the default limit when limit is omitted", async () => { 229 229 + const did = "did:plc:alice"; 230 230 + await createRepoWithPosts(db, did, ["test1", "test2"]); 231 231 + 232 232 + const res = await app.request( 233 233 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post`, 234 234 + ); 235 235 + const body = await res.json(); 236 236 + 237 237 + expect(res.status).toBe(200); 238 238 + expect(body.records).toHaveLength(2); 239 239 + }); 240 240 + 241 241 + it("caps limit at 100", async () => { 242 242 + const did = "did:plc:alice"; 243 243 + await createRepoWithPosts(db, did, ["test1", "test2"]); 244 244 + 245 245 + const res = await app.request( 246 246 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&limit=999`, 247 247 + ); 248 248 + const body = await res.json(); 249 249 + 250 250 + expect(res.status).toBe(200); 251 251 + expect(body.records).toHaveLength(2); 252 252 + expect(body.cursor).toBeUndefined(); 253 253 + }); 254 254 + 255 255 + it("paginates correctly with cursor chaining", async () => { 256 256 + const did = "did:plc:alice"; 257 257 + await createRepoWithPosts(db, did, ["test1", "test2", "test3"]); 258 258 + 259 259 + const firstRes = await app.request( 260 260 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&limit=1`, 261 261 + ); 262 262 + const firstBody = await firstRes.json(); 263 263 + 264 264 + const secondRes = await app.request( 265 265 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&limit=1&cursor=${firstBody.cursor}`, 266 266 + ); 267 267 + const secondBody = await secondRes.json(); 268 268 + 269 269 + const thirdRes = await app.request( 270 270 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&limit=1&cursor=${secondBody.cursor}`, 271 271 + ); 272 272 + const thirdBody = await thirdRes.json(); 273 273 + 274 274 + expect(firstBody.records[0].value.text).toBe("post test1"); 275 275 + expect(secondBody.records[0].value.text).toBe("post test2"); 276 276 + expect(thirdBody.records[0].value.text).toBe("post test3"); 277 277 + expect(thirdBody.cursor).toBeUndefined(); 278 278 + }); 279 279 + 280 280 + it("paginates correctly with cursor and reverse", async () => { 281 281 + const did = "did:plc:alice"; 282 282 + await createRepoWithPosts(db, did, ["test1", "test2", "test3"]); 283 283 + 284 284 + const firstRes = await app.request( 285 285 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&limit=1&reverse=true`, 286 286 + ); 287 287 + const firstBody = await firstRes.json(); 288 288 + 289 289 + expect(firstBody.records).toHaveLength(1); 290 290 + expect(firstBody.records[0].uri).toContain("test3"); 291 291 + expect(firstBody.cursor).toBeDefined(); 292 292 + 293 293 + const secondRes = await app.request( 294 294 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&limit=1&reverse=true&cursor=${firstBody.cursor}`, 295 295 + ); 296 296 + const secondBody = await secondRes.json(); 297 297 + 298 298 + expect(secondBody.records).toHaveLength(1); 299 299 + expect(secondBody.records[0].uri).toContain("test2"); 300 300 + 301 301 + const thirdRes = await app.request( 302 302 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&limit=1&reverse=true&cursor=${secondBody.cursor}`, 303 303 + ); 304 304 + const thirdBody = await thirdRes.json(); 305 305 + 306 306 + expect(thirdBody.records).toHaveLength(1); 307 307 + expect(thirdBody.records[0].uri).toContain("test1"); 308 308 + expect(thirdBody.cursor).toBeUndefined(); 309 309 + }); 310 310 + 311 311 + it("returns records in reverse rkey order", async () => { 312 312 + const did = "did:plc:alice"; 313 313 + await createRepoWithPosts(db, did, ["test1", "test2", "test3"]); 314 314 + 315 315 + const res = await app.request( 316 316 + `/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=app.bsky.feed.post&reverse=true`, 317 317 + ); 318 318 + const body = await res.json(); 319 319 + 320 320 + expect(body.records.map((record: { uri: string }) => record.uri)).toEqual([ 321 321 + `at://${did}/app.bsky.feed.post/test3`, 322 322 + `at://${did}/app.bsky.feed.post/test2`, 323 323 + `at://${did}/app.bsky.feed.post/test1`, 324 324 + ]); 325 325 + }); 326 326 + 327 327 + it("returns 400 when repo is missing", async () => { 328 328 + const res = await app.request( 329 329 + "/xrpc/com.atproto.repo.listRecords?collection=app.bsky.feed.post", 330 330 + ); 331 331 + const body = await res.json(); 332 332 + 333 333 + expect(res.status).toBe(400); 334 334 + expect(body).toEqual({ 335 335 + error: "InvalidRequest", 336 336 + message: "missing repo parameter", 337 337 + }); 338 338 + }); 339 339 + 340 340 + it("returns 400 when collection is missing", async () => { 341 341 + const res = await app.request("/xrpc/com.atproto.repo.listRecords?repo=did:plc:alice"); 342 342 + const body = await res.json(); 343 343 + 344 344 + expect(res.status).toBe(400); 345 345 + expect(body).toEqual({ 346 346 + error: "InvalidRequest", 347 347 + message: "missing collection parameter", 348 348 + }); 349 349 + }); 350 350 + 351 351 + it("works with a handle as the repo param", async () => { 352 352 + const did = "did:plc:alice"; 353 353 + await createRepoWithPosts(db, did, ["test1"]); 354 354 + setHandle(db, did, "alice.test.example"); 355 355 + 356 356 + const res = await app.request( 357 357 + "/xrpc/com.atproto.repo.listRecords?repo=alice.test.example&collection=app.bsky.feed.post", 358 358 + ); 359 359 + const body = await res.json(); 360 360 + 361 361 + expect(res.status).toBe(200); 362 362 + expect(body.records).toHaveLength(1); 363 363 + }); 364 364 + }); 365 365 + 366 366 + describe("describeRepo", () => { 367 367 + it("returns the expected shape", async () => { 368 368 + const did = "did:plc:alice"; 369 369 + const fakeDidDoc = { id: did, verificationMethod: [] }; 370 370 + const { storage } = await createRepoWithPost(db, did); 371 371 + setHandle(db, did, "alice.test.example"); 372 372 + storage.addCollection("app.bsky.feed.post"); 373 373 + 374 374 + vi.stubGlobal("fetch", async (url: string) => { 375 375 + if (url === `${testConfig.plcUrl}/${did}`) { 376 376 + return new Response(JSON.stringify(fakeDidDoc), { status: 200 }); 377 377 + } 378 378 + return new Response("not found", { status: 404 }); 379 379 + }); 380 380 + 381 381 + const res = await app.request(`/xrpc/com.atproto.repo.describeRepo?repo=${did}`); 382 382 + const body = await res.json(); 383 383 + 384 384 + expect(res.status).toBe(200); 385 385 + expect(body).toEqual({ 386 386 + handle: "alice.test.example", 387 387 + did, 388 388 + didDoc: fakeDidDoc, 389 389 + collections: ["app.bsky.feed.post"], 390 390 + handleIsCorrect: true, 391 391 + }); 392 392 + }); 393 393 + 394 394 + it("returns handleIsCorrect true when a handle is set", async () => { 395 395 + const did = "did:plc:alice"; 396 396 + await createRepoWithPost(db, did); 397 397 + setHandle(db, did, "alice.test.example"); 398 398 + vi.stubGlobal("fetch", async () => new Response("{}", { status: 200 })); 399 399 + 400 400 + const res = await app.request(`/xrpc/com.atproto.repo.describeRepo?repo=${did}`); 401 401 + const body = await res.json(); 402 402 + 403 403 + expect(body.handleIsCorrect).toBe(true); 404 404 + }); 405 405 + 406 406 + it("returns handleIsCorrect false when the handle is null", async () => { 407 407 + const did = "did:plc:alice"; 408 408 + await createRepoWithPost(db, did); 409 409 + vi.stubGlobal("fetch", async () => new Response("{}", { status: 200 })); 410 410 + 411 411 + const res = await app.request(`/xrpc/com.atproto.repo.describeRepo?repo=${did}`); 412 412 + const body = await res.json(); 413 413 + 414 414 + expect(body.handle).toBe(""); 415 415 + expect(body.handleIsCorrect).toBe(false); 416 416 + }); 417 417 + 418 418 + it("returns collections from storage", async () => { 419 419 + const did = "did:plc:alice"; 420 420 + const { storage } = await createRepoWithPost(db, did); 421 421 + storage.addCollection("app.bsky.graph.follow"); 422 422 + storage.addCollection("app.bsky.feed.post"); 423 423 + vi.stubGlobal("fetch", async () => new Response("{}", { status: 200 })); 424 424 + 425 425 + const res = await app.request(`/xrpc/com.atproto.repo.describeRepo?repo=${did}`); 426 426 + const body = await res.json(); 427 427 + 428 428 + expect(body.collections).toEqual([ 429 429 + "app.bsky.feed.post", 430 430 + "app.bsky.graph.follow", 431 431 + ]); 432 432 + }); 433 433 + 434 434 + it("returns 400 when repo is missing", async () => { 435 435 + const res = await app.request("/xrpc/com.atproto.repo.describeRepo"); 436 436 + const body = await res.json(); 437 437 + 438 438 + expect(res.status).toBe(400); 439 439 + expect(body).toEqual({ 440 440 + error: "InvalidRequest", 441 441 + message: "missing repo parameter", 442 442 + }); 443 443 + }); 444 444 + 445 445 + it("returns 400 when the repo is unknown", async () => { 446 446 + const res = await app.request( 447 447 + "/xrpc/com.atproto.repo.describeRepo?repo=did:plc:missing", 448 448 + ); 449 449 + const body = await res.json(); 450 450 + 451 451 + expect(res.status).toBe(400); 452 452 + expect(body.error).toBe("RepoNotFound"); 453 453 + }); 454 454 + 455 455 + it("works with a handle as the repo param", async () => { 456 456 + const did = "did:plc:alice"; 457 457 + await createRepoWithPost(db, did); 458 458 + setHandle(db, did, "alice.test.example"); 459 459 + vi.stubGlobal("fetch", async () => new Response("{}", { status: 200 })); 460 460 + 461 461 + const res = await app.request( 462 462 + "/xrpc/com.atproto.repo.describeRepo?repo=alice.test.example", 463 463 + ); 464 464 + 465 465 + expect(res.status).toBe(200); 466 466 + }); 467 467 + }); 468 468 + 469 469 + describe("describeServer", () => { 470 470 + it("returns the expected server description", async () => { 471 471 + const res = await app.request("/xrpc/com.atproto.server.describeServer"); 472 472 + const body = await res.json(); 473 473 + 474 474 + expect(res.status).toBe(200); 475 475 + expect(body).toEqual({ 476 476 + did: "did:web:pds.test.example", 477 477 + availableUserDomains: ["test.example"], 478 478 + }); 479 479 + }); 480 480 + }); 481 481 + });