@atproto/pds 0.5.12 → 0.5.15

package/src/well-known.ts

@@ -1,30 +0,0 @@
-import { Router } from 'express'
-import { HandleString } from '@atproto/syntax'
-import { AppContext } from './context.js'
-
-export const createRouter = (ctx: AppContext): Router => {
-  const router = Router()
-
-  router.get('/.well-known/atproto-did', async function (req, res) {
-    const handle = req.hostname as HandleString
-    const supportedHandle = ctx.cfg.identity.serviceHandleDomains.some(
-      (host) => handle.endsWith(host) || handle === host.slice(1),
-    )
-    if (!supportedHandle) {
-      return res.status(404).send('User not found')
-    }
-    let did: string | undefined
-    try {
-      const user = await ctx.accountManager.getAccount(handle)
-      did = user?.did
-    } catch (err) {
-      return res.status(500).send('Internal Server Error')
-    }
-    if (!did) {
-      return res.status(404).send('User not found')
-    }
-    res.type('text/plain').send(did)
-  })
-
-  return router
-}

package/test.env

@@ -1,2 +0,0 @@
-LOG_ENABLED=true
-LOG_DESTINATION=test.log

package/tests/__snapshots__/takedown-appeal.test.ts.snap

@@ -1,43 +0,0 @@
-// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
-
-exports[`appeal account takedown actor takedown allows appeal request. 1`] = `
-{
-  "accountStats": {
-    "$type": "tools.ozone.moderation.defs#accountStats",
-    "appealCount": 0,
-    "escalateCount": 0,
-    "reportCount": 0,
-    "suspendCount": 0,
-    "takedownCount": 1,
-  },
-  "ageAssuranceState": "unknown",
-  "appealed": true,
-  "createdAt": "1970-01-01T00:00:00.000Z",
-  "hosting": {
-    "$type": "tools.ozone.moderation.defs#accountHosting",
-    "status": "unknown",
-  },
-  "id": 1,
-  "lastAppealedAt": "1970-01-01T00:00:00.000Z",
-  "lastReportedAt": "1970-01-01T00:00:00.000Z",
-  "lastReviewedAt": "1970-01-01T00:00:00.000Z",
-  "lastReviewedBy": "user(0)",
-  "priorityScore": 0,
-  "recordsStats": {
-    "$type": "tools.ozone.moderation.defs#recordsStats",
-  },
-  "reviewState": "tools.ozone.moderation.defs#reviewEscalated",
-  "subject": {
-    "$type": "com.atproto.admin.defs#repoRef",
-    "did": "user(1)",
-  },
-  "subjectBlobCids": [],
-  "subjectRepoHandle": "jeff.test",
-  "tags": [
-    "lang:und",
-    "report:appeal",
-  ],
-  "takendown": true,
-  "updatedAt": "1970-01-01T00:00:00.000Z",
-}
-`;

package/tests/_oauth_client_assets_middleware.ts

@@ -1,23 +0,0 @@
-import { IncomingMessage, ServerResponse } from 'node:http'
-import files from '@atproto/oauth-client-browser-example' with { type: 'json' }
-
-export function oauthClientAssetsMiddleware(
-  req: IncomingMessage,
-  res: ServerResponse,
-  next?: (err?: unknown) => void,
-): void {
-  const path = req.url?.split('?')[0].slice(1) || 'index.html'
-  const file = Object.hasOwn(files, path) ? files[path] : null
-
-  if (file) {
-    res
-      .writeHead(200, 'OK', { 'content-type': file.mime })
-      .end(Buffer.from(file.data, 'base64'))
-  } else if (next) {
-    next()
-  } else {
-    res
-      .writeHead(404, 'Not Found', { 'content-type': 'text/plain' })
-      .end('Page not found')
-  }
-}

package/tests/_puppeteer.ts

