@atproto-labs/handle-resolver 0.4.3 → 0.4.4

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @atproto-labs/handle-resolver
 
+## 0.4.4
+
+### Patch Changes
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Update TypeScript build to rely on references to composite internal projects
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Bundle only necessary files in the NPM tarball, including the `CHANGELOG.md` and `README.md` files (if present).
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Build with `noImplicitAny` enabled
+
+- Updated dependencies [[`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07)]:
+  - @atproto-labs/simple-store-memory@0.2.3
+  - @atproto-labs/simple-store@0.4.3
+  - @atproto/did@0.5.3
+
 ## 0.4.3
 
 ### Patch Changes

package/package.json

@@ -1,9 +1,6 @@
 {
   "name": "@atproto-labs/handle-resolver",
-  "version": "0.4.3",
-  "engines": {
-    "node": ">=22"
-  },
+  "version": "0.4.4",
   "license": "MIT",
   "description": "Isomorphic ATProto handle to DID resolver",
   "keywords": [
@@ -21,6 +18,10 @@
     "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/internal/handle-resolver"
   },
+  "files": [
+    "./dist",
+    "./CHANGELOG.md"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -28,13 +29,15 @@
       "default": "./dist/index.js"
     }
   },
+  "engines": {
+    "node": ">=22"
+  },
   "dependencies": {
     "zod": "^3.23.8",
-    "@atproto-labs/simple-store-memory": "^0.2.2",
-    "@atproto/did": "^0.5.2",
-    "@atproto-labs/simple-store": "^0.4.2"
+    "@atproto-labs/simple-store": "^0.4.3",
+    "@atproto/did": "^0.5.3",
+    "@atproto-labs/simple-store-memory": "^0.2.3"
   },
-  "devDependencies": {},
   "scripts": {
     "build": "tsgo --build tsconfig.build.json"
   }

package/src/atproto-doh-handle-resolver.ts

@@ -1,124 +0,0 @@
-import {
-  AtprotoHandleResolver,
-  AtprotoHandleResolverOptions,
-} from './atproto-handle-resolver.js'
-import { HandleResolverError } from './handle-resolver-error.js'
-import { ResolveTxt } from './internal-resolvers/dns-handle-resolver.js'
-import { HandleResolver } from './types.js'
-
-export type AtprotoDohHandleResolverOptions = Omit<
-  AtprotoHandleResolverOptions,
-  'resolveTxt' | 'resolveTxtFallback'
-> & {
-  dohEndpoint: string | URL
-}
-
-export class AtprotoDohHandleResolver
-  extends AtprotoHandleResolver
-  implements HandleResolver
-{
-  constructor(options: AtprotoDohHandleResolverOptions) {
-    super({
-      ...options,
-      resolveTxt: dohResolveTxtFactory(options),
-      resolveTxtFallback: undefined,
-    })
-  }
-}
-
-/**
- * Resolver for DNS-over-HTTPS (DoH) handles. Only works with servers supporting
- * Google Flavoured "application/dns-json" queries.
- *
- * @see {@link https://developers.google.com/speed/public-dns/docs/doh/json}
- * @see {@link https://developers.cloudflare.com/1.1.1.1/encryption/dns-over-https/make-api-requests/dns-json/}
- * @todo Add support for DoH using application/dns-message (?)
- */
-function dohResolveTxtFactory({
-  dohEndpoint,
-  fetch = globalThis.fetch,
-}: AtprotoDohHandleResolverOptions): ResolveTxt {
-  return async (hostname) => {
-    const url = new URL(dohEndpoint)
-    url.searchParams.set('type', 'TXT')
-    url.searchParams.set('name', hostname)
-
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: { accept: 'application/dns-json' },
-      redirect: 'follow',
-    })
-    try {
-      const contentType = response.headers.get('content-type')?.trim()
-      if (!response.ok) {
-        const message = contentType?.startsWith('text/plain')
-          ? await response.text()
-          : `Failed to resolve ${hostname}`
-        throw new HandleResolverError(message)
-      } else if (contentType?.match(/application\/(dns-)?json/i) == null) {
-        throw new HandleResolverError('Unexpected response from DoH server')
-      }
-
-      const result = asResult(await response.json())
-      return result.Answer?.filter(isAnswerTxt).map(extractTxtData) ?? null
-    } finally {
-      // Make sure to always cancel the response body as some engines (Node 👀)
-      // do not do this automatically.
-      // https://undici.nodejs.org/#/?id=garbage-collection
-      if (response.bodyUsed === false) {
-        // Handle rejection asynchronously
-        void response.body?.cancel().catch(onCancelError)
-      }
-    }
-  }
-}
-
-function onCancelError(err: unknown) {
-  if (!(err instanceof DOMException) || err.name !== 'AbortError') {
-    console.error('An error occurred while cancelling the response body:', err)
-  }
-}
-
-type Result = { Status: number; Answer?: Answer[] }
-function isResult(result: unknown): result is Result {
-  if (typeof result !== 'object' || result === null) return false
-  if (!('Status' in result) || typeof result.Status !== 'number') return false
-  if ('Answer' in result && !isArrayOf(result.Answer, isAnswer)) return false
-  return true
-}
-function asResult(result: unknown): Result {
-  if (isResult(result)) return result
-  throw new HandleResolverError('Invalid DoH response')
-}
-
-function isArrayOf<T>(
-  value: unknown,
-  predicate: (v: unknown) => v is T,
-): value is T[] {
-  return Array.isArray(value) && value.every(predicate)
-}
-
-type Answer = { name: string; type: number; data: string; TTL: number }
-function isAnswer(answer: unknown): answer is Answer {
-  return (
-    typeof answer === 'object' &&
-    answer !== null &&
-    'name' in answer &&
-    typeof answer.name === 'string' &&
-    'type' in answer &&
-    typeof answer.type === 'number' &&
-    'data' in answer &&
-    typeof answer.data === 'string' &&
-    'TTL' in answer &&
-    typeof answer.TTL === 'number'
-  )
-}
-
-type AnswerTxt = Answer & { type: 16 }
-function isAnswerTxt(answer: Answer): answer is AnswerTxt {
-  return answer.type === 16
-}
-
-function extractTxtData(answer: AnswerTxt): string {
-  return answer.data.replace(/^"|"$/g, '').replace(/\\"/g, '"')
-}

package/src/atproto-handle-resolver.ts

@@ -1,79 +0,0 @@
-import {
-  DnsHandleResolver,
-  ResolveTxt,
-} from './internal-resolvers/dns-handle-resolver.js'
-import {
-  WellKnownHandleResolver,
-  WellKnownHandleResolverOptions,
-} from './internal-resolvers/well-known-handler-resolver.js'
-import {
-  HandleResolver,
-  ResolveHandleOptions,
-  ResolvedHandle,
-} from './types.js'
-
-export type { ResolveTxt }
-export type AtprotoHandleResolverOptions = WellKnownHandleResolverOptions & {
-  resolveTxt: ResolveTxt
-  resolveTxtFallback?: ResolveTxt
-}
-
-const noop = () => {}
-
-/**
- * Implementation of the official ATPROTO handle resolution strategy.
- * This implementation relies on two primitives:
- * - HTTP Well-Known URI resolution (requires a `fetch()` implementation)
- * - DNS TXT record resolution (requires a `resolveTxt()` function)
- */
-export class AtprotoHandleResolver implements HandleResolver {
-  private readonly httpResolver: HandleResolver
-  private readonly dnsResolver: HandleResolver
-  private readonly dnsResolverFallback?: HandleResolver
-
-  constructor(options: AtprotoHandleResolverOptions) {
-    this.httpResolver = new WellKnownHandleResolver(options)
-    this.dnsResolver = new DnsHandleResolver(options.resolveTxt)
-    this.dnsResolverFallback = options.resolveTxtFallback
-      ? new DnsHandleResolver(options.resolveTxtFallback)
-      : undefined
-  }
-
-  async resolve(
-    handle: string,
-    options?: ResolveHandleOptions,
-  ): Promise<ResolvedHandle> {
-    options?.signal?.throwIfAborted()
-
-    const abortController = new AbortController()
-    const { signal } = abortController
-    options?.signal?.addEventListener('abort', () => abortController.abort(), {
-      signal,
-    })
-
-    const wrappedOptions = { ...options, signal }
-
-    try {
-      const dnsPromise = this.dnsResolver.resolve(handle, wrappedOptions)
-      const httpPromise = this.httpResolver.resolve(handle, wrappedOptions)
-
-      // Prevent uncaught promise rejection
-      httpPromise.catch(noop)
-
-      const dnsRes = await dnsPromise
-      if (dnsRes) return dnsRes
-
-      signal.throwIfAborted()
-
-      const res = await httpPromise
-      if (res) return res
-
-      signal.throwIfAborted()
-
-      return this.dnsResolverFallback?.resolve(handle, wrappedOptions) ?? null
-    } finally {
-      // Cancel pending requests, and remove "abort" listener on incoming signal
-      abortController.abort()
-    }
-  }
-}

package/src/cached-handle-resolver.ts

@@ -1,36 +0,0 @@
-import { CachedGetter, SimpleStore } from '@atproto-labs/simple-store'
-import { SimpleStoreMemory } from '@atproto-labs/simple-store-memory'
-import {
-  HandleResolver,
-  ResolveHandleOptions,
-  ResolvedHandle,
-} from './types.js'
-
-export type HandleCache = SimpleStore<string, ResolvedHandle>
-
-export class CachedHandleResolver implements HandleResolver {
-  private getter: CachedGetter<string, ResolvedHandle>
-
-  constructor(
-    /**
-     * The resolver that will be used to resolve handles.
-     */
-    resolver: HandleResolver,
-    cache: HandleCache = new SimpleStoreMemory<string, ResolvedHandle>({
-      max: 1000,
-      ttl: 10 * 60e3,
-    }),
-  ) {
-    this.getter = new CachedGetter<string, ResolvedHandle>(
-      (handle, options) => resolver.resolve(handle, options),
-      cache,
-    )
-  }
-
-  async resolve(
-    handle: string,
-    options?: ResolveHandleOptions,
-  ): Promise<ResolvedHandle> {
-    return this.getter.get(handle, options)
-  }
-}

package/src/create-handle-resolver.ts

@@ -1,28 +0,0 @@
-import { CachedHandleResolver, HandleCache } from './cached-handle-resolver.js'
-import { HandleResolver } from './types.js'
-import {
-  XrpcHandleResolver,
-  XrpcHandleResolverOptions,
-} from './xrpc-handle-resolver.js'
-
-export type CreateHandleResolverOptions = {
-  handleResolver: URL | string | HandleResolver
-  handleCache?: HandleCache
-} & Partial<XrpcHandleResolverOptions>
-
-export function createHandleResolver(
-  options: CreateHandleResolverOptions,
-): HandleResolver {
-  const { handleResolver, handleCache } = options
-
-  if (handleResolver instanceof CachedHandleResolver && !handleCache) {
-    return handleResolver
-  }
-
-  return new CachedHandleResolver(
-    typeof handleResolver === 'string' || handleResolver instanceof URL
-      ? new XrpcHandleResolver(handleResolver, options)
-      : handleResolver,
-    handleCache,
-  )
-}

package/src/handle-resolver-error.ts

@@ -1,3 +0,0 @@
-export class HandleResolverError extends Error {
-  name = 'HandleResolverError'
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-export * from './handle-resolver-error.js'
-export * from './types.js'
-
-// Main Handle Resolvers strategies
-export * from './xrpc-handle-resolver.js'
-export * from './atproto-doh-handle-resolver.js'
-export * from './atproto-handle-resolver.js'
-
-// Handle Resolver Caching utility
-export * from './cached-handle-resolver.js'
-
-// utils
-export * from './create-handle-resolver.js'

package/src/internal-resolvers/dns-handle-resolver.ts

@@ -1,38 +0,0 @@
-import { HandleResolver, ResolvedHandle, isResolvedHandle } from '../types.js'
-
-const SUBDOMAIN = '_atproto'
-const PREFIX = 'did='
-
-/**
- * DNS TXT record resolver. Return `null` if the hostname successfully does not
- * resolve to a valid DID. Throw an error if an unexpected error occurs.
- */
-export type ResolveTxt = (hostname: string) => Promise<null | string[]>
-
-export class DnsHandleResolver implements HandleResolver {
-  constructor(protected resolveTxt: ResolveTxt) {}
-
-  async resolve(handle: string): Promise<ResolvedHandle> {
-    const results = await this.resolveTxt.call(null, `${SUBDOMAIN}.${handle}`)
-
-    if (!results) return null
-
-    for (let i = 0; i < results.length; i++) {
-      // If the line does not start with "did=", skip it
-      if (!results[i].startsWith(PREFIX)) continue
-
-      // Ensure no other entry starting with "did=" follows
-      for (let j = i + 1; j < results.length; j++) {
-        if (results[j].startsWith(PREFIX)) return null
-      }
-
-      // Note: No trimming (to be consistent with spec)
-      const did = results[i].slice(PREFIX.length)
-
-      // Invalid DBS record
-      return isResolvedHandle(did) ? did : null
-    }
-
-    return null
-  }
-}

package/src/internal-resolvers/well-known-handler-resolver.ts

@@ -1,53 +0,0 @@
-import {
-  HandleResolver,
-  ResolveHandleOptions,
-  ResolvedHandle,
-  isResolvedHandle,
-} from '../types.js'
-
-export type WellKnownHandleResolverOptions = {
-  /**
-   * Fetch function to use for HTTP requests. Allows customizing the request
-   * behavior, e.g. adding headers, setting a timeout, mocking, etc. The
-   * provided fetch function will be wrapped with a safeFetchWrap function that
-   * adds SSRF protection.
-   *
-   * @default `globalThis.fetch`
-   */
-  fetch?: typeof globalThis.fetch
-}
-
-export class WellKnownHandleResolver implements HandleResolver {
-  protected readonly fetch: typeof globalThis.fetch
-
-  constructor(options?: WellKnownHandleResolverOptions) {
-    this.fetch = options?.fetch ?? globalThis.fetch
-  }
-
-  public async resolve(
-    handle: string,
-    options?: ResolveHandleOptions,
-  ): Promise<ResolvedHandle> {
-    const url = new URL('/.well-known/atproto-did', `https://${handle}`)
-
-    try {
-      const response = await this.fetch.call(null, url, {
-        cache: options?.noCache ? 'no-cache' : undefined,
-        signal: options?.signal,
-        redirect: 'error',
-      })
-      const text = await response.text()
-      const firstLine = text.split('\n')[0]!.trim()
-
-      if (isResolvedHandle(firstLine)) return firstLine
-
-      return null
-    } catch (err) {
-      // The the request failed, assume the handle does not resolve to a DID,
-      // unless the failure was due to the signal being aborted.
-      options?.signal?.throwIfAborted()
-
-      return null
-    }
-  }
-}

