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

@@ -8,7 +8,7 @@ jobs:
     timeout-minutes: 10
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [16.x]
     steps:
     - uses: actions/checkout@v2
     - name: Use Node.js ${{ matrix.node-version }}
@@ -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: [16.x, 18.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,19 +50,20 @@ jobs:
     timeout-minutes: 10
     services:
       mongodb:
-        image: mongo:4.2
+        image: mongo:4.4
         ports:
           - 27017:27017
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [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: Generate coverage report

.npmrc

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

lib/DidResolutionResult.js

@@ -0,0 +1,36 @@
+/*!
+ * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
+ */
+import {isDidUrl} from '@digitalbazaar/did-io';
+
+/**
+ * Creates the JSON-LD for the response.
+ *
+ * @param {object} options - Options to use.
+ * @param {string} [options.did=''] - The did being resolved.
+ * @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({
+    did = '',
+    didDocument = {},
+    didDocumentMetadata = null,
+    error
+  }) {
+    this['@context'] = 'https://w3id.org/did-resolution/v1';
+    this.didDocument = didDocument;
+    this.didDocumentMetadata = didDocumentMetadata;
+    const hasDereferencingMetadata = isDidUrl({did});
+    const metadataProperty = hasDereferencingMetadata ?
+      '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,10 @@
 /*!
  * 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'];
-
-const basePath = '/1.0/resolve/identifiers/:did';
+const basePath = '/1.0/identifiers/resolve/:did';
 cfg.routes = {basePath};

lib/didResolver.js

@@ -0,0 +1,152 @@
+/*!
+ * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
+ */
+import {didIo} from '@bedrock/did-io';
+import {DidResolutionResult} from './DidResolutionResult.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 {object} options.didOptions - Options to be passed to the did
+ *   method driver.
+ * @param {object} options.resolverOptions - Options for the resolver such as
+ *   the format of the response data.
+ *
+ * @returns {object} - Returns a status code and the resolution data.
+ */
+export const resolveDid = async ({
+  did,
+  didOptions: rawOptions,
+  resolverOptions
+}) => {
+  let error;
+  let didDocument;
+  try {
+    const didOptions = _convertDidOptions({didOptions: rawOptions});
+    didDocument = await didIo.get({did, options: didOptions});
+  } catch(e) {
+    logger.error(`DID resolution error: ${did}`, {error: e});
+    error = e;
+  }
+  return _formatResponse({resolverOptions, didDocument, error, did});
+};
+
+/**
+ * Did Resolvers can return the didDocument itself or wrapped with metadata.
+ *
+ * @private
+ *
+ * @param {object} options - Options to use.
+ * @param {object} options.resolverOptions - Options for the did resolver
+ *   usually found in headers.
+ * @param {object} options.didDocument - A didDocument.
+ * @param {Error} [options.error] - An error.
+ * @param {string} options.did - The did being resolved or derefernced.
+ *
+ * @returns {{statusCode: number, resolutionResult: object}} - What to return
+ *   as the response.
+ */
+function _formatResponse({resolverOptions, didDocument, error, did}) {
+  const {accept = ''} = resolverOptions;
+  const didResolutionContext = 'https://w3id.org/did-resolution';
+  const addMetadata = accept.includes(didResolutionContext);
+  if(!addMetadata) {
+    if(error) {
+      throw error;
+    }
+    return {
+      // FIXME services are not handled here yet
+      statusCode: 200,
+      resolutionResult: didDocument
+    };
+  }
+  return {
+    //FIXME services should return 303
+    statusCode: error ? _errorCodeToStatusCode({code: error.code}) : 200,
+    resolutionResult: new DidResolutionResult({did, didDocument, error})
+  };
+}
+
+/**
+ * Matches an error.code to a status code or 500.
+ *
+ * @see https://w3c-ccg.github.io/did-resolution/
+ * @private
+ *
+ * @param {object} options - Options to use.
+ * @param {string} options.code - An error.
+ *
+ * @returns {number} - An http status code.
+ */
+function _errorCodeToStatusCode({code}) {
+  const statuses = [
+    // if the did resolves to a service return 303
+    {statusCode: 303, codes: ['service']},
+    {
+      statusCode: 400,
+      // FIXME these codes should have more specific statusCodes soon
+      codes: [
+        'invalidDid',
+        'invalidDidUrl',
+        'unsupportedPublicKeyType',
+        'invalidPublicKeyType',
+        'invalidPublicKey',
+        'invalidPublicKeyLength'
+      ]
+    },
+    {statusCode: 404, codes: ['notFound']},
+    // if the did has been deactivated return 410
+    {statusCode: 410, codes: ['deactivated']},
+    {statusCode: 406, codes: ['representationNotSupported']},
+    {statusCode: 500, codes: ['internalError']},
+    {statusCode: 501, codes: ['methodNotSupported']},
+  ];
+  const {statusCode = 500} = statuses.find(
+    ({codes}) => codes.includes(code)) || {};
+  return statusCode;
+}
+
+// takes in search params / url queries
+// and then converts properties that should be booleans
+// to booleans
+function _convertDidOptions({didOptions}) {
+  if(!didOptions) {
+    return;
+  }
+  if(didOptions.enableExperimentalPublicKeyTypes) {
+    didOptions.enableExperimentalPublicKeyTypes = _convertSearchParamToBoolean({
+      param: didOptions.enableExperimentalPublicKeyTypes
+    });
+  }
+  return didOptions;
+}
+
+/**
+ * Search Params are encoded as strings so this turns
+ * strings of value '0' or 'false' into false.
+ *
+ * @param {object} options - Options to use.
+ * @param {string} options.param - The param value.
+ *
+ * @returns {boolean} Returns a boolean.
+ */
+function _convertSearchParamToBoolean({param}) {
+  if(typeof param !== 'string') {
+    return Boolean(param);
+  }
+  // the param must start & end with one of these values ignoring case
+  const booleanParam = /^((?<false>0|false)|(?<true>1|true))$/i;
+  const {groups} = booleanParam.exec(param.trim()) || {};
+  if(!groups) {
+    throw new Error(
+      `Expected search param to be 0, "false", 1, or "true" received ${param}`);
+  }
+  // if we captured a false value return false
+  if(groups.false !== undefined) {
+    return false;
+  }
+  return true;
+}

lib/http.js

@@ -1,61 +1,36 @@
 /*!
  * 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,
+  } = 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
+      const didOptions = {...req.query};
+      // the accept header tells the resolver how to format the response data
+      const resolverOptions = {...req.headers};
       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,
+          didOptions,
+          resolverOptions
+        });
+        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,7 @@
 /*!
  * 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');