@atproto/bsky 0.0.250 → 0.0.253

package/tests/_util.ts

@@ -1,292 +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 { expect } from 'vitest'
-import {
-  $Typed,
-  AppBskyEmbedRecord,
-  AppBskyEmbedRecordWithMedia,
-  AppBskyFeedDefs,
-  AppBskyFeedGetPostThread,
-  AppBskyLabelerDefs,
-  lexToJson,
-} from '@atproto/api'
-import { ifCid, validateCidString } from '@atproto/lex'
-import { AtUri } from '@atproto/syntax'
-
-type ThreadViewPost = Extract<
-  AppBskyFeedGetPostThread.OutputSchema['thread'],
-  { post: { uri: string } }
->
-
-export function assertIsThreadViewPost(
-  value: unknown,
-): asserts value is ThreadViewPost {
-  expect(value).toMatchObject({
-    $type: 'app.bsky.feed.defs#threadViewPost',
-  })
-}
-
-// 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) => {
-    // @TODO this should never happen since lexToJson removes cids (can we
-    // simply remove this check?)
-    const cid = ifCid(item)
-    if (cid !== null) {
-      return take(cids, cid.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
-      }
-    }
-    if (str.match(/^\d+__bafy/)) {
-      return constantKeysetCursor
-    }
-    if (str.match(/\/img\/[^/]+\/.+\/did:plc:[^/]+\/[^/@]+(?:@[\w]+)?$/)) {
-      // Match image urls, 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.match(/\/vid\/did%3Aplc%3A[^/]+\/[^/]+\/[^/]+$/)) {
-      // Match video urls
-      const match = str.match(/\/vid\/(did%3Aplc%3A[^/]+)\/([^/]+)\/[^/]+$/)
-      if (!match) return str
-      const [, did, cid] = match
-      return str
-        .replace(did, take(users, decodeURIComponent(did)))
-        .replace(cid, take(cids, cid))
-    }
-    if (validateCidString(str)) {
-      return take(cids, str)
-    }
-    return item
-  })
-}
-
-// Feed testing utils
-
-export const getOriginator = (item: AppBskyFeedDefs.FeedViewPost) => {
-  if (AppBskyFeedDefs.isReasonRepost(item.reason)) {
-    return item.reason.by.did
-  } else {
-    return item.post.author.did
-  }
-}
-
-// 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: Record<string, number>, value: string): string
-export function take(
-  obj: Record<string, number>,
-  value?: string,
-): 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'
-
-const mapLeafValues = (
-  obj: unknown,
-  fn: (val: unknown) => unknown,
-): unknown => {
-  if (Array.isArray(obj)) {
-    return obj.map((item) => mapLeafValues(item, fn))
-  }
-  if (obj && typeof obj === 'object') {
-    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
-}
-
-// @NOTE mutates
-export const stripViewer = <T extends { viewer?: unknown }>(
-  val: T,
-): Omit<T, 'viewer'> => {
-  delete val.viewer
-  return val
-}
-
-// @NOTE mutates
-export function stripViewerFromPost(
-  postUnknown: object,
-  withType?: false,
-): AppBskyFeedDefs.PostView
-export function stripViewerFromPost(
-  postUnknown: object,
-  withType: true,
-): $Typed<AppBskyFeedDefs.PostView>
-export function stripViewerFromPost(
-  postUnknown: object,
-  withType = false,
-): AppBskyFeedDefs.PostView {
-  if ('$type' in postUnknown && !AppBskyFeedDefs.isPostView(postUnknown)) {
-    throw new Error('Expected post view')
-  }
-  const post = postUnknown as AppBskyFeedDefs.PostView
-  if (withType) {
-    post.$type = 'app.bsky.feed.defs#postView'
-  } else {
-    delete post.$type
-  }
-  post.author = stripViewer(post.author)
-
-  const recordEmbed = extractRecordEmbed(post.embed)
-
-  if (recordEmbed) {
-    recordEmbed.author = stripViewer(recordEmbed.author)
-    recordEmbed.embeds?.forEach((deepEmbed) => {
-      const deepRecordEmbed = extractRecordEmbed(deepEmbed)
-      if (deepRecordEmbed) {
-        deepRecordEmbed.author = stripViewer(deepRecordEmbed.author)
-      }
-    })
-  }
-  return stripViewer(post)
-}
-
-const extractRecordEmbed = (embed: AppBskyFeedDefs.PostView['embed']) =>
-  AppBskyEmbedRecord.isView(embed)
-    ? AppBskyEmbedRecord.isViewRecord(embed.record)
-      ? embed.record
-      : undefined
-    : AppBskyEmbedRecordWithMedia.isView(embed)
-      ? AppBskyEmbedRecord.isViewRecord(embed.record.record)
-        ? embed.record.record
-        : undefined
-      : undefined
-
-// @NOTE mutates
-export const stripViewerFromThread = <T>(threadUnknown: T): T => {
-  if (!AppBskyFeedDefs.isThreadViewPost(threadUnknown)) {
-    return threadUnknown
-  }
-
-  const thread = threadUnknown as typeof threadUnknown &
-    AppBskyFeedDefs.ThreadViewPost
-
-  // @ts-expect-error "viewer" does not exist on type 'ThreadViewPost'
-  delete thread.viewer
-
-  thread.post = stripViewerFromPost(thread.post)
-  if (AppBskyFeedDefs.isThreadViewPost(thread.parent)) {
-    thread.parent = stripViewerFromThread(thread.parent)
-  }
-  if (thread.replies) {
-    thread.replies = thread.replies.map(stripViewerFromThread)
-  }
-  return thread
-}
-
-// @NOTE mutates
-export const stripViewerFromLabeler = (
-  serviceUnknown: object,
-): AppBskyLabelerDefs.LabelerView => {
-  if (
-    '$type' in serviceUnknown &&
-    !AppBskyLabelerDefs.isLabelerView(serviceUnknown) &&
-    !AppBskyLabelerDefs.isLabelerViewDetailed(serviceUnknown)
-  ) {
-    throw new Error('Expected mod service view')
-  }
-  const labeler = serviceUnknown as AppBskyLabelerDefs.LabelerView
-  labeler.creator = stripViewer(labeler.creator)
-  return stripViewer(labeler)
-}
-
-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 })
-  })
-}

