@atproto/bsky 0.0.250 → 0.0.253

package/src/image/sharp.ts

@@ -1,89 +0,0 @@
-import { PassThrough, Readable } from 'node:stream'
-import { pipeline } from 'node:stream/promises'
-import sharp from 'sharp'
-import { errHasMsg } from '@atproto/common'
-import { ImageInfo, Options, formatsToMimes } from './util.js'
-
-export type { Options }
-
-/**
- * Scale up to hit any specified minimum size
- */
-export function createImageUpscaler({ min = false }: Options) {
-  // Due to the way sharp works, up-scaling must happen in a separate processor
-  // than down-scaling.
-  return typeof min !== 'boolean'
-    ? sharp().resize({
-        fit: 'outside',
-        width: min.width,
-        height: min.height,
-        withoutReduction: true,
-        withoutEnlargement: false,
-      })
-    : new PassThrough()
-}
-
-/**
- * Scale down (or possibly up if min is true) to desired size, then compress
- * to the desired format.
- */
-export function createImageProcessor({
-  height,
-  width,
-  min = false,
-  fit = 'cover',
-  format,
-  quality = 100,
-}: Options) {
-  const processor = sharp().resize({
-    fit,
-    width,
-    height,
-    withoutEnlargement: min !== true,
-  })
-
-  if (format === 'jpeg') {
-    return processor.jpeg({ quality })
-  } else if (format === 'webp') {
-    return processor.webp({ quality })
-  } else {
-    throw new Error(`Unhandled case: ${format}`)
-  }
-}
-
-export async function maybeGetInfo(
-  stream: Readable,
-): Promise<ImageInfo | null> {
-  try {
-    const processor = sharp()
-
-    const [{ size, height, width, format }] = await Promise.all([
-      processor.metadata(),
-      pipeline(stream, processor), // Handles error propagation
-    ])
-
-    if (size == null || height == null || width == null || format == null) {
-      return null
-    }
-
-    return {
-      height,
-      width,
-      size,
-      mime: formatsToMimes.get(format) ?? 'unknown',
-    }
-  } catch (err) {
-    if (errHasMsg(err, 'Input buffer contains unsupported image format')) {
-      return null
-    }
-    throw err
-  }
-}
-
-export async function getInfo(stream: Readable): Promise<ImageInfo> {
-  const maybeInfo = await maybeGetInfo(stream)
-  if (!maybeInfo) {
-    throw new Error('could not obtain all image metadata')
-  }
-  return maybeInfo
-}

package/src/image/uri.ts

@@ -1,114 +0,0 @@
-import { UriString, isUriString } from '@atproto/lex'
-import { Options } from './util.js'
-
-// @NOTE if there are any additions here, ensure to include them on ImageUriBuilder.presets
-export type ImagePreset =
-  | 'avatar'
-  | 'banner'
-  | 'feed_thumbnail'
-  | 'feed_fullsize'
-
-const PATH_REGEX = /^\/(.+?)\/plain\/(.+?)\/(.+?)(?:@(.+?))?$/
-
-export class ImageUriBuilder {
-  public endpoint: UriString
-
-  constructor(endpoint: string) {
-    if (!isUriString(endpoint)) {
-      throw new Error('ImageUriBuilder endpoint must be a valid UriString')
-    }
-    this.endpoint = endpoint
-  }
-
-  static presets: ImagePreset[] = [
-    'avatar',
-    'banner',
-    'feed_thumbnail',
-    'feed_fullsize',
-  ]
-
-  getPresetUri(id: ImagePreset, did: string, cid: string): UriString {
-    const options = presets[id]
-    if (!options) {
-      throw new Error(`Unrecognized requested common uri type: ${id}`)
-    }
-
-    const path = ImageUriBuilder.getPath({
-      preset: id,
-      did,
-      cid,
-    })
-
-    return `${this.endpoint}${path}`
-  }
-
-  static getPath(opts: { preset: ImagePreset } & BlobLocation) {
-    return `/${opts.preset}/plain/${opts.did}/${opts.cid}`
-  }
-
-  static getOptions(
-    path: string,
-  ): Options & BlobLocation & { preset: ImagePreset } {
-    const match = path.match(PATH_REGEX)
-    if (!match) {
-      throw new BadPathError('Invalid path')
-    }
-    const [, presetUnsafe, did, cid, formatUnsafe] = match
-    if (!(ImageUriBuilder.presets as string[]).includes(presetUnsafe)) {
-      throw new BadPathError('Invalid path: bad preset')
-    }
-    if (
-      formatUnsafe !== undefined &&
-      formatUnsafe !== 'jpeg' &&
-      formatUnsafe !== 'webp'
-    ) {
-      throw new BadPathError('Invalid path: bad format')
-    }
-    const preset = presetUnsafe as ImagePreset
-    const format = formatUnsafe as Options['format']
-    return {
-      ...presets[preset],
-      format: format ?? presets[preset].format,
-      did,
-      cid,
-      preset,
-    }
-  }
-}
-
-type BlobLocation = { cid: string; did: string }
-
-export class BadPathError extends Error {}
-
-// @NOTE these prefix settings don't get used anywhere in this package,
-// but they serve as soft documentation of the behavior in production.
-export const presets: Record<ImagePreset, Options> = {
-  avatar: {
-    format: 'webp',
-    fit: 'cover',
-    height: 1000,
-    width: 1000,
-    min: true,
-  },
-  banner: {
-    format: 'webp',
-    fit: 'cover',
-    height: 1000,
-    width: 3000,
-    min: true,
-  },
-  feed_thumbnail: {
-    format: 'webp',
-    fit: 'inside',
-    height: 2000,
-    width: 2000,
-    min: true,
-  },
-  feed_fullsize: {
-    format: 'webp',
-    fit: 'inside',
-    height: 1000,
-    width: 1000,
-    min: true,
-  },
-}

