bluesky-social · matthieusieben · Jun 23, 2025 · Jun 21, 2025 · Jun 23, 2025 · Jun 23, 2025
diff --git a/.changeset/dirty-ducks-add.md b/.changeset/dirty-ducks-add.md
@@ -0,0 +1,5 @@
+---
+"@atproto/oauth-client": patch
+---
+
+Allow providing custom `identityProvider` implementation as `OAuthClient` constructor option
diff --git a/.changeset/few-rivers-chew.md b/.changeset/few-rivers-chew.md
@@ -0,0 +1,5 @@
+---
+"@atproto-labs/identity-resolver": minor
+---
+
+Identity resolver's `resolve()` method returns value consistent with `com.atproto.identity.resolveIdentity`
diff --git a/.changeset/four-bags-act.md b/.changeset/four-bags-act.md
@@ -0,0 +1,5 @@
+---
+"@atproto-labs/identity-resolver": minor
+---
+
+`IdentityResolver` is now an interface. The `IdentityResolverProto` class is the default implementation for the `IdentityResolver` interface.
diff --git a/.changeset/neat-rocks-buy.md b/.changeset/neat-rocks-buy.md
@@ -0,0 +1,5 @@
+---
+"@atproto/oauth-client": minor
+---
+
+`didResolver` and `handleResolver` no longer exposed on `OAuthClient` class
diff --git a/.changeset/soft-melons-bathe.md b/.changeset/soft-melons-bathe.md
@@ -0,0 +1,5 @@
+---
+"@atproto-labs/identity-resolver": patch
+---
+
+Export `HANDLE_INVALID` constant
@@ -0,0 +1,126 @@
+import {
+  AtprotoDid,
+  AtprotoIdentityDidMethods,
+  DidDocument,
+  DidResolver,
+  ResolveDidOptions,
+  isAtprotoDid,
+} from '@atproto-labs/did-resolver'
+import {
+  HandleResolver,
+  ResolveHandleOptions,
+} from '@atproto-labs/handle-resolver'
+import { HANDLE_INVALID } from './constants.js'
+import { IdentityResolverError } from './identity-resolver-error.js'
+import {
+  IdentityInfo,
+  IdentityResolver,
+  ResolveIdentityOptions,
+} from './identity-resolver.js'
+import { asNormalizedHandle, extractNormalizedHandle } from './util.js'
+
+// @TODO Move this to its own package as soon as we have a distinct
+// implementation based on XRPC calls to the
+// "com.atproto.identity.resolveIdentity" method.
+
+/**
+ * Implementation of the official ATPROTO identity resolution strategy.
+ * This implementation relies on two primitives:
+ * - DID resolution (using the `DidResolver` interface)
+ * - Handle resolution (using the `HandleResolver` interface)
+ */
+export class AtprotoIdentityResolver implements IdentityResolver {
+  constructor(
+    protected readonly didResolver: DidResolver<AtprotoIdentityDidMethods>,
+    protected readonly handleResolver: HandleResolver,
+  ) {}
+
+  public async resolve(
+    input: string,
+    options?: ResolveIdentityOptions,
+  ): Promise<IdentityInfo> {
+    return isAtprotoDid(input)
+      ? this.resolveFromDid(input, options)
+      : this.resolveFromHandle(input, options)
+  }
+
+  public async resolveFromDid(
+    did: AtprotoDid,
+    options?: ResolveDidOptions,
+  ): Promise<IdentityInfo> {
+    const document = await this.getDocumentFromDid(did, options)
+
+    options?.signal?.throwIfAborted()
+
+    // We will only return the document's handle alias if it resolves to the
+    // same DID as the input.
+    const handle = extractNormalizedHandle(document)
+    const resolvedDid = handle
+      ? await this.handleResolver
+          .resolve(handle, options)
+          .catch(() => undefined) // Ignore errors (temporarily unavailable)
+      : undefined
+
+    return {
+      did: document.id,
+      didDoc: document,
+      handle: handle && resolvedDid === did ? handle : HANDLE_INVALID,
+    }
+  }
+
+  public async resolveFromHandle(
+    handle: string,
+    options?: ResolveHandleOptions,
+  ): Promise<IdentityInfo> {
+    const document = awa
8000
it this.getDocumentFromHandle(handle, options)
+
+    // @NOTE bi-directional resolution enforced in getDocumentFromHandle()
+
+    return {
+      did: document.id,
+      didDoc: document,
+      handle: extractNormalizedHandle(document) || HANDLE_INVALID,
+    }
+  }
+
+  public async getDocumentFromDid(
+    did: AtprotoDid,
+    options?: ResolveDidOptions,
+  ): Promise<DidDocument<AtprotoIdentityDidMethods>> {
+    return this.didResolver.resolve(did, options)
+  }
+
+  public async getDocumentFromHandle(
+    input: string,
+    options?: ResolveHandleOptions,
+  ): Promise<DidDocument<AtprotoIdentityDidMethods>> {
+    const handle = asNormalizedHandle(input)
+    if (!handle) {
+      throw new IdentityResolverError(`Invalid handle "${input}" provided.`)
+    }
+
+    const did = await this.handleResolver.resolve(handle, options)
+
+    if (!did) {
+      throw new IdentityResolverError(
+        `Handle "${handle}" does not resolve to a DID`,
+      )
+    }
+
+    options?.signal?.throwIfAborted()
+
+    // Note: Not using "return this.resolveDid(did, options)" to make the extra
+    // check for the handle in the DID document:
+
+    const document = await this.didResolver.resolve(did, options)
+
+    // Enforce bi-directional resolution
+    if (handle !== extractNormalizedHandle(document)) {
+      throw new IdentityResolverError(
+        `Did document for "${did}" does not include the handle "${handle}"`,
+      )
+    }
+
+    return document
+  }
+}
@@ -0,0 +1 @@
+export const HANDLE_INVALID = 'handle.invalid'
@@ -2,119 +2,32 @@ import {
   AtprotoDid,
   AtprotoIdentityDidMethods,
   DidDocument,
-  DidResolver,
-  ResolveDidOptions,
-  isAtprotoDid,
 } from '@atproto-labs/did-resolver'
