@atproto/pds 0.5.12 → 0.5.14

package/src/api/com/atproto/sync/getLatestCommit.ts

@@ -1,33 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { isUserOrAdmin } from '../../../../auth-verifier.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { assertRepoAvailability } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.sync.getLatestCommit, {
-    auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
-      authorize: () => {
-        // always allow
-      },
-    }),
-    handler: async ({ params, auth }) => {
-      const { did } = params
-      await assertRepoAvailability(ctx, did, isUserOrAdmin(auth, did))
-
-      const root = await ctx.actorStore.read(did, (store) =>
-        store.repo.storage.getRootDetailed(),
-      )
-      if (root === null) {
-        throw new InvalidRequestError(
-          `Could not find root for DID: ${did}`,
-          'RepoNotFound',
-        )
-      }
-      return {
-        encoding: 'application/json' as const,
-        body: { cid: root.cid.toString(), rev: root.rev },
-      }
-    },
-  })
-}

package/src/api/com/atproto/sync/getRecord.ts

@@ -1,49 +0,0 @@
-import stream from 'node:stream'
-import { byteIterableToStream } from '@atproto/common'
-import * as repo from '@atproto/repo'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { SqlRepoReader } from '../../../../actor-store/repo/sql-repo-reader.js'
-import { isUserOrAdmin } from '../../../../auth-verifier.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { assertRepoAvailability } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.sync.getRecord, {
-    auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
-      authorize: () => {
-        // always allow
-      },
-    }),
-    handler: async ({ params, auth }) => {
-      const { did, collection, rkey } = params
-      await assertRepoAvailability(ctx, did, isUserOrAdmin(auth, did))
-
-      // must open up the db outside of store interface so that we can close the file handle after finished streaming
-      const actorDb = await ctx.actorStore.openDb(did)
-
-      let carStream: stream.Readable
-      try {
-        const storage = new SqlRepoReader(actorDb)
-        const commit = await storage.getRoot()
-
-        if (!commit) {
-          throw new InvalidRequestError(`Could not find repo for DID: ${did}`)
-        }
-        const carIter = repo.getRecords(storage, commit, [{ collection, rkey }])
-        carStream = byteIterableToStream(carIter)
-      } catch (err) {
-        actorDb.close()
-        throw err
-      }
-      const closeDb = () => actorDb.close()
-      carStream.on('error', closeDb)
-      carStream.on('close', closeDb)
-
-      return {
-        encoding: 'application/vnd.ipld.car' as const,
-        body: carStream,
-      }
-    },
-  })
-}

package/src/api/com/atproto/sync/getRepo.ts

@@ -1,75 +0,0 @@
-import stream from 'node:stream'
-import {
-  MINUTE,
-  byteIterableToStream,
-  coalesceByteStream,
-} from '@atproto/common'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import {
-  RepoRootNotFoundError,
-  SqlRepoReader,
-} from '../../../../actor-store/repo/sql-repo-reader.js'
-import { AuthScope } from '../../../../auth-scope.js'
-import { isUserOrAdmin } from '../../../../auth-verifier.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { assertRepoAvailability } from './util.js'
-
-const CAR_STREAM_CHUNK_SIZE = 64 * 1024
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.sync.getRepo, {
-    auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
-      additional: [AuthScope.Takendown],
-      authorize: () => {
-        // always allow
-      },
-    }),
-    rateLimit: {
-      durationMs: 5 * MINUTE,
-      points: 6000,
-    },
-    handler: async ({ req, params, auth }) => {
-      const { did, since } = params
-      await assertRepoAvailability(ctx, did, isUserOrAdmin(auth, did))
-
-      const carStream = await getCarStream(ctx, did, since)
-
-      return {
-        encoding: 'application/vnd.ipld.car' as const,
-        // @NOTE If the client asked for compression (via "accept-encoding"), we
-        // coalesce the CAR stream into larger chunks to improve compression
-        // efficiency. See https://github.com/bluesky-social/atproto/pull/5078
-        //
-        // @TODO This would be better handled by xrpc-server and/or the
-        // compression middleware instead of manually coalescing the stream.
-        body: req.headers['accept-encoding']
-          ? coalesceByteStream(carStream, CAR_STREAM_CHUNK_SIZE)
-          : carStream,
-      }
-    },
-  })
-}
-
-export const getCarStream = async (
-  ctx: AppContext,
-  did: string,
-  since?: string,
-): Promise<stream.Readable> => {
-  const actorDb = await ctx.actorStore.openDb(did)
-  try {
-    const storage = new SqlRepoReader(actorDb)
-    const carIter = await storage.getCarStream(since)
-    const carStream = byteIterableToStream(carIter)
-    const closeDb = () => actorDb.close()
-    carStream.on('error', closeDb)
-    carStream.on('close', closeDb)
-    return carStream
-  } catch (err) {
-    await actorDb.close()
-    if (err instanceof RepoRootNotFoundError) {
-      throw new InvalidRequestError(`Could not find repo for DID: ${did}`)
-    }
-    throw err
-  }
-}

