+28

README.md

··· 20 20 21 21 **Platform options:** 22 22 - **Node.js** - Simple setup, filesystem storage, ideal for self-hosting 23 23 + - **Deno** - Modern runtime with built-in TypeScript, uses node:sqlite 23 24 - **Cloudflare Workers** - Edge deployment with Durable Objects and R2 24 25 25 26 ## Quick Start (Node.js) ··· 114 115 npm run setup -- --pds https://your-worker.workers.dev 115 116 ``` 116 117 118 118 + ## Deploy: Deno 119 119 + 120 120 + Requires Deno 2.2+ for `node:sqlite` support. 121 121 + 122 122 + ```bash 123 123 + cd examples/deno 124 124 + deno run --allow-net --allow-read --allow-write --allow-env main.ts 125 125 + ``` 126 126 + 127 127 + See [examples/deno/README.md](examples/deno/README.md) for configuration options. 128 128 + 117 129 ## Testing 118 130 119 131 ```bash 120 132 npm test # Unit tests 121 133 npm run test:e2e:node # E2E against Node.js 134 134 + npm run test:e2e:deno # E2E against Deno 122 135 npm run test:e2e:cloudflare # E2E against Cloudflare 123 136 npm run test:coverage # Coverage report 124 137 ``` ··· 163 176 |---------|-------------| 164 177 | @pds/core | Platform-agnostic business logic and XRPC handlers | 165 178 | @pds/node | Node.js HTTP server with WebSocket support | 179 179 + | @pds/deno | Deno HTTP server with WebSocket support | 166 180 | @pds/cloudflare | Cloudflare Workers entry point with Durable Objects | 167 181 | @pds/storage-sqlite | SQLite storage adapter (better-sqlite3 or node:sqlite) | 168 182 | @pds/blobs-fs | Filesystem blob storage for Node.js | 183 183 + | @pds/blobs-deno | Filesystem blob storage for Deno | 169 184 | @pds/blobs-s3 | S3-compatible blob storage | 170 185 171 186 **Node.js usage:** ··· 189 204 export { PDSDurableObject } from '@pds/cloudflare' 190 205 ``` 191 206 207 207 + **Deno usage:** 208 208 + ```typescript 209 209 + import { createServer } from '@pds/deno' 210 210 + 211 211 + const server = createServer({ 212 212 + dbPath: './pds.db', 213 213 + blobsDir: './blobs', 214 214 + jwtSecret: Deno.env.get('JWT_SECRET'), 215 215 + }) 216 216 + ``` 217 217 + 192 218 ## Contributing 193 219 194 220 **Before submitting a PR:** ··· 211 237 packages/ 212 238 core/ # Platform-agnostic core 213 239 node/ # Node.js adapter 240 240 + deno/ # Deno adapter 214 241 cloudflare/ # Cloudflare adapter 215 242 storage-*/ # Storage implementations 216 243 blobs-*/ # Blob storage implementations 217 244 examples/ 218 245 node/ # Node.js example 246 246 + deno/ # Deno example 219 247 cloudflare/ # Cloudflare example 220 248 ```

+703

docs/plans/2026-01-12-deno-support.md

