@atproto/bsky 0.0.123 → 0.0.125

package/src/lexicon/types/com/atproto/repo/listRecords.ts

@@ -20,10 +20,6 @@ export interface QueryParams {
   /** The number of records to return. */
   limit: number
   cursor?: string
-  /** DEPRECATED: The lowest sort-ordered rkey to start from (exclusive) */
-  rkeyStart?: string
-  /** DEPRECATED: The highest sort-ordered rkey to stop at (exclusive) */
-  rkeyEnd?: string
   /** Flag to reverse the order of the returned records. */
   reverse?: boolean
 }

package/src/lexicon/types/com/atproto/sync/getRecord.ts

@@ -19,8 +19,6 @@ export interface QueryParams {
   collection: string
   /** Record Key */
   rkey: string
-  /** DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit */
-  commit?: string
 }
 
 export type InputSchema = undefined

package/src/lexicon/types/com/atproto/sync/subscribeRepos.ts

@@ -22,9 +22,6 @@ export type OutputSchema =
   | $Typed<Sync>
   | $Typed<Identity>
   | $Typed<Account>
-  | $Typed<Handle>
-  | $Typed<Migrate>
-  | $Typed<Tombstone>
   | $Typed<Info>
   | { $type: string }
 export type HandlerError = ErrorFrame<'FutureCursor' | 'ConsumerTooSlow'>
@@ -150,62 +147,6 @@ export function validateAccount<V>(v: V) {
   return validate<Account & V>(v, id, hashAccount)
 }
 
