@atproto/bsky 0.0.250 → 0.0.253

package/src/kws.ts

@@ -1,197 +0,0 @@
-import { z } from 'zod'
-import { KwsExternalPayload } from './api/kws/types.js'
-import { serializeExternalPayload } from './api/kws/util.js'
-import { buildBasicAuth } from './auth-verifier.js'
-import { KwsConfig } from './config.js'
-import { httpLogger as log } from './logger.js'
-
-export const createKwsClient = (cfg: KwsConfig): KwsClient => {
-  return new KwsClient(cfg)
-}
-
-// Not `.strict()` to avoid breaking if KWS adds fields.
-const authResponseSchema = z.object({
-  access_token: z.string(),
-})
-
-const EXTERNAL_PAYLOAD_CHAR_LIMIT = 200
-/**
- * Thrown when the provided external payload exceeds KWS's character limit.
- * This is most commonly caused by DIDs that are too long, such as for
- * `did:web` DIDs. But it's very rare, and the client has special handling for
- * this case.
- */
-export class KwsExternalPayloadError extends Error {}
-
-export type KWSSendEmailRequestCommon = {
-  email: string
-  location: string
-  language: string
-  externalPayload: string
-}
-
-export type KWSSendEmailRequest =
-  | (KWSSendEmailRequestCommon & {
-      userContext: 'adult'
-    })
-  | (KWSSendEmailRequestCommon & {
-      userContext: 'age'
-      minimumAge: number
-    })
-
-export class KwsClient {
-  constructor(public cfg: KwsConfig) {}
-
-  private async auth() {
-    try {
-      const res = await fetch(
-        `${this.cfg.authOrigin}/auth/realms/kws/protocol/openid-connect/token`,
-        {
-          method: 'POST',
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/x-www-form-urlencoded',
-            Authorization: buildBasicAuth(this.cfg.clientId, this.cfg.apiKey),
-          },
-          body: new URLSearchParams({
-            grant_type: 'client_credentials',
-            scope: 'verification',
-          }),
-        },
-      )
-      if (!res.ok) {
-        const errorText = await res.text()
-        throw new Error(
-          `Failed to fetch age assurance access token: status: ${res.status}, statusText: ${res.statusText}, errorText: ${errorText}`,
-        )
-      }
-
-      const auth = await res.json()
-      const authResponse = authResponseSchema.parse(auth)
-      return authResponse.access_token
-    } catch (err) {
-      log.error({ err }, 'Failed to authenticate with KWS')
-      throw err
-    }
-  }
-
-  private async fetchWithAuth(
-    url: string,
-    init: RequestInit,
-  ): Promise<Response> {
-    const accessToken = await this.auth()
-
-    return fetch(url, {
-      ...init,
-      headers: {
-        ...(init.headers ?? {}),
-        Authorization: `Bearer ${accessToken}`,
-      },
-    })
-  }
-
-  /**
-   * @deprecated Use `sendAdultVerifiedFlowEmail` or `sendAgeVerifiedFlowEmail` instead.
-   */
-  async sendEmail({
-    countryCode,
-    email,
-    externalPayload,
-    language,
-  }: {
-    countryCode: string
-    email: string
-    externalPayload: KwsExternalPayload
-    language: string
-  }) {
-    const serializedExternalPayload = serializeExternalPayload(externalPayload)
-    if (serializedExternalPayload.length > EXTERNAL_PAYLOAD_CHAR_LIMIT) {
-      throw new KwsExternalPayloadError()
-    }
-
-    const res = await this.fetchWithAuth(
-      `${this.cfg.apiOrigin}/v1/verifications/send-email`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': this.cfg.userAgent,
-        },
-        body: JSON.stringify({
-          email,
-          externalPayload: serializedExternalPayload,
-          language,
-          location: countryCode,
-          userContext: 'adult',
-        }),
-      },
-    )
-
-    if (!res.ok) {
-      const errorText = await res.text()
-      log.error(
-        { status: res.status, statusText: res.statusText, errorText },
-        'Failed to send age assurance email',
-      )
-      throw new Error('Failed to send age assurance email')
-    }
-
-    return res.json()
-  }
-
-  /**
-   * Sends a KWS verification email with the given properties.
-   */
-  async email(props: KWSSendEmailRequest) {
-    const res = await this.fetchWithAuth(
-      `${this.cfg.apiOrigin}/v1/verifications/send-email`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': this.cfg.userAgent,
-        },
-        body: JSON.stringify(props),
-      },
-    )
-
-    if (!res.ok) {
-      const errorText = await res.text()
-      log.error(
-        {
-          status: res.status,
-          statusText: res.statusText,
-          errorText,
-          flow: props.userContext,
-        },
-        'Failed to send KWS email',
-      )
-      throw new Error('Failed to send KWS email')
-    }
-
-    return res.json()
-  }
-
-  /**
-   * Sends an email to the user initiating an `adult` verification flow, which
-   * results in `adult-verified` events/webhooks.
-   */
-  async sendAdultVerifiedFlowEmail(props: KWSSendEmailRequestCommon) {
-    return this.email({
-      ...props,
-      userContext: 'adult',
-    })
-  }
-
-  /**
-   * Sends an email to the user initiating an `age` verification flow, which
-   * results in `age-verified` events/webhooks.
-   */
-  async sendAgeVerifiedFlowEmail(props: KWSSendEmailRequestCommon) {
-    return this.email({
-      ...props,
-      userContext: 'age',
-      minimumAge: 16, // KWS required value
-    })
-  }
-}

