@atproto/bsky 0.0.25 → 0.0.27

package/src/ingester/config.ts

@@ -10,6 +10,10 @@ export interface IngesterConfigValues {
   redisPassword?: string
   repoProvider: string
   labelProvider?: string
+  bsyncUrl?: string
+  bsyncApiKey?: string
+  bsyncHttpVersion?: '1.1' | '2'
+  bsyncIgnoreBadTls?: boolean
   ingesterPartitionCount: number
   ingesterNamespace?: string
   ingesterSubLockId?: number
@@ -42,6 +46,16 @@ export class IngesterConfig {
       overrides?.redisPassword || process.env.REDIS_PASSWORD || undefined
     const repoProvider = overrides?.repoProvider || process.env.REPO_PROVIDER // E.g. ws://abc.com:4000
     const labelProvider = overrides?.labelProvider || process.env.LABEL_PROVIDER
+    const bsyncUrl =
+      overrides?.bsyncUrl || process.env.BSKY_BSYNC_URL || undefined
+    const bsyncApiKey =
+      overrides?.bsyncApiKey || process.env.BSKY_BSYNC_API_KEY || undefined
+    const bsyncHttpVersion =
+      overrides?.bsyncHttpVersion || process.env.BSKY_BSYNC_HTTP_VERSION || '2'
+    const bsyncIgnoreBadTls =
+      overrides?.bsyncIgnoreBadTls ||
+      process.env.BSKY_BSYNC_IGNORE_BAD_TLS === 'true'
+    assert(bsyncHttpVersion === '1.1' || bsyncHttpVersion === '2')
     const ingesterPartitionCount =
       overrides?.ingesterPartitionCount ||
       maybeParseInt(process.env.INGESTER_PARTITION_COUNT)
@@ -72,6 +86,10 @@ export class IngesterConfig {
       redisPassword,
       repoProvider,
       labelProvider,
+      bsyncUrl,
+      bsyncApiKey,
+      bsyncHttpVersion,
+      bsyncIgnoreBadTls,
       ingesterPartitionCount,
       ingesterSubLockId,
       ingesterNamespace,
@@ -117,6 +135,22 @@ export class IngesterConfig {
     return this.cfg.labelProvider
   }
 
+  get bsyncUrl() {
+    return this.cfg.bsyncUrl
+  }
+
+  get bsyncApiKey() {
+    return this.cfg.bsyncApiKey
+  }
+
+  get bsyncHttpVersion() {
+    return this.cfg.bsyncHttpVersion
+  }
+
+  get bsyncIgnoreBadTls() {
+    return this.cfg.bsyncIgnoreBadTls
+  }
+
   get ingesterPartitionCount() {
     return this.cfg.ingesterPartitionCount
   }

package/src/ingester/context.ts

@@ -2,6 +2,7 @@ import { PrimaryDatabase } from '../db'
 import { Redis } from '../redis'
 import { IngesterConfig } from './config'
 import { LabelSubscription } from './label-subscription'
+import { MuteSubscription } from './mute-subscription'
 
 export class IngesterContext {
   constructor(
@@ -10,6 +11,7 @@ export class IngesterContext {
       redis: Redis
       cfg: IngesterConfig
       labelSubscription?: LabelSubscription
+      muteSubscription?: MuteSubscription
     },
   ) {}
 
@@ -28,6 +30,10 @@ export class IngesterContext {
   get labelSubscription(): LabelSubscription | undefined {
     return this.opts.labelSubscription
   }
+
+  get muteSubscription(): MuteSubscription | undefined {
+    return this.opts.muteSubscription
+  }
 }
 
 export default IngesterContext

package/src/ingester/index.ts

@@ -5,7 +5,9 @@ import { Redis } from '../redis'
 import { IngesterConfig } from './config'
 import { IngesterContext } from './context'
 import { IngesterSubscription } from './subscription'
+import { authWithApiKey, createBsyncClient } from '../bsync'
 import { LabelSubscription } from './label-subscription'
+import { MuteSubscription } from './mute-subscription'
 
 export { IngesterConfig } from './config'
 export type { IngesterConfigValues } from './config'
@@ -27,14 +29,28 @@ export class BskyIngester {
     cfg: IngesterConfig
   }): BskyIngester {
     const { db, redis, cfg } = opts
+    const bsyncClient = cfg.bsyncUrl
+      ? createBsyncClient({
+          baseUrl: cfg.bsyncUrl,
+          httpVersion: cfg.bsyncHttpVersion ?? '2',
+          nodeOptions: { rejectUnauthorized: !cfg.bsyncIgnoreBadTls },
+          interceptors: cfg.bsyncApiKey
+            ? [authWithApiKey(cfg.bsyncApiKey)]
+            : [],
+        })
+      : undefined
     const labelSubscription = cfg.labelProvider
       ? new LabelSubscription(db, cfg.labelProvider)
       : undefined
+    const muteSubscription = bsyncClient
+      ? new MuteSubscription(db, redis, bsyncClient)
+      : undefined
     const ctx = new IngesterContext({
       db,
       redis,
       cfg,
       labelSubscription,
+      muteSubscription,
     })
     const sub = new IngesterSubscription(ctx, {
       service: cfg.repoProvider,
@@ -73,11 +89,13 @@ export class BskyIngester {
       )
     }, 500)
     await this.ctx.labelSubscription?.start()
+    await this.ctx.muteSubscription?.start()
     this.sub.run()
     return this
   }
 
   async destroy(opts?: { skipDb: boolean }): Promise<void> {
+    await this.ctx.muteSubscription?.destroy()
     await this.ctx.labelSubscription?.destroy()
     await this.sub.destroy()
     clearInterval(this.subStatsInterval)

package/src/ingester/mute-subscription.ts

@@ -0,0 +1,213 @@
+import assert from 'node:assert'
+import { PrimaryDatabase } from '../db'
+import { Redis } from '../redis'
+import { BsyncClient, Code, isBsyncError } from '../bsync'
+import { MuteOperation, MuteOperation_Type } from '../proto/bsync_pb'
+import logger from './logger'
+import { wait } from '@atproto/common'
+import {
+  AtUri,
+  InvalidDidError,
+  ensureValidAtUri,
+  ensureValidDid,
+} from '@atproto/syntax'
+import { ids } from '../lexicon/lexicons'
+
+const CURSOR_KEY = 'ingester:mute:cursor'
+
+export class MuteSubscription {
+  ac = new AbortController()
+  running: Promise<void> | undefined
+  cursor: string | null = null
+
+  constructor(
+    public db: PrimaryDatabase,
+    public redis: Redis,
+    public bsyncClient: BsyncClient,
+  ) {}
+
+  async start() {
+    if (this.running) return
+    this.ac = new AbortController()
+    this.running = this.run()
+      .catch((err) => {
+        // allow this to cause an unhandled rejection, let deployment handle the crash.
+        logger.error({ err }, 'mute subscription crashed')
+        throw err
+      })
+      .finally(() => (this.running = undefined))
+  }
+
+  private async run() {
+    this.cursor = await this.getCursor()
+    while (!this.ac.signal.aborted) {
+      try {
+        // get page of mute ops, long-polling
+        const page = await this.bsyncClient.scanMuteOperations(
+          {
+            limit: 100,
+            cursor: this.cursor ?? undefined,
+          },
+          { signal: this.ac.signal },
+        )
+        if (!page.cursor) {
+          throw new BadResponseError('cursor is missing')
+        }
+        // process
+        const now = new Date()
+        for (const op of page.operations) {
+          if (this.ac.signal.aborted) return
+          if (op.type === MuteOperation_Type.ADD) {
+            await this.handleAddOp(op, now)
+          } else if (op.type === MuteOperation_Type.REMOVE) {
+            await this.handleRemoveOp(op)
+          } else if (op.type === MuteOperation_Type.CLEAR) {
+            await this.handleClearOp(op)
+          } else {
+            logger.warn(
+              { id: op.id, type: op.type },
+              'unknown mute subscription op type',
+            )
+          }
+        }
+        // update cursor
+        await this.setCursor(page.cursor)
+        this.cursor = page.cursor
+      } catch (err) {
+        if (isBsyncError(err, Code.Canceled)) {
+          return // canceled, probably from destroy()
+        }
+        if (err instanceof BadResponseError) {
+          logger.warn({ err }, 'bad response from bsync')
+        } else {
+          logger.error({ err }, 'unexpected error processing mute subscription')
+        }
+        await wait(1000) // wait a second before trying again
+      }
+    }
+  }
+
+  async handleAddOp(op: MuteOperation, createdAt: Date) {
+    assert(op.type === MuteOperation_Type.ADD)
+    if (!isValidDid(op.actorDid)) {
+      logger.warn({ id: op.id, type: op.type }, 'bad actor in mute op')
+      return
+    }
+    if (isValidDid(op.subject)) {
+      await this.db.db
+        .insertInto('mute')
+        .values({
+          subjectDid: op.subject,
+          mutedByDid: op.actorDid,
+          createdAt: createdAt.toISOString(),
+        })
+        .onConflict((oc) => oc.doNothing())
+        .execute()
+    } else {
+      const listUri = isValidAtUri(op.subject)
+        ? new AtUri(op.subject)
+        : undefined
+      if (listUri?.collection !== ids.AppBskyGraphList) {
+        logger.warn({ id: op.id, type: op.type }, 'bad subject in mute op')
+        return
+      }
+      await this.db.db
+        .insertInto('list_mute')
+        .values({
+          listUri: op.subject,
+          mutedByDid: op.actorDid,
+          createdAt: createdAt.toISOString(),
+        })
+        .onConflict((oc) => oc.doNothing())
+        .execute()
+    }
+  }
+
+  async handleRemoveOp(op: MuteOperation) {
+    assert(op.type === MuteOperation_Type.REMOVE)
+    if (!isValidDid(op.actorDid)) {
+      logger.warn({ id: op.id, type: op.type }, 'bad actor in mute op')
+      return
+    }
+    if (isValidDid(op.subject)) {
+      await this.db.db
+        .deleteFrom('mute')
+        .where('subjectDid', '=', op.subject)
+        .where('mutedByDid', '=', op.actorDid)
+        .execute()
+    } else {
+      const listUri = isValidAtUri(op.subject)
+        ? new AtUri(op.subject)
+        : undefined
+      if (listUri?.collection !== ids.AppBskyGraphList) {
+        logger.warn({ id: op.id, type: op.type }, 'bad subject in mute op')
+        return
+      }
+      await this.db.db
+        .deleteFrom('list_mute')
+        .where('listUri', '=', op.subject)
+        .where('mutedByDid', '=', op.actorDid)
+        .execute()
+    }
+  }
+
+  async handleClearOp(op: MuteOperation) {
+    assert(op.type === MuteOperation_Type.CLEAR)
+    if (!isValidDid(op.actorDid)) {
+      logger.warn({ id: op.id, type: op.type }, 'bad actor in mute op')
+      return
+    }
+    if (op.subject) {
+      logger.warn({ id: op.id, type: op.type }, 'bad subject in mute op')
+      return
+    }
+    await this.db.db
+      .deleteFrom('mute')
+      .where('mutedByDid', '=', op.actorDid)
+      .execute()
+    await this.db.db
+      .deleteFrom('list_mute')
+      .where('mutedByDid', '=', op.actorDid)
+      .execute()
+  }
+
+  async getCursor(): Promise<string | null> {
+    return await this.redis.get(CURSOR_KEY)
+  }
+
+  async setCursor(cursor: string): Promise<void> {
+    await this.redis.set(CURSOR_KEY, cursor)
+  }
+
+  async destroy() {
+    this.ac.abort()
+    await this.running
+  }
+
+  get destroyed() {
+    return this.ac.signal.aborted
+  }
+}
+
+class BadResponseError extends Error {}
+
+const isValidDid = (did: string) => {
+  try {
+    ensureValidDid(did)
+    return true
+  } catch (err) {
+    if (err instanceof InvalidDidError) {
+      return false
+    }
+    throw err
+  }
+}
+
+const isValidAtUri = (uri: string) => {
+  try {
+    ensureValidAtUri(uri)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/lexicon/index.ts

@@ -114,6 +114,7 @@ import * as AppBskyGraphGetListBlocks from './types/app/bsky/graph/getListBlocks
 import * as AppBskyGraphGetListMutes from './types/app/bsky/graph/getListMutes'
 import * as AppBskyGraphGetLists from './types/app/bsky/graph/getLists'
 import * as AppBskyGraphGetMutes from './types/app/bsky/graph/getMutes'
+import * as AppBskyGraphGetRelationships from './types/app/bsky/graph/getRelationships'
 import * as AppBskyGraphGetSuggestedFollowsByActor from './types/app/bsky/graph/getSuggestedFollowsByActor'
 import * as AppBskyGraphMuteActor from './types/app/bsky/graph/muteActor'
 import * as AppBskyGraphMuteActorList from './types/app/bsky/graph/muteActorList'
@@ -124,6 +125,7 @@ import * as AppBskyNotificationListNotifications from './types/app/bsky/notifica
 import * as AppBskyNotificationRegisterPush from './types/app/bsky/notification/registerPush'
 import * as AppBskyNotificationUpdateSeen from './types/app/bsky/notification/updateSeen'
 import * as AppBskyUnspeccedGetPopularFeedGenerators from './types/app/bsky/unspecced/getPopularFeedGenerators'
+import * as AppBskyUnspeccedGetTaggedSuggestions from './types/app/bsky/unspecced/getTaggedSuggestions'
 import * as AppBskyUnspeccedGetTimelineSkeleton from './types/app/bsky/unspecced/getTimelineSkeleton'
 import * as AppBskyUnspeccedSearchActorsSkeleton from './types/app/bsky/unspecced/searchActorsSkeleton'
 import * as AppBskyUnspeccedSearchPostsSkeleton from './types/app/bsky/unspecced/searchPostsSkeleton'
@@ -1479,6 +1481,17 @@ export class AppBskyGraphNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  getRelationships<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppBskyGraphGetRelationships.Handler<ExtractAuth<AV>>,
+      AppBskyGraphGetRelationships.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.bsky.graph.getRelationships' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getSuggestedFollowsByActor<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
@@ -1613,6 +1626,17 @@ export class AppBskyUnspeccedNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  getTaggedSuggestions<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppBskyUnspeccedGetTaggedSuggestions.Handler<ExtractAuth<AV>>,
+      AppBskyUnspeccedGetTaggedSuggestions.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.bsky.unspecced.getTaggedSuggestions' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getTimelineSkeleton<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,

package/src/lexicon/lexicons.ts

@@ -4615,6 +4615,7 @@ export const schemaDict = {
             'lex:app.bsky.actor.defs#personalDetailsPref',
             'lex:app.bsky.actor.defs#feedViewPref',
             'lex:app.bsky.actor.defs#threadViewPref',
+            'lex:app.bsky.actor.defs#interestsPref',
           ],
         },
       },
@@ -4718,6 +4719,23 @@ export const schemaDict = {
           },
         },
       },
+      interestsPref: {
+        type: 'object',
+        required: ['tags'],
+        properties: {
+          tags: {
+            type: 'array',
+            maxLength: 100,
+            items: {
+              type: 'string',
+              maxLength: 640,
+              maxGraphemes: 64,
+            },
+            description:
+              "A list of tags which describe the account owner's interests gathered during onboarding.",
+          },
+        },
+      },
     },
   },
   AppBskyActorGetPreferences: {
@@ -6925,6 +6943,45 @@ export const schemaDict = {
           },
         },
       },