-/** DEPRECATED -- Use #identity event instead */
-export interface Handle {
-  $type?: 'com.atproto.sync.subscribeRepos#handle'
-  seq: number
-  did: string
-  handle: string
-  time: string
-}
-
-const hashHandle = 'handle'
-
-export function isHandle<V>(v: V) {
-  return is$typed(v, id, hashHandle)
-}
-
-export function validateHandle<V>(v: V) {
-  return validate<Handle & V>(v, id, hashHandle)
-}
-
-/** DEPRECATED -- Use #account event instead */
-export interface Migrate {
-  $type?: 'com.atproto.sync.subscribeRepos#migrate'
-  seq: number
-  did: string
-  migrateTo: string | null
-  time: string
-}
-
-const hashMigrate = 'migrate'
-
-export function isMigrate<V>(v: V) {
-  return is$typed(v, id, hashMigrate)
-}
-
-export function validateMigrate<V>(v: V) {
-  return validate<Migrate & V>(v, id, hashMigrate)
-}
-
-/** DEPRECATED -- Use #account event instead */
-export interface Tombstone {
-  $type?: 'com.atproto.sync.subscribeRepos#tombstone'
-  seq: number
-  did: string
-  time: string
-}
-
-const hashTombstone = 'tombstone'
-
-export function isTombstone<V>(v: V) {
-  return is$typed(v, id, hashTombstone)
-}
-
-export function validateTombstone<V>(v: V) {
-  return validate<Tombstone & V>(v, id, hashTombstone)
-}
-
 export interface Info {
   $type?: 'com.atproto.sync.subscribeRepos#info'
   name: 'OutdatedCursor' | (string & {})

package/src/logger.ts

@@ -15,6 +15,8 @@ export const hydrationLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky:hydration')
 export const featureGatesLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky:featuregates')
+export const dataplaneLogger: ReturnType<typeof subsystemLogger> =
+  subsystemLogger('bsky:dp')
 export const httpLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky')
 

package/src/views/index.ts

@@ -592,12 +592,15 @@ export class Views {
   ): Un$Typed<LabelerViewDetailed> | undefined {
     const baseView = this.labeler(did, state)
     if (!baseView) return
-    const record = state.labelers?.get(did)
-    if (!record) return
+    const labeler = state.labelers?.get(did)
+    if (!labeler) return
 
     return {
       ...baseView,
-      policies: record.record.policies,
+      policies: labeler.record.policies,
+      reasonTypes: labeler.record.reasonTypes,
+      subjectTypes: labeler.record.subjectTypes,
+      subjectCollections: labeler.record.subjectCollections,
     }
   }
 

package/tests/etcd.test.ts

@@ -0,0 +1,301 @@
+import EventEmitter from 'node:events'
+import { Etcd3, IKeyValue } from 'etcd3'
+import { EtcdHostList } from '../src'
+import { EtcdMap } from '../src/etcd'
+
+describe('etcd', () => {
+  describe('EtcdMap', () => {
+    it('initializes values based on current keys', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: '1' })
+      etcd.watcher.set('service/b', { value: '2' })
+      etcd.watcher.set('service/c', { value: '3' })
+      const map = new EtcdMap(etcd as unknown as Etcd3)
+      await map.connect()
+      expect(map.get('service/a')).toBe('1')
+      expect(map.get('service/b')).toBe('2')
+      expect(map.get('service/c')).toBe('3')
+      expect([...map.values()]).toEqual(['1', '2', '3'])
+    })
+
+    it('maintains key updates', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: '1' })
+      etcd.watcher.set('service/b', { value: '2' })
+      etcd.watcher.set('service/c', { value: '3' })
+      const map = new EtcdMap(etcd as unknown as Etcd3)
+      await map.connect()
+      etcd.watcher.set('service/b', { value: '4' })
+      expect(map.get('service/a')).toBe('1')
+      expect(map.get('service/b')).toBe('4')
+      expect(map.get('service/c')).toBe('3')
+      expect([...map.values()]).toEqual(['1', '4', '3'])
+    })
+
+    it('maintains key creates', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: '1' })
+      const map = new EtcdMap(etcd as unknown as Etcd3)
+      await map.connect()
+      etcd.watcher.set('service/b', { value: '2' })
+      expect(map.get('service/a')).toBe('1')
+      expect(map.get('service/b')).toBe('2')
+      expect([...map.values()]).toEqual(['1', '2'])
+    })
+
+    it('maintains key deletions', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: '1' })
+      etcd.watcher.set('service/b', { value: '2' })
+      const map = new EtcdMap(etcd as unknown as Etcd3)
+      await map.connect()
+      etcd.watcher.del('service/b')
+      expect(map.get('service/a')).toBe('1')
+      expect(map.get('service/b')).toBe(null)
+      expect([...map.values()]).toEqual(['1'])
+    })
+
+    it('notifies of updates', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: '1' })
+      etcd.watcher.set('service/b', { value: '2' })
+      const map = new EtcdMap(etcd as unknown as Etcd3)
+      await map.connect()
+      const states: string[][] = [[...map.values()]]
+      map.onUpdate((update) => {
+        states.push([...update.values()])
+      })
+      etcd.watcher.set('service/c', { value: '3' })
+      etcd.watcher.del('service/b')
+      etcd.watcher.set('service/a', { value: '4' })
+      expect(states).toEqual([
+        ['1', '2'],
+        ['1', '2', '3'],
+        ['1', '3'],
+        ['4', '3'],
+      ])
+    })
+
+    it('ignores out-of-order updates', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: '1' })
+      const map = new EtcdMap(etcd as unknown as Etcd3)
+      await map.connect()
+      const states: string[][] = [[...map.values()]]
+      map.onUpdate((update) => {
+        states.push([...update.values()])
+      })
+      etcd.watcher.set('service/a', { value: '2' })
+      etcd.watcher.set('service/a', { value: '3', overrideRev: 1 }) // old rev
+      etcd.watcher.set('service/a', { value: '4' })
+      expect(map.get('service/a')).toBe('4')
+      expect(states).toEqual([['1'], ['2'], ['4']]) // never witnessed 3
+    })
+  })
+
+  describe('EtcdHostList', () => {
+    it('initializes values based on current keys', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: 'http://192.168.1.1' })
+      etcd.watcher.set('service/b', { value: 'http://192.168.1.2' })
+      etcd.watcher.set('service/c', { value: 'http://192.168.1.3' })
+      const hostList = new EtcdHostList(etcd as unknown as Etcd3, '')
+      await hostList.connect()
+      expect([...hostList.get()]).toEqual([
+        'http://192.168.1.1',
+        'http://192.168.1.2',
+        'http://192.168.1.3',
+      ])
+    })
+
+    it('maintains key updates', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: 'http://192.168.1.1' })
+      etcd.watcher.set('service/b', { value: 'http://192.168.1.2' })
+      etcd.watcher.set('service/c', { value: 'http://192.168.1.3' })
+      const hostList = new EtcdHostList(etcd as unknown as Etcd3, '')
+      await hostList.connect()
+      etcd.watcher.set('service/b', { value: 'http://192.168.1.4' })
+      expect([...hostList.get()]).toEqual([
+        'http://192.168.1.1',
+        'http://192.168.1.4',
+        'http://192.168.1.3',
+      ])
+    })
+
+    it('maintains key creates', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: 'http://192.168.1.1' })
+      const hostList = new EtcdHostList(etcd as unknown as Etcd3, '')
+      await hostList.connect()
+      etcd.watcher.set('service/b', { value: 'http://192.168.1.2' })
+      expect([...hostList.get()]).toEqual([
+        'http://192.168.1.1',
+        'http://192.168.1.2',
+      ])
+    })
+
+    it('maintains key deletions', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: 'http://192.168.1.1' })
+      etcd.watcher.set('service/b', { value: 'http://192.168.1.2' })
+      const hostList = new EtcdHostList(etcd as unknown as Etcd3, '')
+      await hostList.connect()
+      etcd.watcher.del('service/b')
+      expect([...hostList.get()]).toEqual(['http://192.168.1.1'])
+    })
+
+    it('notifies of updates', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: 'http://192.168.1.1' })
+      etcd.watcher.set('service/b', { value: 'http://192.168.1.2' })
+      const hostList = new EtcdHostList(etcd as unknown as Etcd3, '')
+      await hostList.connect()
+      const states: string[][] = [[...hostList.get()]]
+      hostList.onUpdate((updated) => {
+        expect([...updated]).toEqual([...hostList.get()])
+        states.push([...updated])
+      })
+      etcd.watcher.set('service/c', { value: 'http://192.168.1.3' })
+      etcd.watcher.del('service/b')
+      etcd.watcher.set('service/a', { value: 'http://192.168.1.4' })
+      expect(states).toEqual([
+        ['http://192.168.1.1', 'http://192.168.1.2'],
+        ['http://192.168.1.1', 'http://192.168.1.2', 'http://192.168.1.3'],
+        ['http://192.168.1.1', 'http://192.168.1.3'],
+        ['http://192.168.1.4', 'http://192.168.1.3'],
+      ])
+    })
+
+    it('ignores bad host values', async () => {
+      const etcd = new MockEtcd()
+      etcd.watcher.set('service/a', { value: 'not-a-host' })
+      etcd.watcher.set('service/b', { value: 'http://192.168.1.2' })
+      const hostList = new EtcdHostList(etcd as unknown as Etcd3, '')
+      await hostList.connect()
+      expect([...hostList.get()]).toEqual(['http://192.168.1.2'])
+      etcd.watcher.set('service/a', { value: 'http://192.168.1.1' })
+      etcd.watcher.set('service/c', { value: 'not-a-host' })
+      expect([...hostList.get()]).toEqual([
+        'http://192.168.1.1',
+        'http://192.168.1.2',
+      ])
+      etcd.watcher.set('service/c', { value: 'http://192.168.1.3' })
+      expect([...hostList.get()]).toEqual([
+        'http://192.168.1.1',
+        'http://192.168.1.2',
+        'http://192.168.1.3',
+      ])
+    })
+
+    it('falls back to static host list when uninitialized or no keys available', async () => {
+      const etcd = new MockEtcd()
+      const hostList = new EtcdHostList(etcd as unknown as Etcd3, '', [
+        'http://10.0.0.1',
+        'http://10.0.0.2',
+      ])
+      etcd.watcher.set('service/a', { value: 'http://192.168.1.1' })
+      expect([...hostList.get()]).toEqual([
+        'http://10.0.0.1',
+        'http://10.0.0.2',
+      ])
+      await hostList.connect()
+      const states: string[][] = [[...hostList.get()]]
+      hostList.onUpdate((updated) => {
+        states.push([...updated])
+      })
+      etcd.watcher.del('service/a')
+      etcd.watcher.set('service/b', { value: 'http://192.168.1.2' })
+      expect(states).toEqual([
+        ['http://192.168.1.1'],
+        ['http://10.0.0.1', 'http://10.0.0.2'],
+        ['http://192.168.1.2'],
+      ])
+    })
+  })
+})
+
+class MockEtcd {
+  public watcher = new MockWatcher()
+  watch() {
+    const watcher = this.watcher
+    return {
+      prefix() {
+        return {
+          watcher() {
+            return watcher
+          },
+        }
+      },
+    }
+  }
+  getAll() {
+    const watcher = this.watcher
+    return {
+      prefix() {
+        return {
+          async exec(): Promise<{ kvs: IKeyValue[] }> {
+            return { kvs: watcher.getAll() }
+          },
+        }
+      },
+    }
+  }
+}
+
+class MockWatcher extends EventEmitter {
+  rev = 1
+  kvs: IKeyValue[] = []
+  constructor() {
+    super()
+    process.nextTick(() => this.emit('connected', {}))
+  }
+  get(key: string): IKeyValue | null {
+    const found = this.kvs.find((kv) => kv.key.toString() === key)
+    return found ?? null
+  }
+  getAll(): IKeyValue[] {
+    return [...this.kvs]
+  }
+  set(
+    key: string,
+    { value, overrideRev }: { value: string; overrideRev?: number },
+  ) {
+    const found = this.kvs.find((kv) => kv.key.toString() === key)
+    const rev = overrideRev ?? ++this.rev
+    if (found) {
+      found.value = Buffer.from(value)
+      found.mod_revision = rev.toString()
+      found.version = (parseInt(found.version, 10) + 1).toString()
+      this.emit('put', found)
+    } else {
+      const created = {
+        key: Buffer.from(key),
+        value: Buffer.from(value),
+        create_revision: rev.toString(),
+        mod_revision: rev.toString(),
+        version: '1',
+        lease: '0',
+      }
+      this.kvs.push(created)
+      this.emit('put', created)
+    }
+  }
+  del(key: string) {
+    const foundIdx = this.kvs.findIndex((kv) => kv.key.toString() === key)
+    if (foundIdx === -1) return
+    const [deleted] = this.kvs.splice(foundIdx, 1)
+    const rev = ++this.rev
+    deleted.value = Buffer.from('')
+    deleted.mod_revision = rev.toString()
+    deleted.create_revision = '0'
+    deleted.version = '0'
+    this.emit('delete', deleted)
+  }
+  on(evt: 'connected', listener: (res: unknown) => void): any
+  on(evt: 'put', listener: (kv: IKeyValue) => void): any
+  on(evt: 'delete', listener: (kv: IKeyValue) => void): any
+  on(evt: string, listener: (...args: any[]) => void) {
+    super.on(evt, listener)
+  }
+}

