@atproto/bsky 0.0.27 → 0.0.29

package/src/feed-gen/mutuals.ts

@@ -1,57 +0,0 @@
-import { QueryParams as SkeletonParams } from '../lexicon/types/app/bsky/feed/getFeedSkeleton'
-import AppContext from '../context'
-import { paginate } from '../db/pagination'
-import { AlgoHandler, AlgoResponse } from './types'
-import { FeedKeyset, getFeedDateThreshold } from '../api/app/bsky/util/feed'
-import { AuthRequiredError } from '@atproto/xrpc-server'
-
-const handler: AlgoHandler = async (
-  ctx: AppContext,
-  params: SkeletonParams,
-  viewer: string | null,
-): Promise<AlgoResponse> => {
-  if (!viewer) {
-    throw new AuthRequiredError('This feed requires being logged-in')
-  }
-
-  const { limit = 50, cursor } = params
-  const db = ctx.db.getReplica('feed')
-  const feedService = ctx.services.feed(db)
-  const { ref } = db.db.dynamic
-
-  const mutualsSubquery = db.db
-    .selectFrom('follow')
-    .where('follow.creator', '=', viewer)
-    .whereExists((qb) =>
-      qb
-        .selectFrom('follow as follow_inner')
-        .whereRef('follow_inner.creator', '=', 'follow.subjectDid')
-        .where('follow_inner.subjectDid', '=', viewer)
-        .selectAll(),
-    )
-    .select('follow.subjectDid')
-
-  const keyset = new FeedKeyset(ref('feed_item.sortAt'), ref('feed_item.cid'))
-  const sortFrom = keyset.unpack(cursor)?.primary
-
-  let feedQb = feedService
-    .selectFeedItemQb()
-    .where('feed_item.type', '=', 'post') // ensures originatorDid is post.creator
-    .where((qb) =>
-      qb
-        .where('originatorDid', '=', viewer)
-        .orWhere('originatorDid', 'in', mutualsSubquery),
-    )
-    .where('feed_item.sortAt', '>', getFeedDateThreshold(sortFrom))
-
-  feedQb = paginate(feedQb, { limit, cursor, keyset })
-
-  const feedItems = await feedQb.execute()
-
-  return {
-    feedItems,
-    cursor: keyset.packFromResult(feedItems),
-  }
-}
-
-export default handler

package/src/feed-gen/types.ts

@@ -1,32 +0,0 @@
-import AppContext from '../context'
-import { SkeletonFeedPost } from '../lexicon/types/app/bsky/feed/defs'
-import { QueryParams as SkeletonParams } from '../lexicon/types/app/bsky/feed/getFeedSkeleton'
-import { FeedRow } from '../services/feed'
-
-export type AlgoResponse = {
-  feedItems: FeedRow[]
-  resHeaders?: Record<string, string>
-  cursor?: string
-}
-
-export type AlgoHandler = (
-  ctx: AppContext,
-  params: SkeletonParams,
-  viewer: string | null,
-) => Promise<AlgoResponse>
-
-export type MountedAlgos = Record<string, AlgoHandler>
-
-export const toSkeletonItem = (feedItem: {
-  uri: string
-  postUri: string
-}): SkeletonFeedPost => ({
-  post: feedItem.postUri,
-  reason:
-    feedItem.uri === feedItem.postUri
-      ? undefined
-      : {
-          $type: 'app.bsky.feed.defs#skeletonReasonRepost',
-          repost: feedItem.uri,
-        },
-})

package/tests/algos/hot-classic.test.ts