package/src/image/util.ts

@@ -1,41 +0,0 @@
-import type { FormatEnum, OutputInfo } from 'sharp'
-
-export type ImageMime = `image/${string}`
-
-export type Options = Dimensions & {
-  format: 'jpeg' | 'webp'
-  // When 'cover' (default), scale to fill given dimensions, cropping if necessary.
-  // When 'inside', scale to fit within given dimensions.
-  fit?: 'cover' | 'inside'
-  // When false (default), do not scale up.
-  // When true, scale up to hit dimensions given in options.
-  // Otherwise, scale up to hit specified min dimensions.
-  min?: Dimensions | boolean
-  // A number 1-100
-  quality?: number
-}
-
-export type ImageInfo = Dimensions & {
-  size: number
-  mime: ImageMime | 'unknown'
-}
-
-export type Dimensions = { height: number; width: number }
-
-export const formatsToMimes = new Map<keyof FormatEnum, ImageMime>([
-  ['jpg', 'image/jpeg'],
-  ['jpeg', 'image/jpeg'],
-  ['png', 'image/png'],
-  ['gif', 'image/gif'],
-  ['svg', 'image/svg+xml'],
-  ['tif', 'image/tiff'],
-  ['tiff', 'image/tiff'],
-  ['webp', 'image/webp'],
-  ['avif', 'image/avif'],
-  ['heif', 'image/heif'],
-  ['jp2', 'image/jp2'],
-  ['jxl', 'image/jxl'],
-  ['webp', 'image/webp'],
-])
-
-export type SharpInfo = OutputInfo & { format: keyof FormatEnum }

package/src/index.ts