package/tests/views/__snapshots__/labeler-service.test.ts.snap

@@ -170,3 +170,49 @@ Object {
   ],
 }
 `;
+
+exports[`labeler service views returns additional labeler data 1`] = `
+Object {
+  "views": Array [
+    Object {
+      "$type": "app.bsky.labeler.defs#labelerViewDetailed",
+      "cid": "cids(0)",
+      "creator": Object {
+        "associated": Object {
+          "labeler": true,
+        },
+        "did": "user(0)",
+        "handle": "carol.test",
+        "labels": Array [],
+        "viewer": Object {
+          "blockedBy": false,
+          "following": "record(1)",
+          "muted": false,
+        },
+      },
+      "indexedAt": "1970-01-01T00:00:00.000Z",
+      "labels": Array [],
+      "likeCount": 0,
+      "policies": Object {
+        "labelValues": Array [
+          "spam",
+          "!hide",
+          "scam",
+          "impersonation",
+        ],
+      },
+      "reasonTypes": Array [
+        "com.atproto.moderation.defs#reasonOther",
+      ],
+      "subjectCollections": Array [
+        "app.bsky.feed.post",
+      ],
+      "subjectTypes": Array [
+        "record",
+      ],
+      "uri": "record(0)",
+      "viewer": Object {},
+    },
+  ],
+}
+`;

package/tests/views/__snapshots__/notifications.test.ts.snap

@@ -384,7 +384,7 @@ Array [
 
 exports[`notification views fetches notifications with default priority 1`] = `
 Object {
-  "cursor": "0000000000000__bafycid",
+  "cursor": "1970-01-01T00:00:00.000Z",
   "notifications": Array [
     Object {
       "author": Object {
@@ -486,7 +486,7 @@ Object {
 
 exports[`notification views fetches notifications with explicit priority 1`] = `
 Object {
-  "cursor": "0000000000000__bafycid",
+  "cursor": "1970-01-01T00:00:00.000Z",
   "notifications": Array [
     Object {
       "author": Object {
@@ -588,7 +588,7 @@ Object {
 
 exports[`notification views fetches notifications with explicit priority 2`] = `
 Object {
-  "cursor": "0000000000000__bafycid",
+  "cursor": "1970-01-01T00:00:00.000Z",
   "notifications": Array [
     Object {
       "author": Object {

package/tests/views/labeler-service.test.ts

@@ -1,5 +1,9 @@
 import assert from 'node:assert'
-import { AtpAgent } from '@atproto/api'
+import {
+  AppBskyLabelerDefs,
+  AtpAgent,
+  ComAtprotoModerationDefs,
+} from '@atproto/api'
 import { RecordRef, SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
 import { ids } from '../../src/lexicon/lexicons'
 import { isView as isRecordEmbedView } from '../../src/lexicon/types/app/bsky/embed/record'
@@ -14,6 +18,7 @@ describe('labeler service views', () => {
   // account dids, for convenience
   let alice: string
   let bob: string
+  let carol: string
 
   let aliceService: RecordRef
 
@@ -27,6 +32,7 @@ describe('labeler service views', () => {
     await basicSeed(sc)
     alice = sc.dids.alice
     bob = sc.dids.bob
+    carol = sc.dids.carol
 
     const aliceRes = await pdsAgent.api.com.atproto.repo.createRecord(
       {
@@ -190,4 +196,47 @@ describe('labeler service views', () => {
     // Cleanup
     await network.bsky.ctx.dataplane.untakedownActor({ did: alice })
   })
+
+  it(`returns additional labeler data`, async () => {
+    await pdsAgent.api.com.atproto.repo.createRecord(
+      {
+        repo: carol,
+        collection: ids.AppBskyLabelerService,
+        rkey: 'self',
+        record: {
+          policies: {
+            labelValues: ['spam', '!hide', 'scam', 'impersonation'],
+          },
+          createdAt: new Date().toISOString(),
+          reasonTypes: [ComAtprotoModerationDefs.REASONOTHER],
+          subjectTypes: ['record'],
+          subjectCollections: ['app.bsky.feed.post'],
+        },
+      },
+      { headers: sc.getHeaders(carol), encoding: 'application/json' },
+    )
+    await network.processAll()
+
+    const view = await agent.api.app.bsky.labeler.getServices(
+      { dids: [carol], detailed: true },
+      {
+        headers: await network.serviceHeaders(
+          bob,
+          ids.AppBskyLabelerGetServices,
+        ),
+      },
+    )
+
+    const labelerView = view.data.views[0]
+    expect(AppBskyLabelerDefs.isLabelerViewDetailed(labelerView)).toBe(true)
+    // for TS only
+    if (!AppBskyLabelerDefs.isLabelerViewDetailed(labelerView)) return
+    expect(labelerView).toBeTruthy()
+    expect(labelerView.reasonTypes).toEqual([
+      ComAtprotoModerationDefs.REASONOTHER,
+    ])
+    expect(labelerView.subjectTypes).toEqual(['record'])
+    expect(labelerView.subjectCollections).toEqual(['app.bsky.feed.post'])
+    expect(forSnapshot(view.data)).toMatchSnapshot()
+  })
 })