package/tests/admin/admin-auth.test.ts

@@ -1,190 +0,0 @@
-import assert from 'node:assert'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { $Typed, AtpAgent, ComAtprotoAdminDefs, ids } from '@atproto/api'
-import { Secp256k1Keypair } from '@atproto/crypto'
-import { SeedClient, TestNetwork, usersSeed } from '@atproto/dev-env'
-import { createServiceAuthHeaders } from '@atproto/xrpc-server'
-
-describe('admin auth', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let repoSubject: $Typed<ComAtprotoAdminDefs.RepoRef>
-
-  const modServiceDid = 'did:example:mod'
-  const altModDid = 'did:example:alt'
-  let modServiceKey: Secp256k1Keypair
-  let bskyDid: string
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_admin_auth',
-      bsky: {
-        modServiceDid,
-      },
-    })
-
-    bskyDid = network.bsky.ctx.cfg.serverDid
-
-    modServiceKey = await Secp256k1Keypair.create()
-    const origResolve = network.bsky.dataplane.idResolver.did.resolve
-    network.bsky.dataplane.idResolver.did.resolve = async function (
-      did: string,
-      forceRefresh?: boolean,
-    ) {
-      if (did === modServiceDid || did === altModDid) {
-        return {
-          '@context': [
-            'https://www.w3.org/ns/did/v1',
-            'https://w3id.org/security/multikey/v1',
-            'https://w3id.org/security/suites/secp256k1-2019/v1',
-          ],
-          id: did,
-          verificationMethod: [
-            {
-              id: `${did}#atproto`,
-              type: 'Multikey',
-              controller: did,
-              publicKeyMultibase: modServiceKey.did().replace('did:key:', ''),
-            },
-          ],
-        }
-      }
-      return origResolve.call(this, did, forceRefresh)
-    }
-
-    agent = network.bsky.getAgent()
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-    await network.processAll()
-    repoSubject = {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: sc.dids.bob,
-    }
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('allows service auth requests from the configured appview did', async () => {
-    const updateHeaders = await createServiceAuthHeaders({
-      iss: modServiceDid,
-      aud: bskyDid,
-      lxm: ids.ComAtprotoAdminUpdateSubjectStatus,
-      keypair: modServiceKey,
-    })
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...updateHeaders,
-        encoding: 'application/json',
-      },
-    )
-
-    const getHeaders = await createServiceAuthHeaders({
-      iss: modServiceDid,
-      aud: bskyDid,
-      lxm: ids.ComAtprotoAdminGetSubjectStatus,
-      keypair: modServiceKey,
-    })
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      { did: repoSubject.did },
-      getHeaders,
-    )
-    assert(ComAtprotoAdminDefs.isRepoRef(res.data.subject))
-    expect(res.data.subject.did).toBe(repoSubject.did)
-    expect(res.data.takedown?.applied).toBe(true)
-  })
-
-  it('does not allow requests from another did', async () => {
-    const headers = await createServiceAuthHeaders({
-      iss: altModDid,
-      aud: bskyDid,
-      lxm: ids.ComAtprotoAdminUpdateSubjectStatus,
-      keypair: modServiceKey,
-    })
-    const attempt = agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...headers,
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow('Untrusted issuer')
-  })
-
-  it('does not allow requests from an authenticated user', async () => {
-    const aliceKey = await network.pds.ctx.actorStore.keypair(sc.dids.alice)
-    const headers = await createServiceAuthHeaders({
-      iss: sc.dids.alice,
-      aud: bskyDid,
-      lxm: ids.ComAtprotoAdminUpdateSubjectStatus,
-      keypair: aliceKey,
-    })
-    const attempt = agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...headers,
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow('Untrusted issuer')
-  })
-
-  it('does not allow requests with a bad signature', async () => {
-    const badKey = await Secp256k1Keypair.create()
-    const headers = await createServiceAuthHeaders({
-      iss: modServiceDid,
-      aud: bskyDid,
-      lxm: ids.ComAtprotoAdminUpdateSubjectStatus,
-      keypair: badKey,
-    })
-    const attempt = agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...headers,
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow(
-      'jwt signature does not match jwt issuer',
-    )
-  })
-
-  it('does not allow requests with a bad aud', async () => {
-    // repo subject is bob, so we set alice as the audience
-    const headers = await createServiceAuthHeaders({
-      iss: modServiceDid,
-      aud: sc.dids.alice,
-      lxm: ids.ComAtprotoAdminUpdateSubjectStatus,
-      keypair: modServiceKey,
-    })
-    const attempt = agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...headers,
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow(
-      'jwt audience does not match service did',
-    )
-  })
-})