package/src/logger.ts

@@ -1,40 +0,0 @@
-import { IncomingMessage } from 'node:http'
-import { stdSerializers } from 'pino'
-import { pinoHttp } from 'pino-http'
-import { obfuscateHeaders, subsystemLogger } from '@atproto/common'
-
-export const dbLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsky:db')
-export const cacheLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsky:cache')
-export const subLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsky:sub')
-export const labelerLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsky:labeler')
-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 ageAssuranceLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsky:aa')
-export const viewsLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsky:views')
-export const httpLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsky')
-
-export const loggerMiddleware = pinoHttp({
-  logger: httpLogger,
-  serializers: {
-    err: (err: unknown) => ({
-      code: err?.['code'],
-      message: err?.['message'],
-    }),
-    req: (req: IncomingMessage) => {
-      const serialized = stdSerializers.req(req)
-      const headers = obfuscateHeaders(serialized.headers)
-      return { ...serialized, headers }
-    },
-  },
-})

package/src/pipeline.ts

@@ -1,60 +0,0 @@
-import { HydrationState } from './hydration/hydrator.js'
-
-export function createPipeline<Params, Skeleton, View, Context>(
-  skeletonFn: SkeletonFn<Context, Params, Skeleton>,
-  hydrationFn: HydrationFn<Context, Params, Skeleton>,
-  rulesFn: RulesFn<Context, Params, Skeleton>,
-  presentationFn: PresentationFn<Context, Params, Skeleton, View>,
-) {
-  return async (params: Params, ctx: Context) => {
-    const skeleton = await skeletonFn({ ctx, params })
-    const hydration = await hydrationFn({ ctx, params, skeleton })
-    const appliedRules = rulesFn({ ctx, params, skeleton, hydration })
-    return presentationFn({ ctx, params, skeleton: appliedRules, hydration })
-  }
-}
-
-export type SkeletonFn<Context, Params, Skeleton> = (
-  input: SkeletonFnInput<Context, Params>,
-) => Promise<Skeleton>
-
-export type SkeletonFnInput<Context, Params> = {
-  ctx: Context
-  params: Params
-}
-
-export type HydrationFn<Context, Params, Skeleton> = (
-  input: HydrationFnInput<Context, Params, Skeleton>,
-) => Promise<HydrationState>
-
-export type HydrationFnInput<Context, Params, Skeleton> = {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-}
-
-export type RulesFn<Context, Params, Skeleton> = (
-  input: RulesFnInput<Context, Params, Skeleton>,
-) => Skeleton
-
-export type RulesFnInput<Context, Params, Skeleton> = {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-  hydration: HydrationState
-}
-
-export type PresentationFn<Context, Params, Skeleton, View> = (
-  input: PresentationFnInput<Context, Params, Skeleton>,
-) => View
-
-export type PresentationFnInput<Context, Params, Skeleton> = {
-  ctx: Context
-  params: Params
-  skeleton: Skeleton
-  hydration: HydrationState
-}
-
-export function noRules<S>(input: { skeleton: S }) {
-  return input.skeleton
-}