··· 1 1 + # Deno Support Implementation Plan 2 2 + 3 3 + > **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. 4 4 + 5 5 + **Goal:** Add Deno runtime support to pds.js by abstracting the SQLite driver and creating a Deno HTTP/WebSocket adapter. 6 6 + 7 7 + **Architecture:** Create a minimal SQLite driver interface that both `better-sqlite3` (Node) and `node:sqlite` (Deno 2.2+) implement natively. Add a new `@pds/deno` package for the HTTP server adapter using `Deno.serve()`. Reuse `@pds/storage-sqlite` unchanged except for type annotations. 8 8 + 9 9 + **Tech Stack:** Deno 2.2+, node:sqlite, Deno.serve(), TypeScript/JSDoc 10 10 + 11 11 + --- 12 12 + 13 13 + ## Task 1: Add SQLite Driver Interface Types 14 14 + 15 15 + **Files:** 16 16 + - Create: `packages/storage-sqlite/driver.js` 17 17 + 18 18 + **Step 1: Create the driver interface file** 19 19 + 20 20 + ```javascript 21 21 + // @pds/storage-sqlite/driver - SQLite driver interface types 22 22 + // Both better-sqlite3 and node:sqlite implement this interface natively 23 23 + 24 24 + /** 25 25 + * @typedef {Object} SQLiteStatement 26 26 + * @property {(...args: unknown[]) => unknown} get - Single row query 27 27 + * @property {(...args: unknown[]) => unknown[]} all - Multi-row query 28 28 + * @property {(...args: unknown[]) => {changes: number}} run - Execute INSERT/UPDATE/DELETE 29 29 + */ 30 30 + 31 31 + /** 32 32 + * @typedef {Object} SQLiteDatabase 33 33 + * @property {(sql: string) => void} exec - Execute raw SQL (DDL, multiple statements) 34 34 + * @property {(sql: string) => SQLiteStatement} prepare - Create prepared statement 35 35 + */ 36 36 + 37 37 + export {}; 38 38 + ``` 39 39 + 40 40 + **Step 2: Verify file created** 41 41 + 42 42 + Run: `cat packages/storage-sqlite/driver.js` 43 43 + Expected: File contents shown 44 44 + 45 45 + **Step 3: Commit** 46 46 + 47 47 + ```bash 48 48 + git add packages/storage-sqlite/driver.js 49 49 + git commit -m "feat(storage-sqlite): add SQLite driver interface types" 50 50 + ``` 51 51 + 52 52 + --- 53 53 + 54 54 + ## Task 2: Update Storage Functions to Use Driver Interface 55 55 + 56 56 + **Files:** 57 57 + - Modify: `packages/storage-sqlite/index.js` (lines 24-28 and 314-318) 58 58 + 59 59 + **Step 1: Update createActorStorage type annotation** 60 60 + 61 61 + Change line 28 from: 62 62 + ```javascript 63 63 + * @param {import('better-sqlite3').Database} db 64 64 + ``` 65 65 + to: 66 66 + ```javascript 67 67 + * @param {import('./driver.js').SQLiteDatabase} db 68 68 + ``` 69 69 + 70 70 + **Step 2: Update createSharedStorage type annotation** 71 71 + 72 72 + Change line 318 from: 73 73 + ```javascript 74 74 + * @param {import('better-sqlite3').Database} db 75 75 + ``` 76 76 + to: 77 77 + ```javascript 78 78 + * @param {import('./driver.js').SQLiteDatabase} db 79 79 + ``` 80 80 + 81 81 + **Step 3: Run existing tests to verify no breakage** 82 82 + 83 83 + Run: `pnpm test` 84 84 + Expected: All tests pass 85 85 + 86 86 + **Step 4: Commit** 87 87 + 88 88 + ```bash 89 89 + git add packages/storage-sqlite/index.js 90 90 + git commit -m "feat(storage-sqlite): use driver interface instead of better-sqlite3 types" 91 91 + ``` 92 92 + 93 93 + --- 94 94 + 95 95 + ## Task 3: Export Driver Types from Package 96 96 + 97 97 + **Files:** 98 98 + - Modify: `packages/storage-sqlite/package.json` 99 99 + 100 100 + **Step 1: Add driver.js to exports** 101 101 + 102 102 + Add to the exports field: 103 103 + ```json 104 104 + { 105 105 + "exports": { 106 106 + ".": "./index.js", 107 107 + "./driver": "./driver.js" 108 108 + } 109 109 + } 110 110 + ``` 111 111 + 112 112 + **Step 2: Verify package.json is valid** 113 113 + 114 114 + Run: `node -e "console.log(JSON.parse(require('fs').readFileSync('packages/storage-sqlite/package.json')))"` 115 115 + Expected: No JSON parse errors 116 116 + 117 117 + **Step 3: Commit** 118 118 + 119 119 + ```bash 120 120 + git add packages/storage-sqlite/package.json 121 121 + git commit -m "feat(storage-sqlite): export driver interface types" 122 122 + ``` 123 123 + 124 124 + --- 125 125 + 126 126 + ## Task 4: Create @pds/deno Package Structure 127 127 + 128 128 + **Files:** 129 129 + - Create: `packages/deno/package.json` 130 130 + - Create: `packages/deno/deno.json` 131 131 + 132 132 + **Step 1: Create package.json** 133 133 + 134 134 + ```json 135 135 + { 136 136 + "name": "@pds/deno", 137 137 + "version": "0.7.0", 138 138 + "type": "module", 139 139 + "exports": { 140 140 + ".": "./index.js" 141 141 + }, 142 142 + "dependencies": { 143 143 + "@pds/core": "workspace:*" 144 144 + } 145 145 + } 146 146 + ``` 147 147 + 148 148 + **Step 2: Create deno.json** 149 149 + 150 150 + ```json 151 151 + { 152 152 + "name": "@pds/deno", 153 153 + "version": "0.7.0", 154 154 + "exports": "./index.js", 155 155 + "imports": { 156 156 + "@pds/core": "../core/index.js", 157 157 + "@pds/core/": "../core/" 158 158 + } 159 159 + } 160 160 + ``` 161 161 + 162 162 + **Step 3: Commit** 163 163 + 164 164 + ```bash 165 165 + git add packages/deno/package.json packages/deno/deno.json 166 166 + git commit -m "feat(deno): create package structure" 167 167 + ``` 168 168 + 169 169 + --- 170 170 + 171 171 + ## Task 5: Implement Deno WebSocket Port 172 172 + 173 173 + **Files:** 174 174 + - Create: `packages/deno/index.js` 175 175 + 176 176 + **Step 1: Create the WebSocket port implementation** 177 177 + 178 178 + ```javascript 179 179 + // @pds/deno - Deno HTTP server adapter 180 180 + 181 181 + /** 182 182 + * Create WebSocket port for Deno 183 183 + * @param {Map<Request, {socket: WebSocket, response: Response}>} upgradeMap 184 184 + * @returns {import('@pds/core/ports.js').WebSocketPort} 185 185 + */ 186 186 + export function createWebSocketPort(upgradeMap) { 187 187 + /** @type {Set<WebSocket>} */ 188 188 + const clients = new Set(); 189 189 + 190 190 + return { 191 191 + isUpgrade(request) { 192 192 + return request.headers.get('upgrade')?.toLowerCase() === 'websocket'; 193 193 + }, 194 194 + 195 195 + upgrade(request, onConnect) { 196 196 + const upgrade = Deno.upgradeWebSocket(request); 197 197 + const { socket, response } = upgrade; 198 198 + 199 199 + clients.add(socket); 200 200 + socket.onclose = () => clients.delete(socket); 201 201 + 202 202 + socket.onopen = () => { 203 203 + onConnect({ 204 204 + send(data) { 205 205 + if (socket.readyState === WebSocket.OPEN) { 206 206 + socket.send(data); 207 207 + } 208 208 + }, 209 209 + close() { 210 210 + socket.close(); 211 211 + }, 212 212 + }); 213 213 + }; 214 214 + 215 215 + return response; 216 216 + }, 217 217 + 218 218 + broadcast(data) { 219 219 + for (const client of clients) { 220 220 + if (client.readyState === WebSocket.OPEN) { 221 221 + try { 222 222 + client.send(data); 223 223 + } catch { 224 224 + // Client may have disconnected 225 225 + } 226 226 + } 227 227 + } 228 228 + }, 229 229 + }; 230 230 + } 231 231 + ``` 232 232 + 233 233 + **Step 2: Commit** 234 234 + 235 235 + ```bash 236 236 + git add packages/deno/index.js 237 237 + git commit -m "feat(deno): implement WebSocket port" 238 238 + ``` 239 239 + 240 240 + --- 241 241 + 242 242 + ## Task 6: Implement Deno HTTP Server 243 243 + 244 244 + **Files:** 245 245 + - Modify: `packages/deno/index.js` 246 246 + 247 247 + **Step 1: Add createServer function** 248 248 + 249 249 + Append to `packages/deno/index.js`: 250 250 + 251 251 + ```javascript 252 252 + import { PersonalDataServer } from '@pds/core'; 253 253 + 254 254 + /** 255 255 + * @typedef {Object} DenoServerOptions 256 256 + * @property {import('@pds/core/ports.js').ActorStoragePort} actorStorage 257 257 + * @property {import('@pds/core/ports.js').SharedStoragePort} sharedStorage 258 258 + * @property {import('@pds/core/ports.js').BlobPort} blobs 259 259 + * @property {string} jwtSecret 260 260 + * @property {number} [port=3000] 261 261 + * @property {string} [hostname] 262 262 + * @property {string} [appviewUrl] 263 263 + * @property {string} [appviewDid] 264 264 + * @property {string} [relayUrl] 265 265 + * @property {string} [password] 266 266 + */ 267 267 + 268 268 + /** 269 269 + * @typedef {Object} DenoServer 270 270 + * @property {PersonalDataServer} pds 271 271 + * @property {Deno.HttpServer} server 272 272 + * @property {() => void} close 273 273 + */ 274 274 + 275 275 + /** 276 276 + * Create Deno PDS server 277 277 + * @param {DenoServerOptions} options 278 278 + * @returns {DenoServer} 279 279 + */ 280 280 + export function createServer({ 281 281 + actorStorage, 282 282 + sharedStorage, 283 283 + blobs, 284 284 + jwtSecret, 285 285 + port = 3000, 286 286 + hostname, 287 287 + appviewUrl, 288 288 + appviewDid, 289 289 + relayUrl, 290 290 + password, 291 291 + }) { 292 292 + /** @type {Map<Request, {socket: WebSocket, response: Response}>} */ 293 293 + const upgradeMap = new Map(); 294 294 + const webSocket = createWebSocketPort(upgradeMap); 295 295 + 296 296 + const pds = new PersonalDataServer({ 297 297 + actorStorage, 298 298 + sharedStorage, 299 299 + blobs, 300 300 + webSocket, 301 301 + jwtSecret, 302 302 + hostname, 303 303 + appviewUrl, 304 304 + appviewDid, 305 305 + relayUrl, 306 306 + password, 307 307 + }); 308 308 + 309 309 + const server = Deno.serve({ port }, async (request) => { 310 310 + // Handle WebSocket upgrade 311 311 + if (webSocket.isUpgrade(request)) { 312 312 + return pds.fetch(request); 313 313 + } 314 314 + 315 315 + // Handle regular HTTP 316 316 + return pds.fetch(request); 317 317 + }); 318 318 + 319 319 + // Cleanup interval (every hour) 320 320 + const cleanupInterval = setInterval( 321 321 + async () => { 322 322 + await pds.runBlobCleanup(); 323 323 + await sharedStorage.cleanupExpiredDpopJtis(); 324 324 + }, 325 325 + 60 * 60 * 1000, 326 326 + ); 327 327 + 328 328 + return { 329 329 + pds, 330 330 + server, 331 331 + port, 332 332 + close() { 333 333 + clearInterval(cleanupInterval); 334 334 + server.shutdown(); 335 335 + }, 336 336 + }; 337 337 + } 338 338 + 339 339 + /** 340 340 + * Create server from environment variables 341 341 + * @param {Object} deps - Storage dependencies 342 342 + * @param {import('@pds/core/ports.js').ActorStoragePort} deps.actorStorage 343 343 + * @param {import('@pds/core/ports.js').SharedStoragePort} deps.sharedStorage 344 344 + * @param {import('@pds/core/ports.js').BlobPort} deps.blobs 345 345 + * @returns {DenoServer} 346 346 + */ 347 347 + export function createServerFromEnv({ actorStorage, sharedStorage, blobs }) { 348 348 + return createServer({ 349 349 + actorStorage, 350 350 + sharedStorage, 351 351 + blobs, 352 352 + jwtSecret: Deno.env.get('JWT_SECRET') || 'development-secret', 353 353 + port: parseInt(Deno.env.get('PORT') || '3000', 10), 354 354 + hostname: Deno.env.get('HOSTNAME'), 355 355 + appviewUrl: Deno.env.get('APPVIEW_URL'), 356 356 + appviewDid: Deno.env.get('APPVIEW_DID'), 357 357 + relayUrl: Deno.env.get('RELAY_URL'), 358 358 + password: Deno.env.get('PDS_PASSWORD'), 359 359 + }); 360 360 + } 361 361 + ``` 362 362 + 363 363 + **Step 2: Run type check** 364 364 + 365 365 + Run: `pnpm exec tsc --noEmit` 366 366 + Expected: No type errors 367 367 + 368 368 + **Step 3: Commit** 369 369 + 370 370 + ```bash 371 371 + git add packages/deno/index.js 372 372 + git commit -m "feat(deno): implement HTTP server with createServer" 373 373 + ``` 374 374 + 375 375 + --- 376 376 + 377 377 + ## Task 7: Create Deno Example 378 378 + 379 379 + **Files:** 380 380 + - Create: `examples/deno/main.ts` 381 381 + - Create: `examples/deno/deno.json` 382 382 + 383 383 + **Step 1: Create deno.json** 384 384 + 385 385 + ```json 386 386 + { 387 387 + "imports": { 388 388 + "@pds/core": "../../packages/core/index.js", 389 389 + "@pds/core/": "../../packages/core/", 390 390 + "@pds/deno": "../../packages/deno/index.js", 391 391 + "@pds/storage-sqlite": "../../packages/storage-sqlite/index.js", 392 392 + "@pds/blobs-s3": "../../packages/blobs-s3/index.js" 393 393 + } 394 394 + } 395 395 + ``` 396 396 + 397 397 + **Step 2: Create main.ts** 398 398 + 399 399 + ```typescript 400 400 + import { DatabaseSync } from 'node:sqlite'; 401 401 + import { createActorStorage, createSharedStorage } from '@pds/storage-sqlite'; 402 402 + import { createServer } from '@pds/deno'; 403 403 + 404 404 + // Initialize SQLite database 405 405 + const dbPath = Deno.env.get('PDS_DB_PATH') || './pds.db'; 406 406 + const db = new DatabaseSync(dbPath); 407 407 + 408 408 + // Create storage adapters 409 409 + const actorStorage = createActorStorage(db); 410 410 + const sharedStorage = createSharedStorage(db); 411 411 + 412 412 + // For blobs, use S3 or implement Deno filesystem adapter 413 413 + // This example uses a minimal in-memory blob store for demo purposes 414 414 + const blobs = { 415 415 + async get(_did: string, _cid: string) { 416 416 + return null; // TODO: implement with Deno.readFile or S3 417 417 + }, 418 418 + async put(_did: string, _cid: string, _data: Uint8Array, _mimeType: string) { 419 419 + // TODO: implement 420 420 + }, 421 421 + async delete(_did: string, _cid: string) { 422 422 + // TODO: implement 423 423 + }, 424 424 + }; 425 425 + 426 426 + // Create and start server 427 427 + const server = createServer({ 428 428 + actorStorage, 429 429 + sharedStorage, 430 430 + blobs, 431 431 + jwtSecret: Deno.env.get('JWT_SECRET') || 'development-secret', 432 432 + port: parseInt(Deno.env.get('PORT') || '3000', 10), 433 433 + hostname: Deno.env.get('HOSTNAME'), 434 434 + appviewUrl: Deno.env.get('APPVIEW_URL'), 435 435 + appviewDid: Deno.env.get('APPVIEW_DID'), 436 436 + relayUrl: Deno.env.get('RELAY_URL'), 437 437 + password: Deno.env.get('PDS_PASSWORD'), 438 438 + }); 439 439 + 440 440 + console.log(`PDS running on http://localhost:${server.port}`); 441 441 + 442 442 + // Handle shutdown 443 443 + Deno.addSignalListener('SIGINT', () => { 444 444 + console.log('Shutting down...'); 445 445 + server.close(); 446 446 + db.close(); 447 447 + Deno.exit(0); 448 448 + }); 449 449 + ``` 450 450 + 451 451 + **Step 3: Commit** 452 452 + 453 453 + ```bash 454 454 + git add examples/deno/main.ts examples/deno/deno.json 455 455 + git commit -m "feat(examples): add Deno example" 456 456 + ``` 457 457 + 458 458 + --- 459 459 + 460 460 + ## Task 8: Add Deno Filesystem Blobs (Optional) 461 461 + 462 462 + **Files:** 463 463 + - Create: `packages/blobs-deno/index.js` 464 464 + - Create: `packages/blobs-deno/package.json` 465 465 + - Create: `packages/blobs-deno/deno.json` 466 466 + 467 467 + **Step 1: Create package.json** 468 468 + 469 469 + ```json 470 470 + { 471 471 + "name": "@pds/blobs-deno", 472 472 + "version": "0.7.0", 473 473 + "type": "module", 474 474 + "exports": { 475 475 + ".": "./index.js" 476 476 + } 477 477 + } 478 478 + ``` 479 479 + 480 480 + **Step 2: Create deno.json** 481 481 + 482 482 + ```json 483 483 + { 484 484 + "name": "@pds/blobs-deno", 485 485 + "version": "0.7.0", 486 486 + "exports": "./index.js" 487 487 + } 488 488 + ``` 489 489 + 490 490 + **Step 3: Create index.js** 491 491 + 492 492 + ```javascript 493 493 + // @pds/blobs-deno - Deno filesystem blob storage 494 494 + 495 495 + import { join, dirname } from 'node:path'; 496 496 + 497 497 + /** 498 498 + * Create filesystem blob storage for Deno 499 499 + * @param {string} baseDir - Base directory for blob storage 500 500 + * @returns {import('@pds/core/ports.js').BlobPort} 501 501 + */ 502 502 + export function createDenoBlobs(baseDir) { 503 503 + /** 504 504 + * Get blob file path 505 505 + * @param {string} did 506 506 + * @param {string} cid 507 507 + */ 508 508 + function blobPath(did, cid) { 509 509 + // Use first 2 chars of CID for sharding 510 510 + const shard = cid.slice(0, 2); 511 511 + return join(baseDir, did, shard, cid); 512 512 + } 513 513 + 514 514 + return { 515 515 + async get(did, cid) { 516 516 + try { 517 517 + const path = blobPath(did, cid); 518 518 + const data = await Deno.readFile(path); 519 519 + const metaPath = `${path}.meta`; 520 520 + const meta = JSON.parse(await Deno.readTextFile(metaPath)); 521 521 + return { data, mimeType: meta.mimeType }; 522 522 + } catch (e) { 523 523 + if (e instanceof Deno.errors.NotFound) { 524 524 + return null; 525 525 + } 526 526 + throw e; 527 527 + } 528 528 + }, 529 529 + 530 530 + async put(did, cid, data, mimeType) { 531 531 + const path = blobPath(did, cid); 532 532 + await Deno.mkdir(dirname(path), { recursive: true }); 533 533 + await Deno.writeFile(path, data); 534 534 + await Deno.writeTextFile(`${path}.meta`, JSON.stringify({ mimeType })); 535 535 + }, 536 536 + 537 537 + async delete(did, cid) { 538 538 + try { 539 539 + const path = blobPath(did, cid); 540 540 + await Deno.remove(path); 541 541 + await Deno.remove(`${path}.meta`); 542 542 + } catch (e) { 543 543 + if (!(e instanceof Deno.errors.NotFound)) { 544 544 + throw e; 545 545 + } 546 546 + } 547 547 + }, 548 548 + }; 549 549 + } 550 550 + ``` 551 551 + 552 552 + **Step 4: Commit** 553 553 + 554 554 + ```bash 555 555 + git add packages/blobs-deno/ 556 556 + git commit -m "feat(blobs-deno): add Deno filesystem blob storage" 557 557 + ``` 558 558 + 559 559 + --- 560 560 + 561 561 + ## Task 9: Update Deno Example to Use Blobs 562 562 + 563 563 + **Files:** 564 564 + - Modify: `examples/deno/main.ts` 565 565 + - Modify: `examples/deno/deno.json` 566 566 + 567 567 + **Step 1: Update deno.json imports** 568 568 + 569 569 + Add to imports: 570 570 + ```json 571 571 + "@pds/blobs-deno": "../../packages/blobs-deno/index.js" 572 572 + ``` 573 573 + 574 574 + **Step 2: Update main.ts to use blobs-deno** 575 575 + 576 576 + Replace the placeholder blobs with: 577 577 + 578 578 + ```typescript 579 579 + import { createDenoBlobs } from '@pds/blobs-deno'; 580 580 + 581 581 + const blobsDir = Deno.env.get('PDS_BLOBS_DIR') || './blobs'; 582 582 + const blobs = createDenoBlobs(blobsDir); 583 583 + ``` 584 584 + 585 585 + **Step 3: Commit** 586 586 + 587 587 + ```bash 588 588 + git add examples/deno/main.ts examples/deno/deno.json 589 589 + git commit -m "feat(examples): use blobs-deno in Deno example" 590 590 + ``` 591 591 + 592 592 + --- 593 593 + 594 594 + ## Task 10: Add README for Deno Example 595 595 + 596 596 + **Files:** 597 597 + - Create: `examples/deno/README.md` 598 598 + 599 599 + **Step 1: Create README** 600 600 + 601 601 + ```markdown 602 602 + # Deno PDS Example 603 603 + 604 604 + Minimal PDS server running on Deno. 605 605 + 606 606 + ## Requirements 607 607 + 608 608 + - Deno 2.2+ (for `node:sqlite` support) 609 609 + 610 610 + ## Quick Start 611 611 + 612 612 + ```bash 613 613 + cd examples/deno 614 614 + deno run --allow-net --allow-read --allow-write --allow-env main.ts 615 615 + ``` 616 616 + 617 617 + ## Environment Variables 618 618 + 619 619 + | Variable | Description | Default | 620 620 + |----------|-------------|---------| 621 621 + | `PDS_DB_PATH` | SQLite database path | `./pds.db` | 622 622 + | `PDS_BLOBS_DIR` | Blob storage directory | `./blobs` | 623 623 + | `JWT_SECRET` | JWT signing secret | `development-secret` | 624 624 + | `PORT` | Server port | `3000` | 625 625 + | `HOSTNAME` | PDS hostname | - | 626 626 + | `APPVIEW_URL` | AppView URL for proxying | - | 627 627 + | `APPVIEW_DID` | AppView DID for service auth | - | 628 628 + | `RELAY_URL` | Relay URL for firehose | - | 629 629 + | `PDS_PASSWORD` | Password for createSession | - | 630 630 + 631 631 + ## Permissions 632 632 + 633 633 + The server requires these Deno permissions: 634 634 + 635 635 + - `--allow-net` - HTTP server and outbound requests 636 636 + - `--allow-read` - Read database and blob files 637 637 + - `--allow-write` - Write database and blob files 638 638 + - `--allow-env` - Read environment variables 639 639 + ``` 640 640 + 641 641 + **Step 2: Commit** 642 642 + 643 643 + ```bash 644 644 + git add examples/deno/README.md 645 645 + git commit -m "docs(examples): add Deno example README" 646 646 + ``` 647 647 + 648 648 + --- 649 649 + 650 650 + ## Task 11: Test Deno Example Manually 651 651 + 652 652 + **Step 1: Run the Deno example** 653 653 + 654 654 + ```bash 655 655 + cd examples/deno 656 656 + deno run --allow-net --allow-read --allow-write --allow-env main.ts 657 657 + ``` 658 658 + 659 659 + Expected: Server starts, prints "PDS running on http://localhost:3000" 660 660 + 661 661 + **Step 2: Test health endpoint** 662 662 + 663 663 + ```bash 664 664 + curl http://localhost:3000/xrpc/_health 665 665 + ``` 666 666 + 667 667 + Expected: `{"version":"..."}` 668 668 + 669 669 + **Step 3: Test describe server** 670 670 + 671 671 + ```bash 672 672 + curl http://localhost:3000/xrpc/com.atproto.server.describeServer 673 673 + ``` 674 674 + 675 675 + Expected: JSON response with server description 676 676 + 677 677 + --- 678 678 + 679 679 + ## Task 12: Update Root README 680 680 + 681 681 + **Files:** 682 682 + - Modify: `README.md` 683 683 + 684 684 + **Step 1: Add Deno to supported platforms** 685 685 + 686 686 + Add to the platforms section: 687 687 + ```markdown 688 688 + ### Deno 689 689 + 690 690 + ```bash 691 691 + cd examples/deno 692 692 + deno run --allow-net --allow-read --allow-write --allow-env main.ts 693 693 + ``` 694 694 + 695 695 + Requires Deno 2.2+ for `node:sqlite` support. 696 696 + ``` 697 697 + 698 698 + **Step 2: Commit** 699 699 + 700 700 + ```bash 701 701 + git add README.md 702 702 + git commit -m "docs: add Deno to supported platforms" 703 703 + ```

