Update did key v7

.eslintrc.cjs

@@ -0,0 +1,14 @@
+module.exports = {
+  env: {
+    node: true
+  },
+  extends: [
+    'eslint-config-digitalbazaar',
+    'eslint-config-digitalbazaar/jsdoc',
+    'eslint-config-digitalbazaar/module',
+  ],
+  parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module'
+  }
+};

.github/workflows/main.yml

@@ -24,19 +24,20 @@ jobs:
     timeout-minutes: 10
     services:
       mongodb:
-        image: mongo:4.2
+        image: mongo:4.4
         ports:
           - 27017:27017
     strategy:
       matrix:
-        node-version: [12.x, 14.x]
+        node-version: [14.x, 16.x]
     steps:
     - uses: actions/checkout@v2
     - name: Use Node.js ${{ matrix.node-version }}
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
     - run: |
+        npm install
         cd test
         npm install
     - name: Run test with Node.js ${{ matrix.node-version }}
@@ -49,7 +50,7 @@ jobs:
     timeout-minutes: 10
     services:
       mongodb:
-        image: mongo:4.2
+        image: mongo:4.4
         ports:
           - 27017:27017
     strategy:
@@ -62,6 +63,7 @@ jobs:
       with:
         node-version: ${{ matrix.node-version }}
     - run: |
+        npm install
         cd test
         npm install
     - name: Generate coverage report

.npmrc

@@ -0,0 +1 @@
+legacy-peer-deps=true

lib/DidResolutionResult.js

@@ -0,0 +1,35 @@
+/*!
+ * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
+ */
+
+/**
+ * Creates the json-ld for the response.
+ *
+ * @param {object} options - Options to use.
+ * @param {boolean} [options.isDidUrl=false] - Does the response need
+ *   didDereferencingMetadata?
+ * @param {object} [options.didDocument={}] - The didDocument for the
+ *   response.
+ * @param {object|null} [options.didDocumentMetadata=null] - Meta data
+ *   for the didDocument.
+ * @param {Error} options.error - An error if any was raised.
+ */
+export class DidResolutionResult {
+  constructor({
+    isDidUrl = false,
+    didDocument = {},
+    didDocumentMetadata = null,
+    error
+  }) {
+    this['@context'] = 'https://w3id.org/did-resolution/v1';
+    this.didDocument = didDocument;
+    this.didDocumentMetadata = didDocumentMetadata;
+    const metadataProperty = isDidUrl ?
+      'didDereferencingMetadata' : 'didResolutionMetadata';
+    this[metadataProperty] = {};
+    // only define error if it was passed in
+    if(error) {
+      this[metadataProperty].error = error.code || 'internalError';
+    }
+  }
+}

lib/config.js

@@ -1,14 +1,21 @@
 /*!
  * Copyright (c) 2021 Digital Bazaar, Inc. All rights reserved.
  */
-import bedrock from 'bedrock';
-const {config} = bedrock;
+import {config} from '@bedrock/core';
 
 const namespace = 'bedrock-did-resolver-http';
 const cfg = config[namespace] = {};
 
-// support did:key and veres one keys by default
-cfg.supportedMethods = ['key', 'v1'];
+// a list of which did:methods we supported
+// experimental is for tests only
+cfg.supportedMethods = ['key', 'v1', 'experimental'];
+// FIXME this can be expanded to support Multikey or JsonWebKey2020
+cfg.publicKeyFormats = [
+  'Ed25519VerificationKey2020',
+  'X25519KeyAgreementKey2020',
+  // this is strictly for testing
+  'ExperimentalVerificationKey2022'
+];
 
 const basePath = '/1.0/resolve/identifiers/:did';
 cfg.routes = {basePath};

lib/didComponents.js