package/src/types.ts

@@ -1,37 +0,0 @@
-import { AtprotoDid, isAtprotoDid } from '@atproto/did'
-export type { AtprotoDid, AtprotoIdentityDidMethods } from '@atproto/did'
-
-export type ResolveHandleOptions = {
-  signal?: AbortSignal
-  noCache?: boolean
-}
-
-/**
- * @see {@link https://atproto.com/specs/did#blessed-did-methods}
- */
-export type ResolvedHandle = null | AtprotoDid
-
-/**
- * @see {@link https://atproto.com/specs/did#blessed-did-methods}
- */
-export function isResolvedHandle(value: unknown): value is ResolvedHandle {
-  return value === null || isAtprotoDid(value)
-}
-
-export function asResolvedHandle<T>(value: T): null | (T & AtprotoDid) {
-  return isResolvedHandle(value) ? value : null
-}
-
-export interface HandleResolver {
-  /**
-   * @returns the DID that corresponds to the given handle, or `null` if no DID
-   * is found. `null` should only be returned if no unexpected behavior occurred
-   * during the resolution process.
-   * @throws Error if the resolution method fails due to an unexpected error, or
-   * if the resolution is aborted ({@link ResolveHandleOptions}).
-   */
-  resolve(
-    handle: string,
-    options?: ResolveHandleOptions,
-  ): Promise<ResolvedHandle>
-}