+37

examples/deno/README.md

··· 1 1 + # Deno PDS Example 2 2 + 3 3 + Minimal PDS server running on Deno. 4 4 + 5 5 + ## Requirements 6 6 + 7 7 + - Deno 2.2+ (for `node:sqlite` support) 8 8 + 9 9 + ## Quick Start 10 10 + 11 11 + ```bash 12 12 + cd examples/deno 13 13 + deno run --allow-net --allow-read --allow-write --allow-env main.ts 14 14 + ``` 15 15 + 16 16 + ## Environment Variables 17 17 + 18 18 + | Variable | Description | Default | 19 19 + |----------|-------------|---------| 20 20 + | `PDS_DB_PATH` | SQLite database path | `./pds.db` | 21 21 + | `PDS_BLOBS_DIR` | Blob storage directory | `./blobs` | 22 22 + | `JWT_SECRET` | JWT signing secret | `development-secret` | 23 23 + | `PORT` | Server port | `3000` | 24 24 + | `HOSTNAME` | PDS hostname | - | 25 25 + | `APPVIEW_URL` | AppView URL for proxying | - | 26 26 + | `APPVIEW_DID` | AppView DID for service auth | - | 27 27 + | `RELAY_URL` | Relay URL for firehose | - | 28 28 + | `PDS_PASSWORD` | Password for createSession | - | 29 29 + 30 30 + ## Permissions 31 31 + 32 32 + The server requires these Deno permissions: 33 33 + 34 34 + - `--allow-net` - HTTP server and outbound requests 35 35 + - `--allow-read` - Read database and blob files 36 36 + - `--allow-write` - Write database and blob files 37 37 + - `--allow-env` - Read environment variables