package/src/redis.ts

@@ -1,205 +0,0 @@
-import assert from 'node:assert'
-import { Redis as RedisDriver } from 'ioredis'
-
-export class Redis {
-  driver: RedisDriver
-  namespace?: string
-  constructor(opts: RedisOptions) {
-    if ('sentinel' in opts) {
-      assert(opts.sentinel && Array.isArray(opts.hosts) && opts.hosts.length)
-      this.driver = new RedisDriver({
-        name: opts.sentinel,
-        sentinels: opts.hosts.map((h) => addressParts(h, 26379)),
-        password: opts.password,
-        db: opts.db,
-        commandTimeout: opts.commandTimeout,
-      })
-    } else if ('host' in opts) {
-      assert(opts.host)
-      this.driver = new RedisDriver({
-        ...addressParts(opts.host),
-        password: opts.password,
-        db: opts.db,
-        commandTimeout: opts.commandTimeout,
-      })
-    } else {
-      assert(opts.driver)
-      this.driver = opts.driver
-    }
-    this.namespace = opts.namespace
-  }
-
-  withNamespace(namespace: string): Redis {
-    return new Redis({ driver: this.driver, namespace })
-  }
-
-  async readStreams(
-    streams: StreamRef[],
-    opts: { count: number; blockMs?: number },
-  ) {
-    const allRead = await this.driver.xreadBuffer(
-      'COUNT',
-      opts.count, // events per stream
-      'BLOCK',
-      opts.blockMs ?? 1000, // millis
-      'STREAMS',
-      ...streams.map((s) => this.ns(s.key)),
-      ...streams.map((s) => s.cursor),
-    )
-    const results: StreamOutput[] = []
-    for (const [key, messages] of allRead ?? []) {
-      const result: StreamOutput = {
-        key: this.rmns(key.toString()),
-        messages: [],
-      }
-      results.push(result)
-      for (const [seqBuf, values] of messages) {
-        const message = { cursor: seqBuf.toString(), contents: {} }
-        result.messages.push(message)
-        for (let i = 0; i < values.length; ++i) {
-          if (i % 2 === 0) continue
-          const field = values[i - 1].toString()
-          message.contents[field] = values[i]
-        }
-      }
-    }
-    return results
-  }
-
-  async addToStream(
-    key: string,
-    id: number | string,
-    fields: [key: string, value: string | Buffer][],
-  ) {
-    await this.driver.xadd(this.ns(key), id, ...fields.flat())
-  }
-
-  async addMultiToStream(
-    evts: {
-      key: string
-      id: number | string
-      fields: [key: string, value: string | Buffer][]
-    }[],
-  ) {
-    const pipeline = this.driver.pipeline()
-    for (const { key, id, fields } of evts) {
-      pipeline.xadd(this.ns(key), id, ...fields.flat())
-    }
-    return (await pipeline.exec()) ?? []
-  }
-
-  async trimStream(key: string, cursor: number | string) {
-    await this.driver.xtrim(this.ns(key), 'MINID', cursor)
-  }
-
-  async streamLengths(keys: string[]) {
-    const pipeline = this.driver.pipeline()
-    for (const key of keys) {
-      pipeline.xlen(this.ns(key))
-    }
-    const results = await pipeline.exec()
-    return (results ?? []).map(([, len = 0]) => Number(len))
-  }
-
-  async get(key: string) {
-    return await this.driver.get(this.ns(key))
-  }
-
-  async set(key: string, val: string | number, ttlMs?: number) {
-    if (ttlMs !== undefined) {
-      await this.driver.set(this.ns(key), val, 'PX', ttlMs)
-    } else {
-      await this.driver.set(this.ns(key), val)
-    }
-  }
-
-  async getMulti(keys: string[]) {
-    const namespaced = keys.map((k) => this.ns(k))
-    const got = await this.driver.mget(...namespaced)
-    const results = {}
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      results[key] = got[i]
-    }
-    return results
-  }
-
-  async setMulti(vals: Record<string, string | number>, ttlMs?: number) {
-    if (Object.keys(vals).length === 0) {
-      return
-    }
-    let builder = this.driver.multi({ pipeline: true })
-    for (const key of Object.keys(vals)) {
-      if (ttlMs !== undefined) {
-        builder = builder.set(this.ns(key), vals[key], 'PX', ttlMs)
-      } else {
-        builder = builder.set(this.ns(key), vals[key])
-      }
-    }
-    await builder.exec()
-  }
-
-  async del(key: string) {
-    return await this.driver.del(this.ns(key))
-  }
-
-  async expire(key: string, seconds: number) {
-    return await this.driver.expire(this.ns(key), seconds)
-  }
-
-  async zremrangebyscore(key: string, min: number, max: number) {
-    return await this.driver.zremrangebyscore(this.ns(key), min, max)
-  }
-
-  async zcount(key: string, min: number, max: number) {
-    return await this.driver.zcount(this.ns(key), min, max)
-  }
-
-  async zadd(key: string, score: number, member: number | string) {
-    return await this.driver.zadd(this.ns(key), score, member)
-  }
-
-  async destroy() {
-    await this.driver.quit()
-  }
-
-  // namespace redis keys
-  ns(key: string) {
-    return this.namespace ? `${this.namespace}:${key}` : key
-  }
-
-  // remove namespace from redis key
-  rmns(key: string) {
-    return this.namespace && key.startsWith(`${this.namespace}:`)
-      ? key.replace(`${this.namespace}:`, '')
-      : key
-  }
-}
-
-type StreamRef = { key: string; cursor: string | number }
-
-type StreamOutput = {
-  key: string
-  messages: { cursor: string; contents: Record<string, Buffer | undefined> }[]
-}
-
-export type RedisOptions = (
-  | { driver: RedisDriver }
-  | { host: string }
-  | { sentinel: string; hosts: string[] }
-) & {
-  password?: string
-  namespace?: string
-  db?: number
-  commandTimeout?: number
-}
-
-export function addressParts(
-  addr: string,
-  defaultPort = 6379,
-): { host: string; port: number } {
-  const [host, portStr, ...others] = addr.split(':')
-  const port = portStr ? parseInt(portStr, 10) : defaultPort
-  assert(host && !isNaN(port) && !others.length, `invalid address: ${addr}`)
-  return { host, port }
-}