@@ -1,312 +0,0 @@
-import events from 'node:events'
-import http from 'node:http'
-import { AddressInfo } from 'node:net'
-import compression from 'compression'
-import cors from 'cors'
-import { Etcd3 } from 'etcd3'
-import express from 'express'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { DAY, SECOND } from '@atproto/common'
-import { Keypair } from '@atproto/crypto'
-import { IdResolver } from '@atproto/identity'
-import { Client } from '@atproto/lex'
-import { createServer } from '@atproto/xrpc-server'
-import { createBlobDispatcher } from './api/blob-dispatcher.js'
-import API, {
-  blobResolver,
-  external,
-  health,
-  sitemap,
-  wellKnown,
-} from './api/index.js'
-import { AuthVerifier, createPublicKeyObject } from './auth-verifier.js'
-import { authWithApiKey as bsyncAuth, createBsyncClient } from './bsync.js'
-import { ServerConfig } from './config.js'
-import { AppContext } from './context.js'
-import {
-  authWithApiKey as courierAuth,
-  createCourierClient,
-} from './courier.js'
-import {
-  BasicHostList,
-  EtcdHostList,
-  createDataPlaneClient,
-} from './data-plane/client/index.js'
-import * as error from './error.js'
-import { FeatureGatesClient } from './feature-gates/index.js'
-import { Hydrator } from './hydration/hydrator.js'
-import * as imageServer from './image/server.js'
-import { ImageUriBuilder } from './image/uri.js'
-import { createKwsClient } from './kws.js'
-import { loggerMiddleware } from './logger.js'
-import {
-  authWithApiKey as rolodexAuth,
-  createRolodexClient,
-} from './rolodex.js'
-import { createStashClient } from './stash.js'
-import { Views } from './views/index.js'
-import { VideoUriBuilder } from './views/util.js'
-
-export { ServerConfig } from './config.js'
-export type { ServerConfigValues } from './config.js'
-export { AppContext } from './context.js'
-export * from './data-plane/index.js'
-export { BackgroundQueue } from './data-plane/server/background.js'
-export { Database } from './data-plane/server/db/index.js'
-export { Redis } from './redis.js'
-
-export class BskyAppView {
-  public ctx: AppContext
-  public app: express.Application
-  public server?: http.Server
-  private terminator?: httpTerminator.HttpTerminator
-
-  constructor(opts: { ctx: AppContext; app: express.Application }) {
-    this.ctx = opts.ctx
-    this.app = opts.app
-  }
-
-  static create(opts: {
-    config: ServerConfig
-    signingKey: Keypair
-  }): BskyAppView {
-    const { config, signingKey } = opts
-    const app = express()
-    app.set('trust proxy', true)
-    app.use(cors({ maxAge: DAY / SECOND }))
-    app.use(loggerMiddleware)
-    app.use(compression())
-
-    // used solely for handle resolution: identity lookups occur on dataplane
-    const idResolver = new IdResolver({
-      plcUrl: config.didPlcUrl,
-      backupNameservers: config.handleResolveNameservers,
-    })
-
-    const imgUriBuilderUrl =
-      config.cdnUrl ||
-      (config.publicUrl ? `${config.publicUrl}/img` : undefined)
-    if (!imgUriBuilderUrl) {
-      throw new Error('No image URI builder URL could be determined')
-    }
-    const imgUriBuilder = new ImageUriBuilder(imgUriBuilderUrl)
-    const videoUriBuilder = new VideoUriBuilder({
-      playlistUrlPattern:
-        config.videoPlaylistUrlPattern ||
-        `${config.publicUrl}/vid/%s/%s/playlist.m3u8`,
-      thumbnailUrlPattern:
-        config.videoThumbnailUrlPattern ||
-        `${config.publicUrl}/vid/%s/%s/thumbnail.jpg`,
-    })
-
-    const searchClient = config.searchUrl
-      ? new Client(
-          {
-            service: config.searchUrl,
-          },
-          {
-            // Trust internal services to send us well-formed responses
-            strictResponseProcessing: false,
-            validateResponse: config.debugMode,
-          },
-        )
-      : undefined
-
-    const suggestionsClient = config.suggestionsUrl
-      ? new Client(
-          {
-            service: config.suggestionsUrl,
-            headers: config.suggestionsApiKey
-              ? { authorization: `Bearer ${config.suggestionsApiKey}` }
-              : undefined,
-          },
-          {
-            // Trust internal services to send us well-formed responses
-            strictResponseProcessing: false,
-            validateResponse: config.debugMode,
-          },
-        )
-      : undefined
-
-    const topicsClient = config.topicsUrl
-      ? new Client(
-          {
-            service: config.topicsUrl,
-            headers: config.topicsApiKey
-              ? { authorization: `Bearer ${config.topicsApiKey}` }
-              : undefined,
-          },
-          {
-            // Trust internal services to send us well-formed responses
-            strictResponseProcessing: false,
-            validateResponse: config.debugMode,
-          },
-        )
-      : undefined
-
-    const etcd = config.etcdHosts.length
-      ? new Etcd3({ hosts: config.etcdHosts })
-      : undefined
-
-    const dataplaneHostList =
-      etcd && config.dataplaneUrlsEtcdKeyPrefix
-        ? new EtcdHostList(
-            etcd,
-            config.dataplaneUrlsEtcdKeyPrefix,
-            config.dataplaneUrls,
-          )
-        : new BasicHostList(config.dataplaneUrls)
-
-    const featureGatesClient = new FeatureGatesClient({
-      growthBookApiHost: config.growthBookApiHost,
-      growthBookClientKey: config.growthBookClientKey,
-      eventProxyTrackingEndpoint: config.eventProxyTrackingEndpoint,
-    })
-
-    const dataplane = createDataPlaneClient(dataplaneHostList, {
-      httpVersion: config.dataplaneHttpVersion,
-      rejectUnauthorized: !config.dataplaneIgnoreBadTls,
-    })
-    const hydrator = new Hydrator(dataplane, config.labelsFromIssuerDids, {
-      debugFieldAllowedDids: config.debugFieldAllowedDids,
-      featureGatesClient,
-    })
-    const views = new Views({
-      imgUriBuilder: imgUriBuilder,
-      videoUriBuilder: videoUriBuilder,
-      indexedAtEpoch: config.indexedAtEpoch,
-      threadTagsBumpDown: [...config.threadTagsBumpDown],
-      threadTagsHide: [...config.threadTagsHide],
-      visibilityTagHide: config.visibilityTagHide,
-      visibilityTagRankPrefix: config.visibilityTagRankPrefix,
-    })
-
-    const bsyncClient = createBsyncClient({
-      baseUrl: config.bsyncUrl,
-      httpVersion: config.bsyncHttpVersion ?? '2',
-      nodeOptions: { rejectUnauthorized: !config.bsyncIgnoreBadTls },
-      interceptors: config.bsyncApiKey ? [bsyncAuth(config.bsyncApiKey)] : [],
-    })
-
-    const stashClient = createStashClient(bsyncClient)
-
-    const courierClient = config.courierUrl
-      ? createCourierClient({
-          baseUrl: config.courierUrl,
-          httpVersion: config.courierHttpVersion ?? '2',
-          nodeOptions: { rejectUnauthorized: !config.courierIgnoreBadTls },
-          interceptors: config.courierApiKey
-            ? [courierAuth(config.courierApiKey)]
-            : [],
-        })
-      : undefined
-
-    const rolodexClient = config.rolodexUrl
-      ? createRolodexClient({
-          baseUrl: config.rolodexUrl,
-          httpVersion: config.rolodexHttpVersion ?? '2',
-          nodeOptions: { rejectUnauthorized: !config.rolodexIgnoreBadTls },
-          interceptors: config.rolodexApiKey
-            ? [rolodexAuth(config.rolodexApiKey)]
-            : [],
-        })
-      : undefined
-
-    const kwsClient = config.kws ? createKwsClient(config.kws) : undefined
-
-    const entrywayJwtPublicKey = config.entrywayJwtPublicKeyHex
-      ? createPublicKeyObject(config.entrywayJwtPublicKeyHex)
-      : undefined
-    const authVerifier = new AuthVerifier(dataplane, {
-      ownDid: config.serverDid,
-      alternateAudienceDids: config.alternateAudienceDids,
-      modServiceDid: config.modServiceDid,
-      adminPasses: config.adminPasswords,
-      entrywayJwtPublicKey,
-    })
-
-    const blobDispatcher = createBlobDispatcher(config)
-
-    const ctx = new AppContext({
-      cfg: config,
-      etcd,
-      dataplane,
-      dataplaneHostList,
-      searchClient,
-      suggestionsClient,
-      topicsClient,
-      hydrator,
-      views,
-      signingKey,
-      idResolver,
-      bsyncClient,
-      stashClient,
-      courierClient,
-      rolodexClient,
-      authVerifier,
-      featureGatesClient,
-      blobDispatcher,
-      kwsClient,
-    })
-
-    const server = createServer([], {
-      validateResponse: config.debugMode,
-      payload: {
-        jsonLimit: 100 * 1024, // 100kb
-        textLimit: 100 * 1024, // 100kb
-        blobLimit: 5 * 1024 * 1024, // 5mb
-      },
-    })
-
-    API(server, ctx)
-
-    app.use(health.createRouter(ctx))
-    app.use(wellKnown.createRouter(ctx))
-    app.use(blobResolver.createMiddleware(ctx))
-    app.use(imageServer.createMiddleware(ctx, { prefix: '/img/' }))
-
-    if (config.dataplaneUrls.length > 0 || config.dataplaneUrlsEtcdKeyPrefix) {
-      app.use(sitemap.createRouter(ctx))
-    }
-
-    app.use(server.router)
-    app.use(error.handler)
-    app.use('/external', external.createRouter(ctx))
-
-    return new BskyAppView({ ctx, app })
-  }
-
-  async start(): Promise<http.Server> {
-    if (this.ctx.dataplaneHostList instanceof EtcdHostList) {
-      await this.ctx.dataplaneHostList.connect()
-    }
-    this.ctx.featureGatesClient.start() // lazy, no await
-    const server = this.app.listen(this.ctx.cfg.port)
-    this.server = server
-    server.keepAliveTimeout = 90000
-    this.terminator = httpTerminator.createHttpTerminator({ server })
-    await events.once(server, 'listening')
-    const { port } = server.address() as AddressInfo
-    this.ctx.cfg.assignPort(port)
-    return server
-  }
-
-  async destroy(): Promise<void> {
-    try {
-      await this.ctx.featureGatesClient.destroy()
-    } finally {
-      try {
-        await this.terminator?.terminate()
-      } finally {
-        await this.ctx.etcd?.close()
-      }
-    }
-  }
-
-  async [Symbol.asyncDispose]() {
-    await this.destroy()
-  }
-}
-
-export default BskyAppView