@atcute/identity-resolver 0.1.0

package/lib/handle/methods/well-known.ts

@@ -0,0 +1,50 @@
+import { isAtprotoDid, type AtprotoDid, type Handle } from '@atcute/identity';
+import { FailedResponseError, isResponseOk, pipe, readResponseAsText } from '@atcute/util-fetch';
+
+import * as err from '../../errors.js';
+import type { HandleResolver, ResolveHandleOptions } from '../../types.js';
+
+export interface WellKnownHandleResolverOptions {
+	fetch?: typeof fetch;
+}
+
+const fetchWellKnownHandler = pipe(isResponseOk, readResponseAsText(2048 + 16));
+
+export class WellKnownHandleResolver implements HandleResolver {
+	#fetch: typeof fetch;
+
+	constructor({ fetch: fetchThis = fetch }: WellKnownHandleResolverOptions = {}) {
+		this.#fetch = fetchThis;
+	}
+
+	async resolve(handle: Handle, options?: ResolveHandleOptions): Promise<AtprotoDid> {
+		let text: string;
+
+		try {
+			const url = new URL('/.well-known/atproto-did', `https://${handle}`);
+
+			const response = await (0, this.#fetch)(url, {
+				signal: options?.signal,
+				cache: options?.noCache ? 'no-cache' : 'default',
+				redirect: 'error',
+			});
+
+			const handled = await fetchWellKnownHandler(response);
+
+			text = handled.text;
+		} catch (cause) {
+			if (cause instanceof FailedResponseError && cause.status === 404) {
+				throw new err.DidNotFoundError(handle);
+			}
+
+			throw new err.FailedHandleResolutionError(handle, { cause });
+		}
+
+		const did = text.split('\n')[0]!.trim();
+		if (!isAtprotoDid(did)) {
+			throw new err.InvalidResolvedHandleError(handle, did);
+		}
+
+		return did;
+	}
+}

package/lib/handle/methods/xrpc.ts

@@ -0,0 +1,65 @@
+import * as v from '@badrap/valita';
+
+import { isAtprotoDid, type AtprotoDid, type Handle } from '@atcute/identity';
+import {
+	FailedResponseError,
+	isResponseOk,
+	parseResponseAsJson,
+	pipe,
+	validateJsonWith,
+} from '@atcute/util-fetch';
+
+import * as err from '../../errors.js';
+import type { HandleResolver, ResolveHandleOptions } from '../../types.js';
+
+const response = v.object({
+	did: v.string().assert((input) => isAtprotoDid(input)),
+});
+
+const fetchXrpcHandler = pipe(
+	isResponseOk,
+	parseResponseAsJson(/^application\/json$/, 4 * 1024),
+	validateJsonWith(response, { mode: 'passthrough' }),
+);
+
+export interface XrpcHandleResolverOptions {
+	serviceUrl: string;
+	fetch?: typeof fetch;
+}
+
+export class XrpcHandleResolver implements HandleResolver {
+	readonly serviceUrl: string;
+	#fetch: typeof fetch;
+
+	constructor({ serviceUrl, fetch: fetchThis = fetch }: XrpcHandleResolverOptions) {
+		this.serviceUrl = serviceUrl;
+		this.#fetch = fetchThis;
+	}
+
+	async resolve(handle: Handle, options?: ResolveHandleOptions): Promise<AtprotoDid> {
+		let json: v.Infer<typeof response>;
+
+		try {
+			const url = new URL(`/xrpc/com.atproto.identity.resolveHandle`, this.serviceUrl);
+			url.searchParams.set('handle', handle);
+
+			const response = await this.#fetch(url, {
+				signal: options?.signal,
+				cache: options?.noCache ? 'no-cache' : 'default',
+				headers: { accept: 'application/json' },
+			});
+
+			const handled = await fetchXrpcHandler(response);
+
+			json = handled.json;
+		} catch (cause) {
+			if (cause instanceof FailedResponseError && cause.status === 400) {
+				throw new err.DidNotFoundError(handle);
+			}
+
+			throw new err.FailedHandleResolutionError(handle, { cause });
+		}
+
+		return json.did;
+	}
+}

package/lib/index.ts

@@ -0,0 +1,11 @@
+export * from './did/composite.js';
+export * from './did/methods/plc.js';
+export * from './did/methods/web.js';
+
+export * from './handle/composite.js';
+export * from './handle/methods/doh-json.js';
+export * from './handle/methods/well-known.js';
+export * from './handle/methods/xrpc.js';
+
+export * from './errors.js';
+export * from './types.js';

package/lib/types.ts

@@ -0,0 +1,19 @@
+import type { AtprotoDid, Did, DidDocument, Handle } from '@atcute/identity';
+
+export interface ResolveDidDocumentOptions {
+	signal?: AbortSignal;
+	noCache?: boolean;
+}
+
+export interface DidDocumentResolver<TMethod extends string> {
+	resolve(did: Did<TMethod>, options?: ResolveDidDocumentOptions): Promise<DidDocument>;
+}
+
+export interface ResolveHandleOptions {
+	signal?: AbortSignal;
+	noCache?: boolean;
+}
+
+export interface HandleResolver {
+	resolve(handle: Handle, options?: ResolveHandleOptions): Promise<AtprotoDid>;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "type": "module",
+  "name": "@atcute/identity-resolver",
+  "version": "0.1.0",
+  "description": "atproto handle and DID document resolution",
+  "keywords": [
+    "atproto",
+    "did"
+  ],
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/mary-ext/atcute",
+    "directory": "packages/identity/identity-resolver"
+  },
+  "files": [
+    "dist/",
+    "lib/",
+    "!lib/**/*.bench.ts",
+    "!lib/**/*.test.ts"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "@atcute/identity": "^0.1.0"
+  },
+  "dependencies": {
+    "@badrap/valita": "^0.4.2",
+    "@atcute/util-fetch": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.1",
+    "@atcute/identity": "^0.1.0"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "test": "bun test --coverage",
+    "prepublish": "rm -rf dist; pnpm run build"
+  }
+}