package/src/api/com/atproto/sync/getRepoStatus.ts

@@ -1,34 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { formatAccountStatus } from '../../../../account-manager/account-manager.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { assertRepoAvailability } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.sync.getRepoStatus, {
-    handler: async ({ params }) => {
-      const { did } = params
-      const account = await assertRepoAvailability(ctx, did, true)
-
-      const { active, status } = formatAccountStatus(account)
-
-      let rev: string | undefined = undefined
-      if (active) {
-        const root = await ctx.actorStore.read(did, (store) =>
-          store.repo.storage.getRootDetailed(),
-        )
-        rev = root.rev
-      }
-
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          did,
-          active,
-          status,
-          rev,
-        },
-      }
-    },
-  })
-}

package/src/api/com/atproto/sync/index.ts

@@ -1,27 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import getCheckout from './deprecated/getCheckout.js'
-import getHead from './deprecated/getHead.js'
-import getBlob from './getBlob.js'
-import getBlocks from './getBlocks.js'
-import getLatestCommit from './getLatestCommit.js'
-import getRecord from './getRecord.js'
-import getRepo from './getRepo.js'
-import getRepoStatus from './getRepoStatus.js'
-import listBlobs from './listBlobs.js'
-import listRepos from './listRepos.js'
-import subscribeRepos from './subscribeRepos.js'
-
-export default function (server: Server, ctx: AppContext) {
-  getBlob(server, ctx)
-  getBlocks(server, ctx)
-  getLatestCommit(server, ctx)
-  getRepoStatus(server, ctx)
-  getRecord(server, ctx)
-  getRepo(server, ctx)
-  subscribeRepos(server, ctx)
-  listBlobs(server, ctx)
-  listRepos(server, ctx)
-  getCheckout(server, ctx)
-  getHead(server, ctx)
-}

package/src/api/com/atproto/sync/listBlobs.ts

@@ -1,33 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AuthScope } from '../../../../auth-scope.js'
-import { isUserOrAdmin } from '../../../../auth-verifier.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { assertRepoAvailability } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.sync.listBlobs, {
-    auth: ctx.authVerifier.authorizationOrAdminTokenOptional({
-      additional: [AuthScope.Takendown],
-      authorize: () => {
-        // always allow
-      },
-    }),
-    handler: async ({ params, auth }) => {
-      const { did, since, limit, cursor } = params
-      await assertRepoAvailability(ctx, did, isUserOrAdmin(auth, did))
-
-      const blobCids = await ctx.actorStore.read(did, (store) =>
-        store.repo.blob.listBlobs({ since, limit, cursor }),
-      )
-
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          cursor: blobCids.at(-1),
-          cids: blobCids,
-        },
-      }
-    },
-  })
-}

package/src/api/com/atproto/sync/listRepos.ts

