@atproto/ozone 0.0.2

package/tests/_util.ts

@@ -0,0 +1,192 @@
+import { AtUri } from '@atproto/syntax'
+import { lexToJson } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import {
+  FeedViewPost,
+  PostView,
+  isPostView,
+  isThreadViewPost,
+} from '../src/lexicon/types/app/bsky/feed/defs'
+import { isViewRecord } from '../src/lexicon/types/app/bsky/embed/record'
+
+// 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) => {
+    const asCid = CID.asCID(item)
+    if (asCid !== null) {
+      return take(cids, asCid.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
+      const match = str.match(
+        /\/img\/[^/]+\/.+\/(did:plc:[^/]+)\/([^/]+)@[\w]+$/,
+      )
+      if (!match) return str
+      const [, did, cid] = match
+      return str.replace(did, take(users, did)).replace(cid, take(cids, cid))
+    }
+    let isCid: boolean
+    try {
+      CID.parse(str)
+      isCid = true
+    } catch (_err) {
+      isCid = false
+    }
+    if (isCid) {
+      return take(cids, str)
+    }
+    return item
+  })
+}
+
+// Feed testing utils
+
+export const getOriginator = (item: FeedViewPost) => {
+  if (!item.reason) {
+    return item.post.author.did
+  } else {
+    return (item.reason.by as { [did: string]: string }).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, 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'
+
+const mapLeafValues = (obj: unknown, fn: (val: 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?: Record<string, unknown> }>(
+  val: T,
+): T => {
+  delete val.viewer
+  return val
+}
+
+// @NOTE mutates
+export const stripViewerFromPost = (postUnknown: unknown): PostView => {
+  if (postUnknown?.['$type'] && !isPostView(postUnknown)) {
+    throw new Error('Expected post view')
+  }
+  const post = postUnknown as PostView
+  post.author = stripViewer(post.author)
+  const recordEmbed =
+    post.embed && isViewRecord(post.embed.record)
+      ? post.embed.record // Record from record embed
+      : post.embed?.['record'] && isViewRecord(post.embed['record']['record'])
+      ? post.embed['record']['record'] // Record from record-with-media embed
+      : undefined
+  if (recordEmbed) {
+    recordEmbed.author = stripViewer(recordEmbed.author)
+    recordEmbed.embeds?.forEach((deepEmbed) => {
+      const deepRecordEmbed = isViewRecord(deepEmbed.record)
+        ? deepEmbed.record // Record from record embed
+        : deepEmbed['record'] && isViewRecord(deepEmbed['record']['record'])
+        ? deepEmbed['record']['record'] // Record from record-with-media embed
+        : undefined
+      if (deepRecordEmbed) {
+        deepRecordEmbed.author = stripViewer(deepRecordEmbed.author)
+      }
+    })
+  }
+  return stripViewer(post)
+}
+
+// @NOTE mutates
+export const stripViewerFromThread = <T>(thread: T): T => {
+  if (!isThreadViewPost(thread)) return thread
+  delete thread.viewer
+  thread.post = stripViewerFromPost(thread.post)
+  if (isThreadViewPost(thread.parent)) {
+    thread.parent = stripViewerFromThread(thread.parent)
+  }
+  if (thread.replies) {
+    thread.replies = thread.replies.map(stripViewerFromThread)
+  }
+  return thread
+}

package/tests/db.test.ts

@@ -0,0 +1,184 @@
+import { sql } from 'kysely'
+import { wait } from '@atproto/common'
+import { TestNetwork } from '@atproto/dev-env'
+import { Database } from '../src'
+
+describe('db', () => {
+  let network: TestNetwork
+  let db: Database
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_db',
+    })
+    db = network.ozone.ctx.db
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('handles client errors without crashing.', async () => {
+    const tryKillConnection = db.transaction(async (dbTxn) => {
+      const result = await sql`select pg_backend_pid() as pid;`.execute(
+        dbTxn.db,
+      )
+      const pid = result.rows[0]?.['pid'] as number
+      await sql`select pg_terminate_backend(${pid});`.execute(db.db)
+      await sql`select 1;`.execute(dbTxn.db)
+    })
+    // This should throw, but no unhandled error
+    await expect(tryKillConnection).rejects.toThrow()
+  })
+
+  it('handles pool errors without crashing.', async () => {
+    const conn1 = await db.pool.connect()
+    const conn2 = await db.pool.connect()
+    const result = await conn1.query('select pg_backend_pid() as pid;')
+    const conn1pid: number = result.rows[0].pid
+    conn1.release()
+    await wait(100) // let release apply, conn is now idle on pool.
+    await conn2.query(`select pg_terminate_backend(${conn1pid});`)
+    conn2.release()
+  })
+
+  describe('transaction()', () => {
+    it('commits changes', async () => {
+      const result = await db.transaction(async (dbTxn) => {
+        return await dbTxn.db
+          .insertInto('repo_push_event')
+          .values({
+            eventType: 'takedown',
+            subjectDid: 'x',
+          })
+          .returning('subjectDid')
+          .executeTakeFirst()
+      })
+
+      if (!result) {
+        return expect(result).toBeTruthy()
+      }
+
+      expect(result.subjectDid).toEqual('x')
+
+      const row = await db.db
+        .selectFrom('repo_push_event')
+        .selectAll()
+        .where('subjectDid', '=', 'x')
+        .executeTakeFirst()
+
+      expect(row).toMatchObject({
+        eventType: 'takedown',
+        subjectDid: 'x',
+      })
+    })
+
+    it('rolls-back changes on failure', async () => {
+      const promise = db.transaction(async (dbTxn) => {
+        await dbTxn.db
+          .insertInto('repo_push_event')
+          .values({
+            eventType: 'takedown',
+            subjectDid: 'y',
+          })
+          .returning('subjectDid')
+          .executeTakeFirst()
+
+        throw new Error('Oops!')
+      })
+
+      await expect(promise).rejects.toThrow('Oops!')
+
+      const row = await db.db
+        .selectFrom('repo_push_event')
+        .selectAll()
+        .where('subjectDid', '=', 'y')
+        .executeTakeFirst()
+
+      expect(row).toBeUndefined()
+    })
+
+    it('indicates isTransaction', async () => {
+      expect(db.isTransaction).toEqual(false)
+
+      await db.transaction(async (dbTxn) => {
+        expect(db.isTransaction).toEqual(false)
+        expect(dbTxn.isTransaction).toEqual(true)
+      })
+
+      expect(db.isTransaction).toEqual(false)
+    })
+
+    it('asserts transaction', async () => {
+      expect(() => db.assertTransaction()).toThrow('Transaction required')
+
+      await db.transaction(async (dbTxn) => {
+        expect(() => dbTxn.assertTransaction()).not.toThrow()
+      })
+    })
+
+    it('does not allow leaky transactions', async () => {
+      let leakedTx: Database | undefined
+
+      const tx = db.transaction(async (dbTxn) => {
+        leakedTx = dbTxn
+        await dbTxn.db
+          .insertInto('repo_push_event')
+          .values({ eventType: 'takedown', subjectDid: 'a' })
+          .execute()
+        throw new Error('test tx failed')
+      })
+      await expect(tx).rejects.toThrow('test tx failed')
+
+      const attempt = leakedTx?.db
+        .insertInto('repo_push_event')
+        .values({ eventType: 'takedown', subjectDid: 'b' })
+        .execute()
+      await expect(attempt).rejects.toThrow('tx already failed')
+
+      const res = await db.db
+        .selectFrom('repo_push_event')
+        .selectAll()
+        .where('subjectDid', 'in', ['a', 'b'])
+        .execute()
+
+      expect(res.length).toBe(0)
+    })
+
+    it('ensures all inflight queries are rolled back', async () => {
+      let promise: Promise<unknown> | undefined = undefined
+      const names: string[] = []
+      try {
+        await db.transaction(async (dbTxn) => {
+          const queries: Promise<unknown>[] = []
+          for (let i = 0; i < 20; i++) {
+            const name = `user${i}`
+            const query = dbTxn.db
+              .insertInto('repo_push_event')
+              .values({
+                eventType: 'takedown',
+                subjectDid: name,
+              })
+              .execute()
+            names.push(name)
+            queries.push(query)
+          }
+          promise = Promise.allSettled(queries)
+          throw new Error()
+        })
+      } catch (err) {
+        expect(err).toBeDefined()
+      }
+      if (promise) {
+        await promise
+      }
+
+      const res = await db.db
+        .selectFrom('repo_push_event')
+        .selectAll()
+        .where('subjectDid', 'in', names)
+        .execute()
+      expect(res.length).toBe(0)
+    })
+  })
+})

package/tests/get-record.test.ts

@@ -0,0 +1,110 @@
+import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
+import AtpAgent from '@atproto/api'
+import { AtUri } from '@atproto/syntax'
+import {
+  REASONOTHER,
+  REASONSPAM,
+} from '../src/lexicon/types/com/atproto/moderation/defs'
+import { forSnapshot } from './_util'
+
+describe('admin get record view', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_admin_get_record',
+    })
+    agent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  beforeAll(async () => {
+    await sc.emitModerationEvent({
+      event: { $type: 'com.atproto.admin.defs#modEventFlag' },
+      subject: {
+        $type: 'com.atproto.repo.strongRef',
+        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+        cid: sc.posts[sc.dids.alice][0].ref.cidStr,
+      },
+    })
+    await sc.createReport({
+      reportedBy: sc.dids.bob,
+      reasonType: REASONSPAM,
+      subject: {
+        $type: 'com.atproto.repo.strongRef',
+        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+        cid: sc.posts[sc.dids.alice][0].ref.cidStr,
+      },
+    })
+    await sc.createReport({
+      reportedBy: sc.dids.carol,
+      reasonType: REASONOTHER,
+      reason: 'defamation',
+      subject: {
+        $type: 'com.atproto.repo.strongRef',
+        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+        cid: sc.posts[sc.dids.alice][0].ref.cidStr,
+      },
+    })
+    await sc.emitModerationEvent({
+      event: { $type: 'com.atproto.admin.defs#modEventTakedown' },
+      subject: {
+        $type: 'com.atproto.repo.strongRef',
+        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+        cid: sc.posts[sc.dids.alice][0].ref.cidStr,
+      },
+    })
+  })
+
+  it('gets a record by uri, even when taken down.', async () => {
+    const result = await agent.api.com.atproto.admin.getRecord(
+      { uri: sc.posts[sc.dids.alice][0].ref.uriStr },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    expect(forSnapshot(result.data)).toMatchSnapshot()
+  })
+
+  it('gets a record by uri and cid.', async () => {
+    const result = await agent.api.com.atproto.admin.getRecord(
+      {
+        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+        cid: sc.posts[sc.dids.alice][0].ref.cidStr,
+      },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    expect(forSnapshot(result.data)).toMatchSnapshot()
+  })
+
+  it('fails when record does not exist.', async () => {
+    const promise = agent.api.com.atproto.admin.getRecord(
+      {
+        uri: AtUri.make(
+          sc.dids.alice,
+          'app.bsky.feed.post',
+          'badrkey',
+        ).toString(),
+      },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    await expect(promise).rejects.toThrow('Record not found')
+  })
+
+  it('fails when record cid does not exist.', async () => {
+    const promise = agent.api.com.atproto.admin.getRecord(
+      {
+        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+        cid: sc.posts[sc.dids.alice][1].ref.cidStr, // Mismatching cid
+      },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    await expect(promise).rejects.toThrow('Record not found')
+  })
+})

package/tests/get-repo.test.ts

@@ -0,0 +1,131 @@
+import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
+import AtpAgent from '@atproto/api'
+import {
+  REASONOTHER,
+  REASONSPAM,
+} from '../src/lexicon/types/com/atproto/moderation/defs'
+import { forSnapshot } from './_util'
+
+describe('admin get repo view', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_admin_get_repo',
+    })
+    agent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  beforeAll(async () => {
+    await sc.emitModerationEvent({
+      event: { $type: 'com.atproto.admin.defs#modEventAcknowledge' },
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.alice,
+      },
+    })
+    await sc.createReport({
+      reportedBy: sc.dids.bob,
+      reasonType: REASONSPAM,
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.alice,
+      },
+    })
+    await sc.createReport({
+      reportedBy: sc.dids.carol,
+      reasonType: REASONOTHER,
+      reason: 'defamation',
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.alice,
+      },
+    })
+    await sc.emitModerationEvent({
+      event: { $type: 'com.atproto.admin.defs#modEventTakedown' },
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.alice,
+      },
+    })
+  })
+
+  it('gets a repo by did, even when taken down.', async () => {
+    const result = await agent.api.com.atproto.admin.getRepo(
+      { did: sc.dids.alice },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    expect(forSnapshot(result.data)).toMatchSnapshot()
+  })
+
+  it('does not include account emails for triage mods.', async () => {
+    const { data: admin } = await agent.api.com.atproto.admin.getRepo(
+      { did: sc.dids.bob },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    const { data: moderator } = await agent.api.com.atproto.admin.getRepo(
+      { did: sc.dids.bob },
+      { headers: network.pds.adminAuthHeaders('moderator') },
+    )
+    const { data: triage } = await agent.api.com.atproto.admin.getRepo(
+      { did: sc.dids.bob },
+      { headers: network.pds.adminAuthHeaders('triage') },
+    )
+    expect(admin.email).toEqual('bob@test.com')
+    expect(moderator.email).toEqual('bob@test.com')
+    expect(triage.email).toBeUndefined()
+    expect(triage).toEqual({ ...admin, email: undefined })
+  })
+
+  it('includes emailConfirmedAt timestamp', async () => {
+    const { data: beforeEmailVerification } =
+      await agent.api.com.atproto.admin.getRepo(
+        { did: sc.dids.bob },
+        { headers: network.pds.adminAuthHeaders() },
+      )
+
+    expect(beforeEmailVerification.emailConfirmedAt).toBeUndefined()
+    const timestampBeforeVerification = Date.now()
+    const bobsAccount = sc.accounts[sc.dids.bob]
+    const verificationToken =
+      await network.pds.ctx.accountManager.createEmailToken(
+        sc.dids.bob,
+        'confirm_email',
+      )
+    await agent.api.com.atproto.server.confirmEmail(
+      { email: bobsAccount.email, token: verificationToken },
+      {
+        encoding: 'application/json',
+
+        headers: sc.getHeaders(sc.dids.bob),
+      },
+    )
+    const { data: afterEmailVerification } =
+      await agent.api.com.atproto.admin.getRepo(
+        { did: sc.dids.bob },
+        { headers: network.pds.adminAuthHeaders() },
+      )
+
+    expect(afterEmailVerification.emailConfirmedAt).toBeTruthy()
+    expect(
+      new Date(afterEmailVerification.emailConfirmedAt as string).getTime(),
+    ).toBeGreaterThan(timestampBeforeVerification)
+  })
+
+  it('fails when repo does not exist.', async () => {
+    const promise = agent.api.com.atproto.admin.getRepo(
+      { did: 'did:plc:doesnotexist' },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    await expect(promise).rejects.toThrow('Repo not found')
+  })
+})