Switch to using @digitalbazaar/did-io

Upgrade dependencies

Author: Wes Biggs

README.md

@@ -1,42 +1,43 @@
 # Overview
 
 This package implements a generic resolver for the `dsnp` DID method (that is, DIDs of the form `did:dsnp:123456`, where `123456` is a [DSNP User Id](https://spec.dsnp.org/DSNP/Identifiers.html#dsnp-user-id) in decimal format).
-This resolver should be used with one or more plugins for specific DSNP systems (see below).
+This resolver must be used with one or more plugins for specific DSNP systems (see below).
 
 # Usage
 
-This package follows the conventions described in the [`did-resolver`](https://github.com/decentralized-identity/did-resolver) package and exposes a `getResolver()` function which returns a mapping from the `dsnp` DID method to a resolver function.
-Pass an array of plugins to the `getResolver()` method.
+This package follows the conventions described in the [`@digitalbazaar/did-io`](https://github.com/digitalbazaar/did-io) package and exposes a `driver()` function which returns an object with a `get(options)` method.
+Pass an array of DSNPResolver objects to the `driver()` method.
 
 ## Usage for DSNP DID method only
 
 ```
-import { Resolver } from "did-resolver";
-import dsnpResolver from "@dsnp/did-resolver"; 
+import { CachedResolver } from "@digitalbazaar/did-io";
+import didDsnp from "@dsnp/did-resolver";
 import { FooResolver} from "dsnp-did-resolver-plugin-foo"; // See below for known plugins
 // ... additional dsnp-did-resolver plugins if needed
 
-const resolver = new Resolver(dsnpResolver.getResolver(
-  [ new FooResolver() ]
-));
+const resolver = new CachedResolver();
+resolver.use(didDsnp.driver([ new FooResolver() ]));
+
 const myDid = "did:dsnp:123456";
-const result = await resolver.resolve(myDid);
+const result = await resolver.get({ did: myDid });
 console.log(JSON.stringify(result, null, 2));
 ```
 
 ## Usage with other DID method resolvers
 
-The Resolver constructor can combine resolvers for multiple DID methods as described in the `did-resolver` [documentation](https://github.com/decentralized-identity/did-resolver#readme).
-For example, if you also want to be able to resolve `did:ethr:*` DIDs, you would import and include the `ethr` resolver and pass its destructured resolver alongside the DSNP one to the constructor as follows:
+The CachedResolver can combine drivers for multiple DID methods as described in the `did-io` [documentation](https://github.com/digitalbazaar/did-io#readme).
+For example, if you also want to be able to resolve `did:web:*` DIDs, you can use the `did-method-web` driver alongside the DSNP driver.
 
 ```
-import ethrResolver from "ethr-did-resolver";
-// ... additional did-resolver packages; 
+import { CachedResolver } from "@digitalbazaar/did-io";
+import didWeb from "@digitalbazaar/did-method-web";
+import didDsnp from "@dsnp/did-resolver";
+
+const resolver = new CachedResolver();
+resolver.use(didWeb.driver());
+resolver.use(didDsnp.driver([ new FooResolver() ]));
 
-const resolver = new Resolver({
-  ...dsnpResolver.getResolver([plugin]),
-  ...ethrResolver.getResolver()
-});
 // usage is same as in previous example
 ```
 
@@ -52,22 +53,20 @@ Plugins should implement the `DSNPResolver` interface, which includes a `resolve
 
 ```
 export interface DSNPResolver {
-  resolve(dsnpUserId: bigint): Promise<DIDDocument | null>;
+  resolve(dsnpUserId: bigint): Promise<object | null>;
 }
 ```
 
-The `DIDDocument` type is defined in the `did-resolver` package.
-
 The `resolve()` function should return `null` if the DSNP User Id cannot be resolved to a DID document for any reason.
 Plugins should avoid throwing errors except in dire circumstances, as errors from one plugin will cause any further plugins that have been registered to *not* be called.
 
-`DSNPResolver` instances are passed to the `getResolver()` function.
+`DSNPResolver` instances can be passed to the `CachedResolver` `use()` function.
 
 ## Known plugins
 
 | System | Plugin package
 |---|---|
-| Frequency | [`@dsnp/did-resolver-plugin-frequency`](https://github.com/AmplicaLabs/dsnp-did-resolver-plugin-frequency) | 
+| Frequency | [`@dsnp/did-resolver-plugin-frequency`](https://github.com/ProjectLibertyLabs/dsnp-did-resolver-plugin-frequency) | 
 
 Please submit a pull request with any additional plugins.
 

index.test.ts

@@ -1,19 +1,15 @@
-import {
-  DIDDocument,
-  DIDResolutionResult,
-  ParsedDID,
-  Resolvable,
-  DIDResolutionOptions,
-} from "did-resolver";
 import { expect, jest, test } from "@jest/globals";
-import { DSNPResolver, getResolver } from "./index.js";
+import { driver } from "./index.js";
+import { CachedResolver } from "@digitalbazaar/did-io";
 
-const someDocument: DIDDocument = {
+import type { DSNPResolver } from "./index.js";
+
+const someDocument: object = {
   id: "",
 };
 
 class Plugin1 implements DSNPResolver {
-  async resolve(dsnpUserId: bigint): Promise<DIDDocument | null> {
+  async resolve(dsnpUserId: bigint) {
     if (dsnpUserId === 123456n) {
       return someDocument;
     } else {
@@ -23,7 +19,7 @@ class Plugin1 implements DSNPResolver {
 }
 
 class Plugin2 implements DSNPResolver {
-  async resolve(dsnpUserId: bigint): Promise<DIDDocument | null> {
+  async resolve(dsnpUserId: bigint) {
     if (dsnpUserId === 234567n) {
       return someDocument;
     } else {
@@ -32,103 +28,56 @@ class Plugin2 implements DSNPResolver {
   }
 }
 
-function errorResult(error: string): DIDResolutionResult {
-  return {
-    didDocument: null,
-    didDocumentMetadata: {},
-    didResolutionMetadata: { error },
-  };
-}
-
-type GetResolverOutput = {
-  [method: string]: (
-    did: string,
-    parsed: ParsedDID,
-    resolver: Resolvable,
-    options: DIDResolutionOptions,
-  ) => Promise<DIDResolutionResult>;
-};
-
-const dummyResolvable: Resolvable = {
-  resolve: async (
-    didUrl: string,
-    options?: DIDResolutionOptions,
-  ): Promise<DIDResolutionResult> => {
-    return errorResult("dummy resolvable");
-  },
-};
-
 describe("dsnp-did-resolver", () => {
-  let resolver: GetResolverOutput;
+  let resolver: {
+    method: string;
+    get: (options: { did: string }) => Promise<object>;
+  };
 
   beforeAll(() => {
-    resolver = getResolver([new Plugin1(), new Plugin2()]);
+    resolver = driver([new Plugin1(), new Plugin2()]);
   });
 
   async function doResolve(id: string) {
     const did = `did:dsnp:${id}`;
-    return await resolver.dsnp(
-      did,
-      {
-        did,
-        didUrl: did,
-        method: "dsnp",
-        id,
-      },
-      dummyResolvable,
-      {},
-    );
+    return await resolver.get({ did });
   }
 
   it("claims to resolve 'dsnp' DID method", () => {
-    expect(resolver.dsnp).not.toBeNull();
+    expect(resolver.method).toEqual("dsnp");
   });
 
   it("rejects non-DSNP DIDs", async () => {
     const did = "did:xyz:123";
-    const output = await resolver.dsnp(
-      did,
-      { did, didUrl: did, method: "xyz", id: "123" },
-      dummyResolvable,
-      {},
-    );
-    expect(output).toEqual(errorResult("unsupportedDidMethod"));
+    const output = await expect(resolver.get({ did })).rejects.toThrow();
   });
 
   it("rejects invalid DSNP User Ids", async () => {
-    let output;
-    output = await doResolve("");
-    expect(output).toEqual(errorResult("invalidDid"));
-    output = await doResolve("abc");
-    expect(output).toEqual(errorResult("notFound"));
-    output = await doResolve("123.456");
-    expect(output).toEqual(errorResult("notFound"));
-    output = await doResolve("-123456");
-    expect(output).toEqual(errorResult("notFound"));
-    output = await doResolve(BigInt(2n ** 64n).toString());
-    expect(output).toEqual(errorResult("notFound"));
+    await expect(doResolve("")).rejects.toThrow();
+    await expect(doResolve("abc")).rejects.toThrow();
+    await expect(doResolve("123.456")).rejects.toThrow();
+    await expect(doResolve("-123456")).rejects.toThrow();
+    await expect(doResolve(BigInt(2n ** 64n).toString())).rejects.toThrow();
   });
 
   it("returns expected output for a resolved DID from first plugin", async () => {
     const output = await doResolve("123456");
-    expect(output).toEqual({
-      didResolutionMetadata: { contentType: "application/did+ld+json" },
-      didDocument: someDocument,
-      didDocumentMetadata: {},
-    });
+    expect(output).toEqual(someDocument);
   });
 
   it("returns expected output for a resolved DID from second plugin", async () => {
     const output = await doResolve("234567");
-    expect(output).toEqual({
-      didResolutionMetadata: { contentType: "application/did+ld+json" },
-      didDocument: someDocument,
-      didDocumentMetadata: {},
-    });
+    expect(output).toEqual(someDocument);
+  });
+
+  it("throws for a valid but unresolved DID", async () => {
+    await expect(doResolve("654321")).rejects.toThrow();
   });
 
-  it("returns 'notFound' output for a valid but unresolved DID", async () => {
-    const output = await doResolve("654321");
-    expect(output).toEqual(errorResult("notFound"));
+  it("works with did-io framework", async () => {
+    const didResolver = new CachedResolver();
+    didResolver.use(resolver);
+    const output = await didResolver.get({ did: "did:dsnp:123456" });
+    expect(output).toEqual(someDocument);
   });
 });

index.ts

@@ -1,71 +1,52 @@
-import {
-  Resolver,
-  ParsedDID,
-  Resolvable,
-  DIDResolutionOptions,
-  DIDResolutionResult,
-  DIDDocument,
-} from "did-resolver";
-
 export interface DSNPResolver {
-  resolve(dsnpUserId: bigint): Promise<DIDDocument | null>;
+  resolve(dsnpUserId: bigint): Promise<object | null>;
 }
 
-const notFoundResult: DIDResolutionResult = {
-  didDocument: null,
-  didDocumentMetadata: {},
-  didResolutionMetadata: { error: "notFound" },
-};
-
-export function getResolver(dsnpResolvers: DSNPResolver[]) {
-  async function resolve(
-    did: string,
-    parsed: ParsedDID,
-    resolver: Resolvable,
-    options: DIDResolutionOptions,
-  ): Promise<DIDResolutionResult> {
-    if (parsed.id === "") {
-      return {
-        didDocument: null,
-        didDocumentMetadata: {},
-        didResolutionMetadata: { error: "invalidDid" },
-      };
+export function driver(dsnpResolvers: DSNPResolver[]) {
+  async function get(options: { did: string }): Promise<object> {
+    const did = options.did;
+    if (!did || !did.startsWith("did:dsnp:")) {
+      throw new Error("Not a valid DSNP DID");
     }
-    if (parsed.method !== "dsnp") {
-      return {
-        didDocument: null,
-        didDocumentMetadata: {},
-        didResolutionMetadata: { error: "unsupportedDidMethod" },
-      };
+    const id = did.substring("did:dsnp:".length);
+    if (id === "") {
+      throw new Error("Missing DSNP User Id");
     }
+
     let dsnpUserId: bigint = 0n;
     try {
-      dsnpUserId = BigInt(parsed.id);
+      dsnpUserId = BigInt(id);
     } catch (e) {
-      return notFoundResult;
+      throw new Error("Could not parse DSNP User Id");
     }
     if (dsnpUserId < 0n || dsnpUserId >= 2n ** 64n) {
-      return notFoundResult;
+      throw new Error("DSNP User Id not in valid range");
     }
 
     for (const dsnpResolver of dsnpResolvers) {
       try {
         const output = await dsnpResolver.resolve(dsnpUserId);
-        if (output)
-          return {
-            didResolutionMetadata: { contentType: "application/did+ld+json" },
-            didDocument: output,
-            didDocumentMetadata: {},
-          };
+        if (output) return output;
       } catch (cause) {
         throw new Error(`Error resolving DSNP User Id ${dsnpUserId}`, {
           cause,
         });
       }
     }
 
-    return notFoundResult;
+    throw new Error("DSNP User Id not found");
   }
 
-  return { dsnp: resolve };
+  if (!dsnpResolvers || dsnpResolvers.length === 0)
+    throw new Error("Must provide at least one DSNPResolver");
+
+  return {
+    method: "dsnp",
+    get,
+    generate: () => {
+      throw new Error("generate() is not implemented");
+    },
+  };
 }
+
+export default { driver };

js.d.ts

@@ -1,23 +1 @@
-declare module "@digitalbazaar/vc" {
-  export function defaultDocumentLoader(url: string): any;
-  export function issue(
-    params: any,
-  ): import("./types/openapi.d.ts").Components.Schemas.VerifiableCredentialWithEd25519Proof;
-  export function verifyCredential(options: any): any;
-}
-
-declare module "@digitalbazaar/ed25519-verification-key-2020" {
-  export interface Ed25519VerificationKey2020 {}
-}
-
-declare module "@digitalbazaar/ed25519-signature-2020" {
-  export class Ed25519Signature2020 {
-    constructor(o: any);
-    verificationMethod: string;
-  }
-  export const suiteContext: any;
-}
-
-declare module "jsonld-signatures" {
-  export function extendContextLoader(extension: (string) => any);
-}
+declare module "@digitalbazaar/did-io";