@atproto/pds 0.4.20 → 0.4.22

package/src/api/app/bsky/feed/index.ts

@@ -1,35 +1,15 @@
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
-import getActorFeeds from './getActorFeeds'
 import getActorLikes from './getActorLikes'
 import getAuthorFeed from './getAuthorFeed'
 import getFeed from './getFeed'
-import getFeedGenerator from './getFeedGenerator'
-import getFeedGenerators from './getFeedGenerators'
-import getLikes from './getLikes'
-import getListFeed from './getListFeed'
-import getPosts from './getPosts'
 import getPostThread from './getPostThread'
-import getRepostedBy from './getRepostedBy'
-import getSuggestedFeeds from './getSuggestedFeeds'
 import getTimeline from './getTimeline'
-import searchPosts from './searchPosts'
-import sendInteractions from './sendInteractions'
 
 export default function (server: Server, ctx: AppContext) {
-  getActorFeeds(server, ctx)
   getActorLikes(server, ctx)
   getAuthorFeed(server, ctx)
   getFeed(server, ctx)
-  getFeedGenerator(server, ctx)
-  getFeedGenerators(server, ctx)
-  getLikes(server, ctx)
-  getListFeed(server, ctx)
-  getPosts(server, ctx)
   getPostThread(server, ctx)
-  getRepostedBy(server, ctx)
-  getSuggestedFeeds(server, ctx)
   getTimeline(server, ctx)
-  searchPosts(server, ctx)
-  sendInteractions(server, ctx)
 }

package/src/api/app/bsky/index.ts

@@ -2,16 +2,10 @@ import { Server } from '../../../lexicon'
 import AppContext from '../../../context'
 import actor from './actor'
 import feed from './feed'
-import graph from './graph'
-import labeler from './labeler'
 import notification from './notification'
-import unspecced from './unspecced'
 
 export default function (server: Server, ctx: AppContext) {
   actor(server, ctx)
   feed(server, ctx)
-  graph(server, ctx)
-  labeler(server, ctx)
   notification(server, ctx)
-  unspecced(server, ctx)
 }

package/src/api/app/bsky/notification/index.ts

@@ -1,14 +1,7 @@
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
-
-import getUnreadCount from './getUnreadCount'
-import listNotifications from './listNotifications'
 import registerPush from './registerPush'
-import updateSeen from './updateSeen'
 
 export default function (server: Server, ctx: AppContext) {
-  getUnreadCount(server, ctx)
-  listNotifications(server, ctx)
   registerPush(server, ctx)
-  updateSeen(server, ctx)
 }

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

@@ -2,7 +2,6 @@ import AppContext from '../../../context'
 import { Server } from '../../../lexicon'
 import admin from './admin'
 import identity from './identity'
-import moderation from './moderation'
 import repo from './repo'
 import serverMethods from './server'
 import sync from './sync'
@@ -11,7 +10,6 @@ import temp from './temp'
 export default function (server: Server, ctx: AppContext) {
   admin(server, ctx)
   identity(server, ctx)
-  moderation(server, ctx)
   repo(server, ctx)
   serverMethods(server, ctx)
   sync(server, ctx)

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

@@ -32,6 +32,6 @@ export default function (server: Server, ctx: AppContext) {
       throw new InvalidRequestError(`Could not locate record`)
     }
 
-    return await pipethrough(ctx, req)
+    return await pipethrough(ctx, req, null)
   })
 }

package/src/api/index.ts

@@ -1,12 +1,10 @@
 import { Server } from '../lexicon'
 import comAtproto from './com/atproto'
 import appBsky from './app/bsky'
-import toolsOzone from './tools/ozone'
 import AppContext from '../context'
 
 export default function (server: Server, ctx: AppContext) {
   comAtproto(server, ctx)
   appBsky(server, ctx)
-  toolsOzone(server, ctx)
   return server
 }

package/src/context.ts

@@ -6,7 +6,12 @@ import * as crypto from '@atproto/crypto'
 import { IdResolver } from '@atproto/identity'
 import { AtpAgent } from '@atproto/api'
 import { KmsKeypair, S3BlobStore } from '@atproto/aws'