@@ -1,74 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { formatAccountStatus } from '../../../../account-manager/account-manager.js'
-import { AppContext } from '../../../../context.js'
-import { Cursor, GenericKeyset, paginate } from '../../../../db/pagination.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.sync.listRepos, async ({ params }) => {
-    const { limit, cursor } = params
-    const db = ctx.accountManager.db
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('actor')
-      .innerJoin('repo_root', 'repo_root.did', 'actor.did')
-      .select([
-        'actor.did as did',
-        'repo_root.cid as head',
-        'repo_root.rev as rev',
-        'actor.createdAt as createdAt',
-        'actor.deactivatedAt as deactivatedAt',
-        'actor.takedownRef as takedownRef',
-      ])
-    const keyset = new TimeDidKeyset(ref('actor.createdAt'), ref('actor.did'))
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-      direction: 'asc',
-      tryIndex: true,
-    })
-    const res = await builder.execute()
-    const repos = res.map((row): com.atproto.sync.listRepos.Repo => {
-      const { active, status } = formatAccountStatus(row)
-      return {
-        did: row.did,
-        head: row.head,
-        rev: row.rev ?? '',
-        active,
-        status,
-      }
-    })
-    return {
-      encoding: 'application/json' as const,
-      body: {
-        cursor: keyset.packFromResult(res),
-        repos,
-      },
-    }
-  })
-}
-
-type TimeDidResult = { createdAt: string; did: string }
-
-export class TimeDidKeyset extends GenericKeyset<TimeDidResult, Cursor> {
-  labelResult(result: TimeDidResult): Cursor {
-    return { primary: result.createdAt, secondary: result.did }
-  }
-  labeledResultToCursor(labeled: Cursor) {
-    return {
-      primary: new Date(labeled.primary).getTime().toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: Cursor) {
-    const primaryDate = new Date(parseInt(cursor.primary, 10))
-    if (isNaN(primaryDate.getTime())) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: primaryDate.toISOString(),
-      secondary: cursor.secondary,
-    }
-  }
-}

package/src/api/com/atproto/sync/subscribeRepos.ts

@@ -1,73 +0,0 @@
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { httpLogger } from '../../../../logger.js'
-import { Outbox } from '../../../../sequencer/outbox.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(
-    com.atproto.sync.subscribeRepos,
-    async function* ({
-      params,
-      signal,
-    }): AsyncGenerator<com.atproto.sync.subscribeRepos.$Message> {
-      const { cursor } = params
-      const outbox = new Outbox(ctx.sequencer, {
-        maxBufferSize: ctx.cfg.subscription.maxBuffer,
-      })
-      httpLogger.info({ cursor }, 'request to com.atproto.sync.subscribeRepos')
-
-      const backfillTime = new Date(
-        Date.now() - ctx.cfg.subscription.repoBackfillLimitMs,
-      ).toISOString()
-      let outboxCursor: number | undefined = undefined
-      if (cursor !== undefined) {
-        const [next, curr] = await Promise.all([
-          ctx.sequencer.next(cursor),
-          ctx.sequencer.curr(),
-        ])
-        if (cursor > (curr ?? 0)) {
-          throw new InvalidRequestError('Cursor in the future.', 'FutureCursor')
-        } else if (next && next.sequencedAt < backfillTime) {
-          // if cursor is before backfill time, find earliest cursor from backfill window
-          yield com.atproto.sync.subscribeRepos.info.$build({
-            name: 'OutdatedCursor',
-            message: 'Requested cursor exceeded limit. Possibly missing events',
-          })
-          const startEvt = await ctx.sequencer.earliestAfterTime(backfillTime)
-          outboxCursor = startEvt?.seq ? startEvt.seq - 1 : undefined
-        } else {
-          outboxCursor = cursor
-        }
-      }
-
-      for await (const evt of outbox.events(outboxCursor, signal)) {
-        if (evt.type === 'commit') {
-          yield com.atproto.sync.subscribeRepos.commit.$build({
-            seq: evt.seq,
-            time: evt.time,
-            ...evt.evt,
-          })
-        } else if (evt.type === 'sync') {
-          yield com.atproto.sync.subscribeRepos.sync.$build({
-            seq: evt.seq,
-            time: evt.time,
-            ...evt.evt,
-          })
-        } else if (evt.type === 'identity') {
-          yield com.atproto.sync.subscribeRepos.identity.$build({
-            seq: evt.seq,
-            time: evt.time,
-            ...evt.evt,
-          })
-        } else if (evt.type === 'account') {
-          yield com.atproto.sync.subscribeRepos.account.$build({
-            seq: evt.seq,
-            time: evt.time,
-            ...evt.evt,
-          })
-        }
-      }
-    },
-  )
-}

package/src/api/com/atproto/sync/util.ts

