@atproto/pds 0.4.196 → 0.4.198

package/src/config/env.ts

@@ -1,6 +1,6 @@
 import { envBool, envInt, envList, envStr } from '@atproto/common'
 
-export const readEnv = (): ServerEnvironment => {
+export function readEnv() {
   return {
     // service
     port: envInt('PDS_PORT'),
@@ -73,7 +73,7 @@ export const readEnv = (): ServerEnvironment => {
     didCacheMaxTTL: envInt('PDS_DID_CACHE_MAX_TTL'),
     resolverTimeout: envInt('PDS_ID_RESOLVER_TIMEOUT'),
     recoveryDidKey: envStr('PDS_RECOVERY_DID_KEY'),
-    serviceHandleDomains: envList('PDS_SERVICE_HANDLE_DOMAINS'),
+    serviceHandleDomains: envList('PDS_SERVICE_HANDLE_DOMAINS'), // public hostname by default
     handleBackupNameservers: envList('PDS_HANDLE_BACKUP_NAMESERVERS'),
     enableDidDocWithSession: envBool('PDS_ENABLE_DID_DOC_WITH_SESSION'),
 
@@ -151,154 +151,10 @@ export const readEnv = (): ServerEnvironment => {
     proxyMaxResponseSize: envInt('PDS_PROXY_MAX_RESPONSE_SIZE'),
     proxyMaxRetries: envInt('PDS_PROXY_MAX_RETRIES'),
     proxyPreferCompressed: envBool('PDS_PROXY_PREFER_COMPRESSED'),
+
+    // lexicon resolution
+    lexiconDidAuthority: envStr('PDS_LEXICON_AUTHORITY_DID'),
   }
 }
 
-export type ServerEnvironment = {
-  // service
-  port?: number
-  hostname?: string
-  serviceDid?: string
-  serviceName?: string
-  version?: string
-  homeUrl?: string
-  logoUrl?: string
-  privacyPolicyUrl?: string
-  supportUrl?: string
-  termsOfServiceUrl?: string
-  contactEmailAddress?: string
-  acceptingImports?: boolean
-  maxImportSize?: number
-  blobUploadLimit?: number
-  devMode?: boolean
-
-  // OAuth
-  hcaptchaSiteKey?: string
-  hcaptchaSecretKey?: string
-  hcaptchaTokenSalt?: string
-  trustedOAuthClients?: string[]
-
-  // branding
-  lightColor?: string
-  darkColor?: string
-  primaryColor?: string
-  primaryColorContrast?: string
-  primaryColorHue?: number
-  errorColor?: string
-  errorColorContrast?: string
-  errorColorHue?: number
-  warningColor?: string
-  warningColorContrast?: string
-  warningColorHue?: number
-  successColor?: string
-  successColorContrast?: string
-  successColorHue?: number
-
-  // database
-  dataDirectory?: string
-  disableWalAutoCheckpoint?: boolean
-  accountDbLocation?: string
-  sequencerDbLocation?: string
-  didCacheDbLocation?: string
-
-  // actor store
-  actorStoreDirectory?: string
-  actorStoreCacheSize?: number
-
-  // blobstore: one required
-  blobstoreS3Bucket?: string
-  blobstoreDiskLocation?: string
-  blobstoreDiskTmpLocation?: string
-
-  // -- optional s3 parameters
-  blobstoreS3Region?: string
-  blobstoreS3Endpoint?: string
-  blobstoreS3ForcePathStyle?: boolean
-  blobstoreS3AccessKeyId?: string
-  blobstoreS3SecretAccessKey?: string
-  blobstoreS3UploadTimeoutMs?: number
-
-  // identity
-  didPlcUrl?: string
-  didCacheStaleTTL?: number
-  didCacheMaxTTL?: number
-  resolverTimeout?: number
-  recoveryDidKey?: string
-  serviceHandleDomains?: string[] // public hostname by default
-  handleBackupNameservers?: string[]
-  enableDidDocWithSession?: boolean
-
-  // entryway
-  entrywayUrl?: string
-  entrywayDid?: string
-  entrywayJwtVerifyKeyK256PublicKeyHex?: string
-  entrywayPlcRotationKey?: string
-
-  // invites
-  inviteRequired?: boolean
-  inviteInterval?: number
-  inviteEpoch?: number
-
-  // email
-  emailSmtpUrl?: string
-  emailFromAddress?: string
-  moderationEmailSmtpUrl?: string
-  moderationEmailAddress?: string
-
-  // subscription
-  maxSubscriptionBuffer?: number
-  repoBackfillLimitMs?: number
-
-  // appview
-  bskyAppViewUrl?: string
-  bskyAppViewDid?: string
-  bskyAppViewCdnUrlPattern?: string
-
-  // mod service
-  modServiceUrl?: string
-  modServiceDid?: string
-
-  // report service
-  reportServiceUrl?: string
-  reportServiceDid?: string
-
-  // rate limits
-  rateLimitsEnabled?: boolean
-  rateLimitBypassKey?: string
-  rateLimitBypassIps?: string[]
-
-  // redis
-  redisScratchAddress?: string
-  redisScratchPassword?: string
-
-  // crawler
-  crawlers?: string[]
-
-  // secrets
-  dpopSecret?: string
-  jwtSecret?: string
-  adminPassword?: string
-  entrywayAdminToken?: string
-
-  // keys
-  plcRotationKeyKmsKeyId?: string
-  plcRotationKeyK256PrivateKeyHex?: string
-
-  // user provided url http requests
-  disableSsrfProtection?: boolean
-
-  // fetch
-  fetchForceLogging?: boolean
-  fetchMaxResponseSize?: number
-
-  // lexicon resolver
-  lexiconDidAuthority?: string
-
-  // proxy
-  proxyAllowHTTP2?: boolean
-  proxyHeadersTimeout?: number
-  proxyBodyTimeout?: number
-  proxyMaxResponseSize?: number
-  proxyMaxRetries?: number
-  proxyPreferCompressed?: boolean
-}
+export type ServerEnvironment = Partial<ReturnType<typeof readEnv>>

package/src/context.ts

@@ -9,13 +9,10 @@ import { AtpAgent } from '@atproto/api'
 import { KmsKeypair, S3BlobStore } from '@atproto/aws'
 import * as crypto from '@atproto/crypto'
 import { IdResolver } from '@atproto/identity'
-import {
-  LexiconResolver,
-  buildLexiconResolver,
-} from '@atproto/lexicon-resolver'
 import {
   AccessTokenMode,
   JoseKey,
+  LexResolver,
   OAuthProvider,
   OAuthVerifier,
 } from '@atproto/oauth-provider'
@@ -328,48 +325,6 @@ export class AppContext {
       },
     })
 
-    const baseLexiconResolver = buildLexiconResolver({
-      idResolver,
-      rpc: { fetch: safeFetch },
-    })
-
-    const getLexiconAuthority = (_nsid: string): string | undefined => {
-      // At the moment, only a single override strategy is supported by
-      // specifying a did through which all the lexicons will be resolved. We
-      // might need more granular control in the future (e.g. per-nsid
-      // overrides)
-      return cfg.lexicon.didAuthority
-    }
-
-    const lexiconResolver: LexiconResolver = async (input) => {
-      const nsid: string = String(input)
-      try {
-        const result = await baseLexiconResolver(input, {
-          didAuthority: getLexiconAuthority(nsid),
-          // Right now, the lexicon resolver is only used by the oauth-provider,
-          // which caches the responses internally (through the LexiconStore).
-          // Since the `LexiconResolver` does not allow specifying a
-          // `forceRefresh` option, we hard code it here. Should PDSs need to
-          // resolve lexicons for other purposes (e.g. record validation), we'd
-          // probably want to either implement caching as built into the
-          // lexiconResolver here, or allow the caller (oauth-provider, etc.) to
-          // specify a `forceRefresh` option by altering the LexiconResolver
-          // interface.
-          forceRefresh: true,
-        })
-
-        const cid = result.cid.toString()
-        const uri = result.uri.toString()
-        lexiconResolverLogger.info({ nsid, uri, cid }, 'Resolved lexicon')
-
-        return result
-      } catch (err) {
-        lexiconResolverLogger.error({ nsid, err }, 'Lexicon resolution failed')
-
-        throw err
-      }
-    }
-
     const oauthProvider = cfg.oauth.provider
       ? new OAuthProvider({
           issuer: cfg.oauth.issuer,
@@ -393,7 +348,44 @@ export class AppContext {
           hcaptcha: cfg.oauth.provider.hcaptcha,
           branding: cfg.oauth.provider.branding,
           safeFetch,
-          lexiconResolver,
+          lexResolver: new LexResolver({
+            fetch: safeFetch,
+            plcDirectoryUrl: cfg.identity.plcUrl,
+            hooks: {
+              onResolveAuthority: ({ nsid }) => {
+                lexiconResolverLogger.debug(
+                  { nsid: nsid.toString() },
+                  'Resolving lexicon DID authority',
+                )
+                // Override the lexicon did resolution to point to a custom PDS
+                return cfg.lexicon.didAuthority
+              },
+              onResolveAuthorityResult({ nsid, did }) {
+                lexiconResolverLogger.info(
+                  { nsid: nsid.toString(), did },
+                  'Resolved lexicon DID',
+                )
+              },
+              onResolveAuthorityError({ nsid, err }) {
+                lexiconResolverLogger.error(
+                  { nsid: nsid.toString(), err },
+                  'Lexicon DID resolution error',
+                )
+              },
+              onFetchResult({ uri, cid }) {
+                lexiconResolverLogger.info(
+                  { uri: uri.toString(), cid: cid.toString() },
+                  'Fetched lexicon',
+                )
+              },
+              onFetchError({ err, uri }) {
+                lexiconResolverLogger.error(
+                  { uri: uri.toString(), err },
+                  'Lexicon fetch error',
+                )
+              },
+            },
+          }),
           metadata: {
             protected_resources: [new URL(cfg.oauth.issuer).origin],
           },

package/src/lexicon/index.ts

@@ -23,6 +23,13 @@ import * as AppBskyAgeassuranceGetState from './types/app/bsky/ageassurance/getS
 import * as AppBskyBookmarkCreateBookmark from './types/app/bsky/bookmark/createBookmark.js'
 import * as AppBskyBookmarkDeleteBookmark from './types/app/bsky/bookmark/deleteBookmark.js'
 import * as AppBskyBookmarkGetBookmarks from './types/app/bsky/bookmark/getBookmarks.js'
+import * as AppBskyContactDismissMatch from './types/app/bsky/contact/dismissMatch.js'
+import * as AppBskyContactGetMatches from './types/app/bsky/contact/getMatches.js'
+import * as AppBskyContactGetSyncStatus from './types/app/bsky/contact/getSyncStatus.js'
+import * as AppBskyContactImportContacts from './types/app/bsky/contact/importContacts.js'
+import * as AppBskyContactRemoveData from './types/app/bsky/contact/removeData.js'
+import * as AppBskyContactStartPhoneVerification from './types/app/bsky/contact/startPhoneVerification.js'
+import * as AppBskyContactVerifyPhone from './types/app/bsky/contact/verifyPhone.js'
 import * as AppBskyFeedDescribeFeedGenerator from './types/app/bsky/feed/describeFeedGenerator.js'
 import * as AppBskyFeedGetActorFeeds from './types/app/bsky/feed/getActorFeeds.js'
 import * as AppBskyFeedGetActorLikes from './types/app/bsky/feed/getActorLikes.js'
@@ -397,6 +404,7 @@ export class AppBskyNS {
   actor: AppBskyActorNS
   ageassurance: AppBskyAgeassuranceNS
   bookmark: AppBskyBookmarkNS
+  contact: AppBskyContactNS
   embed: AppBskyEmbedNS
   feed: AppBskyFeedNS
   graph: AppBskyGraphNS
@@ -411,6 +419,7 @@ export class AppBskyNS {
     this.actor = new AppBskyActorNS(server)
     this.ageassurance = new AppBskyAgeassuranceNS(server)
     this.bookmark = new AppBskyBookmarkNS(server)
+    this.contact = new AppBskyContactNS(server)
     this.embed = new AppBskyEmbedNS(server)
     this.feed = new AppBskyFeedNS(server)
     this.graph = new AppBskyGraphNS(server)
@@ -602,6 +611,98 @@ export class AppBskyBookmarkNS {
   }
 }
 
+export class AppBskyContactNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  dismissMatch<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyContactDismissMatch.QueryParams,
+      AppBskyContactDismissMatch.HandlerInput,
+      AppBskyContactDismissMatch.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.contact.dismissMatch' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getMatches<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyContactGetMatches.QueryParams,
+      AppBskyContactGetMatches.HandlerInput,
+      AppBskyContactGetMatches.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.contact.getMatches' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getSyncStatus<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyContactGetSyncStatus.QueryParams,
+      AppBskyContactGetSyncStatus.HandlerInput,
+      AppBskyContactGetSyncStatus.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.contact.getSyncStatus' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  importContacts<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyContactImportContacts.QueryParams,
+      AppBskyContactImportContacts.HandlerInput,
+      AppBskyContactImportContacts.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.contact.importContacts' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  removeData<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyContactRemoveData.QueryParams,
+      AppBskyContactRemoveData.HandlerInput,
+      AppBskyContactRemoveData.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.contact.removeData' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  startPhoneVerification<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyContactStartPhoneVerification.QueryParams,
+      AppBskyContactStartPhoneVerification.HandlerInput,
+      AppBskyContactStartPhoneVerification.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.contact.startPhoneVerification' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  verifyPhone<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyContactVerifyPhone.QueryParams,
+      AppBskyContactVerifyPhone.HandlerInput,
+      AppBskyContactVerifyPhone.HandlerOutput
+    >,
+  ) {
+    const nsid = 'app.bsky.contact.verifyPhone' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
 export class AppBskyEmbedNS {
   _server: Server