package/src/xrpc-handle-resolver.ts

@@ -1,92 +0,0 @@
-import { z } from 'zod'
-import { HandleResolverError } from './handle-resolver-error.js'
-import {
-  HandleResolver,
-  ResolveHandleOptions,
-  ResolvedHandle,
-  isResolvedHandle,
-} from './types.js'
-
-export const xrpcErrorSchema = z.object({
-  error: z.string(),
-  message: z.string().optional(),
-})
-
-export type XrpcHandleResolverOptions = {
-  /**
-   * Fetch function to use for HTTP requests. Allows customizing the request
-   * behavior, e.g. adding headers, setting a timeout, mocking, etc.
-   *
-   * @default globalThis.fetch
-   */
-  fetch?: typeof globalThis.fetch
-}
-
-export class XrpcHandleResolver implements HandleResolver {
-  /**
-   * URL of the atproto lexicon server. This is the base URL where the
-   * `com.atproto.identity.resolveHandle` XRPC method is located.
-   */
-  protected readonly serviceUrl: URL
-  protected readonly fetch: typeof globalThis.fetch
-
-  constructor(service: URL | string, options?: XrpcHandleResolverOptions) {
-    this.serviceUrl = new URL(service)
-    this.fetch = options?.fetch ?? globalThis.fetch
-  }
-
-  public async resolve(
-    handle: string,
-    options?: ResolveHandleOptions,
-  ): Promise<ResolvedHandle> {
-    const url = new URL(
-      '/xrpc/com.atproto.identity.resolveHandle',
-      this.serviceUrl,
-    )
-    url.searchParams.set('handle', handle)
-
-    const response = await this.fetch.call(null, url, {
-      cache: options?.noCache ? 'no-cache' : undefined,
-      signal: options?.signal,
-      redirect: 'error',
-    })
-    const payload = await response.json()
-
-    // The response should either be
-    // - 400 Bad Request with { error: 'InvalidRequest', message: 'Unable to resolve handle' }
-    // - 200 OK with { did: NonNullable<ResolvedHandle> }
-    // Any other response is considered unexpected behavior an should throw an error.
-
-    if (response.status === 400) {
-      const { error, data } = xrpcErrorSchema.safeParse(payload)
-      if (error) {
-        throw new HandleResolverError(
-          `Invalid response from resolveHandle method: ${error.message}`,
-          { cause: error },
-        )
-      }
-      if (
-        data.error === 'InvalidRequest' &&
-        data.message === 'Unable to resolve handle'
-      ) {
-        return null
-      }
-    }
-
-    if (!response.ok) {
-      throw new HandleResolverError(
-        'Invalid status code from resolveHandle method',
-      )
-    }
-
-    const value: unknown = payload?.did
-
-    if (!isResolvedHandle(value)) {
-      throw new HandleResolverError(
-        'Invalid DID returned from resolveHandle method',
-      )
-    }
-
-    return value
-  }
-}

package/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../../tsconfig/isomorphic.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist",
-  },
-  "include": ["./src"],
-}

package/tsconfig.build.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"7.0.0-dev.20260614.1","root":["./src/atproto-doh-handle-resolver.ts","./src/atproto-handle-resolver.ts","./src/cached-handle-resolver.ts","./src/create-handle-resolver.ts","./src/handle-resolver-error.ts","./src/index.ts","./src/types.ts","./src/xrpc-handle-resolver.ts","./src/internal-resolvers/dns-handle-resolver.ts","./src/internal-resolvers/well-known-handler-resolver.ts"]}

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "include": [],
-  "references": [{ "path": "./tsconfig.build.json" }],
-}