@atproto/identity 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# ATP DID Resolver
+
+A library for resolving ATP's Decentralized ID methods.

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: [['@babel/preset-env']],
+}

package/build.js

@@ -0,0 +1,23 @@
+const pkgJson = require('@npmcli/package-json')
+const { nodeExternalsPlugin } = require('esbuild-node-externals')
+
+const buildShallow =
+  process.argv.includes('--shallow') || process.env.ATP_BUILD_SHALLOW === 'true'
+
+if (process.argv.includes('--update-main-to-dist')) {
+  return pkgJson
+    .load(__dirname)
+    .then((pkg) => pkg.update({ main: 'dist/index.js' }))
+    .then((pkg) => pkg.save())
+}
+
+require('esbuild').build({
+  logLevel: 'info',
+  entryPoints: ['src/index.ts'],
+  sourcemap: true,
+  bundle: true,
+  sourcemap: true,
+  outdir: 'dist',
+  platform: 'node',
+  plugins: buildShallow ? [nodeExternalsPlugin()] : [],
+})

package/dist/atp-did.d.ts

@@ -0,0 +1,14 @@
+import { DIDDocument } from 'did-resolver';
+export declare type AtpData = {
+    did: string;
+    signingKey: string;
+    recoveryKey: string;
+    handle: string;
+    atpPds: string;
+};
+export declare const getDid: (doc: DIDDocument) => string;
+export declare const getKey: (doc: DIDDocument, id: string) => string | undefined;
+export declare const getHandle: (doc: DIDDocument) => string | undefined;
+export declare const getAtpPds: (doc: DIDDocument) => string | undefined;
+export declare const parseToAtpDocument: (doc: DIDDocument) => Partial<AtpData>;
+export declare const ensureAtpDocument: (doc: DIDDocument) => AtpData;

package/dist/atproto-data.d.ts

@@ -0,0 +1,7 @@
+import { DidDocument, AtprotoData } from './types';
+export declare const getDid: (doc: DidDocument) => string;
+export declare const getKey: (doc: DidDocument) => string | undefined;
+export declare const getHandle: (doc: DidDocument) => string | undefined;
+export declare const getPds: (doc: DidDocument) => string | undefined;
+export declare const parseToAtprotoDocument: (doc: DidDocument) => Partial<AtprotoData>;
+export declare const ensureAtpDocument: (doc: DidDocument) => AtprotoData;

package/dist/base-resolver.d.ts

@@ -0,0 +1,16 @@
+import { AtprotoData, DidDocument } from './types';
+import { DidCache } from './did-cache';
+export declare abstract class BaseResolver {
+    cache?: DidCache | undefined;
+    constructor(cache?: DidCache | undefined);
+    abstract resolveDidNoCheck(did: string): Promise<unknown | null>;
+    validateDidDoc(did: string, val: unknown): DidDocument;
+    resolveDidNoCache(did: string): Promise<DidDocument | null>;
+    refreshCache(did: string): Promise<void>;
+    resolveDid(did: string, forceRefresh?: boolean): Promise<DidDocument | null>;
+    ensureResolveDid(did: string, forceRefresh?: boolean): Promise<DidDocument>;
+    resolveAtprotoData(did: string, forceRefresh?: boolean): Promise<AtprotoData>;
+    resolveAtprotoKey(did: string, forceRefresh?: boolean): Promise<string>;
+    verifySignature(did: string, data: Uint8Array, sig: Uint8Array, forceRefresh?: boolean): Promise<boolean>;
+}
+export default BaseResolver;

package/dist/did/atproto-data.d.ts

@@ -0,0 +1,8 @@
+import { DidDocument, AtprotoData } from '../types';
+export declare const getDid: (doc: DidDocument) => string;
+export declare const getKey: (doc: DidDocument) => string | undefined;
+export declare const getHandle: (doc: DidDocument) => string | undefined;
+export declare const getPds: (doc: DidDocument) => string | undefined;
+export declare const getFeedGen: (doc: DidDocument) => string | undefined;
+export declare const parseToAtprotoDocument: (doc: DidDocument) => Partial<AtprotoData>;
+export declare const ensureAtpDocument: (doc: DidDocument) => AtprotoData;

package/dist/did/base-resolver.d.ts

@@ -0,0 +1,15 @@
+import { DidCache, AtprotoData, DidDocument } from '../types';
+export declare abstract class BaseResolver {
+    cache?: DidCache | undefined;
+    constructor(cache?: DidCache | undefined);
+    abstract resolveNoCheck(did: string): Promise<unknown | null>;
+    validateDidDoc(did: string, val: unknown): DidDocument;
+    resolveNoCache(did: string): Promise<DidDocument | null>;
+    refreshCache(did: string): Promise<void>;
+    resolve(did: string, forceRefresh?: boolean): Promise<DidDocument | null>;
+    ensureResolve(did: string, forceRefresh?: boolean): Promise<DidDocument>;
+    resolveAtprotoData(did: string, forceRefresh?: boolean): Promise<AtprotoData>;
+    resolveAtprotoKey(did: string, forceRefresh?: boolean): Promise<string>;
+    verifySignature(did: string, data: Uint8Array, sig: Uint8Array, forceRefresh?: boolean): Promise<boolean>;
+}
+export default BaseResolver;

