@atproto/pds 0.5.12 → 0.5.14

package/tests/proxied/proxy-catchall.test.ts

@@ -1,256 +0,0 @@
-import { once } from 'node:events'
-import http from 'node:http'
-import { AddressInfo } from 'node:net'
-import { setTimeout as sleep } from 'node:timers/promises'
-import * as plc from '@did-plc/lib'
-import express from 'express'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import AtpAgent from '@atproto/api'
-import { Keypair } from '@atproto/crypto'
-import { TestNetworkNoAppView } from '@atproto/dev-env'
-import { LexiconDocument } from '@atproto/lex-document'
-
-const lexicons = [
-  {
-    lexicon: 1,
-    id: 'com.example.ok',
-    defs: {
-      main: {
-        type: 'query',
-        output: {
-          encoding: 'application/json',
-          schema: { type: 'object', properties: { foo: { type: 'string' } } },
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'com.example.slow',
-    defs: {
-      main: {
-        type: 'query',
-        output: {
-          encoding: 'application/json',
-          schema: { type: 'object', properties: { foo: { type: 'string' } } },
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'com.example.abort',
-    defs: {
-      main: {
-        type: 'query',
-        output: {
-          encoding: 'application/json',
-          schema: { type: 'object', properties: { foo: { type: 'string' } } },
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'com.example.error',
-    defs: {
-      main: {
-        type: 'query',
-        output: {
-          encoding: 'application/json',
-          schema: { type: 'object', properties: { foo: { type: 'string' } } },
-        },
-      },
-    },
-  },
-] as const satisfies LexiconDocument[]
-
-describe('proxy header', () => {
-  let network: TestNetworkNoAppView
-  let alice: AtpAgent
-
-  let proxyServer: ProxyServer
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'proxy_catchall',
-    })
-
-    const serviceId = 'proxy_test'
-
-    proxyServer = await ProxyServer.create(
-      network.pds.ctx.plcClient,
-      network.pds.ctx.plcRotationKey,
-      serviceId,
-    )
-
-    alice = network.pds.getAgent().withProxy(serviceId, proxyServer.did)
-
-    for (const lex of lexicons) alice.lex.add(lex)
-
-    await alice.createAccount({
-      email: 'alice@test.com',
-      handle: 'alice.test',
-      password: 'alice-pass',
-    })
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await proxyServer?.close()
-    await network?.close()
-  })
-
-  it('rejects when upstream unavailable', async () => {
-    const serviceId = 'foo_bar'
-
-    const proxyServer = await ProxyServer.create(
-      network.pds.ctx.plcClient,
-      network.pds.ctx.plcRotationKey,
-      serviceId,
-    )
-
-    // Make sure the service is not available
-    await proxyServer.close()
-
-    const client = alice.withProxy(serviceId, proxyServer.did)
-    for (const lex of lexicons) client.lex.add(lex)
-
-    await expect(client.call('com.example.ok')).rejects.toThrow(
-      'Upstream service unreachable',
-    )
-  })
-
-  it('successfully proxies requests', async () => {
-    await expect(alice.call('com.example.ok')).resolves.toMatchObject({
-      data: { foo: 'ok' },
-      success: true,
-    })
-  })
-
-  it('handles cancelled upstream requests', async () => {
-    await expect(alice.call('com.example.abort')).rejects.toThrow('terminated')
-  })
-
-  it('handles failing upstream requests', async () => {
-    await expect(alice.call('com.example.error')).rejects.toThrow(
-      expect.objectContaining({
-        status: 502,
-        error: 'FooBar',
-        message: 'My message',
-      }),
-    )
-  })
-
-  it('handles cancelled downstream requests', async () => {
-    const ac = new AbortController()
-
-    setTimeout(() => ac.abort(), 20)
-
-    await expect(
-      alice.call('com.example.slow', {}, undefined, { signal: ac.signal }),
-    ).rejects.toThrow('This operation was aborted')
-
-    await expect(alice.call('com.example.slow')).resolves.toMatchObject({
-      data: { foo: 'slow' },
-      success: true,
-    })
-  })
-})
-
-class ProxyServer {
-  private terminator: httpTerminator.HttpTerminator
-
-  constructor(
-    server: http.Server,
-    public did: string,
-  ) {
-    this.terminator = httpTerminator.createHttpTerminator({ server })
-  }
-
-  static async create(
-    plcClient: plc.Client,
-    keypair: Keypair,
-    serviceId: string,
-  ): Promise<ProxyServer> {
-    const app = express()
-
-    app.get('/xrpc/com.example.ok', (req, res) => {
-      res.status(200)
-      res.setHeader('content-type', 'application/json')
-      res.send('{"foo":"ok"}')
-    })
-
-    app.get('/xrpc/com.example.slow', async (req, res) => {
-      const wait = async (ms: number) => {
-        if (res.destroyed) return
-        const ac = new AbortController()
-        const abort = () => ac.abort()
-        res.on('close', abort)
-        try {
-          await sleep(ms, undefined, { signal: ac.signal })
-        } finally {
-          res.off('close', abort)
-        }
-      }
-
-      await wait(50)
-
-      res.status(200)
-      res.setHeader('content-type', 'application/json')
-      res.flushHeaders()
-
-      await wait(50)
-
-      for (const char of '{"foo":"slow"}') {
-        res.write(char)
-        await wait(10)
-      }
-
-      res.end()
-    })
-
-    app.get('/xrpc/com.example.abort', async (req, res) => {
-      res.status(200)
-      res.setHeader('content-type', 'application/json')
-      res.write('{"foo"')
-      await sleep(50)
-      res.destroy(new Error('abort'))
-    })
-
-    app.get('/xrpc/com.example.error', async (req, res) => {
-      res.status(500).json({ error: 'FooBar', message: 'My message' })
-    })
-
-    const server = app.listen(0)
-    server.keepAliveTimeout = 30 * 1000
-    server.headersTimeout = 35 * 1000
-    await once(server, 'listening')
-    const { port } = server.address() as AddressInfo
-
-    const plcOp = await plc.signOperation(
-      {
-        type: 'plc_operation',
-        rotationKeys: [keypair.did()],
-        alsoKnownAs: [],
-        verificationMethods: {},
-        services: {
-          [serviceId]: {
-            type: 'TestAtprotoService',
-            endpoint: `http://localhost:${port}`,
-          },
-        },
-        prev: null,
-      },
-      keypair,
-    )
-    const did = await plc.didForCreateOp(plcOp)
-    await plcClient.sendOperation(did, plcOp)
-    return new ProxyServer(server, did)
-  }
-
-  async close() {
-    await this.terminator.terminate()
-  }
-}

package/tests/proxied/proxy-header.test.ts

@@ -1,239 +0,0 @@
-import assert from 'node:assert'
-import { once } from 'node:events'
-import http from 'node:http'
-import { AddressInfo } from 'node:net'
-import * as plc from '@did-plc/lib'
-import express from 'express'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { Keypair } from '@atproto/crypto'
-import { SeedClient, TestNetworkNoAppView, usersSeed } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import { verifyJwt } from '@atproto/xrpc-server'
-import { parseProxyHeader } from '../../src/pipethrough.js'
-
-describe('proxy header', () => {
-  let network: TestNetworkNoAppView
-  let sc: SeedClient
-
-  let alice: DidString
-
-  let proxyServer: ProxyServer
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'proxy_header',
-    })
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-
-    proxyServer = await ProxyServer.create(
-      network.pds.ctx.plcClient,
-      network.pds.ctx.plcRotationKey,
-      'atproto_test',
-    )
-
-    alice = sc.dids.alice
-    await network.processAll()
-  }, 20_000) // @NOTE seeding can take a while
-
-  afterAll(async () => {
-    await proxyServer?.close()
-    await network?.close()
-  })
-
-  it('parses proxy header', async () => {
-    expect(parseProxyHeader(network.pds.ctx, `#atproto_test`)).rejects.toThrow(
-      'no did specified in proxy header',
-    )
-
-    expect(
-      parseProxyHeader(network.pds.ctx, `${proxyServer.did}#atproto_test#foo`),
-    ).rejects.toThrow('invalid proxy header format')
-
-    expect(
-      parseProxyHeader(network.pds.ctx, `${proxyServer.did}#atproto_test `),
-    ).rejects.toThrow('proxy header cannot contain spaces')
-
-    expect(
-      parseProxyHeader(network.pds.ctx, ` ${proxyServer.did}#atproto_test`),
-    ).rejects.toThrow('proxy header cannot contain spaces')
-
-    expect(parseProxyHeader(network.pds.ctx, `did:foo#bar`)).rejects.toThrow(
-      'Poorly formatted DID: did:foo',
-    )
-
-    expect(
-      parseProxyHeader(network.pds.ctx, `did:foo:bar#baz`),
-    ).rejects.toThrow('Unsupported DID method: did:foo:bar')
-
-    expect(
-      parseProxyHeader(network.pds.ctx, `did:toString:foo#bar`),
-    ).rejects.toThrow('Unsupported DID method: did:toString:foo')
-
-    expect(parseProxyHeader(network.pds.ctx, `foo#bar`)).rejects.toThrow(
-      'Poorly formatted DID: foo',
-    )
-
-    expect(
-      parseProxyHeader(network.pds.ctx, `${proxyServer.did}#atproto_test`),
-    ).resolves.toEqual({
-      did: proxyServer.did,
-      url: proxyServer.url,
-      serviceId: 'atproto_test',
-    })
-  })
-
-  it('proxies requests based on header', async () => {
-    const path = `/xrpc/app.bsky.actor.getProfile?actor=${alice}`
-    await fetch(`${network.pds.url}${path}`, {
-      headers: {
-        ...sc.getHeaders(alice),
-        'atproto-proxy': `${proxyServer.did}#atproto_test`,
-      },
-    })
-    const req = proxyServer.requests.at(-1)
-    assert(req)
-    expect(req.url).toEqual(path)
-    assert(req.auth)
-    const verified = await verifyJwt(
-      req.auth.replace('Bearer ', ''),
-      proxyServer.did,
-      'app.bsky.actor.getProfile',
-      (iss) => network.pds.ctx.idResolver.did.resolveAtprotoKey(iss, true),
-    )
-    expect(verified.aud).toBe(proxyServer.did)
-    expect(verified.iss).toBe(alice)
-  })
-
-  it('fails on a non-existant did', async () => {
-    const path = `/xrpc/app.bsky.actor.getProfile?actor=${alice}`
-    const response = await fetch(`${network.pds.url}${path}`, {
-      headers: {
-        ...sc.getHeaders(alice),
-        'atproto-proxy': `did:plc:12345678123456781234578#atproto_test`,
-      },
-    })
-
-    await expect(response.json()).resolves.toMatchObject({
-      message: 'could not resolve proxy did',
-    })
-
-    expect(proxyServer.requests.length).toBe(1)
-  })
-
-  it('fails when a service is not specified', async () => {
-    const path = `/xrpc/app.bsky.actor.getProfile?actor=${alice}`
-    const response = await fetch(`${network.pds.url}${path}`, {
-      headers: {
-        ...sc.getHeaders(alice),
-        'atproto-proxy': proxyServer.did,
-      },
-    })
-
-    await expect(response.json()).resolves.toMatchObject({
-      message: 'no service id specified in proxy header',
-    })
-
-    expect(proxyServer.requests.length).toBe(1)
-  })
-
-  it('fails on a non-existant service', async () => {
-    const path = `/xrpc/app.bsky.actor.getProfile?actor=${alice}`
-    const response = await fetch(`${network.pds.url}${path}`, {
-      headers: {
-        ...sc.getHeaders(alice),
-        'atproto-proxy': `${proxyServer.did}#atproto_bad`,
-      },
-    })
-
-    await expect(response.json()).resolves.toMatchObject({
-      message: 'could not resolve proxy did service url',
-    })
-
-    expect(proxyServer.requests.length).toBe(1)
-  })
-
-  it('handles failing manual pipethroughs', async () => {
-    // This is a PDS endpoint which uses a manual pipethrough() in its handler
-    const path = '/xrpc/app.bsky.actor.getPreferences'
-    const res = await fetch(`${network.pds.url}${path}`, {
-      headers: {
-        ...sc.getHeaders(alice),
-        'atproto-proxy': `${proxyServer.did}#atproto_test`,
-      },
-    })
-    await res.arrayBuffer() // drain
-    expect(res.status).toBe(501)
-  })
-})
-
-type ProxyReq = {
-  url: string
-  auth: string | undefined
-}
-
-class ProxyServer {
-  private terminator: httpTerminator.HttpTerminator
-
-  constructor(
-    server: http.Server,
-    public url: string,
-    public did: string,
-    public requests: ProxyReq[],
-  ) {
-    this.terminator = httpTerminator.createHttpTerminator({ server })
-  }
-
-  static async create(
-    plcClient: plc.Client,
-    keypair: Keypair,
-    serviceId: string,
-  ): Promise<ProxyServer> {
-    const requests: ProxyReq[] = []
-    const app = express()
-
-    // This is a PDS endpoint which uses a manual pipethrough() in its handler
-    app.get('/xrpc/app.bsky.actor.getPreferences', (req, res) => {
-      res.sendStatus(501)
-    })
-
-    app.get('*', (req, res) => {
-      requests.push({
-        url: req.url,
-        auth: req.header('authorization'),
-      })
-      res.sendStatus(200)
-    })
-
-    const server = app.listen(0)
-    await once(server, 'listening')
-
-    const { port } = server.address() as AddressInfo
-
-    const url = `http://localhost:${port}`
-    const plcOp = await plc.signOperation(
-      {
-        type: 'plc_operation',
-        rotationKeys: [keypair.did()],
-        alsoKnownAs: [],
-        verificationMethods: {},
-        services: {
-          [serviceId]: {
-            type: 'TestAtprotoService',
-            endpoint: url,
-          },
-        },
-        prev: null,
-      },
-      keypair,
-    )
-    const did = await plc.didForCreateOp(plcOp)
-    await plcClient.sendOperation(did, plcOp)
-    return new ProxyServer(server, url, did, requests)
-  }
-
-  async close(): Promise<void> {
-    await this.terminator.terminate()
-  }
-}

package/tests/proxied/proxy-oauth-aud.test.ts

@@ -1,182 +0,0 @@
-import { once } from 'node:events'
-import http from 'node:http'
-import { AddressInfo } from 'node:net'
-import * as plc from '@did-plc/lib'
-import express from 'express'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { Keypair } from '@atproto/crypto'
-import { SeedClient, TestNetworkNoAppView, usersSeed } from '@atproto/dev-env'
-import { ScopePermissions } from '@atproto/oauth-scopes'
-import { DidString } from '@atproto/syntax'
-import { AppContext } from '../../src/context.js'
-import { proxyHandler } from '../../src/pipethrough.js'
-
-// Regression test for the OAuth service-proxying audience fix.
-//
-// Before the fix, proxyHandler passed a bare DID as `aud` to the rpc scope
-// check. An OAuth caller granted `rpc:<lxm>?aud=<did>#<serviceId>` (the
-// canonical scope shape used in atproto OAuth) had no way to match, so
-// proxied calls failed at the scope check. The fix combines the proxied
-// service id into the scope-check audience as `<did>#<serviceId>`.
-//
-// We use a real PDS AppContext (so every field is real-typed). Only the
-// `authVerifier.authorization` method is replaced, with a thin stub that
-// drives the OAuth path off an `x-test-scope` request header — letting us
-// exercise the rpc scope check without minting a real OAuth token. A
-// separate express app mounts a fresh proxyHandler against the real ctx
-// and forwards to a real upstream ProxyServer.
-
-describe('proxy oauth audience', () => {
-  let network: TestNetworkNoAppView
-  let sc: SeedClient
-  let alice: string
-  let upstream: ProxyServer
-  let terminator: httpTerminator.HttpTerminator
-  let serverUrl: string
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'proxy_oauth_aud',
-    })
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-    alice = sc.dids.alice
-    upstream = await ProxyServer.create(
-      network.pds.ctx.plcClient,
-      network.pds.ctx.plcRotationKey,
-      'atproto_test',
-    )
-
-    // Replace only the `authorization` method on the real AuthVerifier so
-    // every other ctx field stays real and real-typed. The override's
-    // signature is constrained by AuthVerifier['authorization']: an OAuth
-    // shape change in the real verifier breaks the body of this stub at
-    // compile time.
-    const stubAuthorization: typeof network.pds.ctx.authVerifier.authorization =
-      ({ authorize }) => {
-        return async (ctx) => {
-          const scopeHeader = ctx.req.headers['x-test-scope'] as
-            | string
-            | undefined
-          const permissions = new ScopePermissions(
-            scopeHeader?.split(' ') ?? [],
-          )
-          await authorize(permissions, ctx)
-          return {
-            credentials: {
-              type: 'oauth',
-              did: alice as DidString,
-              permissions,
-            },
-          }
-        }
-      }
-    network.pds.ctx.authVerifier.authorization = stubAuthorization
-
-    const app = express()
-    // dev-env exports AppContext from its built dist/, while we import
-    // proxyHandler from src/. Cast at this boundary to bridge the two
-    // identical shapes; downstream behavior is real.
-    app.all('/xrpc/*', proxyHandler(network.pds.ctx as unknown as AppContext))
-    app.use(
-      (
-        err: Error & { status?: number; statusCode?: number },
-        _req: express.Request,
-        res: express.Response,
-        _next: express.NextFunction,
-      ) => {
-        if (res.headersSent) return
-        res.status(err.status ?? err.statusCode ?? 500).end()
-      },
-    )
-    const server = app.listen(0)
-    await once(server, 'listening')
-    terminator = httpTerminator.createHttpTerminator({ server })
-    serverUrl = `http://localhost:${(server.address() as AddressInfo).port}`
-  })
-
-  afterAll(async () => {
-    await Promise.all([
-      terminator?.terminate(),
-      upstream?.close(),
-      network?.close(),
-    ])
-  })
-
-  it('matches an OAuth rpc scope granted with combined did#serviceId aud', async () => {
-    // Pre-fix this would have rejected because the scope check received
-    // bare-DID aud and never matched the combined-form scope. A 200 here
-    // implies the scope check ran with combined-form aud.
-    const res = await fetch(`${serverUrl}/xrpc/app.bsky.feed.getFeed`, {
-      headers: {
-        'atproto-proxy': `${upstream.did}#atproto_test`,
-        'x-test-scope': `rpc:app.bsky.feed.getFeed?aud=${encodeURIComponent(`${upstream.did}#atproto_test`)}`,
-      },
-    })
-    expect(res.status).toBe(200)
-  })
-
-  it('rejects an OAuth rpc scope granted for a different service id', async () => {
-    // Same DID, different service id — both forms parse as valid scope
-    // audiences, but the runtime aud (`upstream.did#atproto_test`) doesn't
-    // match the granted aud (`upstream.did#atproto_other`).
-    const res = await fetch(`${serverUrl}/xrpc/app.bsky.feed.getFeed`, {
-      headers: {
-        'atproto-proxy': `${upstream.did}#atproto_test`,
-        'x-test-scope': `rpc:app.bsky.feed.getFeed?aud=${encodeURIComponent(`${upstream.did}#atproto_other`)}`,
-      },
-    })
-    expect([401, 403]).toContain(res.status)
-  })
-})
-
-class ProxyServer {
-  private terminator: httpTerminator.HttpTerminator
-
-  constructor(
-    server: http.Server,
-    public url: string,
-    public did: string,
-  ) {
-    this.terminator = httpTerminator.createHttpTerminator({ server })
-  }
-
-  static async create(
-    plcClient: plc.Client,
-    keypair: Keypair,
-    serviceId: string,
-  ): Promise<ProxyServer> {
-    const app = express()
-    app.all('*', (_req, res) => res.sendStatus(200))
-
-    const server = app.listen(0)
-    await once(server, 'listening')
-
-    const { port } = server.address() as AddressInfo
-    const url = `http://localhost:${port}`
-    const plcOp = await plc.signOperation(
-      {
-        type: 'plc_operation',
-        rotationKeys: [keypair.did()],
-        alsoKnownAs: [],
-        verificationMethods: {},
-        services: {
-          [serviceId]: {
-            type: 'TestAtprotoService',
-            endpoint: url,
-          },
-        },
-        prev: null,
-      },
-      keypair,
-    )
-    const did = await plc.didForCreateOp(plcOp)
-    await plcClient.sendOperation(did, plcOp)
-    return new ProxyServer(server, url, did)
-  }
-
-  close(): Promise<void> {
-    return this.terminator.terminate()
-  }
-}