+9

examples/deno/deno.json

··· 1 1 + { 2 2 + "imports": { 3 3 + "@pds/deno": "../../packages/deno/index.js", 4 4 + "@pds/core": "../../packages/core/index.js", 5 5 + "@pds/core/": "../../packages/core/", 6 6 + "@pds/storage-sqlite": "../../packages/storage-sqlite/index.js", 7 7 + "@pds/blobs-deno": "../../packages/blobs-deno/index.js" 8 8 + } 9 9 + }

+25

examples/deno/main.ts

··· 1 1 + import { createServer } from '@pds/deno'; 2 2 + 3 3 + const { listen, close } = await createServer({ 4 4 + dbPath: Deno.env.get('PDS_DB_PATH') || './pds.db', 5 5 + blobsDir: Deno.env.get('PDS_BLOBS_DIR') || './blobs', 6 6 + jwtSecret: Deno.env.get('JWT_SECRET') || 'development-secret', 7 7 + port: parseInt(Deno.env.get('PORT') || '3000', 10), 8 8 + hostname: Deno.env.get('HOSTNAME'), 9 9 + appviewUrl: Deno.env.get('APPVIEW_URL'), 10 10 + appviewDid: Deno.env.get('APPVIEW_DID'), 11 11 + relayUrl: Deno.env.get('RELAY_URL'), 12 12 + password: Deno.env.get('PDS_PASSWORD'), 13 13 + }); 14 14 + 15 15 + await listen(); 16 16 + 17 17 + // Handle shutdown (SIGINT for Ctrl+C, SIGTERM for Docker/K8s) 18 18 + async function shutdown() { 19 19 + console.log('Shutting down...'); 20 20 + await close(); 21 21 + Deno.exit(0); 22 22 + } 23 23 + 24 24 + Deno.addSignalListener('SIGINT', shutdown); 25 25 + Deno.addSignalListener('SIGTERM', shutdown);