@@ -1,147 +0,0 @@
-import assert from 'node:assert'
-import { type Browser, Handler, type Page, Target, TargetType } from 'puppeteer'
-
-export class PageHelper implements AsyncDisposable {
-  constructor(protected readonly page: Page) {}
-
-  async goto(url: string | URL) {
-    await this.page.goto(url.toString())
-  }
-
-  isClosed() {
-    return this.page.isClosed()
-  }
-
-  async title() {
-    await this.waitForNetworkIdle()
-    return this.page.title()
-  }
-
-  async waitForNetworkIdle() {
-    await this.page.waitForNetworkIdle()
-  }
-
-  async waitForPopup(run: () => Promise<unknown>): Promise<PageHelper> {
-    const browser = this.page.browser()
-    const popupPromise = new Promise<Page | null>((resolve, reject) => {
-      const cleanup = () => {
-        clearTimeout(timeout)
-        browser.off('targetcreated', targetcreated)
-      }
-
-      const timeout = setTimeout(() => {
-        cleanup()
-        reject(new Error('Timeout waiting for popup'))
-      }, 5_000)
-
-      const targetcreated: Handler<Target> = async (target) => {
-        switch (target.type()) {
-          case TargetType.BACKGROUND_PAGE:
-          case TargetType.PAGE: {
-            cleanup()
-            resolve(target.page())
-          }
-        }
-      }
-
-      browser.once('targetcreated', targetcreated)
-    })
-
-    await run()
-    const popup = await popupPromise
-    assert(popup, 'Popup page not found')
-
-    return new PageHelper(popup)
-  }
-
-  async navigationAction(run: () => unknown | Promise<unknown>): Promise<void> {
-    const promise = this.page.waitForNavigation({ timeout: 10_000 })
-    await run()
-    await promise
-  }
-
-  async navigationClick(text: string, tag = 'button') {
-    return this.navigationAction(() => this.clickOnText(text, tag))
-  }
-
-  async assertTitle(expected: string) {
-    await expect(this.title()).resolves.toBe(expected)
-  }
-
-  async clickOn(selector: string) {
-    const elementHandle = await this.getVisibleElement(selector)
-    await elementHandle.click()
-    return elementHandle
-  }
-
-  async clickOnText(text: string, tag = 'button') {
-    return this.clickOn(`${tag}::-p-text(${JSON.stringify(text)})`)
-  }
-
-  async clickOnAriaLabel(label: string, tag = 'button') {
-    return this.clickOn(`${tag}[aria-label=${JSON.stringify(label)}]`)
-  }
-
-  async typeIn(selector: string, text: string) {
-    const elementHandle = await this.getVisibleElement(selector)
-    elementHandle.focus()
-    await elementHandle.click({ clickCount: 3 }) // Select all existing text
-    await elementHandle.press('Backspace') // Clear the input
-    await elementHandle.type(text)
-    return elementHandle
-  }
-
-  async typeInInput(name: string, text: string) {
-    return this.typeIn(`input[name=${JSON.stringify(name)}]`, text)
-  }
-
-  async ensureTextVisibility(text: string, tag = 'p', timeout = 5_000) {
-    await this.page.waitForSelector(
-      `${tag}::-p-text(${JSON.stringify(text)})`,
-      {
-        visible: true,
-        timeout,
-      },
-    )
-  }
-
-  async ensureNotification(text: string) {
-    return this.ensureTextVisibility(text, 'div')
-  }
-
-  protected async getVisibleElement(selector: string) {
-    const elementHandle = await this.page.waitForSelector(selector, {
-      visible: true,
-      timeout: 5_000,
-    })
-
-    assert(elementHandle, `Element not found: ${selector}`)
-
-    return elementHandle
-  }
-
-  async [Symbol.asyncDispose]() {
-    return this.page.close()
-  }
-
-  static async from(
-    browser: Browser,
-    options?: { languages?: readonly string[] },
-  ) {
-    const page = await browser.newPage()
-
-    if (options?.languages?.length) {
-      // Spoof navigator language settings
-      await page.evaluateOnNewDocument(`
-        Object.defineProperty(navigator, 'languages', {
-          get: () => ${JSON.stringify(options.languages)},
-        })
-        Object.defineProperty(navigator, 'language', {
-          get: () => ${JSON.stringify(options.languages[0])},
-        })
-      `)
-    }
-
-    return new PageHelper(page)
-  }
-}

package/tests/_types.d.ts

@@ -1,16 +0,0 @@
-declare module 'nodemailer/lib/mailer' {
-  namespace Mail {
-    interface Options {
-      from?: string | { name?: string; address: string }
-      to?: string | string[]
-      subject?: string
-      text?: string
-      html?: string
-      [key: string]: any
-    }
-  }
-  class Mail {
-    constructor(transporter: any)
-  }
-  export = Mail
-}

package/tests/_util.ts