package/tests/admin/moderation.test.ts

@@ -1,222 +0,0 @@
-import assert from 'node:assert'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import {
-  $Typed,
-  AtpAgent,
-  ComAtprotoAdminDefs,
-  ComAtprotoRepoStrongRef,
-} from '@atproto/api'
-import { ImageRef, SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-
-describe('moderation', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let repoSubject: $Typed<ComAtprotoAdminDefs.RepoRef>
-  let recordSubject: $Typed<ComAtprotoRepoStrongRef.Main>
-  let blobSubject: $Typed<ComAtprotoAdminDefs.RepoBlobRef>
-  let blobRef: ImageRef
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_moderation',
-    })
-
-    agent = network.bsky.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    await network.processAll()
-    repoSubject = {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: sc.dids.bob,
-    }
-    const post = sc.posts[sc.dids.carol][0]
-    recordSubject = {
-      $type: 'com.atproto.repo.strongRef',
-      uri: post.ref.uriStr,
-      cid: post.ref.cidStr,
-    }
-    blobRef = post.images[1]
-    blobSubject = {
-      $type: 'com.atproto.admin.defs#repoBlobRef',
-      did: sc.dids.carol,
-      cid: blobRef.image.ref.toString(),
-    }
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('takes down accounts', async () => {
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.bsky.adminAuthHeaders(),
-      },
-    )
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        did: repoSubject.did,
-      },
-      { headers: network.bsky.adminAuthHeaders() },
-    )
-    assert(ComAtprotoAdminDefs.isRepoRef(res.data.subject))
-    expect(res.data.subject.did).toEqual(sc.dids.bob)
-    expect(res.data.takedown?.applied).toBe(true)
-    // expect(res.data.takedown?.ref).toBe('test-repo') @TODO add these checks back in once takedown refs make it into dataplane
-  })
-
-  it('restores takendown accounts', async () => {
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: false },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.bsky.adminAuthHeaders(),
-      },
-    )
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        did: repoSubject.did,
-      },
-      { headers: network.bsky.adminAuthHeaders() },
-    )
-    assert(ComAtprotoAdminDefs.isRepoRef(res.data.subject))
-    expect(res.data.subject.did).toEqual(sc.dids.bob)
-    expect(res.data.takedown?.applied).toBe(false)
-    expect(res.data.takedown?.ref).toBeUndefined()
-  })
-
-  it('takes down records', async () => {
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: recordSubject,
-        takedown: { applied: true, ref: 'test-record' },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.bsky.adminAuthHeaders(),
-      },
-    )
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        uri: recordSubject.uri,
-      },
-      { headers: network.bsky.adminAuthHeaders() },
-    )
-    assert(ComAtprotoRepoStrongRef.isMain(res.data.subject))
-    expect(res.data.subject.uri).toEqual(recordSubject.uri)
-    expect(res.data.takedown?.applied).toBe(true)
-    // expect(res.data.takedown?.ref).toBe('test-record')
-  })
-
-  it('restores takendown records', async () => {
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: recordSubject,
-        takedown: { applied: false },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.bsky.adminAuthHeaders(),
-      },
-    )
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        uri: recordSubject.uri,
-      },
-      { headers: network.bsky.adminAuthHeaders() },
-    )
-    assert(ComAtprotoRepoStrongRef.isMain(res.data.subject))
-    expect(res.data.subject.uri).toEqual(recordSubject.uri)
-    expect(res.data.takedown?.applied).toBe(false)
-    expect(res.data.takedown?.ref).toBeUndefined()
-  })
-
-  describe('blob takedown', () => {
-    let blobUri: string
-    let imageUri: string
-
-    beforeAll(async () => {
-      blobUri = `${network.bsky.url}/blob/${blobSubject.did}/${blobSubject.cid}`
-      imageUri = network.bsky.ctx.views.imgUriBuilder
-        .getPresetUri('feed_thumbnail', blobSubject.did, blobSubject.cid)
-        .replace(network.bsky.ctx.cfg.publicUrl || '', network.bsky.url)
-      // Warm image server cache
-      const res = await fetch(imageUri)
-      await res.arrayBuffer() // flush response
-      assert(res.ok)
-      expect(res.headers.get('content-type')).toEqual('image/webp')
-      const cached = await fetch(imageUri)
-      await cached.arrayBuffer() // flush response
-      assert(cached.ok)
-      expect(cached.headers.get('x-cache')).toEqual('hit')
-      expect(cached.headers.get('content-type')).toEqual('image/webp')
-    })
-
-    it('takes down blobs', async () => {
-      await agent.api.com.atproto.admin.updateSubjectStatus(
-        {
-          subject: blobSubject,
-          takedown: { applied: true, ref: 'test-blob' },
-        },
-        {
-          encoding: 'application/json',
-          headers: network.bsky.adminAuthHeaders(),
-        },
-      )
-      const res = await agent.api.com.atproto.admin.getSubjectStatus(
-        {
-          did: blobSubject.did,
-          blob: blobSubject.cid,
-        },
-        { headers: network.bsky.adminAuthHeaders() },
-      )
-      assert(ComAtprotoAdminDefs.isRepoBlobRef(res.data.subject))
-      expect(res.data.subject.did).toEqual(blobSubject.did)
-      expect(res.data.subject.cid).toEqual(blobSubject.cid)
-      expect(res.data.takedown?.applied).toBe(true)
-      // expect(res.data.takedown?.ref).toBe('test-blob')
-    })
-
-    it('prevents resolution of blob', async () => {
-      const resolveBlob = await fetch(blobUri)
-      expect(resolveBlob.status).toEqual(404)
-      expect(await resolveBlob.json()).toEqual({
-        error: 'NotFoundError',
-        message: 'Blob not found',
-      })
-    })
-
-    it('restores blob when takedown is removed', async () => {
-      await agent.api.com.atproto.admin.updateSubjectStatus(
-        {
-          subject: blobSubject,
-          takedown: { applied: false },
-        },
-        {
-          encoding: 'application/json',
-          headers: network.bsky.adminAuthHeaders(),
-        },
-      )
-
-      // Can resolve blob
-      const resolveBlob = await fetch(blobUri)
-      expect(resolveBlob.status).toEqual(200)
-
-      // Can fetch through image server
-      const fetchImage = await fetch(imageUri)
-      expect(fetchImage.status).toEqual(200)
-      const size = Number(fetchImage.headers.get('content-length'))
-      expect(size).toBeGreaterThan(9000)
-    })
-  })
-})