@@ -1,87 +0,0 @@
-import AtpAgent, { AtUri } from '@atproto/api'
-import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
-import { makeAlgos } from '../../src'
-
-describe('algo hot-classic', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  // account dids, for convenience
-  let alice: string
-  let bob: string
-
-  const feedPublisherDid = 'did:example:feed-publisher'
-  const feedUri = AtUri.make(
-    feedPublisherDid,
-    'app.bsky.feed.generator',
-    'hot-classic',
-  ).toString()
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_algo_hot_classic',
-      bsky: { algos: makeAlgos(feedPublisherDid) },
-    })
-    agent = new AtpAgent({ service: network.bsky.url })
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network.close()
-  })
-
-  it('returns well liked posts', async () => {
-    const img = await sc.uploadFile(
-      alice,
-      '../dev-env/src/seed/img/key-landscape-small.jpg',
-      'image/jpeg',
-    )
-    const one = await sc.post(alice, 'first post', undefined, [img])
-    const two = await sc.post(bob, 'bobby boi')
-    const three = await sc.reply(bob, one.ref, one.ref, 'reply')
-
-    for (let i = 0; i < 12; i++) {
-      const name = `user${i}`
-      await sc.createAccount(name, {
-        handle: `user${i}.test`,
-        email: `user${i}@test.com`,
-        password: 'password',
-      })
-      await sc.like(sc.dids[name], one.ref)
-      await sc.like(sc.dids[name], two.ref)
-      await sc.like(sc.dids[name], three.ref)
-    }
-    await network.processAll()
-
-    const res = await agent.api.app.bsky.feed.getFeed(
-      { feed: feedUri },
-      { headers: await network.serviceHeaders(alice) },
-    )
-    const feedUris = res.data.feed.map((i) => i.post.uri).sort()
-    const expected = [one.ref.uriStr, two.ref.uriStr].sort()
-    expect(feedUris).toEqual(expected)
-  })
-
-  it('paginates', async () => {
-    const res = await agent.api.app.bsky.feed.getFeed(
-      { feed: feedUri },
-      { headers: await network.serviceHeaders(alice) },
-    )
-    const first = await agent.api.app.bsky.feed.getFeed(
-      { feed: feedUri, limit: 1 },
-      { headers: await network.serviceHeaders(alice) },
-    )
-    const second = await agent.api.app.bsky.feed.getFeed(
-      { feed: feedUri, cursor: first.data.cursor },
-      { headers: await network.serviceHeaders(alice) },
-    )
-
-    expect([...first.data.feed, ...second.data.feed]).toEqual(res.data.feed)
-  })
-})

package/tests/auto-moderator/fuzzy-matcher.test.ts