package/dist/did/did-resolver.d.ts

@@ -0,0 +1,8 @@
+import { DidResolverOpts } from '../types';
+import BaseResolver from './base-resolver';
+export declare class DidResolver extends BaseResolver {
+    methods: Record<string, BaseResolver>;
+    constructor(opts: DidResolverOpts);
+    resolveNoCheck(did: string): Promise<unknown>;
+}
+export default DidResolver;

package/dist/did/index.d.ts

@@ -0,0 +1,5 @@
+export * from './web-resolver';
+export * from './plc-resolver';
+export * from './did-resolver';
+export * from './atproto-data';
+export * from './memory-cache';

package/dist/did/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("pino").default.Logger<import("pino").default.LoggerOptions>;
+export default logger;

package/dist/did/memory-cache.d.ts

@@ -0,0 +1,17 @@
+import { DidCache, CacheResult, DidDocument } from '../types';
+declare type CacheVal = {
+    doc: DidDocument;
+    updatedAt: number;
+};
+export declare class MemoryCache implements DidCache {
+    staleTTL: number;
+    maxTTL: number;
+    constructor(staleTTL?: number, maxTTL?: number);
+    cache: Map<string, CacheVal>;
+    cacheDid(did: string, doc: DidDocument): Promise<void>;
+    refreshCache(did: string, getDoc: () => Promise<DidDocument | null>): Promise<void>;
+    checkCache(did: string): Promise<CacheResult | null>;
+    clearEntry(did: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export {};

package/dist/did/plc-resolver.d.ts

@@ -0,0 +1,9 @@
+import BaseResolver from './base-resolver';
+import { DidCache } from '../types';
+export declare class DidPlcResolver extends BaseResolver {
+    plcUrl: string;
+    timeout: number;
+    cache?: DidCache | undefined;
+    constructor(plcUrl: string, timeout: number, cache?: DidCache | undefined);
+    resolveNoCheck(did: string): Promise<unknown>;
+}

package/dist/did/web-resolver.d.ts

@@ -0,0 +1,9 @@
+import BaseResolver from './base-resolver';
+import { DidCache } from '../types';
+export declare const DOC_PATH = "/.well-known/did.json";
+export declare class DidWebResolver extends BaseResolver {
+    timeout: number;
+    cache?: DidCache | undefined;
+    constructor(timeout: number, cache?: DidCache | undefined);
+    resolveNoCheck(did: string): Promise<unknown>;
+}

package/dist/did-cache.d.ts

@@ -0,0 +1,8 @@
+import { CacheResult, DidDocument } from './types';
+export declare abstract class DidCache {
+    abstract cacheDid(did: string, doc: DidDocument): Promise<void>;
+    abstract checkCache(did: string): Promise<CacheResult | null>;
+    abstract refreshCache(did: string, getDoc: () => Promise<DidDocument | null>): Promise<void>;
+    abstract clearEntry(did: string): Promise<void>;
+    abstract clear(): Promise<void>;
+}

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+export declare class DidNotFoundError extends Error {
+    did: string;
+    constructor(did: string);
+}
+export declare class PoorlyFormattedDidError extends Error {
+    did: string;
+    constructor(did: string);
+}
+export declare class UnsupportedDidMethodError extends Error {
+    did: string;
+    constructor(did: string);
+}
+export declare class PoorlyFormattedDidDocumentError extends Error {
+    did: string;
+    doc: unknown;
+    constructor(did: string, doc: unknown);
+}
+export declare class UnsupportedDidWebPathError extends Error {
+    did: string;
+    constructor(did: string);
+}

package/dist/handle/index.d.ts

@@ -0,0 +1,8 @@
+import { HandleResolverOpts } from '../types';
+export declare class HandleResolver {
+    timeout: number;
+    constructor(opts?: HandleResolverOpts);
+    resolve(handle: string): Promise<string | undefined>;
+    resolveDns(handle: string): Promise<string | undefined>;
+    resolveHttp(handle: string, signal?: AbortSignal): Promise<string | undefined>;
+}

package/dist/id-resolver.d.ts

@@ -0,0 +1,8 @@
+import { HandleResolver } from './handle';
+import DidResolver from './did/did-resolver';
+import { IdentityResolverOpts } from './types';
+export declare class IdResolver {
+    handle: HandleResolver;
+    did: DidResolver;
+    constructor(opts?: IdentityResolverOpts);
+}

package/dist/identity-resolver.d.ts

@@ -0,0 +1,8 @@
+import { HandleResolver } from './handle';
+import DidResolver from './did/did-resolver';
+import { IdentityResolverOpts } from './types';
+export declare class IdentityResolver {
+    handle: HandleResolver;
+    did: DidResolver;
+    constructor(opts?: Partial<IdentityResolverOpts>);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './did';
+export * from './handle';
+export * from './id-resolver';
+export * from './errors';
+export * from './types';