+8

examples/deno/package.json

··· 1 1 + { 2 2 + "name": "@pds/example-deno", 3 3 + "private": true, 4 4 + "type": "module", 5 5 + "devDependencies": { 6 6 + "@types/deno": "^2.5.0" 7 7 + } 8 8 + }

+23

examples/deno/tsconfig.json

··· 1 1 + { 2 2 + "compilerOptions": { 3 3 + "target": "ES2022", 4 4 + "module": "ES2022", 5 5 + "moduleResolution": "bundler", 6 6 + "strict": true, 7 7 + "noEmit": true, 8 8 + "skipLibCheck": true, 9 9 + "allowJs": true, 10 10 + "checkJs": false, 11 11 + "types": ["@types/deno", "node"], 12 12 + "baseUrl": ".", 13 13 + "paths": { 14 14 + "@pds/core": ["../../packages/core/index.js"], 15 15 + "@pds/core/*": ["../../packages/core/*"], 16 16 + "@pds/deno": ["../../packages/deno/index.js"], 17 17 + "@pds/storage-sqlite": ["../../packages/storage-sqlite/index.js"], 18 18 + "@pds/blobs-deno": ["../../packages/blobs-deno/index.js"] 19 19 + } 20 20 + }, 21 21 + "include": ["./**/*.ts"], 22 22 + "exclude": [] 23 23 + }

+13 -2

examples/node/index.js

··· 1 1 // Example Node.js PDS server 2 2 - import { createServerFromEnv } from '@pds/node'; 2 2 + import { createServer } from '@pds/node'; 3 3 + 4 4 + const { listen } = await createServer({ 5 5 + dbPath: process.env.PDS_DB_PATH || './pds.db', 6 6 + blobsDir: process.env.PDS_BLOBS_DIR || './blobs', 7 7 + jwtSecret: process.env.JWT_SECRET || 'development-secret', 8 8 + port: parseInt(process.env.PORT || '3000', 10), 9 9 + hostname: process.env.HOSTNAME, 10 10 + appviewUrl: process.env.APPVIEW_URL, 11 11 + appviewDid: process.env.APPVIEW_DID, 12 12 + relayUrl: process.env.RELAY_URL, 13 13 + password: process.env.PDS_PASSWORD, 14 14 + }); 3 15 4 4 - const { listen } = await createServerFromEnv(); 5 16 await listen();

+1

package.json

··· 15 15 "test:watch": "vitest", 16 16 "test:coverage": "vitest run --coverage", 17 17 "test:e2e:node": "PLATFORM=node vitest run test/e2e.test.js", 18 18 + "test:e2e:deno": "PLATFORM=deno vitest run test/e2e.test.js", 18 19 "test:e2e:cloudflare": "PLATFORM=cloudflare vitest run test/e2e.test.js", 19 20 "setup": "node scripts/setup.js", 20 21 "format": "biome format --write .",

+5

packages/blobs-deno/deno.json

··· 1 1 + { 2 2 + "name": "@pds/blobs-deno", 3 3 + "version": "0.7.0", 4 4 + "exports": "./index.js" 5 5 + }

+58

packages/blobs-deno/index.js

··· 1 1 + // @pds/blobs-deno - Deno filesystem blob storage 2 2 + /// <reference types="@types/deno" /> 3 3 + 4 4 + import { join, dirname } from 'node:path'; 5 5 + 6 6 + /** 7 7 + * Create filesystem blob storage for Deno 8 8 + * @param {string} baseDir - Base directory for blob storage 9 9 + * @returns {import('@pds/core/ports.js').BlobPort} 10 10 + */ 11 11 + export function createDenoBlobs(baseDir) { 12 12 + /** 13 13 + * Get blob file path 14 14 + * @param {string} did 15 15 + * @param {string} cid 16 16 + */ 17 17 + function blobPath(did, cid) { 18 18 + // Use chars 1-3 of CID for sharding (matches @pds/blobs-fs) 19 19 + const shard = cid.slice(1, 3); 20 20 + return join(baseDir, did, shard, cid); 21 21 + } 22 22 + 23 23 + return { 24 24 + async get(did, cid) { 25 25 + try { 26 26 + const path = blobPath(did, cid); 27 27 + const data = await Deno.readFile(path); 28 28 + const metaPath = `${path}.meta`; 29 29 + const meta = JSON.parse(await Deno.readTextFile(metaPath)); 30 30 + return { data, mimeType: meta.mimeType }; 31 31 + } catch (e) { 32 32 + if (e instanceof Deno.errors.NotFound) { 33 33 + return null; 34 34 + } 35 35 + throw e; 36 36 + } 37 37 + }, 38 38 + 39 39 + async put(did, cid, data, mimeType) { 40 40 + const path = blobPath(did, cid); 41 41 + await Deno.mkdir(dirname(path), { recursive: true }); 42 42 + await Deno.writeFile(path, data); 43 43 + await Deno.writeTextFile(`${path}.meta`, JSON.stringify({ mimeType })); 44 44 + }, 45 45 + 46 46 + async delete(did, cid) { 47 47 + try { 48 48 + const path = blobPath(did, cid); 49 49 + await Deno.remove(path); 50 50 + await Deno.remove(`${path}.meta`); 51 51 + } catch (e) { 52 52 + if (!(e instanceof Deno.errors.NotFound)) { 53 53 + throw e; 54 54 + } 55 55 + } 56 56 + }, 57 57 + }; 58 58 + }