@@ -1,191 +0,0 @@
-import { RequestListener, createServer } from 'node:http'
-import { AddressInfo } from 'node:net'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { ToolsOzoneModerationDefs, lexToJson } from '@atproto/api'
-import { isCidString } from '@atproto/lex'
-import { isCid, isPlainObject } from '@atproto/lex-data'
-import { AtUri } from '@atproto/syntax'
-
-// Swap out identifiers and dates with stable
-// values for the purpose of snapshot testing
-export const forSnapshot = (obj: unknown) => {
-  const records = { [kTake]: 'record' }
-  const collections = { [kTake]: 'collection' }
-  const users = { [kTake]: 'user' }
-  const cids = { [kTake]: 'cids' }
-  const unknown = { [kTake]: 'unknown' }
-  const toWalk = lexToJson(obj as any) // remove any blobrefs/cids
-  return mapLeafValues(toWalk, (item) => {
-    if (isCid(item)) {
-      return take(cids, item.toString())
-    }
-    if (typeof item !== 'string') {
-      return item
-    }
-    const str = item.startsWith('did:plc:') ? `at://${item}` : item
-    if (str.startsWith('at://')) {
-      const uri = new AtUri(str)
-      if (uri.rkey) {
-        return take(records, str)
-      }
-      if (uri.collection) {
-        return take(collections, str)
-      }
-      if (uri.hostname) {
-        return take(users, str)
-      }
-      return take(unknown, str)
-    }
-    if (str.match(/^\d{4}-\d{2}-\d{2}T/)) {
-      if (str.match(/\d{6}Z$/)) {
-        return constantDate.replace('Z', '000Z') // e.g. microseconds in record createdAt
-      } else if (str.endsWith('+00:00')) {
-        return constantDate.replace('Z', '+00:00') // e.g. timezone in record createdAt
-      } else {
-        return constantDate
-      }
-    }
-    // handles both pds and appview cursor separators
-    if (str.match(/^\d+(?:__|::)bafy/)) {
-      return constantKeysetCursor
-    }
-    if (str.match(/^\d+(?:__|::)did:plc/)) {
-      return constantDidCursor
-    }
-    if (str.match(/\/image\/[^/]+\/.+\/did:plc:[^/]+\/[^/@]+(?:@[\w]+)?$/)) {
-      // Match image urls (pds), stripping optional format suffix (e.g. @webp) for stable snapshots
-      const match = str.match(
-        /\/image\/([^/]+)\/.+\/(did:plc:[^/]+)\/([^/@]+)(?:@[\w]+)?$/,
-      )
-      if (!match) return str
-      const [, sig, did, cid] = match
-      return str
-        .replace(sig, 'sig()')
-        .replace(did, take(users, did))
-        .replace(new RegExp(`${cid}(?:@\\w+)?`), take(cids, cid))
-    }
-    if (str.match(/\/img\/[^/]+\/.+\/did:plc:[^/]+\/[^/@]+(?:@[\w]+)?$/)) {
-      // Match image urls (bsky w/ presets), stripping optional format suffix (e.g. @webp) for stable snapshots
-      const match = str.match(
-        /\/img\/[^/]+\/.+\/(did:plc:[^/]+)\/([^/@]+)(?:@[\w]+)?$/,
-      )
-      if (!match) return str
-      const [, did, cid] = match
-      return str
-        .replace(did, take(users, did))
-        .replace(new RegExp(`${cid}(?:@\\w+)?`), take(cids, cid))
-    }
-    if (str.startsWith('localhost-')) {
-      return 'invite-code'
-    }
-    if (str.match(/^\d+::pds-public-url-/)) {
-      return '0000000000000::invite-code'
-    }
-    if (isCidString(str)) {
-      return take(cids, str)
-    }
-    return item
-  })
-}
-
-// Feed testing utils
-
-// Useful for remapping ids in snapshot testing, to make snapshots deterministic.
-// E.g. you may use this to map this:
-//   [{ uri: 'did://rad'}, { uri: 'did://bad' }, { uri: 'did://rad'}]
-// to this:
-//   [{ uri: '0'}, { uri: '1' }, { uri: '0'}]
-const kTake = Symbol('take')
-export function take(obj, value: string): string
-export function take(obj, value: string | undefined): string | undefined
-export function take(
-  obj: { [s: string]: number; [kTake]?: string },
-  value: string | undefined,
-): string | undefined {
-  if (value === undefined) {
-    return
-  }
-  if (!(value in obj)) {
-    obj[value] = Object.keys(obj).length
-  }
-  const kind = obj[kTake]
-  return typeof kind === 'string'
-    ? `${kind}(${obj[value]})`
-    : String(obj[value])
-}
-
-export const constantDate = new Date(0).toISOString()
-export const constantKeysetCursor = '0000000000000::bafycid'
-export const constantDidCursor = '0000000000000::did'
-
-const mapLeafValues = (obj: unknown, fn: (val: unknown) => unknown) => {
-  if (Array.isArray(obj)) {
-    return obj.map((item) => mapLeafValues(item, fn))
-  }
-  if (isPlainObject(obj)) {
-    return Object.entries(obj).reduce(
-      (collect, [name, value]) =>
-        Object.assign(collect, { [name]: mapLeafValues(value, fn) }),
-      {},
-    )
-  }
-  return fn(obj)
-}
-
-export const paginateAll = async <T extends { cursor?: string }>(
-  fn: (cursor?: string) => Promise<T>,
-  limit = Infinity,
-): Promise<T[]> => {
-  const results: T[] = []
-  let cursor
-  do {
-    const res = await fn(cursor)
-    results.push(res)
-    cursor = res.cursor
-  } while (cursor && results.length < limit)
-  return results
-}
-
-export async function startServer(listener: RequestListener) {
-  return new Promise<AsyncDisposable & { port: number }>((resolve, reject) => {
-    const onListen = () => {
-      const port = (server.address() as AddressInfo).port
-      resolve({ port, [Symbol.asyncDispose]: () => terminator.terminate() })
-      cleanup()
-    }
-    const onError = (err: Error) => {
-      reject(err)
-      cleanup()
-    }
-    const cleanup = () => {
-      server.removeListener('listening', onListen)
-      server.removeListener('error', onError)
-    }
-
-    const server = createServer(listener)
-      .listen(0)
-      .once('listening', onListen)
-      .once('error', onError)
-
-    const terminator = httpTerminator.createHttpTerminator({ server })
-  })
-}
-
-const normalizeSubjectStatus = (
-  subject: ToolsOzoneModerationDefs.SubjectStatusView,
-) => {
-  return { ...subject, tags: subject.tags?.sort() }
-}
-
-export const forSubjectStatusSnapshot = (
-  status:
-    | ToolsOzoneModerationDefs.SubjectStatusView
-    | ToolsOzoneModerationDefs.SubjectStatusView[],
-) => {
-  if (Array.isArray(status)) {
-    return forSnapshot(status.map(normalizeSubjectStatus))
-  }
-
-  return forSnapshot(normalizeSubjectStatus(status))
-}

