@atproto/pds 0.4.90 → 0.4.92

package/src/actor-store/db/schema/index.ts

@@ -1,10 +1,10 @@
 import * as accountPref from './account-pref'
-import * as repoRoot from './repo-root'
-import * as record from './record'
 import * as backlink from './backlink'
-import * as repoBlock from './repo-block'
 import * as blob from './blob'
+import * as record from './record'
 import * as recordBlob from './record-blob'
+import * as repoBlock from './repo-block'
+import * as repoRoot from './repo-root'
 
 export type DatabaseSchema = accountPref.PartialDB &
   repoRoot.PartialDB &

package/src/actor-store/migrate.ts

@@ -1,6 +1,6 @@
 import { sql } from 'kysely'
-import AppContext from '../context'
 import PQueue from 'p-queue'
+import { AppContext } from '../context'
 
 export const forEachActorStore = async (
   ctx: AppContext,

package/src/actor-store/preference/transactor.ts

@@ -1,10 +1,10 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AuthScope } from '../../auth-verifier'
 import {
-  PreferenceReader,
   AccountPreference,
+  PreferenceReader,
   prefMatchNamespace,
 } from './reader'
-import { AuthScope } from '../../auth-verifier'
 import { prefInScope } from './util'
 
 export class PreferenceTransactor extends PreferenceReader {

package/src/actor-store/record/reader.ts

@@ -1,12 +1,21 @@
+import { CID } from 'multiformats/cid'
+import { RepoRecord } from '@atproto/lexicon'
+import { CidSet, cborToLexRecord, formatDataKey } from '@atproto/repo'
 import * as syntax from '@atproto/syntax'
 import { AtUri, ensureValidAtUri } from '@atproto/syntax'
-import { cborToLexRecord } from '@atproto/repo'
-import { CID } from 'multiformats/cid'
 import { countAll, notSoftDeletedClause } from '../../db/util'
 import { ids } from '../../lexicon/lexicons'
-import { ActorDb, Backlink } from '../db'
+import { Record as ProfileRecord } from '../../lexicon/types/app/bsky/actor/profile'
+import { Record as PostRecord } from '../../lexicon/types/app/bsky/feed/post'
 import { StatusAttr } from '../../lexicon/types/com/atproto/admin/defs'
-import { RepoRecord } from '@atproto/lexicon'
+import { LocalRecords } from '../../read-after-write/types'
+import { ActorDb, Backlink } from '../db'
+
+export type RecordDescript = {
+  uri: string
+  path: string
+  cid: CID
+}
 
 export class RecordReader {
   constructor(public db: ActorDb) {}
@@ -19,6 +28,30 @@ export class RecordReader {
     return res?.count ?? 0
   }
 
+  async listAll(): Promise<RecordDescript[]> {
+    const records: RecordDescript[] = []
+    let cursor: string | undefined = ''
+    while (cursor !== undefined) {
+      const res = await this.db.db
+        .selectFrom('record')
+        .select(['uri', 'cid'])
+        .where('uri', '>', cursor)
+        .orderBy('uri', 'asc')
+        .limit(1000)
+        .execute()
+      for (const row of res) {
+        const parsed = new AtUri(row.uri)
+        records.push({
+          uri: row.uri,
+          path: formatDataKey(parsed.collection, parsed.rkey),
+          cid: CID.parse(row.cid),
+        })
+      }
+      cursor = res.at(-1)?.uri
+    }
+    return records
+  }
+
   async listCollections(): Promise<string[]> {
     const collections = await this.db.db
       .selectFrom('record')
@@ -194,6 +227,94 @@ export class RecordReader {
       .flat()
       .map(({ rkey }) => AtUri.make(uri.hostname, uri.collection, rkey))
   }
+
+  async listExistingBlocks(): Promise<CidSet> {
+    const cids = new CidSet()
+    let cursor: string | undefined = ''
+    while (cursor !== undefined) {
+      const res = await this.db.db
+        .selectFrom('repo_block')
+        .select('cid')
+        .where('cid', '>', cursor)
+        .orderBy('cid', 'asc')
+        .limit(1000)
+        .execute()
+      for (const row of res) {
+        cids.add(CID.parse(row.cid))
+      }
+      cursor = res.at(-1)?.cid
+    }
+    return cids
+  }
+
+  async getProfileRecord() {
+    const row = await this.db.db
+      .selectFrom('record')
+      .leftJoin('repo_block', 'repo_block.cid', 'record.cid')
+      .where('record.collection', '=', ids.AppBskyActorProfile)
+      .where('record.rkey', '=', 'self')
+      .selectAll()
+      .executeTakeFirst()
+
+    if (!row?.content) return null
+
+    return cborToLexRecord(row.content) as ProfileRecord
+  }
+
+  async getRecordsSinceRev(rev: string): Promise<LocalRecords> {
+    const result: LocalRecords = { count: 0, profile: null, posts: [] }
+
+    const res = await this.db.db
+      .selectFrom('record')
+      .innerJoin('repo_block', 'repo_block.cid', 'record.cid')
+      .select([
+        'repo_block.content',
+        'uri',
+        'repo_block.cid',
+        'record.indexedAt',
+      ])
+      .where('record.repoRev', '>', rev)
+      .limit(10)
+      .orderBy('record.repoRev', 'asc')
+      .execute()
+
+    // sanity check to ensure that the clock received is not before _all_ local records (for instance in case of account migration)
+    if (res.length > 0) {
+      const sanityCheckRes = await this.db.db
+        .selectFrom('record')
+        .selectAll()
+        .where('record.repoRev', '<=', rev)
+        .limit(1)
+        .executeTakeFirst()
+
+      if (!sanityCheckRes) {
+        return result
+      }
+    }
+
+    for (const cur of res) {
+      result.count++
+
+      const uri = new AtUri(cur.uri)
+      if (uri.collection === ids.AppBskyActorProfile && uri.rkey === 'self') {
+        result.profile = {
+          uri,
+          cid: CID.parse(cur.cid),
+          indexedAt: cur.indexedAt,
+          record: cborToLexRecord(cur.content) as ProfileRecord,
+        }
+      } else if (uri.collection === ids.AppBskyFeedPost) {
+        result.posts.push({
+          uri,
+          cid: CID.parse(cur.cid),
+          indexedAt: cur.indexedAt,
+          record: cborToLexRecord(cur.content) as PostRecord,
+        })
+      }
+    }
+
+    return result
+  }
 }
 
 // @NOTE in the future this can be replaced with a more generic routine that pulls backlinks based on lex docs.

package/src/actor-store/record/transactor.ts

@@ -1,11 +1,11 @@
 import { CID } from 'multiformats/cid'
-import { AtUri } from '@atproto/syntax'
+import { RepoRecord } from '@atproto/lexicon'
 import { BlobStore, WriteOpAction } from '@atproto/repo'
+import { AtUri } from '@atproto/syntax'
+import { StatusAttr } from '../../lexicon/types/com/atproto/admin/defs'
 import { dbLogger as log } from '../../logger'
 import { ActorDb, Backlink } from '../db'
 import { RecordReader, getBacklinks } from './reader'
-import { StatusAttr } from '../../lexicon/types/com/atproto/admin/defs'
-import { RepoRecord } from '@atproto/lexicon'
 
 export class RecordTransactor extends RecordReader {
   constructor(

package/src/actor-store/repo/reader.ts

@@ -1,8 +1,8 @@
 import { BlobStore } from '@atproto/repo'
-import { SqlRepoReader } from './sql-repo-reader'
 import { BlobReader } from '../blob/reader'
 import { ActorDb } from '../db'
 import { RecordReader } from '../record/reader'
+import { SqlRepoReader } from './sql-repo-reader'
 
 export class RepoReader {
   blob: BlobReader

package/src/actor-store/repo/sql-repo-reader.ts

@@ -1,14 +1,14 @@
+import { sql } from 'kysely'
+import { CID } from 'multiformats/cid'
+import { chunkArray, wait } from '@atproto/common'
 import {
   BlockMap,
   CidSet,
   ReadableBlockstore,
   writeCarStream,
 } from '@atproto/repo'
-import { chunkArray, wait } from '@atproto/common'
-import { CID } from 'multiformats/cid'
-import { ActorDb } from '../db'
-import { sql } from 'kysely'
 import { countAll } from '../../db'
+import { ActorDb } from '../db'
 
 export class SqlRepoReader extends ReadableBlockstore {
   cache: BlockMap = new BlockMap()
@@ -19,13 +19,14 @@ export class SqlRepoReader extends ReadableBlockstore {
 
   async getRoot(): Promise<CID> {
     const root = await this.getRootDetailed()
-    return root?.cid ?? null
+    return root.cid
   }
 
   async getRootDetailed(): Promise<{ cid: CID; rev: string }> {
     const res = await this.db.db
       .selectFrom('repo_root')
-      .selectAll()
+      .select(['cid', 'rev'])
+      .limit(1)
       .executeTakeFirstOrThrow()
     return {
       cid: CID.parse(res.cid),

package/src/actor-store/repo/sql-repo-transactor.ts

@@ -1,6 +1,6 @@
-import { CommitData, RepoStorage, BlockMap } from '@atproto/repo'
-import { chunkArray } from '@atproto/common'
 import { CID } from 'multiformats/cid'
+import { chunkArray } from '@atproto/common'
+import { BlockMap, CommitData, RepoStorage } from '@atproto/repo'
 import { ActorDb, RepoBlock } from '../db'
 import { SqlRepoReader } from './sql-repo-reader'
 

package/src/actor-store/repo/transactor.ts

@@ -1,9 +1,10 @@
 import { CID } from 'multiformats/cid'
 import * as crypto from '@atproto/crypto'
 import { BlobStore, CommitData, Repo, WriteOpAction } from '@atproto/repo'
-import { InvalidRequestError } from '@atproto/xrpc-server'
 import { AtUri } from '@atproto/syntax'
-import { SqlRepoTransactor } from './sql-repo-transactor'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { BackgroundQueue } from '../../background'
+import { createWriteToOp, writeToOp } from '../../repo'
 import {
   BadCommitSwapError,
   BadRecordSwapError,
@@ -11,31 +12,37 @@ import {
   PreparedWrite,
 } from '../../repo/types'
 import { BlobTransactor } from '../blob/transactor'
-import { createWriteToOp, writeToOp } from '../../repo'
-import { BackgroundQueue } from '../../background'
 import { ActorDb } from '../db'
 import { RecordTransactor } from '../record/transactor'
 import { RepoReader } from './reader'
+import { SqlRepoTransactor } from './sql-repo-transactor'
 
 export class RepoTransactor extends RepoReader {
   blob: BlobTransactor
   record: RecordTransactor
   storage: SqlRepoTransactor
-  now: string
 
   constructor(
     public db: ActorDb,
+    public blobstore: BlobStore,
     public did: string,
     public signingKey: crypto.Keypair,
-    public blobstore: BlobStore,
     public backgroundQueue: BackgroundQueue,
-    now?: string,
+    public now: string = new Date().toISOString(),
   ) {
     super(db, blobstore)
     this.blob = new BlobTransactor(db, blobstore, backgroundQueue)
     this.record = new RecordTransactor(db, blobstore)
-    this.now = now ?? new Date().toISOString()
-    this.storage = new SqlRepoTransactor(db, this.did, this.now)
+    this.storage = new SqlRepoTransactor(db, did, now)
+  }
+
+  async maybeLoadRepo(): Promise<Repo | null> {
+    const res = await this.db.db
+      .selectFrom('repo_root')
+      .select('cid')
+      .limit(1)
+      .executeTakeFirst()
+    return res ? Repo.load(this.storage, CID.parse(res.cid)) : null
   }
 
   async createRepo(writes: PreparedCreate[]): Promise<CommitData> {

package/src/api/app/bsky/actor/getPreferences.ts

@@ -1,9 +1,10 @@
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 import { AuthScope } from '../../../../auth-verifier'
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
 
 export default function (server: Server, ctx: AppContext) {
-  if (!ctx.cfg.bskyAppView) return
+  if (!ctx.bskyAppView) return
+
   server.app.bsky.actor.getPreferences({
     auth: ctx.authVerifier.accessStandard({
       additional: [AuthScope.Takendown],

package/src/api/app/bsky/actor/getProfile.ts

@@ -1,15 +1,15 @@
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 import { OutputSchema } from '../../../../lexicon/types/app/bsky/actor/getProfile'
 import {
-  LocalViewer,
   LocalRecords,
+  LocalViewer,
   pipethroughReadAfterWrite,
 } from '../../../../read-after-write'
 
 export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx.cfg
-  if (!bskyAppView) return
+  if (!ctx.bskyAppView) return
+
   server.app.bsky.actor.getProfile({
     auth: ctx.authVerifier.accessStandard(),
     handler: async (reqCtx) => {

package/src/api/app/bsky/actor/getProfiles.ts

@@ -1,15 +1,15 @@
-import AppContext from '../../../../context'
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
 import { OutputSchema } from '../../../../lexicon/types/app/bsky/actor/getProfiles'
 import {
+  LocalRecords,
   LocalViewer,
   pipethroughReadAfterWrite,
-  LocalRecords,
 } from '../../../../read-after-write'
 
 export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx.cfg
-  if (!bskyAppView) return
+  if (!ctx.bskyAppView) return
+
   server.app.bsky.actor.getProfiles({
     auth: ctx.authVerifier.accessStandard(),
     handler: async (reqCtx) => {

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

@@ -1,6 +1,5 @@
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
-
 import getPreferences from './getPreferences'
 import getProfile from './getProfile'
 import getProfiles from './getProfiles'

package/src/api/app/bsky/actor/putPreferences.ts

@@ -1,10 +1,11 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 import { AccountPreference } from '../../../../actor-store/preference/reader'
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
 
 export default function (server: Server, ctx: AppContext) {
-  if (!ctx.cfg.bskyAppView) return
+  if (!ctx.bskyAppView) return
+
   server.app.bsky.actor.putPreferences({
     auth: ctx.authVerifier.accessStandard({ checkTakedown: true }),
     handler: async ({ auth, input }) => {

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

@@ -1,15 +1,15 @@
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 import { OutputSchema } from '../../../../lexicon/types/app/bsky/feed/getAuthorFeed'
 import {
+  LocalRecords,
   LocalViewer,
   pipethroughReadAfterWrite,
-  LocalRecords,
 } from '../../../../read-after-write'
 
 export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx.cfg
-  if (!bskyAppView) return
+  if (!ctx.bskyAppView) return
+
   server.app.bsky.feed.getActorLikes({
     auth: ctx.authVerifier.accessStandard(),
     handler: async (reqCtx) => {

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

@@ -1,16 +1,16 @@
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
-import { OutputSchema } from '../../../../lexicon/types/app/bsky/feed/getAuthorFeed'
 import { isReasonRepost } from '../../../../lexicon/types/app/bsky/feed/defs'
+import { OutputSchema } from '../../../../lexicon/types/app/bsky/feed/getAuthorFeed'
 import {
+  LocalRecords,
   LocalViewer,
   pipethroughReadAfterWrite,
-  LocalRecords,
 } from '../../../../read-after-write'
 
 export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx.cfg
-  if (!bskyAppView) return
+  if (!ctx.bskyAppView) return
+
   server.app.bsky.feed.getAuthorFeed({
     auth: ctx.authVerifier.accessStandard(),
     handler: async (reqCtx) => {

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

@@ -1,21 +1,21 @@
+import { InvalidRequestError } from '@atproto/oauth-provider'
+import { AtUri } from '@atproto/syntax'
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
-import { pipethrough } from '../../../../pipethrough'
 import { ids } from '../../../../lexicon/lexicons'
-import { AtUri } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/oauth-provider'
+import { pipethrough } from '../../../../pipethrough'
 
 export default function (server: Server, ctx: AppContext) {
-  const { appViewAgent } = ctx
-  const { bskyAppView } = ctx.cfg
-  if (!appViewAgent || !bskyAppView) return
+  const { bskyAppView } = ctx
+  if (!bskyAppView) return
+
   server.app.bsky.feed.getFeed({
     auth: ctx.authVerifier.accessStandard(),
     handler: async ({ params, auth, req }) => {
       const requester = auth.credentials.did
 
       const feedUrl = new AtUri(params.feed)
-      const { data } = await appViewAgent.com.atproto.repo.getRecord({
+      const { data } = await bskyAppView.agent.com.atproto.repo.getRecord({
         repo: feedUrl.hostname,
         collection: feedUrl.collection,
         rkey: feedUrl.rkey,

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

@@ -1,32 +1,31 @@
 import assert from 'node:assert'
 import { AtUri } from '@atproto/syntax'
 import { XRPCError } from '@atproto/xrpc'
-
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
+import { ids } from '../../../../lexicon/lexicons'
 import {
   ThreadViewPost,
   isThreadViewPost,
 } from '../../../../lexicon/types/app/bsky/feed/defs'
-import { Record as PostRecord } from '../../../../lexicon/types/app/bsky/feed/post'
 import {
   OutputSchema,
   QueryParams,
 } from '../../../../lexicon/types/app/bsky/feed/getPostThread'
+import { Record as PostRecord } from '../../../../lexicon/types/app/bsky/feed/post'
 import {
+  LocalRecords,
   LocalViewer,
+  RecordDescript,
+  formatMungedResponse,
   getLocalLag,
   getRepoRev,
-  LocalRecords,
-  RecordDescript,
   pipethroughReadAfterWrite,
-  formatMungedResponse,
 } from '../../../../read-after-write'
-import { ids } from '../../../../lexicon/lexicons'
 
 export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx.cfg
-  if (!bskyAppView) return
+  if (!ctx.bskyAppView) return
+
   server.app.bsky.feed.getPostThread({
     auth: ctx.authVerifier.accessStandard(),
     handler: async (reqCtx) => {
@@ -191,11 +190,12 @@ const readAfterWriteNotFound = async (
   const highestParent = getHighestParent(thread)
   if (highestParent) {
     try {
-      assert(ctx.appViewAgent)
-      const parentsRes = await ctx.appViewAgent.api.app.bsky.feed.getPostThread(
-        { uri: highestParent, parentHeight: params.parentHeight, depth: 0 },
-        await ctx.appviewAuthHeaders(requester, ids.AppBskyFeedGetPostThread),
-      )
+      assert(ctx.bskyAppView)
+      const parentsRes =
+        await ctx.bskyAppView.agent.app.bsky.feed.getPostThread(
+          { uri: highestParent, parentHeight: params.parentHeight, depth: 0 },
+          await ctx.appviewAuthHeaders(requester, ids.AppBskyFeedGetPostThread),
+        )
       thread.parent = parentsRes.data.thread
     } catch (err) {
       // do nothing

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

@@ -1,15 +1,15 @@
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 import { OutputSchema } from '../../../../lexicon/types/app/bsky/feed/getTimeline'
 import {
+  LocalRecords,
   LocalViewer,
   pipethroughReadAfterWrite,
-  LocalRecords,
 } from '../../../../read-after-write'
 
 export default function (server: Server, ctx: AppContext) {
-  const { bskyAppView } = ctx.cfg
-  if (!bskyAppView) return
+  if (!ctx.bskyAppView) return
+
   server.app.bsky.feed.getTimeline({
     auth: ctx.authVerifier.accessStandard(),
     handler: async (reqCtx) => {

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

@@ -1,5 +1,5 @@
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 import getActorLikes from './getActorLikes'
 import getAuthorFeed from './getAuthorFeed'
 import getFeed from './getFeed'

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

@@ -1,5 +1,5 @@
+import { AppContext } from '../../../context'
 import { Server } from '../../../lexicon'
-import AppContext from '../../../context'
 import actor from './actor'
 import feed from './feed'
 import notification from './notification'

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

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

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

@@ -1,15 +1,16 @@
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
+import { AtpAgent } from '@atproto/api'
 import { getNotif } from '@atproto/identity'
 import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AtpAgent } from '@atproto/api'
-import { getDidDoc } from '../util/resolver'
 import { AuthScope } from '../../../../auth-verifier'
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
 import { ids } from '../../../../lexicon/lexicons'
+import { getDidDoc } from '../util/resolver'
 
 export default function (server: Server, ctx: AppContext) {
-  const { appViewAgent } = ctx
-  if (!appViewAgent) return
+  const { bskyAppView } = ctx
+  if (!bskyAppView) return
+
   server.app.bsky.notification.registerPush({
     auth: ctx.authVerifier.accessStandard({
       additional: [AuthScope.SignupQueued],
@@ -26,8 +27,8 @@ export default function (server: Server, ctx: AppContext) {
         ids.AppBskyNotificationRegisterPush,
       )
 
-      if (ctx.cfg.bskyAppView?.did === serviceDid) {
-        await appViewAgent.api.app.bsky.notification.registerPush(input.body, {
+      if (bskyAppView.did === serviceDid) {
+        await bskyAppView.agent.app.bsky.notification.registerPush(input.body, {
           ...authHeaders,
           encoding: 'application/json',
         })

package/src/api/app/bsky/util/resolver.ts

@@ -1,6 +1,6 @@
 import { DidDocument, PoorlyFormattedDidDocumentError } from '@atproto/identity'
-import AppContext from '../../../../context'
 import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
 
 // provides http-friendly errors during did resolution
 export const getDidDoc = async (ctx: AppContext, did: string) => {

package/src/api/com/atproto/admin/deleteAccount.ts

@@ -1,6 +1,6 @@
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 import { AccountStatus } from '../../../../account-manager'
+import { AppContext } from '../../../../context'
+import { Server } from '../../../../lexicon'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.admin.deleteAccount({

package/src/api/com/atproto/admin/disableAccountInvites.ts

@@ -1,6 +1,6 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.admin.disableAccountInvites({

package/src/api/com/atproto/admin/disableInviteCodes.ts

@@ -1,6 +1,6 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
 import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.admin.disableInviteCodes({