+11

packages/blobs-deno/package.json

··· 1 1 + { 2 2 + "name": "@pds/blobs-deno", 3 3 + "version": "0.7.0", 4 4 + "type": "module", 5 5 + "exports": { 6 6 + ".": "./index.js" 7 7 + }, 8 8 + "devDependencies": { 9 9 + "@types/deno": "^2.5.0" 10 10 + } 11 11 + }

+13

packages/blobs-deno/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "types": ["@types/deno", "node"], 5 5 + "baseUrl": ".", 6 6 + "paths": { 7 7 + "@pds/core": ["../core/index.js"], 8 8 + "@pds/core/*": ["../core/*"] 9 9 + } 10 10 + }, 11 11 + "include": ["./**/*.js"], 12 12 + "exclude": [] 13 13 + }

+11

packages/deno/deno.json

··· 1 1 + { 2 2 + "name": "@pds/deno", 3 3 + "version": "0.7.0", 4 4 + "exports": "./index.js", 5 5 + "imports": { 6 6 + "@pds/core": "../core/index.js", 7 7 + "@pds/core/": "../core/", 8 8 + "@pds/storage-sqlite": "../storage-sqlite/index.js", 9 9 + "@pds/blobs-deno": "../blobs-deno/index.js" 10 10 + } 11 11 + }

+165

packages/deno/index.js

··· 1 1 + // @pds/deno - Deno HTTP server adapter 2 2 + /// <reference types="@types/deno" /> 3 3 + 4 4 + import { DatabaseSync } from 'node:sqlite'; 5 5 + import { PersonalDataServer } from '@pds/core'; 6 6 + import { createActorStorage, createSharedStorage } from '@pds/storage-sqlite'; 7 7 + import { createDenoBlobs } from '@pds/blobs-deno'; 8 8 + 9 9 + /** 10 10 + * Create WebSocket port for Deno 11 11 + * @returns {import('@pds/core/ports.js').WebSocketPort} 12 12 + */ 13 13 + function createWebSocketPort() { 14 14 + /** @type {Set<WebSocket>} */ 15 15 + const clients = new Set(); 16 16 + 17 17 + return { 18 18 + isUpgrade(request) { 19 19 + return request.headers.get('upgrade')?.toLowerCase() === 'websocket'; 20 20 + }, 21 21 + 22 22 + upgrade(request, onConnect) { 23 23 + const upgrade = Deno.upgradeWebSocket(request); 24 24 + const { socket, response } = upgrade; 25 25 + 26 26 + clients.add(socket); 27 27 + socket.onclose = () => clients.delete(socket); 28 28 + socket.onerror = () => clients.delete(socket); 29 29 + 30 30 + socket.onopen = () => { 31 31 + onConnect({ 32 32 + send(data) { 33 33 + if (socket.readyState === WebSocket.OPEN) { 34 34 + socket.send(data); 35 35 + } 36 36 + }, 37 37 + close() { 38 38 + socket.close(); 39 39 + }, 40 40 + }); 41 41 + }; 42 42 + 43 43 + return response; 44 44 + }, 45 45 + 46 46 + broadcast(data) { 47 47 + for (const client of clients) { 48 48 + if (client.readyState === WebSocket.OPEN) { 49 49 + try { 50 50 + client.send(data); 51 51 + } catch { 52 52 + // Client may have disconnected 53 53 + } 54 54 + } 55 55 + } 56 56 + }, 57 57 + }; 58 58 + } 59 59 + 60 60 + /** 61 61 + * @typedef {Object} PdsServer 62 62 + * @property {PersonalDataServer} pds - The PDS instance 63 63 + * @property {Deno.HttpServer | null} server - HTTP server (null until listen() called) 64 64 + * @property {DatabaseSync} db - SQLite database instance 65 65 + * @property {() => Promise<Deno.HttpServer>} listen - Start server 66 66 + * @property {() => Promise<void>} close - Close server 67 67 + */ 68 68 + 69 69 + /** 70 70 + * Create Deno PDS server 71 71 + * @param {Object} options 72 72 + * @param {string} options.dbPath - Path to SQLite database 73 73 + * @param {string} options.blobsDir - Directory for blob storage 74 74 + * @param {string} options.jwtSecret - JWT signing secret 75 75 + * @param {number} [options.port=3000] - Server port 76 76 + * @param {string} [options.hostname] - PDS hostname 77 77 + * @param {string} [options.appviewUrl] - AppView URL for proxying 78 78 + * @param {string} [options.appviewDid] - AppView DID for service auth 79 79 + * @param {string} [options.relayUrl] - Relay URL for firehose notifications 80 80 + * @param {string} [options.password] - Password for createSession 81 81 + * @returns {Promise<PdsServer>} 82 82 + */ 83 83 + export async function createServer({ 84 84 + dbPath, 85 85 + blobsDir, 86 86 + jwtSecret, 87 87 + port = 3000, 88 88 + hostname, 89 89 + appviewUrl, 90 90 + appviewDid, 91 91 + relayUrl, 92 92 + password, 93 93 + }) { 94 94 + const db = new DatabaseSync(dbPath); 95 95 + const actorStorage = createActorStorage(db); 96 96 + const sharedStorage = createSharedStorage(db); 97 97 + const blobs = createDenoBlobs(blobsDir); 98 98 + const webSocket = createWebSocketPort(); 99 99 + 100 100 + const pds = new PersonalDataServer({ 101 101 + actorStorage, 102 102 + sharedStorage, 103 103 + blobs, 104 104 + webSocket, 105 105 + jwtSecret, 106 106 + hostname, 107 107 + appviewUrl, 108 108 + appviewDid, 109 109 + relayUrl, 110 110 + password, 111 111 + }); 112 112 + 113 113 + /** @type {Deno.HttpServer | null} */ 114 114 + let server = null; 115 115 + /** @type {ReturnType<typeof setInterval> | null} */ 116 116 + let cleanupInterval = null; 117 117 + 118 118 + return { 119 119 + pds, 120 120 + get server() { 121 121 + return server; 122 122 + }, 123 123 + db, 124 124 + 125 125 + /** 126 126 + * Start listening on configured port 127 127 + * @returns {Promise<Deno.HttpServer>} 128 128 + */ 129 129 + listen() { 130 130 + return new Promise((resolve) => { 131 131 + server = Deno.serve({ port, onListen: () => { 132 132 + console.log(`PDS listening on http://localhost:${port}`); 133 133 + resolve(server); 134 134 + }}, (request) => pds.fetch(request)); 135 135 + 136 136 + // Start cleanup interval (every hour) 137 137 + cleanupInterval = setInterval( 138 138 + async () => { 139 139 + try { 140 140 + await pds.runBlobCleanup(); 141 141 + await sharedStorage.cleanupExpiredDpopJtis(); 142 142 + } catch (e) { 143 143 + console.error('Cleanup error:', e); 144 144 + } 145 145 + }, 146 146 + 60 * 60 * 1000, 147 147 + ); 148 148 + }); 149 149 + }, 150 150 + 151 151 + /** 152 152 + * Close server and cleanup 153 153 + * @returns {Promise<void>} 154 154 + */ 155 155 + async close() { 156 156 + if (cleanupInterval) { 157 157 + clearInterval(cleanupInterval); 158 158 + } 159 159 + if (server) { 160 160 + await server.shutdown(); 161 161 + } 162 162 + db.close(); 163 163 + }, 164 164 + }; 165 165 + }