-import {
-  HandleResolver,
-  ResolveHandleOptions,
-} from '@atproto-labs/handle-resolver'
-import { IdentityResolverError } from './identity-resolver-error'
-import { asNormalizedHandle, extractNormalizedHandle } from './util'
+import { HANDLE_INVALID } from './constants'
+
+// Consistent with `com.atproto.identity.defs#identityInfo` returned by
+// `com.atproto.identity.resolveIdentity` endpoint.
+export type IdentityInfo = {
+  did: AtprotoDid
 
-export type ResolvedIdentity = {
-  document: DidDocument<AtprotoIdentityDidMethods>
+  didDoc: DidDocument<AtprotoIdentityDidMethods>
 
   /**
-   * Will be defined if the document contains a handle alias that resolves
-   * to the document's DID.
+   * Will be 'handle.invalid' if the handle does not resolve to the
+   * same DID as the input, or if the handle is not present in the DID
+   * document.
    */
-  handle?: string
+  handle: typeof HANDLE_INVALID | string
 }
 
-export type ResolveIdentityOptions = ResolveDidOptions & ResolveHandleOptions
-
-export class IdentityResolver {
-  constructor(
-    readonly didResolver: DidResolver<AtprotoIdentityDidMethods>,
-    readonly handleResolver: HandleResolver,
-  ) {}
+export type ResolveIdentityOptions = {
+  signal?: AbortSignal
+  noCache?: boolean
+}
 
-  public async resolve(
-    input: string,
+export interface IdentityResolver {
+  resolve(
+    identifier: string,
     options?: ResolveIdentityOptions,
-  ): Promise<ResolvedIdentity> {
-    return isAtprotoDid(input)
-      ? this.resolveFromDid(input, options)
-      : this.resolveFromHandle(input, options)
-  }
-
-  public async resolveFromDid(
-    did: AtprotoDid,
-    options?: ResolveDidOptions,
-  ): Promise<ResolvedIdentity> {
-    const document = await this.getDocumentFromDid(did, options)
-
-    options?.signal?.throwIfAborted()
-
-    // We will only return the document's handle alias if it resolves to the
-    // same DID as the input.
-    const handle = extractNormalizedHandle(document)
-      ? await this.handleResolver
-          .resolve(handle, options)
-          .catch(() => undefined) // Ignore errors (temporarily unavailable)
-      : undefined
-
-    return {
-      document,
-      handle: resolvedDid === did ? handle : undefined,
-    }
-  }
-
-  public async resolveFromHandle(
-    handle: string,
-    options?: ResolveHandleOptions,
-  ): Promise<ResolvedIdentity> {
-    const document = await this.getDocumentFromHandle(handle, options)
-
-    // @NOTE bi-directional resolution enforced in getDocumentFromHandle()
-
-    return {
-      document,
-      handle: extractNormalizedHandle(document),
-    }
-  }
-
-  public async getDocumentFromDid(
-    did: AtprotoDid,
-    options?: ResolveDidOptions,
-  ): Promise<DidDocument<AtprotoIdentityDidMethods>> {
-    return this.didResolver.resolve(did, options)
-  }
-
-  public async getDocumentFromHandle(
-    input: string,
-    options?: ResolveHandleOptions,
-  ): Promise<DidDocument<AtprotoIdentityDidMethods>> {
-    const handle = asNormalizedHandle(input)
-    if (!handle) {
-      throw new IdentityResolverError(`Invalid handle "${input}" provided.`)
-    }
-
-    const did = await this.handleResolver.resolve(handle, options)
-
-    if (!did) {
-      throw new IdentityResolverError(
-        `Handle "${handle}" does not resolve to a DID`,
-      )
-    }
-
-    options?.signal?.throwIfAborted()
-
-    // Note: Not using "return this.resolveDid(did, options)" to make the extra
-    // check for the handle in the DID document:
-
-    const document = await this.didResolver.resolve(did, options)
-
-    // Enforce bi-directional resolution
-    if (handle !== extractNormalizedHandle(document)) {
-      throw new IdentityResolverError(
-        `Did document for "${did}" does not include the handle "${handle}"`,
-      )
-    }
-
-    return document
-  }
+  ): Promise<IdentityInfo>
 }
@@ -1,3 +1,5 @@
+export * from './atproto-identity-resolver.js'
+export * from './constants.js'
 export * from './identity-resolver-error.js'
 export * from './identity-resolver.js'
 export * from './util.js'