@@ -1,37 +0,0 @@
-import { AtIdentifierString } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { ActorAccount } from '../../../../account-manager/helpers/account.js'
-import { AppContext } from '../../../../context.js'
-
-export const assertRepoAvailability = async (
-  ctx: AppContext,
-  handleOrDid: AtIdentifierString,
-  isAdminOrSelf: boolean,
-): Promise<ActorAccount> => {
-  const account = await ctx.accountManager.getAccount(handleOrDid, {
-    includeDeactivated: true,
-    includeTakenDown: true,
-  })
-  if (!account) {
-    throw new InvalidRequestError(
-      `Could not find repo for DID: ${handleOrDid}`,
-      'RepoNotFound',
-    )
-  }
-  if (isAdminOrSelf) {
-    return account
-  }
-  if (account.takedownRef) {
-    throw new InvalidRequestError(
-      `Repo has been takendown: ${handleOrDid}`,
-      'RepoTakendown',
-    )
-  }
-  if (account.deactivatedAt) {
-    throw new InvalidRequestError(
-      `Repo has been deactivated: ${handleOrDid}`,
-      'RepoDeactivated',
-    )
-  }
-  return account
-}

package/src/api/com/atproto/temp/checkSignupQueue.ts

@@ -1,34 +0,0 @@
-import { ForbiddenError, Server } from '@atproto/xrpc-server'
-import { AuthScope } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-// THIS IS A TEMPORARY UNSPECCED ROUTE
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.temp.checkSignupQueue, {
-    auth: ctx.authVerifier.authorization({
-      additional: [AuthScope.SignupQueued],
-      authorize: () => {
-        throw new ForbiddenError(
-          'OAuth credentials are not supported for this endpoint',
-        )
-      },
-    }),
-    handler: async ({ req }) => {
-      if (!ctx.entrywayClient) {
-        return {
-          encoding: 'application/json' as const,
-          body: {
-            activated: true,
-          },
-        }
-      }
-
-      const { headers } = ctx.entrywayPassthruHeaders(req)
-
-      return ctx.entrywayClient.xrpc(com.atproto.temp.checkSignupQueue, {
-        headers,
-      })
-    },
-  })
-}

package/src/api/com/atproto/temp/index.ts

@@ -1,7 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import checkSignupQueue from './checkSignupQueue.js'
-
-export default function (server: Server, ctx: AppContext) {
-  checkSignupQueue(server, ctx)
-}

package/src/api/index.ts

@@ -1,10 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../context.js'
-import appBsky from './app/bsky/index.js'
-import comAtproto from './com/atproto/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  comAtproto(server, ctx)
-  appBsky(server, ctx)
-  return server
-}

package/src/api/proxy.ts

@@ -1,44 +0,0 @@
-import { IncomingMessage } from 'node:http'
-import express from 'express'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-
-export function authPassthru(req: IncomingMessage) {
-  const { authorization } = req.headers
-
-  if (authorization) {
-    // DPoP requests are bound to the endpoint being called. Allowing them to be
-    // proxied would require that the receiving end allows DPoP proof not
-    // created for him. Since proxying is mainly there to support legacy
-    // clients, and DPoP is a new feature, we don't support DPoP requests
-    // through the proxy.
-
-    // This is fine since app views are usually called using the requester's
-    // credentials when "auth.credentials.type === 'access'", which is the only
-    // case were DPoP is used.
-    const [type] = authorization.split(' ', 1)
-    if (!type) {
-      throw new InvalidRequestError('Invalid authorization header')
-    }
-    if (type.toLowerCase() === 'dpop' || req.headers['dpop']) {
-      throw new InvalidRequestError('DPoP requests cannot be proxied')
-    }
-
-    return { headers: { authorization } }
-  }
-}
-
-// @NOTE this function may mutate its params input
-// future improvement here would be to forward along all untrusted ips rather than just the first (req.ip)
-export const forwardedFor = (
-  req: express.Request,
-  params: HeadersParam | undefined,
-) => {
-  const result: HeadersParam = params ?? { headers: {} }
-  const ip = req.ip
-  if (ip) {
-    result.headers['x-forwarded-for'] = ip
-  }
-  return result
-}
-
-type HeadersParam = { headers: Record<string, string> }