package/src/rolodex.ts

@@ -1,42 +0,0 @@
-import {
-  Code,
-  ConnectError,
-  Interceptor,
-  PromiseClient,
-  createPromiseClient,
-} from '@connectrpc/connect'
-import {
-  ConnectTransportOptions,
-  createConnectTransport,
-} from '@connectrpc/connect-node'
-import { RolodexService } from './proto/rolodex_connect.js'
-
-// Rolodex is the service that does contact imports following https://docs.bsky.app/blog/contact-import-rfc.
-export type RolodexClient = PromiseClient<typeof RolodexService>
-
-export const createRolodexClient = (
-  opts: ConnectTransportOptions,
-): RolodexClient => {
-  const transport = createConnectTransport(opts)
-  return createPromiseClient(RolodexService, transport)
-}
-
-export { Code }
-
-export const isRolodexError = (
-  err: unknown,
-  code?: Code,
-): err is ConnectError => {
-  if (err instanceof ConnectError) {
-    return !code || err.code === code
-  }
-  return false
-}
-
-export const authWithApiKey =
-  (apiKey: string): Interceptor =>
-  (next) =>
-  (req) => {
-    req.header.set('authorization', `Bearer ${apiKey}`)
-    return next(req)
-  }

package/src/stash.ts

@@ -1,76 +0,0 @@
-import { LexMap, TypedObjectSchema, lexStringify } from '@atproto/lex'
-import { BsyncClient } from './bsync.js'
-import { app } from './lexicons/index.js'
-import { Method } from './proto/bsync_pb.js'
-
-export const Namespaces = {
-  AppBskyAgeassuranceDefsEvent: app.bsky.ageassurance.defs.event,
-  AppBskyBookmarkDefsBookmark: app.bsky.bookmark.defs.bookmark,
-  AppBskyContactDefsNotification: app.bsky.contact.defs.notification,
-  AppBskyDraftDefsDraftWithId: app.bsky.draft.defs.draftWithId,
-  AppBskyNotificationDefsPreferences: app.bsky.notification.defs.preferences,
-  AppBskyNotificationDefsSubjectActivitySubscription:
-    app.bsky.notification.defs.subjectActivitySubscription,
-  AppBskyUnspeccedDefsAgeAssuranceEvent:
-    app.bsky.unspecced.defs.ageAssuranceEvent,
-} as const satisfies Record<string, TypedObjectSchema>
-
-export const createStashClient = (bsyncClient: BsyncClient): StashClient => {
-  return new StashClient(bsyncClient)
-}
-
-// An abstraction over the BsyncClient, that uses the bsync `PutOperation` RPC
-// to store private data, which can be indexed by the dataplane and queried by the appview.
-export class StashClient {
-  constructor(private readonly bsyncClient: BsyncClient) {}
-
-  create(input: CreateInput) {
-    input.namespace.assert(input.payload)
-    return this.putOperation(Method.CREATE, input)
-  }
-
-  update(input: UpdateInput) {
-    input.namespace.assert(input.payload)
-    return this.putOperation(Method.UPDATE, input)
-  }
-
-  delete(input: DeleteInput) {
-    return this.putOperation(Method.DELETE, { ...input, payload: undefined })
-  }
-
-  private async putOperation(
-    method: Method,
-    input: {
-      actorDid: string
-      namespace: TypedObjectSchema
-      key: string
-      payload: LexMap | undefined
-    },
-  ) {
-    const { actorDid, namespace, key, payload } = input
-    await this.bsyncClient.putOperation({
-      actorDid,
-      namespace: namespace.$type,
-      key,
-      method,
-      payload: payload
-        ? Buffer.from(lexStringify({ ...payload, $type: namespace.$type }))
-        : undefined,
-    })
-  }
-}
-
-type CreateInput = {
-  actorDid: string
-  namespace: TypedObjectSchema
-  key: string
-  payload: LexMap
-}
-
-type UpdateInput = CreateInput
-
-type DeleteInput = {
-  actorDid: string
-  namespace: TypedObjectSchema
-  key: string
-}