package/tests/account-deactivation.test.ts

@@ -1,204 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import {
-  ImageRef,
-  SeedClient,
-  TestNetworkNoAppView,
-  basicSeed,
-} from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-
-describe('account deactivation', () => {
-  let network: TestNetworkNoAppView
-
-  let sc: SeedClient
-  let agent: AtpAgent
-
-  let alice: DidString
-  let aliceAvatar: ImageRef
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'account_deactivation',
-    })
-
-    sc = network.getSeedClient()
-    agent = network.pds.getAgent()
-
-    await basicSeed(sc)
-    alice = sc.dids.alice
-
-    aliceAvatar = await sc.uploadFile(
-      alice,
-      '../dev-env/assets/key-portrait-small.jpg',
-      'image/jpeg',
-    )
-    await sc.updateProfile(alice, {
-      avatar: aliceAvatar.image,
-    })
-
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('deactivates account', async () => {
-    await agent.com.atproto.server.deactivateAccount(
-      {},
-      { encoding: 'application/json', headers: sc.getHeaders(alice) },
-    )
-  })
-
-  it('returns deactivated status', async () => {
-    const res = await agent.com.atproto.sync.getRepoStatus({ did: alice })
-    expect(res.data).toEqual({
-      did: alice,
-      active: false,
-      status: 'deactivated',
-    })
-
-    const adminRes = await agent.com.atproto.admin.getAccountInfo(
-      {
-        did: alice,
-      },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(typeof adminRes.data.deactivatedAt).toBeDefined()
-  })
-
-  it('no longer serves repo data', async () => {
-    await expect(
-      agent.com.atproto.sync.getRepo({ did: alice }),
-    ).rejects.toThrow(/Repo has been deactivated/)
-    await expect(
-      agent.com.atproto.sync.getLatestCommit({ did: alice }),
-    ).rejects.toThrow(/Repo has been deactivated/)
-    await expect(
-      agent.com.atproto.sync.listBlobs({ did: alice }),
-    ).rejects.toThrow(/Repo has been deactivated/)
-    const recordUri = sc.posts[alice][0].ref.uri
-    await expect(
-      agent.com.atproto.sync.getRecord({
-        did: alice,
-        collection: recordUri.collection,
-        rkey: recordUri.rkey,
-      }),
-    ).rejects.toThrow(/Repo has been deactivated/)
-    await expect(
-      agent.com.atproto.repo.getRecord({
-        repo: alice,
-        collection: recordUri.collection,
-        rkey: recordUri.rkey,
-      }),
-    ).rejects.toThrow()
-    await expect(
-      agent.com.atproto.repo.describeRepo({
-        repo: alice,
-      }),
-    ).rejects.toThrow(/Repo has been deactivated/)
-
-    await expect(
-      agent.com.atproto.sync.getBlob({
-        did: alice,
-        cid: aliceAvatar.image.ref.toString(),
-      }),
-    ).rejects.toThrow(/Repo has been deactivated/)
-    const listedRepos = await agent.com.atproto.sync.listRepos()
-    const listedAlice = listedRepos.data.repos.find((r) => r.did === alice)
-    expect(listedAlice?.active).toBe(false)
-    expect(listedAlice?.status).toBe('deactivated')
-  })
-
-  it('no longer resolves handle', async () => {
-    await expect(
-      agent.com.atproto.identity.resolveHandle({
-        handle: sc.accounts[alice].handle,
-      }),
-    ).rejects.toThrow()
-  })
-
-  it('still allows login and returns status', async () => {
-    const res = await agent.com.atproto.server.createSession({
-      identifier: alice,
-      password: sc.accounts[alice].password,
-    })
-    expect(res.data.status).toEqual('deactivated')
-  })
-
-  it('returns status on getSession', async () => {
-    const res = await agent.com.atproto.server.getSession(undefined, {
-      headers: sc.getHeaders(alice),
-    })
-    expect(res.data.status).toEqual('deactivated')
-  })
-
-  it('does not allow writes', async () => {
-    const createAttempt = agent.com.atproto.repo.createRecord(
-      {
-        repo: alice,
-        collection: 'app.bsky.feed.post',
-        record: {
-          text: 'blah',
-          createdAt: new Date().toISOString(),
-        },
-      },
-      {
-        encoding: 'application/json',
-        headers: sc.getHeaders(alice),
-      },
-    )
-    const uri = sc.posts[alice][0].ref.uri
-    await expect(createAttempt).rejects.toThrow('Account is deactivated')
-
-    const putAttempt = agent.com.atproto.repo.putRecord(
-      {
-        repo: alice,
-        collection: uri.collection,
-        rkey: uri.rkey,
-        record: {
-          text: 'blah',
-          createdAt: new Date().toISOString(),
-        },
-      },
-      {
-        encoding: 'application/json',
-        headers: sc.getHeaders(alice),
-      },
-    )
-    await expect(putAttempt).rejects.toThrow('Account is deactivated')
-
-    const deleteAttempt = agent.com.atproto.repo.deleteRecord(
-      {
-        repo: alice,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      },
-      {
-        encoding: 'application/json',
-        headers: sc.getHeaders(alice),
-      },
-    )
-    await expect(deleteAttempt).rejects.toThrow('Account is deactivated')
-  })
-
-  it('reactivates', async () => {
-    await agent.com.atproto.server.activateAccount(undefined, {
-      headers: sc.getHeaders(alice),
-    })
-
-    await agent.com.atproto.sync.getRepo({ did: alice })
-
-    const statusRes = await agent.com.atproto.sync.getRepoStatus({ did: alice })
-    expect(statusRes.data.active).toBe(true)
-    expect(statusRes.data.status).toBeUndefined()
-
-    const adminRes = await agent.com.atproto.admin.getAccountInfo(
-      {
-        did: alice,
-      },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(adminRes.data.deactivatedAt).toBeUndefined()
-  })
-})