@@ -1,163 +0,0 @@
-import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
-import { FuzzyMatcher, encode } from '../../src/auto-moderator/fuzzy-matcher'
-import { AtpAgent } from '@atproto/api'
-import { ImageInvalidator } from '../../src/image/invalidator'
-
-describe('fuzzy matcher', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let fuzzyMatcher: FuzzyMatcher
-
-  let alice: string
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'fuzzy_matcher',
-      bsky: {
-        imgInvalidator: new NoopInvalidator(),
-        indexer: {
-          fuzzyMatchB64: encode(['evil']),
-        },
-      },
-    })
-    fuzzyMatcher = new FuzzyMatcher(['evil', 'mean', 'bad'], ['baddie'])
-    agent = network.pds.getClient()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    await network.processAll()
-    alice = sc.dids.alice
-  })
-
-  afterAll(async () => {
-    await network.close()
-  })
-
-  const getAllReports = () => {
-    return network.ozone.ctx.db.db
-      .selectFrom('moderation_event')
-      .where('action', '=', 'com.atproto.admin.defs#modEventReport')
-      .selectAll()
-      .orderBy('id', 'asc')
-      .execute()
-  }
-
-  it('identifies fuzzy matches', () => {
-    expect(fuzzyMatcher.getMatches('evil.john.test')).toMatchObject(['evil'])
-    expect(fuzzyMatcher.getMatches('john.evil.test')).toMatchObject(['evil'])
-    expect(fuzzyMatcher.getMatches('john.test.evil')).toMatchObject(['evil'])
-    expect(fuzzyMatcher.getMatches('ev1l.test.john')).toMatchObject(['evil'])
-    expect(fuzzyMatcher.getMatches('ev-1l.test.john')).toMatchObject(['evil'])
-    expect(fuzzyMatcher.getMatches('ev-11.test.john')).toMatchObject(['evil'])
-    expect(fuzzyMatcher.getMatches('ev.-1.l-test.john')).toMatchObject(['evil'])
-  })
-
-  it('identifies fuzzy false positivies', () => {
-    expect(fuzzyMatcher.getMatches('john.test')).toHaveLength(0)
-    expect(fuzzyMatcher.getMatches('good.john.test')).toHaveLength(0)
-    expect(fuzzyMatcher.getMatches('john.baddie.test')).toHaveLength(0)
-  })
-
-  it('doesnt label any of the content in the seed', async () => {
-    const reports = await getAllReports()
-    expect(reports.length).toBe(0)
-  })
-
-  it('flags a handle with an unacceptable word', async () => {
-    await sc.updateHandle(alice, 'evil.test')
-    await network.processAll()
-    const reports = await getAllReports()
-    expect(reports.length).toBe(1)
-    expect(reports.at(-1)?.subjectDid).toEqual(alice)
-  })
-
-  it('flags a profile with an unacceptable displayName', async () => {
-    const res = await agent.api.com.atproto.repo.putRecord(
-      {
-        repo: alice,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-        record: {
-          displayName: 'evil alice',
-        },
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    await network.processAll()
-
-    const reports = await getAllReports()
-    expect(reports.length).toBe(2)
-    expect(reports.at(-1)?.subjectUri).toEqual(res.data.uri)
-    expect(reports.at(-1)?.subjectCid).toEqual(res.data.cid)
-  })
-
-  it('flags a list with an unacceptable name', async () => {
-    const res = await agent.api.com.atproto.repo.createRecord(
-      {
-        repo: alice,
-        collection: 'app.bsky.graph.list',
-        rkey: 'list',
-        record: {
-          name: 'myevillist',
-          purpose: 'app.bsky.graph.defs#modList',
-          createdAt: new Date().toISOString(),
-        },
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    await network.processAll()
-
-    const reports = await getAllReports()
-    expect(reports.length).toBe(3)
-    expect(reports.at(-1)?.subjectUri).toEqual(res.data.uri)
-    expect(reports.at(-1)?.subjectCid).toEqual(res.data.cid)
-  })
-
-  it('flags a feed generator with an unacceptable displayName', async () => {
-    const res = await agent.api.com.atproto.repo.createRecord(
-      {
-        repo: alice,
-        collection: 'app.bsky.feed.generator',
-        rkey: 'generator',
-        record: {
-          did: alice,
-          displayName: 'myevilfeed',
-          createdAt: new Date().toISOString(),
-        },
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    await network.processAll()
-
-    const reports = await getAllReports()
-    expect(reports.length).toBe(4)
-    expect(reports.at(-1)?.subjectUri).toEqual(res.data.uri)
-    expect(reports.at(-1)?.subjectCid).toEqual(res.data.cid)
-  })
-
-  it('flags a record with an unacceptable rkey', async () => {
-    const res = await agent.api.com.atproto.repo.createRecord(
-      {
-        repo: alice,
-        collection: 'app.bsky.feed.generator',
-        rkey: 'evilrkey',
-        record: {
-          did: alice,
-          displayName: 'totally fine feed',
-          createdAt: new Date().toISOString(),
-        },
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    await network.processAll()
-
-    const reports = await getAllReports()
-    expect(reports.length).toBe(5)
-    expect(reports.at(-1)?.subjectUri).toEqual(res.data.uri)
-    expect(reports.at(-1)?.subjectCid).toEqual(res.data.cid)
-  })
-})
-
-class NoopInvalidator implements ImageInvalidator {
-  async invalidate() {}
-}

package/tests/auto-moderator/takedowns.test.ts

@@ -1,202 +0,0 @@
-import fs from 'fs/promises'
-import { TestNetwork, SeedClient, ImageRef, usersSeed } from '@atproto/dev-env'
-import { AtpAgent } from '@atproto/api'
-import { AutoModerator } from '../../src/auto-moderator'
-import { sha256RawToCid } from '@atproto/common'
-import { CID } from 'multiformats/cid'
-import { AtUri } from '@atproto/syntax'
-import { ImageFlagger } from '../../src/auto-moderator/abyss'
-import { ImageInvalidator } from '../../src/image/invalidator'
-import { sha256 } from '@atproto/crypto'
-import { ids } from '../../src/lexicon/lexicons'
-import { TestOzone } from '@atproto/dev-env/src/ozone'
-import { PrimaryDatabase } from '../../src'
-
-// outside of test suite so that TestLabeler can access them
-let badCid1: CID | undefined = undefined
-let badCid2: CID | undefined = undefined
-
-describe('takedowner', () => {
-  let network: TestNetwork
-  let ozone: TestOzone
-  let bskyDb: PrimaryDatabase
-  let autoMod: AutoModerator
-  let testInvalidator: TestInvalidator
-  let pdsAgent: AtpAgent
-  let sc: SeedClient
-  let alice: string
-  let badBlob1: ImageRef
-  let badBlob2: ImageRef
-  let goodBlob: ImageRef
-
-  beforeAll(async () => {
-    testInvalidator = new TestInvalidator()
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_automod_takedown',
-      bsky: {
-        imgInvalidator: testInvalidator,
-      },
-    })
-    ozone = network.ozone
-    bskyDb = network.bsky.ctx.db.getPrimary()
-    autoMod = network.bsky.indexer.ctx.autoMod
-    autoMod.imageFlagger = new TestFlagger()
-    pdsAgent = new AtpAgent({ service: network.pds.url })
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-    await network.processAll()
-    alice = sc.dids.alice
-    const fileBytes1 = await fs.readFile(
-      '../dev-env/src/seed/img/key-portrait-small.jpg',
-    )
-    const fileBytes2 = await fs.readFile(
-      '../dev-env/src/seed/img/key-portrait-large.jpg',
-    )
-    badCid1 = sha256RawToCid(await sha256(fileBytes1))
-    badCid2 = sha256RawToCid(await sha256(fileBytes2))
-    goodBlob = await sc.uploadFile(
-      alice,
-      '../dev-env/src/seed/img/key-landscape-small.jpg',
-      'image/jpeg',
-    )
-    badBlob1 = await sc.uploadFile(
-      alice,
-      '../dev-env/src/seed/img/key-portrait-small.jpg',
-      'image/jpeg',
-    )
-    badBlob2 = await sc.uploadFile(
-      alice,
-      '../dev-env/src/seed/img/key-portrait-large.jpg',
-      'image/jpeg',
-    )
-  })
-
-  afterAll(async () => {
-    await network.close()
-  })
-
-  it('takes down flagged content in posts', async () => {
-    const post = await sc.post(alice, 'blah', undefined, [goodBlob, badBlob1])
-    await network.processAll()
-    const [modStatus, takedownEvent] = await Promise.all([
-      ozone.ctx.db.db
-        .selectFrom('moderation_subject_status')
-        .where('did', '=', alice)
-        .where(
-          'recordPath',
-          '=',
-          `${post.ref.uri.collection}/${post.ref.uri.rkey}`,
-        )
-        .select(['takendown', 'id'])
-        .executeTakeFirst(),
-      ozone.ctx.db.db
-        .selectFrom('moderation_event')
-        .where('subjectDid', '=', alice)
-        .where('action', '=', 'com.atproto.admin.defs#modEventTakedown')
-        .selectAll()
-        .executeTakeFirst(),
-    ])
-    if (!modStatus || !takedownEvent) {
-      throw new Error('expected mod action')
-    }
-    expect(modStatus.takendown).toEqual(true)
-    const record = await bskyDb.db
-      .selectFrom('record')
-      .where('uri', '=', post.ref.uriStr)
-      .select('takedownRef')
-      .executeTakeFirst()
-    expect(record?.takedownRef).toEqual(`BSKY-TAKEDOWN-${takedownEvent.id}`)
-
-    const recordPds = await network.pds.ctx.actorStore.read(
-      post.ref.uri.hostname,
-      (store) =>
-        store.db.db
-          .selectFrom('record')
-          .where('uri', '=', post.ref.uriStr)
-          .select('takedownRef')
-          .executeTakeFirst(),
-    )
-    expect(recordPds?.takedownRef).toEqual(`BSKY-TAKEDOWN-${takedownEvent.id}`)
-
-    expect(testInvalidator.invalidated.length).toBe(1)
-    expect(testInvalidator.invalidated[0].subject).toBe(
-      badBlob1.image.ref.toString(),
-    )
-  })
-
-  it('takes down flagged content in profiles', async () => {
-    const res = await pdsAgent.api.com.atproto.repo.putRecord(
-      {
-        repo: alice,
-        collection: ids.AppBskyActorProfile,
-        rkey: 'self',
-        record: {
-          avatar: badBlob2.image,
-        },
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    await network.processAll()
-    const [modStatus, takedownEvent] = await Promise.all([
-      ozone.ctx.db.db
-        .selectFrom('moderation_subject_status')
-        .where('did', '=', alice)
-        .where('recordPath', '=', `${ids.AppBskyActorProfile}/self`)
-        .select(['takendown', 'id'])
-        .executeTakeFirst(),
-      ozone.ctx.db.db
-        .selectFrom('moderation_event')
-        .where('subjectDid', '=', alice)
-        .where(
-          'subjectUri',
-          '=',
-          AtUri.make(alice, ids.AppBskyActorProfile, 'self').toString(),
-        )
-        .where('action', '=', 'com.atproto.admin.defs#modEventTakedown')
-        .selectAll()
-        .executeTakeFirst(),
-    ])
-    if (!modStatus || !takedownEvent) {
-      throw new Error('expected mod action')
-    }
-    expect(modStatus.takendown).toEqual(true)
-    const recordBsky = await bskyDb.db
-      .selectFrom('record')
-      .where('uri', '=', res.data.uri)
-      .select('takedownRef')
-      .executeTakeFirst()
-    expect(recordBsky?.takedownRef).toEqual(`BSKY-TAKEDOWN-${takedownEvent.id}`)
-
-    const recordPds = await network.pds.ctx.actorStore.read(alice, (store) =>
-      store.db.db
-        .selectFrom('record')
-        .where('uri', '=', res.data.uri)
-        .select('takedownRef')
-        .executeTakeFirst(),
-    )
-    expect(recordPds?.takedownRef).toEqual(`BSKY-TAKEDOWN-${takedownEvent.id}`)
-
-    expect(testInvalidator.invalidated.length).toBe(2)
-    expect(testInvalidator.invalidated[1].subject).toBe(
-      badBlob2.image.ref.toString(),
-    )
-  })
-})
-
-class TestInvalidator implements ImageInvalidator {
-  public invalidated: { subject: string; paths: string[] }[] = []
-  async invalidate(subject: string, paths: string[]) {
-    this.invalidated.push({ subject, paths })
-  }
-}
-
-class TestFlagger implements ImageFlagger {
-  async scanImage(_did: string, cid: CID, _uri: AtUri): Promise<string[]> {
-    if (cid.equals(badCid1)) {
-      return ['kill-it']
-    } else if (cid.equals(badCid2)) {
-      return ['with-fire']
-    }
-    return []
-  }
-}