+14

packages/deno/package.json

··· 1 1 + { 2 2 + "name": "@pds/deno", 3 3 + "version": "0.7.0", 4 4 + "type": "module", 5 5 + "exports": { 6 6 + ".": "./index.js" 7 7 + }, 8 8 + "dependencies": { 9 9 + "@pds/core": "workspace:*" 10 10 + }, 11 11 + "devDependencies": { 12 12 + "@types/deno": "^2.5.0" 13 13 + } 14 14 + }

+13

packages/deno/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "types": ["@types/deno"], 5 5 + "baseUrl": ".", 6 6 + "paths": { 7 7 + "@pds/core": ["../core/index.js"], 8 8 + "@pds/core/*": ["../core/*"] 9 9 + } 10 10 + }, 11 11 + "include": ["./**/*.js"], 12 12 + "exclude": [] 13 13 + }

-20

packages/node/index.js

··· 273 273 274 274 res.end(); 275 275 } 276 276 - 277 277 - /** 278 278 - * Create PDS server with configuration from environment variables 279 279 - * @param {Object} [overrides] - Override specific options 280 280 - * @returns {Promise<PdsServer>} 281 281 - */ 282 282 - export async function createServerFromEnv(overrides = {}) { 283 283 - return createServer({ 284 284 - dbPath: process.env.PDS_DB_PATH || './pds.db', 285 285 - blobsDir: process.env.PDS_BLOBS_DIR || './blobs', 286 286 - jwtSecret: process.env.JWT_SECRET || 'development-secret', 287 287 - port: parseInt(process.env.PORT || '3000', 10), 288 288 - hostname: process.env.HOSTNAME, 289 289 - appviewUrl: process.env.APPVIEW_URL, 290 290 - appviewDid: process.env.APPVIEW_DID, 291 291 - relayUrl: process.env.RELAY_URL, 292 292 - password: process.env.PDS_PASSWORD, 293 293 - ...overrides, 294 294 - }); 295 295 - }

+17

packages/storage-sqlite/driver.js

··· 1 1 + // @pds/storage-sqlite/driver - SQLite driver interface types 2 2 + // Both better-sqlite3 and node:sqlite implement this interface natively 3 3 + 4 4 + /** 5 5 + * @typedef {Object} SQLiteStatement 6 6 + * @property {(...args: any[]) => any} get - Single row query 7 7 + * @property {(...args: any[]) => any[]} all - Multi-row query 8 8 + * @property {(...args: any[]) => {changes: number | bigint}} run - Execute INSERT/UPDATE/DELETE 9 9 + */ 10 10 + 11 11 + /** 12 12 + * @typedef {Object} SQLiteDatabase 13 13 + * @property {(sql: string) => void} exec - Execute raw SQL (DDL, multiple statements) 14 14 + * @property {(sql: string) => SQLiteStatement} prepare - Create prepared statement 15 15 + */ 16 16 + 17 17 + export {};

+2 -2

packages/storage-sqlite/index.js

··· 23 23 24 24 /** 25 25 * Create storage adapter for better-sqlite3 (Node.js) 26 26 - * @param {import('better-sqlite3').Database} db 26 26 + * @param {import('./driver.js').SQLiteDatabase} db 27 27 * @returns {import('@pds/core/ports').ActorStoragePort} 28 28 */ 29 29 export function createActorStorage(db) { ··· 313 313 314 314 /** 315 315 * Create shared storage adapter for better-sqlite3 (Node.js) 316 316 - * @param {import('better-sqlite3').Database} db 316 316 + * @param {import('./driver.js').SQLiteDatabase} db 317 317 * @returns {import('@pds/core/ports').SharedStoragePort} 318 318 */ 319 319 export function createSharedStorage(db) {

+2 -1

packages/storage-sqlite/package.json

··· 5 5 "main": "index.js", 6 6 "types": "index.d.ts", 7 7 "exports": { 8 8 - ".": "./index.js" 8 8 + ".": "./index.js", 9 9 + "./driver": "./driver.js" 9 10 }, 10 11 "peerDependencies": { 11 12 "better-sqlite3": ">=9.0.0"

+27

pnpm-lock.yaml

··· 59 59 specifier: ^4.54.0 60 60 version: 4.58.0(@cloudflare/workers-types@4.20260111.0) 61 61 62 62 + examples/deno: 63 63 + devDependencies: 64 64 + '@types/deno': 65 65 + specifier: ^2.5.0 66 66 + version: 2.5.0 67 67 + 62 68 examples/node: 63 69 dependencies: 64 70 '@pds/node': ··· 68 74 specifier: ^12.6.0 69 75 version: 12.6.0 70 76 77 77 + packages/blobs-deno: 78 78 + devDependencies: 79 79 + '@types/deno': 80 80 + specifier: ^2.5.0 81 81 + version: 2.5.0 82 82 + 71 83 packages/blobs-fs: {} 72 84 73 85 packages/blobs-s3: {} ··· 79 91 version: link:../core 80 92 81 93 packages/core: {} 94 94 + 95 95 + packages/deno: 96 96 + dependencies: 97 97 + '@pds/core': 98 98 + specifier: workspace:* 99 99 + version: link:../core 100 100 + devDependencies: 101 101 + '@types/deno': 102 102 + specifier: ^2.5.0 103 103 + version: 2.5.0 82 104 83 105 packages/node: 84 106 dependencies: ··· 815 837 816 838 '@types/deep-eql@4.0.2': 817 839 resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==} 840 840 + 841 841 + '@types/deno@2.5.0': 842 842 + resolution: {integrity: sha512-g8JS38vmc0S87jKsFzre+0ZyMOUDHPVokEJymSCRlL57h6f/FdKPWBXgdFh3Z8Ees9sz11qt9VWELU9Y9ZkiVw==} 818 843 819 844 '@types/estree@1.0.8': 820 845 resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==} ··· 1800 1825 assertion-error: 2.0.1 1801 1826 1802 1827 '@types/deep-eql@4.0.2': {} 1828 1828 + 1829 1829 + '@types/deno@2.5.0': {} 1803 1830 1804 1831 '@types/estree@1.0.8': {} 1805 1832

+18 -4

test/e2e.test.js

··· 1 1 /** 2 2 - * E2E tests for PDS - runs against local wrangler dev or Node.js server 2 2 + * E2E tests for PDS - runs against local wrangler dev, Node.js, or Deno server 3 3 * Uses Vitest and fetch 4 4 */ 5 5 ··· 13 13 stopNodeServer, 14 14 USE_LOCAL_INFRA, 15 15 } from './helpers/node-server.js'; 16 16 + import { 17 17 + startDenoServer, 18 18 + stopDenoServer, 19 19 + } from './helpers/deno-server.js'; 16 20 import { getOAuthTokenWithScope, setBaseUrl } from './helpers/oauth.js'; 17 21 import { ensureDockerServices, RELAY_URL } from './helpers/docker-services.js'; 18 22 import { createTestIdentity } from './helpers/identity.js'; 19 23 20 24 const PLATFORM = process.env.PLATFORM || 'cloudflare'; 21 25 const BASE = 22 22 - PLATFORM === 'node' ? 'http://localhost:3000' : 'http://localhost:8787'; 26 26 + PLATFORM === 'node' || PLATFORM === 'deno' 27 27 + ? 'http://localhost:3000' 28 28 + : 'http://localhost:8787'; 23 29 24 30 // Configure oauth helper to use the same BASE 25 31 setBaseUrl(BASE); ··· 134 140 let wrangler = null; 135 141 /** @type {{close: () => Promise<void>}|null} */ 136 142 let nodeServer = null; 143 143 + /** @type {{close: () => Promise<void>}|null} */ 144 144 + let denoServer = null; 137 145 /** @type {string} */ 138 146 let token = ''; 139 147 /** @type {string} */ ··· 150 158 if (PLATFORM === 'node') { 151 159 // Start Node.js server 152 160 nodeServer = await startNodeServer(); 161 161 + } else if (PLATFORM === 'deno') { 162 162 + // Start Deno server 163 163 + denoServer = await startDenoServer(); 153 164 } else { 154 165 // Clear wrangler state for clean slate (like docker reset for node) 155 166 const { rmSync } = await import('node:fs'); ··· 220 231 afterAll(async () => { 221 232 if (PLATFORM === 'node') { 222 233 if (nodeServer) await stopNodeServer(nodeServer); 234 234 + } else if (PLATFORM === 'deno') { 235 235 + if (denoServer) await stopDenoServer(denoServer); 223 236 } else { 224 237 if (wrangler) wrangler.kill(); 225 238 } ··· 2124 2137 describe('Relay sync (requires docker)', () => { 2125 2138 // Skip entire suite if docker infrastructure is disabled or using cloudflare 2126 2139 // Cloudflare wrangler isn't accessible from Docker through Caddy 2127 2127 - const skipRelaySyncTests = !USE_LOCAL_INFRA || PLATFORM !== 'node'; 2140 2140 + const skipRelaySyncTests = 2141 2141 + !USE_LOCAL_INFRA || (PLATFORM !== 'node' && PLATFORM !== 'deno'); 2128 2142 2129 2143 beforeAll(() => { 2130 2144 if (skipRelaySyncTests) { 2131 2145 console.log( 2132 2132 - 'Skipping relay sync tests (requires USE_LOCAL_INFRA=true and PLATFORM=node)', 2146 2146 + 'Skipping relay sync tests (requires USE_LOCAL_INFRA=true and PLATFORM=node or deno)', 2133 2147 ); 2134 2148 } 2135 2149 });