-import { createServiceAuthHeaders } from '@atproto/xrpc-server'
+import {
+  RateLimiter,
+  RateLimiterCreator,
+  RateLimiterOpts,
+  createServiceAuthHeaders,
+} from '@atproto/xrpc-server'
 import { ServerConfig, ServerSecrets } from './config'
 import {
   AuthVerifier,
@@ -39,6 +44,7 @@ export type AppContextOptions = {
   sequencer: Sequencer
   backgroundQueue: BackgroundQueue
   redisScratch?: Redis
+  ratelimitCreator?: RateLimiterCreator
   crawlers: Crawlers
   appViewAgent?: AtpAgent
   moderationAgent?: AtpAgent
@@ -62,6 +68,7 @@ export class AppContext {
   public sequencer: Sequencer
   public backgroundQueue: BackgroundQueue
   public redisScratch?: Redis
+  public ratelimitCreator?: RateLimiterCreator
   public crawlers: Crawlers
   public appViewAgent: AtpAgent | undefined
   public moderationAgent: AtpAgent | undefined
@@ -84,6 +91,7 @@ export class AppContext {
     this.sequencer = opts.sequencer
     this.backgroundQueue = opts.backgroundQueue
     this.redisScratch = opts.redisScratch
+    this.ratelimitCreator = opts.ratelimitCreator
     this.crawlers = opts.crawlers
     this.appViewAgent = opts.appViewAgent
     this.moderationAgent = opts.moderationAgent
@@ -160,6 +168,30 @@ export class AppContext {
       ? getRedisClient(cfg.redis.address, cfg.redis.password)
       : undefined
 
+    let ratelimitCreator: RateLimiterCreator | undefined = undefined
+    if (cfg.rateLimits.enabled) {
+      const bypassSecret = cfg.rateLimits.bypassKey
+      const bypassIps = cfg.rateLimits.bypassIps
+      if (cfg.rateLimits.mode === 'redis') {
+        if (!redisScratch) {
+          throw new Error('Redis not set up for ratelimiting mode: `redis`')
+        }
+        ratelimitCreator = (opts: RateLimiterOpts) =>
+          RateLimiter.redis(redisScratch, {
+            bypassSecret,
+            bypassIps,
+            ...opts,
+          })
+      } else {
+        ratelimitCreator = (opts: RateLimiterOpts) =>
+          RateLimiter.memory({
+            bypassSecret,
+            bypassIps,
+            ...opts,
+          })
+      }
+    }
+
     const appViewAgent = cfg.bskyAppView
       ? new AtpAgent({ service: cfg.bskyAppView.url })
       : undefined
@@ -231,6 +263,7 @@ export class AppContext {
       sequencer,
       backgroundQueue,
       redisScratch,
+      ratelimitCreator,
       crawlers,
       appViewAgent,
       moderationAgent,

package/src/index.ts

@@ -8,12 +8,7 @@ import express from 'express'
 import cors from 'cors'
 import http from 'http'
 import events from 'events'
-import {
-  RateLimiter,
-  RateLimiterCreator,
-  RateLimiterOpts,
-  Options as XrpcServerOptions,
-} from '@atproto/xrpc-server'
+import { Options as XrpcServerOptions } from '@atproto/xrpc-server'
 import { DAY, HOUR, MINUTE } from '@atproto/common'
 import API from './api'
 import * as basicRoutes from './basic-routes'
@@ -25,6 +20,7 @@ import { createServer } from './lexicon'
 import { createHttpTerminator, HttpTerminator } from 'http-terminator'
 import AppContext, { AppContextOptions } from './context'
 import compression from './util/compression'
+import { proxyHandler } from './pipethrough'
 
 export * from './config'
 export { Database } from './db'
@@ -71,51 +67,31 @@ export class PDS {
         textLimit: 100 * 1024, // 100kb
         blobLimit: cfg.service.blobUploadLimit,
       },
-    }
-    if (cfg.rateLimits.enabled) {
-      const bypassSecret = cfg.rateLimits.bypassKey
-      const bypassIps = cfg.rateLimits.bypassIps
-      let rlCreator: RateLimiterCreator
-      if (cfg.rateLimits.mode === 'redis') {
-        if (!ctx.redisScratch) {
-          throw new Error('Redis not set up for ratelimiting mode: `redis`')
-        }
-        rlCreator = (opts: RateLimiterOpts) =>
-          RateLimiter.redis(ctx.redisScratch, {
-            bypassSecret,
-            bypassIps,
-            ...opts,
-          })
-      } else {
-        rlCreator = (opts: RateLimiterOpts) =>
-          RateLimiter.memory({
-            bypassSecret,
-            bypassIps,
-            ...opts,
-          })
-      }
-      xrpcOpts['rateLimits'] = {
-        creator: rlCreator,
-        global: [
-          {
-            name: 'global-ip',
-            durationMs: 5 * MINUTE,
-            points: 3000,
-          },
-        ],
-        shared: [
-          {
-            name: 'repo-write-hour',
-            durationMs: HOUR,
-            points: 5000, // creates=3, puts=2, deletes=1
-          },
-          {
-            name: 'repo-write-day',
-            durationMs: DAY,
-            points: 35000, // creates=3, puts=2, deletes=1
-          },
-        ],
-      }
+      catchall: proxyHandler(ctx),
+      rateLimits: ctx.ratelimitCreator
+        ? {
+            creator: ctx.ratelimitCreator,
+            global: [
+              {
+                name: 'global-ip',
+                durationMs: 5 * MINUTE,
+                points: 3000,
+              },
+            ],
+            shared: [
+              {
+                name: 'repo-write-hour',
+                durationMs: HOUR,
+                points: 5000, // creates=3, puts=2, deletes=1
+              },
+              {
+                name: 'repo-write-day',
+                durationMs: DAY,
+                points: 35000, // creates=3, puts=2, deletes=1
+              },
+            ],
+          }
+        : undefined,
     }
 
     let server = createServer(xrpcOpts)

package/src/lexicon/index.ts

@@ -129,6 +129,23 @@ import * as AppBskyUnspeccedGetSuggestionsSkeleton from './types/app/bsky/unspec
 import * as AppBskyUnspeccedGetTaggedSuggestions from './types/app/bsky/unspecced/getTaggedSuggestions'
 import * as AppBskyUnspeccedSearchActorsSkeleton from './types/app/bsky/unspecced/searchActorsSkeleton'
 import * as AppBskyUnspeccedSearchPostsSkeleton from './types/app/bsky/unspecced/searchPostsSkeleton'
+import * as ChatBskyActorDeleteAccount from './types/chat/bsky/actor/deleteAccount'
+import * as ChatBskyActorExportAccountData from './types/chat/bsky/actor/exportAccountData'
+import * as ChatBskyConvoDeleteMessageForSelf from './types/chat/bsky/convo/deleteMessageForSelf'
+import * as ChatBskyConvoGetConvo from './types/chat/bsky/convo/getConvo'
+import * as ChatBskyConvoGetConvoForMembers from './types/chat/bsky/convo/getConvoForMembers'
+import * as ChatBskyConvoGetLog from './types/chat/bsky/convo/getLog'
+import * as ChatBskyConvoGetMessages from './types/chat/bsky/convo/getMessages'
+import * as ChatBskyConvoLeaveConvo from './types/chat/bsky/convo/leaveConvo'
+import * as ChatBskyConvoListConvos from './types/chat/bsky/convo/listConvos'
+import * as ChatBskyConvoMuteConvo from './types/chat/bsky/convo/muteConvo'
+import * as ChatBskyConvoSendMessage from './types/chat/bsky/convo/sendMessage'
+import * as ChatBskyConvoSendMessageBatch from './types/chat/bsky/convo/sendMessageBatch'
+import * as ChatBskyConvoUnmuteConvo from './types/chat/bsky/convo/unmuteConvo'
+import * as ChatBskyConvoUpdateRead from './types/chat/bsky/convo/updateRead'
+import * as ChatBskyModerationGetActorMetadata from './types/chat/bsky/moderation/getActorMetadata'
+import * as ChatBskyModerationGetMessageContext from './types/chat/bsky/moderation/getMessageContext'
+import * as ChatBskyModerationUpdateActorAccess from './types/chat/bsky/moderation/updateActorAccess'
 import * as ToolsOzoneCommunicationCreateTemplate from './types/tools/ozone/communication/createTemplate'
 import * as ToolsOzoneCommunicationDeleteTemplate from './types/tools/ozone/communication/deleteTemplate'
 import * as ToolsOzoneCommunicationListTemplates from './types/tools/ozone/communication/listTemplates'
@@ -183,12 +200,14 @@ export class Server {
   xrpc: XrpcServer
   com: ComNS
   app: AppNS
+  chat: ChatNS
   tools: ToolsNS
 
   constructor(options?: XrpcOptions) {
     this.xrpc = createXrpcServer(schemas, options)
     this.com = new ComNS(this)
     this.app = new AppNS(this)
+    this.chat = new ChatNS(this)
     this.tools = new ToolsNS(this)
   }
 }
@@ -1713,6 +1732,241 @@ export class AppBskyUnspeccedNS {
   }
 }
 
+export class ChatNS {
+  _server: Server
+  bsky: ChatBskyNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.bsky = new ChatBskyNS(server)
+  }
+}
+
+export class ChatBskyNS {
+  _server: Server
+  actor: ChatBskyActorNS
+  convo: ChatBskyConvoNS
+  moderation: ChatBskyModerationNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.actor = new ChatBskyActorNS(server)
+    this.convo = new ChatBskyConvoNS(server)
+    this.moderation = new ChatBskyModerationNS(server)
+  }
+}
+
+export class ChatBskyActorNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  deleteAccount<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyActorDeleteAccount.Handler<ExtractAuth<AV>>,
+      ChatBskyActorDeleteAccount.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.actor.deleteAccount' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  exportAccountData<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyActorExportAccountData.Handler<ExtractAuth<AV>>,
+      ChatBskyActorExportAccountData.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.actor.exportAccountData' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class ChatBskyConvoNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  deleteMessageForSelf<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoDeleteMessageForSelf.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoDeleteMessageForSelf.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.deleteMessageForSelf' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getConvo<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoGetConvo.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoGetConvo.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.getConvo' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getConvoForMembers<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoGetConvoForMembers.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoGetConvoForMembers.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.getConvoForMembers' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getLog<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoGetLog.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoGetLog.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.getLog' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getMessages<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoGetMessages.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoGetMessages.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.getMessages' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  leaveConvo<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoLeaveConvo.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoLeaveConvo.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.leaveConvo' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  listConvos<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoListConvos.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoListConvos.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.listConvos' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  muteConvo<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoMuteConvo.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoMuteConvo.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.muteConvo' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  sendMessage<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoSendMessage.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoSendMessage.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.sendMessage' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  sendMessageBatch<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoSendMessageBatch.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoSendMessageBatch.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.sendMessageBatch' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  unmuteConvo<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoUnmuteConvo.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoUnmuteConvo.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.unmuteConvo' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  updateRead<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyConvoUpdateRead.Handler<ExtractAuth<AV>>,
+      ChatBskyConvoUpdateRead.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.convo.updateRead' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class ChatBskyModerationNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getActorMetadata<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyModerationGetActorMetadata.Handler<ExtractAuth<AV>>,
+      ChatBskyModerationGetActorMetadata.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.moderation.getActorMetadata' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getMessageContext<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyModerationGetMessageContext.Handler<ExtractAuth<AV>>,
+      ChatBskyModerationGetMessageContext.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.moderation.getMessageContext' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  updateActorAccess<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ChatBskyModerationUpdateActorAccess.Handler<ExtractAuth<AV>>,
+      ChatBskyModerationUpdateActorAccess.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'chat.bsky.moderation.updateActorAccess' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
 export class ToolsNS {
   _server: Server
   ozone: ToolsOzoneNS