package/src/app-view.ts

@@ -1,24 +0,0 @@
-import { format } from 'node:util'
-import { Client } from '@atproto/lex'
-
-export type AppViewOptions = {
-  url: string
-  did: string
-  cdnUrlPattern?: string
-}
-
-export class AppView {
-  public did: string
-  public client: Client
-  private cdnUrlPattern?: string
-
-  constructor(options: AppViewOptions) {
-    this.did = options.did
-    this.client = new Client({ service: options.url })
-    this.cdnUrlPattern = options.cdnUrlPattern
-  }
-
-  getImageUrl(pattern: string, did: string, cid: string): string | undefined {
-    if (this.cdnUrlPattern) return format(this.cdnUrlPattern, pattern, did, cid)
-  }
-}

package/src/auth-output.ts

@@ -1,52 +0,0 @@
-import { ScopePermissions } from '@atproto/oauth-scopes'
-import { DidString } from '@atproto/syntax'
-import { AuthScope } from './auth-scope.js'
-
-export type UnauthenticatedOutput = {
-  credentials: null
-}
-
-export type AdminTokenOutput = {
-  credentials: {
-    type: 'admin_token'
-  }
-}
-
-export type ModServiceOutput = {
-  credentials: {
-    type: 'mod_service'
-    did: DidString
-  }
-}
-
-export type AccessOutput<S extends AuthScope = AuthScope> = {
-  credentials: {
-    type: 'access'
-    did: DidString
-    scope: S
-  }
-}
-
-export type OAuthOutput = {
-  credentials: {
-    type: 'oauth'
-    did: DidString
-    permissions: ScopePermissions
-  }
-}
-
-export type RefreshOutput = {
-  credentials: {
-    type: 'refresh'
-    did: DidString
-    scope: AuthScope.Refresh
-    tokenId: string
-  }
-}
-
-export type UserServiceAuthOutput = {
-  credentials: {
-    type: 'user_service_auth'
-    did: DidString
-  }
-}

package/src/auth-routes.ts

@@ -1,64 +0,0 @@
-import { Router } from 'express'
-import {
-  HandleUnavailableError,
-  InvalidRequestError,
-  SecondAuthenticationFactorRequiredError,
-  UseDpopNonceError,
-  oauthMiddleware,
-  oauthProtectedResourceMetadataSchema,
-} from '@atproto/oauth-provider'
-import { AppContext } from './context.js'
-import { oauthLogger, reqSerializer } from './logger.js'
-
-export const createRouter = ({ oauthProvider, cfg }: AppContext): Router => {
-  const router = Router()
-
-  const oauthProtectedResourceMetadata =
-    oauthProtectedResourceMetadataSchema.parse({
-      resource: cfg.service.publicUrl,
-      authorization_servers: [cfg.entryway?.url ?? cfg.service.publicUrl],
-      bearer_methods_supported: ['header'],
-      scopes_supported: [],
-      resource_documentation: 'https://atproto.com',
-    })
-
-  if (
-    !cfg.service.devMode &&
-    !oauthProtectedResourceMetadata.resource.startsWith('https://')
-  ) {
-    throw new Error('Resource URL must use the https scheme')
-  }
-
-  router.get('/.well-known/oauth-protected-resource', (req, res) => {
-    res.setHeader('Access-Control-Allow-Origin', '*')
-    res.setHeader('Access-Control-Allow-Method', '*')
-    res.setHeader('Access-Control-Allow-Headers', '*')
-    res.status(200).json(oauthProtectedResourceMetadata)
-  })
-
-  if (oauthProvider) {
-    router.use(
-      oauthMiddleware(oauthProvider, {
-        onError: (req, res, err, msg) => {
-          if (!ignoreError(err)) {
-            oauthLogger.error({ err, req: reqSerializer(req) }, msg)
-          }
-        },
-      }),
-    )
-  }
-
-  return router
-}
-
-function ignoreError(err: unknown): boolean {
-  if (err instanceof InvalidRequestError) {
-    return err.error_description === 'Invalid identifier or password'
-  }
-
-  return (
-    err instanceof UseDpopNonceError ||
-    err instanceof HandleUnavailableError ||
-    err instanceof SecondAuthenticationFactorRequiredError
-  )
-}