package/src/util/debug.ts

@@ -1,10 +0,0 @@
-export const debugCatch = <Func extends (...args: any[]) => any>(fn: Func) => {
-  return async (...args: Parameters<Func>) => {
-    try {
-      return (await fn(...args)) as Awaited<ReturnType<Func>>
-    } catch (err) {
-      console.error(err)
-      throw err
-    }
-  }
-}

package/src/util/http.ts

@@ -1,42 +0,0 @@
-import { IncomingMessage, ServerResponse } from 'node:http'
-import createHttpError from 'http-errors'
-
-type IncomingHttpHeaders = Record<string, string | string[] | undefined>
-
-type NextFunction = (err?: unknown) => void
-
-export type Middleware = (
-  req: IncomingMessage,
-  res: ServerResponse,
-  next: NextFunction,
-) => void
-
-export type ResponseData = { statusCode: number; headers: IncomingHttpHeaders }
-
-const RESPONSE_HEADERS_TO_PROXY = new Set([
-  'content-type',
-  'content-length',
-  'content-encoding',
-  'content-language',
-  'cache-control',
-  'last-modified',
-  'etag',
-  'expires',
-  'retry-after',
-  'vary', // Might vary based on "accept" headers
-] as const satisfies (keyof IncomingHttpHeaders)[])
-
-export function proxyResponseHeaders(data: ResponseData, res: ServerResponse) {
-  res.statusCode = data.statusCode >= 500 ? 502 : data.statusCode
-  for (const name of RESPONSE_HEADERS_TO_PROXY) {
-    const val = data.headers[name]
-    if (val) res.setHeader(name, val)
-  }
-}
-
-export function responseSignal(res: ServerResponse): AbortSignal {
-  if (res.destroyed) throw createHttpError(499, 'Client Disconnected')
-  const controller = new AbortController()
-  res.once('close', () => controller.abort())
-  return controller.signal
-}

package/src/util/retry.ts

@@ -1,10 +0,0 @@
-import { createRetryable } from '@atproto/common'
-import { XrpcError } from '@atproto/lex'
-
-export const RETRYABLE_HTTP_STATUS_CODES = new Set([
-  408, 425, 429, 500, 502, 503, 504, 522, 524,
-])
-
-export const retryXrpc = createRetryable((err) => {
-  return err instanceof XrpcError && err.shouldRetry()
-})