+111

test/helpers/deno-server.js

··· 1 1 + // test/helpers/deno-server.js 2 2 + import { spawn } from 'node:child_process'; 3 3 + import { mkdirSync, rmSync } from 'node:fs'; 4 4 + 5 5 + const TEST_DATA_DIR = './test-data'; 6 6 + const TEST_PORT = 3000; 7 7 + const USE_LOCAL_INFRA = process.env.USE_LOCAL_INFRA !== 'false'; 8 8 + 9 9 + /** @type {import('node:child_process').ChildProcess | null} */ 10 10 + let denoProcess = null; 11 11 + 12 12 + /** 13 13 + * Start Deno PDS server for e2e tests 14 14 + * Spawns Deno process running examples/deno/main.ts 15 15 + * @returns {Promise<{close: () => Promise<void>}>} Server instance with close() method 16 16 + */ 17 17 + export async function startDenoServer() { 18 18 + // Fresh data each run 19 19 + rmSync(TEST_DATA_DIR, { recursive: true, force: true }); 20 20 + mkdirSync(TEST_DATA_DIR, { recursive: true }); 21 21 + 22 22 + const hostname = USE_LOCAL_INFRA 23 23 + ? 'host.docker.internal:3443' 24 24 + : `localhost:${TEST_PORT}`; 25 25 + 26 26 + const env = { 27 27 + ...process.env, 28 28 + PDS_DB_PATH: `${TEST_DATA_DIR}/pds.db`, 29 29 + PDS_BLOBS_DIR: `${TEST_DATA_DIR}/blobs`, 30 30 + JWT_SECRET: 'test-secret-for-e2e', 31 31 + HOSTNAME: hostname, 32 32 + PORT: String(TEST_PORT), 33 33 + PDS_PASSWORD: 'test-password', 34 34 + RELAY_URL: USE_LOCAL_INFRA ? 'http://localhost:2470' : '', 35 35 + APPVIEW_URL: 'https://api.bsky.app', 36 36 + APPVIEW_DID: 'did:web:api.bsky.app', 37 37 + }; 38 38 + 39 39 + denoProcess = spawn( 40 40 + 'deno', 41 41 + [ 42 42 + 'run', 43 43 + '--allow-net', 44 44 + '--allow-read', 45 45 + '--allow-write', 46 46 + '--allow-env', 47 47 + '--unstable-ffi', 48 48 + 'examples/deno/main.ts', 49 49 + ], 50 50 + { 51 51 + env, 52 52 + stdio: ['ignore', 'pipe', 'pipe'], 53 53 + cwd: process.cwd(), 54 54 + }, 55 55 + ); 56 56 + 57 57 + // Log output for debugging 58 58 + denoProcess.stdout?.on('data', (data) => { 59 59 + const msg = data.toString().trim(); 60 60 + if (msg) console.log(`[deno] ${msg}`); 61 61 + }); 62 62 + 63 63 + denoProcess.stderr?.on('data', (data) => { 64 64 + const msg = data.toString().trim(); 65 65 + if (msg) console.error(`[deno] ${msg}`); 66 66 + }); 67 67 + 68 68 + // Wait for server to be ready 69 69 + await waitForReady(); 70 70 + 71 71 + return { 72 72 + async close() { 73 73 + if (denoProcess) { 74 74 + denoProcess.kill('SIGTERM'); 75 75 + // Wait for process to exit 76 76 + await new Promise((resolve) => { 77 77 + denoProcess?.on('exit', resolve); 78 78 + // Timeout after 5s 79 79 + setTimeout(resolve, 5000); 80 80 + }); 81 81 + denoProcess = null; 82 82 + } 83 83 + }, 84 84 + }; 85 85 + } 86 86 + 87 87 + /** 88 88 + * Wait for Deno server to be ready 89 89 + */ 90 90 + async function waitForReady(maxAttempts = 30) { 91 91 + for (let i = 0; i < maxAttempts; i++) { 92 92 + try { 93 93 + const res = await fetch(`http://localhost:${TEST_PORT}/`); 94 94 + if (res.ok) return; 95 95 + } catch { 96 96 + // Server not ready yet 97 97 + } 98 98 + await new Promise((r) => setTimeout(r, 500)); 99 99 + } 100 100 + throw new Error('Deno server failed to start'); 101 101 + } 102 102 + 103 103 + /** 104 104 + * Stop Deno PDS server 105 105 + * @param {{close: () => Promise<void>}} server - Server instance from startDenoServer 106 106 + */ 107 107 + export async function stopDenoServer(server) { 108 108 + await server.close(); 109 109 + } 110 110 + 111 111 + export { USE_LOCAL_INFRA, TEST_PORT };

+1 -1

tsconfig.json

··· 24 24 } 25 25 }, 26 26 "include": ["src/**/*.js", "packages/**/*.js", "test/**/*.js"], 27 27 - "exclude": ["node_modules"] 27 27 + "exclude": ["node_modules", "packages/deno", "packages/blobs-deno", "examples/deno"] 28 28 }