+      notFoundActor: {
+        type: 'object',
+        description: 'indicates that a handle or DID could not be resolved',
+        required: ['actor', 'notFound'],
+        properties: {
+          actor: {
+            type: 'string',
+            format: 'at-identifier',
+          },
+          notFound: {
+            type: 'boolean',
+            const: true,
+          },
+        },
+      },
+      relationship: {
+        type: 'object',
+        description:
+          'lists the bi-directional graph relationships between one actor (not indicated in the object), and the target actors (the DID included in the object)',
+        required: ['did'],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
+          },
+          following: {
+            type: 'string',
+            format: 'at-uri',
+            description:
+              'if the actor follows this DID, this is the AT-URI of the follow record',
+          },
+          followedBy: {
+            type: 'string',
+            format: 'at-uri',
+            description:
+              'if the actor is followed by this DID, contains the AT-URI of the follow record',
+          },
+        },
+      },
     },
   },
   AppBskyGraphFollow: {
@@ -7328,6 +7385,65 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyGraphGetRelationships: {
+    lexicon: 1,
+    id: 'app.bsky.graph.getRelationships',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Enumerates public relationships between one account, and a list of other accounts',
+        parameters: {
+          type: 'params',
+          required: ['actor'],
+          properties: {
+            actor: {
+              type: 'string',
+              format: 'at-identifier',
+            },
+            others: {
+              type: 'array',
+              maxLength: 30,
+              items: {
+                type: 'string',
+                format: 'at-identifier',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['relationships'],
+            properties: {
+              actor: {
+                type: 'string',
+                format: 'did',
+              },
+              relationships: {
+                type: 'array',
+                items: {
+                  type: 'union',
+                  refs: [
+                    'lex:app.bsky.graph.defs#relationship',
+                    'lex:app.bsky.graph.defs#notFoundActor',
+                  ],
+                },
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'ActorNotFound',
+            description:
+              'the primary actor at-identifier could not be resolved',
+          },
+        ],
+      },
+    },
+  },
   AppBskyGraphGetSuggestedFollowsByActor: {
     lexicon: 1,
     id: 'app.bsky.graph.getSuggestedFollowsByActor',
@@ -7908,6 +8024,54 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyUnspeccedGetTaggedSuggestions: {
+    lexicon: 1,
+    id: 'app.bsky.unspecced.getTaggedSuggestions',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Get a list of suggestions (feeds and users) tagged with categories',
+        parameters: {
+          type: 'params',
+          properties: {},
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['suggestions'],
+            properties: {
+              suggestions: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.bsky.unspecced.getTaggedSuggestions#suggestion',
+                },
+              },
+            },
+          },
+        },
+      },
+      suggestion: {
+        type: 'object',
+        required: ['tag', 'subjectType', 'subject'],
+        properties: {
+          tag: {
+            type: 'string',
+          },
+          subjectType: {
+            type: 'string',
+            knownValues: ['actor', 'feed'],
+          },
+          subject: {
+            type: 'string',
+            format: 'uri',
+          },
+        },
+      },
+    },
+  },
   AppBskyUnspeccedGetTimelineSkeleton: {
     lexicon: 1,
     id: 'app.bsky.unspecced.getTimelineSkeleton',
@@ -8224,6 +8388,7 @@ export const ids = {
   AppBskyGraphGetListMutes: 'app.bsky.graph.getListMutes',
   AppBskyGraphGetLists: 'app.bsky.graph.getLists',
   AppBskyGraphGetMutes: 'app.bsky.graph.getMutes',
+  AppBskyGraphGetRelationships: 'app.bsky.graph.getRelationships',
   AppBskyGraphGetSuggestedFollowsByActor:
     'app.bsky.graph.getSuggestedFollowsByActor',
   AppBskyGraphList: 'app.bsky.graph.list',
@@ -8242,6 +8407,8 @@ export const ids = {
   AppBskyUnspeccedDefs: 'app.bsky.unspecced.defs',
   AppBskyUnspeccedGetPopularFeedGenerators:
     'app.bsky.unspecced.getPopularFeedGenerators',
+  AppBskyUnspeccedGetTaggedSuggestions:
+    'app.bsky.unspecced.getTaggedSuggestions',
   AppBskyUnspeccedGetTimelineSkeleton: 'app.bsky.unspecced.getTimelineSkeleton',
   AppBskyUnspeccedSearchActorsSkeleton:
     'app.bsky.unspecced.searchActorsSkeleton',

package/src/lexicon/types/app/bsky/actor/defs.ts

@@ -112,6 +112,7 @@ export type Preferences = (
   | PersonalDetailsPref
   | FeedViewPref
   | ThreadViewPref
+  | InterestsPref
   | { $type: string; [k: string]: unknown }
 )[]
 
@@ -233,3 +234,21 @@ export function isThreadViewPref(v: unknown): v is ThreadViewPref {
 export function validateThreadViewPref(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#threadViewPref', v)
 }
+
+export interface InterestsPref {
+  /** A list of tags which describe the account owner's interests gathered during onboarding. */
+  tags: string[]
+  [k: string]: unknown
+}
+
+export function isInterestsPref(v: unknown): v is InterestsPref {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#interestsPref'
+  )
+}
+
+export function validateInterestsPref(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#interestsPref', v)
+}

package/src/lexicon/types/app/bsky/graph/defs.ts

@@ -102,3 +102,44 @@ export function isListViewerState(v: unknown): v is ListViewerState {
 export function validateListViewerState(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.graph.defs#listViewerState', v)
 }
+
+/** indicates that a handle or DID could not be resolved */
+export interface NotFoundActor {
+  actor: string
+  notFound: true
+  [k: string]: unknown
+}
+
+export function isNotFoundActor(v: unknown): v is NotFoundActor {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.graph.defs#notFoundActor'
+  )
+}
+
+export function validateNotFoundActor(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.graph.defs#notFoundActor', v)
+}
+
+/** lists the bi-directional graph relationships between one actor (not indicated in the object), and the target actors (the DID included in the object) */
+export interface Relationship {
+  did: string
+  /** if the actor follows this DID, this is the AT-URI of the follow record */
+  following?: string
+  /** if the actor is followed by this DID, contains the AT-URI of the follow record */
+  followedBy?: string
+  [k: string]: unknown
+}
+
+export function isRelationship(v: unknown): v is Relationship {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.graph.defs#relationship'
+  )
+}
+
+export function validateRelationship(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.graph.defs#relationship', v)
+}