@atproto/pds 0.4.91 → 0.4.93

package/src/oauth/provider.ts

@@ -3,17 +3,11 @@ import {
   OAuthProvider,
   OAuthProviderOptions,
 } from '@atproto/oauth-provider'
-
 import { AccountManager } from '../account-manager/index'
-import { ActorStore } from '../actor-store/index'
 import { oauthLogger } from '../logger'
-import { LocalViewerCreator } from '../read-after-write/index'
-import { DetailedAccountStore } from './detailed-account-store'
 
 export type AuthProviderOptions = {
   accountManager: AccountManager
-  actorStore: ActorStore
-  localViewer: LocalViewerCreator
 } & Pick<
   OAuthProviderOptions,
   'issuer' | 'redis' | 'keyset' | 'dpopSecret' | 'customization'
@@ -23,8 +17,6 @@ export type AuthProviderOptions = {
 export class PdsOAuthProvider extends OAuthProvider {
   constructor({
     accountManager,
-    actorStore,
-    localViewer,
     keyset,
     redis,
     dpopSecret,
@@ -39,6 +31,7 @@ export class PdsOAuthProvider extends OAuthProvider {
       redis,
       safeFetch,
       customization,
+      store: accountManager,
       metadata: {
         // PdsOAuthProvider is used when the PDS is both an authorization server
         // & resource server, in which case the issuer origin is also the
@@ -48,15 +41,6 @@ export class PdsOAuthProvider extends OAuthProvider {
         scopes_supported: ['transition:generic', 'transition:chat.bsky'],
       },
 
-      accountStore: new DetailedAccountStore(
-        accountManager,
-        actorStore,
-        localViewer,
-      ),
-      requestStore: accountManager,
-      deviceStore: accountManager,
-      tokenStore: accountManager,
-
       // If the PDS is both an authorization server & resource server (no
       // entryway), there is no need to use JWTs as access tokens. Instead,
       // the PDS can use tokenId as access tokens. This allows the PDS to

package/src/pipethrough.ts

@@ -1,9 +1,7 @@
-import express from 'express'
 import { IncomingHttpHeaders, ServerResponse } from 'node:http'
 import { PassThrough, Readable } from 'node:stream'
+import express from 'express'
 import { Dispatcher } from 'undici'
-
-import { buildProxiedContentEncoding } from '@atproto-labs/xrpc-utils'
 import {
   decodeStream,
   getServiceEndpoint,
@@ -17,11 +15,11 @@ import {
   HandlerPipeThroughStream,
   InternalServerError,
   InvalidRequestError,
-  parseReqNsid,
   XRPCError as XRPCServerError,
+  parseReqNsid,
 } from '@atproto/xrpc-server'
-
-import AppContext from './context'
+import { buildProxiedContentEncoding } from '@atproto-labs/xrpc-utils'
+import { AppContext } from './context'
 import { ids } from './lexicon/lexicons'
 import { httpLogger } from './logger'
 

package/src/read-after-write/types.ts

@@ -1,8 +1,8 @@
-import { Headers } from '@atproto/xrpc'
-import { AtUri } from '@atproto/syntax'
 import { CID } from 'multiformats/cid'
-import { Record as PostRecord } from '../lexicon/types/app/bsky/feed/post'
+import { AtUri } from '@atproto/syntax'
+import { Headers } from '@atproto/xrpc'
 import { Record as ProfileRecord } from '../lexicon/types/app/bsky/actor/profile'
+import { Record as PostRecord } from '../lexicon/types/app/bsky/feed/post'
 import { LocalViewer } from './viewer'
 
 export type LocalRecords = {

package/src/read-after-write/util.ts

@@ -1,3 +1,4 @@
+import express from 'express'
 import { jsonToLex } from '@atproto/lexicon'
 import { HeadersMap } from '@atproto/xrpc'
 import {
@@ -5,9 +6,7 @@ import {
   HandlerPipeThroughBuffer,
   parseReqNsid,
 } from '@atproto/xrpc-server'
-import express from 'express'
-
-import AppContext from '../context'
+import { AppContext } from '../context'
 import { lexicons } from '../lexicon/lexicons'
 import { readStickyLogger as log } from '../logger'
 import {
@@ -16,7 +15,6 @@ import {
   pipethrough,
 } from '../pipethrough'
 import { HandlerResponse, LocalRecords, MungeFn } from './types'
-import { getRecordsSinceRev } from './viewer'
 
 const REPO_REV_HEADER = 'atproto-repo-rev'
 
@@ -62,7 +60,7 @@ export const pipethroughReadAfterWrite = async <T>(
     const lxm = parseReqNsid(req)
 
     return await ctx.actorStore.read(requester, async (store) => {
-      const local = await getRecordsSinceRev(store, rev)
+      const local = await store.record.getRecordsSinceRev(rev)
       if (local.count === 0) return streamRes
 
       const { buffer } = (bufferRes = await asPipeThroughBuffer(streamRes))

package/src/read-after-write/viewer.ts

@@ -1,133 +1,106 @@
-import util from 'util'
-import { CID } from 'multiformats/cid'
 import { AtUri, INVALID_HANDLE } from '@atproto/syntax'
-import { cborToLexRecord } from '@atproto/repo'
-import { AtpAgent } from '@atproto/api'
 import { createServiceAuthHeaders } from '@atproto/xrpc-server'
-import { Record as PostRecord } from '../lexicon/types/app/bsky/feed/post'
-import { Record as ProfileRecord } from '../lexicon/types/app/bsky/actor/profile'
+import { AccountManager } from '../account-manager'
+import { ActorStoreReader } from '../actor-store/actor-store-reader'
+import { BskyAppView } from '../bsky-app-view'
+import { ImageUrlBuilder } from '../image/image-url-builder'
 import { ids } from '../lexicon/lexicons'
 import {
-  ProfileViewBasic,
   ProfileView,
+  ProfileViewBasic,
   ProfileViewDetailed,
 } from '../lexicon/types/app/bsky/actor/defs'
+import { Record as ProfileRecord } from '../lexicon/types/app/bsky/actor/profile'
 import {
-  FeedViewPost,
-  GeneratorView,
-  PostView,
-} from '../lexicon/types/app/bsky/feed/defs'
-import { ListView } from '../lexicon/types/app/bsky/graph/defs'
+  Main as EmbedExternal,
+  isMain as isEmbedExternal,
+} from '../lexicon/types/app/bsky/embed/external'
 import {
   Main as EmbedImages,
   isMain as isEmbedImages,
 } from '../lexicon/types/app/bsky/embed/images'
-import {
-  Main as EmbedExternal,
-  isMain as isEmbedExternal,
-} from '../lexicon/types/app/bsky/embed/external'
 import {
   Main as EmbedRecord,
-  isMain as isEmbedRecord,
   View as EmbedRecordView,
   ViewRecord,
+  isMain as isEmbedRecord,
 } from '../lexicon/types/app/bsky/embed/record'
 import {
   Main as EmbedRecordWithMedia,
   isMain as isEmbedRecordWithMedia,
 } from '../lexicon/types/app/bsky/embed/recordWithMedia'
-import { ActorStoreReader } from '../actor-store'
+import {
+  FeedViewPost,
+  GeneratorView,
+  PostView,
+} from '../lexicon/types/app/bsky/feed/defs'
+import { Record as PostRecord } from '../lexicon/types/app/bsky/feed/post'
+import { ListView } from '../lexicon/types/app/bsky/graph/defs'
 import { LocalRecords, RecordDescript } from './types'
-import { AccountManager } from '../account-manager'
 
 type CommonSignedUris = 'avatar' | 'banner' | 'feed_thumbnail' | 'feed_fullsize'
 
-export type LocalViewerCreator = (actorStore: ActorStoreReader) => LocalViewer
+export type LocalViewerCreator = (
+  actorStoreReader: ActorStoreReader,
+) => LocalViewer
 
 export class LocalViewer {
-  did: string
-  actorStore: ActorStoreReader
-  accountManager: AccountManager
-  pdsHostname: string
-  appViewAgent?: AtpAgent
-  appviewDid?: string
-  appviewCdnUrlPattern?: string
+  constructor(
+    public readonly actorStoreReader: ActorStoreReader,
+    public readonly accountManager: AccountManager,
+    public readonly imageUrlBuilder: ImageUrlBuilder,
+    public readonly bskyAppView?: BskyAppView,
+  ) {}
 
-  constructor(params: {
-    actorStore: ActorStoreReader
-    accountManager: AccountManager
-    pdsHostname: string
-    appViewAgent?: AtpAgent
-    appviewDid?: string
-    appviewCdnUrlPattern?: string
-  }) {
-    this.did = params.actorStore.did
-    this.actorStore = params.actorStore
-    this.accountManager = params.accountManager
-    this.pdsHostname = params.pdsHostname
-    this.appViewAgent = params.appViewAgent
-    this.appviewDid = params.appviewDid
-    this.appviewCdnUrlPattern = params.appviewCdnUrlPattern
+  get did() {
+    return this.actorStoreReader.did
   }
 
-  static creator(params: {
-    accountManager: AccountManager
-    pdsHostname: string
-    appViewAgent?: AtpAgent
-    appviewDid?: string
-    appviewCdnUrlPattern?: string
-  }): LocalViewerCreator {
-    return (actorStore) => {
-      return new LocalViewer({ ...params, actorStore })
-    }
+  static creator(
+    accountManager: AccountManager,
+    imageUrlBuilder: ImageUrlBuilder,
+    bskyAppView?: BskyAppView,
+  ): LocalViewerCreator {
+    return (actorStore) =>
+      new LocalViewer(actorStore, accountManager, imageUrlBuilder, bskyAppView)
   }
 
   getImageUrl(pattern: CommonSignedUris, cid: string) {
-    if (!this.appviewCdnUrlPattern) {
-      return `https://${this.pdsHostname}/xrpc/${ids.ComAtprotoSyncGetBlob}?did=${this.did}&cid=${cid}`
-    }
-    return util.format(this.appviewCdnUrlPattern, pattern, this.did, cid)
+    return this.imageUrlBuilder.build(pattern, this.did, cid)
   }
 
   async serviceAuthHeaders(did: string, lxm: string) {
-    if (!this.appviewDid) {
+    if (!this.bskyAppView) {
       throw new Error('Could not find bsky appview did')
     }
-    const keypair = await this.actorStore.keypair()
+    const keypair = await this.actorStoreReader.keypair()
 
     return createServiceAuthHeaders({
       iss: did,
-      aud: this.appviewDid,
+      aud: this.bskyAppView.did,
       lxm,
       keypair,
     })
   }
 
   async getRecordsSinceRev(rev: string): Promise<LocalRecords> {
-    return getRecordsSinceRev(this.actorStore, rev)
+    return this.actorStoreReader.record.getRecordsSinceRev(rev)
   }
 
   async getProfileBasic(): Promise<ProfileViewBasic | null> {
-    const profileQuery = this.actorStore.db.db
-      .selectFrom('record')
-      .leftJoin('repo_block', 'repo_block.cid', 'record.cid')
-      .where('record.collection', '=', ids.AppBskyActorProfile)
-      .where('record.rkey', '=', 'self')
-      .selectAll()
     const [profileRes, accountRes] = await Promise.all([
-      profileQuery.executeTakeFirst(),
+      this.actorStoreReader.record.getProfileRecord(),
       this.accountManager.getAccount(this.did),
     ])
+
     if (!accountRes) return null
-    const record = profileRes?.content
-      ? (cborToLexRecord(profileRes.content) as ProfileRecord)
-      : null
+
     return {
       did: this.did,
       handle: accountRes.handle ?? INVALID_HANDLE,
-      displayName: record?.displayName,
-      avatar: record?.avatar
-        ? this.getImageUrl('avatar', record.avatar.ref.toString())
+      displayName: profileRes?.displayName,
+      avatar: profileRes?.avatar
+        ? this.getImageUrl('avatar', profileRes.avatar.ref.toString())
         : undefined,
     }
   }
@@ -239,12 +212,12 @@ export class LocalViewer {
   private async formatRecordEmbedInternal(
     embed: EmbedRecord,
   ): Promise<null | ViewRecord | GeneratorView | ListView> {
-    if (!this.appViewAgent || !this.appviewDid) {
+    if (!this.bskyAppView) {
       return null
     }
     const collection = new AtUri(embed.record.uri).collection
     if (collection === ids.AppBskyFeedPost) {
-      const res = await this.appViewAgent.api.app.bsky.feed.getPosts(
+      const res = await this.bskyAppView.agent.app.bsky.feed.getPosts(
         { uris: [embed.record.uri] },
         await this.serviceAuthHeaders(this.did, ids.AppBskyFeedGetPosts),
       )
@@ -261,7 +234,7 @@ export class LocalViewer {
         indexedAt: post.indexedAt,
       }
     } else if (collection === ids.AppBskyFeedGenerator) {
-      const res = await this.appViewAgent.api.app.bsky.feed.getFeedGenerator(
+      const res = await this.bskyAppView.agent.app.bsky.feed.getFeedGenerator(
         { feed: embed.record.uri },
         await this.serviceAuthHeaders(
           this.did,
@@ -273,7 +246,7 @@ export class LocalViewer {
         ...res.data.view,
       }
     } else if (collection === ids.AppBskyGraphList) {
-      const res = await this.appViewAgent.api.app.bsky.graph.getList(
+      const res = await this.bskyAppView.agent.app.bsky.graph.getList(
         { list: embed.record.uri },
         await this.serviceAuthHeaders(this.did, ids.AppBskyGraphGetList),
       )
@@ -330,50 +303,3 @@ export class LocalViewer {
     }
   }
 }
-
-export const getRecordsSinceRev = async (
-  actorStore: ActorStoreReader,
-  rev: string,
-): Promise<LocalRecords> => {
-  const res = await actorStore.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 actorStore.db.db
-      .selectFrom('record')
-      .selectAll()
-      .where('record.repoRev', '<=', rev)
-      .limit(1)
-      .executeTakeFirst()
-    if (!sanityCheckRes) {
-      return { count: 0, profile: null, posts: [] }
-    }
-  }
-  return res.reduce(
-    (acc, cur) => {
-      const descript = {
-        uri: new AtUri(cur.uri),
-        cid: CID.parse(cur.cid),
-        indexedAt: cur.indexedAt,
-        record: cborToLexRecord(cur.content),
-      }
-      if (
-        descript.uri.collection === ids.AppBskyActorProfile &&
-        descript.uri.rkey === 'self'
-      ) {
-        acc.profile = descript as RecordDescript<ProfileRecord>
-      } else if (descript.uri.collection === ids.AppBskyFeedPost) {
-        acc.posts.push(descript as RecordDescript<PostRecord>)
-      }
-      acc.count++
-      return acc
-    },
-    { count: 0, profile: null, posts: [] } as LocalRecords,
-  )
-}

package/src/redis.ts

@@ -1,4 +1,4 @@
-import assert from 'assert'
+import assert from 'node:assert'
 import { Redis } from 'ioredis'
 import { redisLogger } from './logger'
 

package/src/repo/prepare.ts

@@ -1,9 +1,4 @@
 import { CID } from 'multiformats/cid'
-import {
-  AtUri,
-  ensureValidRecordKey,
-  ensureValidDatetime,
-} from '@atproto/syntax'
 import { TID, check, dataToCborBlock } from '@atproto/common'
 import {
   BlobRef,
@@ -15,30 +10,35 @@ import {
   untypedJsonBlobRef,
 } from '@atproto/lexicon'
 import {
-  cborToLex,
-  RecordDeleteOp,
   RecordCreateOp,
+  RecordDeleteOp,
   RecordUpdateOp,
   RecordWriteOp,
   WriteOpAction,
+  cborToLex,
 } from '@atproto/repo'
 import {
+  AtUri,
+  ensureValidDatetime,
+  ensureValidRecordKey,
+} from '@atproto/syntax'
+import { hasExplicitSlur } from '../handle/explicit-slurs'
+import * as lex from '../lexicon/lexicons'
+import { isRecord as isProfile } from '../lexicon/types/app/bsky/actor/profile'
+import { isRecord as isFeedGenerator } from '../lexicon/types/app/bsky/feed/generator'
+import { isRecord as isPost } from '../lexicon/types/app/bsky/feed/post'
+import { isRecord as isList } from '../lexicon/types/app/bsky/graph/list'
+import { isRecord as isStarterPack } from '../lexicon/types/app/bsky/graph/starterpack'
+import { isTag } from '../lexicon/types/app/bsky/richtext/facet'
+import {
+  InvalidRecordError,
+  PreparedBlobRef,
   PreparedCreate,
-  PreparedUpdate,
   PreparedDelete,
-  InvalidRecordError,
+  PreparedUpdate,
   PreparedWrite,
-  PreparedBlobRef,
   ValidationStatus,
 } from './types'
-import * as lex from '../lexicon/lexicons'
-import { isRecord as isFeedGenerator } from '../lexicon/types/app/bsky/feed/generator'
-import { isRecord as isStarterPack } from '../lexicon/types/app/bsky/graph/starterpack'
-import { isRecord as isPost } from '../lexicon/types/app/bsky/feed/post'
-import { isTag } from '../lexicon/types/app/bsky/richtext/facet'
-import { isRecord as isList } from '../lexicon/types/app/bsky/graph/list'
-import { isRecord as isProfile } from '../lexicon/types/app/bsky/actor/profile'
-import { hasExplicitSlur } from '../handle/explicit-slurs'
 
 export const assertValidRecordWithStatus = (
   record: Record<string, unknown>,

package/src/repo/types.ts

@@ -1,7 +1,7 @@
 import { CID } from 'multiformats/cid'
-import { AtUri } from '@atproto/syntax'
-import { WriteOpAction } from '@atproto/repo'
 import { RepoRecord } from '@atproto/lexicon'
+import { WriteOpAction } from '@atproto/repo'
+import { AtUri } from '@atproto/syntax'
 
 export type ValidationStatus = 'valid' | 'unknown' | undefined
 

package/src/scripts/rebuild-repo.ts

@@ -1,17 +1,13 @@
 import readline from 'node:readline/promises'
-import { CID } from 'multiformats/cid'
+import { TID } from '@atproto/common'
 import {
   BlockMap,
   CidSet,
   MST,
   MemoryBlockstore,
-  formatDataKey,
   signCommit,
 } from '@atproto/repo'
-import { AtUri } from '@atproto/syntax'
-import { TID } from '@atproto/common'
-import { ActorStoreTransactor } from '../actor-store'
-import AppContext from '../context'
+import { AppContext } from '../context'
 
 export const rebuildRepo = async (ctx: AppContext, args: string[]) => {
   const did = args[0]
@@ -23,8 +19,8 @@ export const rebuildRepo = async (ctx: AppContext, args: string[]) => {
   const rev = TID.nextStr()
   const commit = await ctx.actorStore.transact(did, async (store) => {
     const [records, existingCids] = await Promise.all([
-      listAllRecords(store),
-      listExistingBlocks(store),
+      store.record.listAll(),
+      store.record.listExistingBlocks(),
     ])
     let mst = await MST.create(memoryStore)
     for (const record of records) {
@@ -81,53 +77,6 @@ export const rebuildRepo = async (ctx: AppContext, args: string[]) => {
   await ctx.sequencer.sequenceCommit(did, commit, [])
 }
 
-const listExistingBlocks = async (
-  store: ActorStoreTransactor,
-): Promise<CidSet> => {
-  const cids = new CidSet()
-  let cursor: string | undefined = ''
-  while (cursor !== undefined) {
-    const res = await store.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
-}
-
-const listAllRecords = async (
-  store: ActorStoreTransactor,
-): Promise<RecordDescript[]> => {
-  const records: RecordDescript[] = []
-  let cursor: string | undefined = ''
-  while (cursor !== undefined) {
-    const res = await store.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
-}
-
 const promptContinue = async (): Promise<boolean> => {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -136,9 +85,3 @@ const promptContinue = async (): Promise<boolean> => {
   const answer = await rl.question('Continue? y/n ')
   return answer === ''
 }
-
-type RecordDescript = {
-  uri: string
-  path: string
-  cid: CID
-}

package/src/sequencer/db/index.ts

@@ -1,6 +1,6 @@
 import { Database, Migrator } from '../../db'
-import { SequencerDbSchema } from './schema'
 import migrations from './migrations'
+import { SequencerDbSchema } from './schema'
 
 export * from './schema'
 

package/src/sequencer/events.ts

@@ -1,16 +1,16 @@
+import { CID } from 'multiformats/cid'
 import { z } from 'zod'
 import { cborEncode, schema } from '@atproto/common'
 import {
   BlockMap,
-  blocksToCarFile,
   CidSet,
   CommitData,
   WriteOpAction,
+  blocksToCarFile,
 } from '@atproto/repo'
+import { AccountStatus } from '../account-manager'
 import { PreparedWrite } from '../repo'
-import { CID } from 'multiformats/cid'
 import { RepoSeqInsert } from './db'
-import { AccountStatus } from '../account-manager'
 
 export const formatSeqCommit = async (
   did: string,

package/src/sequencer/outbox.ts

@@ -1,6 +1,6 @@
 import { AsyncBuffer, AsyncBufferFullError } from '@atproto/common'
-import { Sequencer, SeqEvt } from '.'
 import { InvalidRequestError } from '@atproto/xrpc-server'
+import { SeqEvt, Sequencer } from '.'
 
 export type OutboxOpts = {
   maxBufferSize: number
@@ -121,5 +121,3 @@ export class Outbox {
     }
   }
 }
-
-export default Outbox

package/src/sequencer/sequencer.ts

@@ -1,8 +1,18 @@
-import EventEmitter from 'events'
+import EventEmitter from 'node:events'
 import TypedEmitter from 'typed-emitter'
-import { seqLogger as log } from '../logger'
 import { SECOND, cborDecode, wait } from '@atproto/common'
 import { CommitData } from '@atproto/repo'
+import { AccountStatus } from '../account-manager/helpers/account'
+import { Crawlers } from '../crawlers'
+import { seqLogger as log } from '../logger'
+import { PreparedWrite } from '../repo'
+import {
+  RepoSeqEntry,
+  RepoSeqInsert,
+  SequencerDb,
+  getDb,
+  getMigrator,
+} from './db'
 import {
   AccountEvt,
   CommitEvt,
@@ -16,16 +26,6 @@ import {
   formatSeqIdentityEvt,
   formatSeqTombstone,
 } from './events'
-import {
-  SequencerDb,
-  getMigrator,
-  RepoSeqEntry,
-  RepoSeqInsert,
-  getDb,
-} from './db'
-import { PreparedWrite } from '../repo'
-import { Crawlers } from '../crawlers'
-import { AccountStatus } from '../account-manager/helpers/account'
 
 export * from './events'
 

package/src/util/compression.ts

@@ -1,5 +1,5 @@
-import express from 'express'
 import compression from 'compression'
+import express from 'express'
 
 export default function () {
   return compression({

package/src/util/params.ts

@@ -1,5 +1,5 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
 import { CID } from 'multiformats/cid'
+import { InvalidRequestError } from '@atproto/xrpc-server'
 
 export const parseCidParam = (cid: string): CID => {
   try {

package/src/well-known.ts

@@ -1,8 +1,8 @@
-import express from 'express'
-import AppContext from './context'
+import { Router } from 'express'
+import { AppContext } from './context'
 
-export const createRouter = (ctx: AppContext): express.Router => {
-  const router = express.Router()
+export const createRouter = (ctx: AppContext): Router => {
+  const router = Router()
 
   router.get('/.well-known/atproto-did', async function (req, res) {
     const handle = req.hostname