@@ -0,0 +1,79 @@
+/*!
+ * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
+ */
+
+/**
+ * Using a colon (:) as the delimiter, split the identifier
+ * into its components: a scheme, a method, a version, and a
+ * multibaseValue. If there are only three components set the
+ * version to the string value 1 and use the last value as
+ * the multibaseValue.
+ *
+ * @param {object} options - Options to use.
+ * @param {string} options.did - A did as a string.
+ *
+ * @returns {object} The components of the did.
+*/
+export const getDidKeyComponents = ({did}) => {
+  const {
+    isDidUrl,
+    didEndIndex,
+    fragment,
+    search,
+    searchParams
+  } = _getUrlComponents({did});
+  // the identifier should be the did before the url syntax starts
+  const identifier = isDidUrl ? did.substring(0, didEndIndex) : did;
+  // split on : unless : is the last character in a did url /(?!:$):/
+  const parts = identifier.split(/(?!:$):/);
+  const [scheme, method, version, multibase] = parts;
+  return {
+    scheme,
+    method,
+    // if multibase exists use the version
+    version: multibase ? version : '1',
+    // multibase maybe undefined
+    // if multibase exists use multibase
+    multibase: multibase || version,
+    parts,
+    did,
+    identifier,
+    // contains the fragment to dereference
+    fragment,
+    // contains the search string
+    search,
+    // contains a map with key value pairs
+    searchParams,
+    isDidUrl
+  };
+};
+
+/**
+ * If the did is a did url it gets the fragment and searchParams.
+ *
+ * @private
+ *
+ * @param {object} options - Options to use.
+ * @param {string} options.did - A potential did url.
+ *
+ * @returns {object} The resulting url components.
+ */
+function _getUrlComponents({did}) {
+  // if there is a fragment `#` or a service `?service` or it contains /
+  // then we are dereferencing a did url
+  const urlParts = /[\/#?]/;
+  const urlMatch = urlParts.exec(did);
+  if(urlMatch) {
+    const urlParts = new URL(did);
+    return {
+      isDidUrl: true,
+      fragment: urlParts.hash,
+      search: urlParts.search,
+      searchParams: urlParts.searchParams,
+      didEndIndex: urlMatch.index
+    };
+  }
+  return {
+    isDidUrl: false
+  };
+}

lib/didResolver.js

@@ -0,0 +1,61 @@
+/*!
+ * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
+ */
+import {
+  validateDidRequest,
+  validateRequestOptions
+} from './validators/index.js';
+import {didIo} from '@bedrock/did-io';
+import {DidResolutionResult} from './DidResolutionResult.js';
+import {getDidKeyComponents} from './didComponents.js';
+import logger from './logger.js';
+
+/**
+ * Resolves a did after validating it.
+ *
+ * @param {object} options - Options to use.
+ * @param {string} options.did - The did or didUrl being resolved.
+ * @param {Array<string>} options.supportedMethods - A list of
+ *   did methods this resolver supports.
+ * @param {Array<string>} options.publicKeyFormats - A list of
+ *   public key formats this resolver supports.
+ * @param {object} options.didOptions - Options passed to the resolver.
+ *
+ * @returns {object} - Returns a status code and the resolution data.
+ */
+export const resolveDid = async ({
+  did,
+  supportedMethods,
+  publicKeyFormats,
+  didOptions
+}) => {
+  let isDidUrl = false;
+  let error;
+  try {
+    const didKeyComponents = getDidKeyComponents({did});
+    isDidUrl = didKeyComponents.isDidUrl;
+    await validateDidRequest({didKeyComponents, supportedMethods, didOptions});
+    const didDocument = await didIo.get({did});
+    // FIXME didOptions should probably be in didIo
+    // in the future
+    validateRequestOptions({
+      did,
+      didDocument,
+      didOptions,
+      publicKeyFormats
+    });
+    return {
+      statusCode: 200,
+      resolutionResult: new DidResolutionResult({didDocument, isDidUrl})
+    };
+  } catch(e) {
+    logger.error(`did resolution error: ${did}`, {error: e});
+    error = e;
+  }
+  if(error) {
+    return {
+      statusCode: error.statusCode || 500,
+      resolutionResult: new DidResolutionResult({error, isDidUrl})
+    };
+  }
+};

lib/http.js

@@ -1,61 +1,37 @@
 /*!
  * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
  */
-import {asyncHandler} from 'bedrock-express';
-import bedrock from 'bedrock';
-import {didIo} from 'bedrock-did-io';
-import logger from './logger';
+
+import * as bedrock from '@bedrock/core';
+import {asyncHandler} from '@bedrock/express';
+import logger from './logger.js';
+import {resolveDid} from './didResolver.js';
 const {config} = bedrock;
 
 bedrock.events.on('bedrock-express.configure.routes', app => {
-  const {routes, supportedMethods} = config['bedrock-did-resolver-http'];
+  const {
+    routes,
+    supportedMethods,
+    publicKeyFormats
+  } = config['bedrock-did-resolver-http'];
   app.get(
     routes.basePath,
     asyncHandler(async (req, res) => {
-      // this can be resolution or dereferencing meta data
-      const metaData = {};
-      const resolutionResult = {
-        '@context': 'https://w3id.org/did-resolution/v1',
-        didDocument: {},
-        didDocumentMetadata: null,
-        didResolutionMetadata: metaData
-      };
       const {did} = req.params;
-      const parsedDid = new URL(did);
-      // if there is a fragment `#` or a service `?service`
-      // then we are dereferencing a did url
-      const didUrl = (parsedDid.hash || parsedDid.search);
-      if(didUrl) {
-        // add a did dereferencing meta
-        resolutionResult.didDereferencingMetadata = metaData;
-        // delete the resolution metadata
-        delete resolutionResult.didResolutionMetadata;
-      }
-      // the second value should always be the method
-      const [prefix, method, id] = did.split(':');
-      // a did must have a did prefix, method, and id
-      if(!((prefix === 'did') && method && id)) {
-        metaData.error = didUrl ? 'invalidDidUrl' : 'invalidDid';
-        return res.status(400).json(resolutionResult);
-      }
-      if(!supportedMethods.includes(method)) {
-        //FIXME this might not be the right error code
-        metaData.error = 'representationNotSupported';
-        return res.status(406).json(resolutionResult);
-      }
+      // did options are passed to the resolver via url queries
+      // except some are headers on the request
+      const didOptions = {...req.headers, ...req.query};
       try {
-        resolutionResult.didDocument = await didIo.get({did});
-      } catch(e) {
-        //FIXME the did resolver error could contain invalidDid, notFound,
-        //or representationNotSupported we need to check for those errors
-        //and newer errors and add that information in the future
-        logger.error('DID Resolution error', {error: e});
-        // the spec doesn't seem to handle what occurs if the
-        // did resolver fails for reasons unrelated to the did such
-        // as database timeouts.
-        metaData.error = 'InternalError';
-        return res.status(500).json(resolutionResult);
+        const {statusCode, resolutionResult} = await resolveDid({
+          did,
+          supportedMethods,
+          publicKeyFormats,
+          didOptions
+        });
+        res.status(statusCode).json(resolutionResult);
+      } catch(error) {
+        logger.error(`Did resolution error ${did}`, {error});
+        throw error;
       }
-      res.json(resolutionResult);
     }));
 });

lib/index.js

@@ -1,8 +1,7 @@
 /*!
- * Copyright (c) 2021 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2021-2022 Digital Bazaar, Inc. All rights reserved.
  */
-'use strict';
+import '@bedrock/express';
 
-// translate `main.js` to CommonJS
-require = require('esm')(module);
-module.exports = require('./main.js');
+import './config.js';
+import './http.js';

lib/logger.js

@@ -2,9 +2,8 @@
 /*!
  * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
  */
-'use strict';
 
-import bedrock from 'bedrock';
+import * as bedrock from '@bedrock/core';
 
 const logger = bedrock.loggers.get('app').child('bedrock-did-resolver-http');