feat: Add did:web resolver

pkg/document/webresolver/resolvehandler.go

@@ -0,0 +1,132 @@
+/*
+Copyright SecureKey Technologies Inc. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package webresolver
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/trustbloc/edge-core/pkg/log"
+	"github.com/trustbloc/sidetree-core-go/pkg/document"
+	"github.com/trustbloc/sidetree-core-go/pkg/docutil"
+)
+
+var logger = log.New("did-web-resolver")
+
+// ErrDocumentNotFound is document not found error.
+var ErrDocumentNotFound = fmt.Errorf("document not found")
+
+// ResolveHandler resolves generic documents.
+type ResolveHandler struct {
+	orbResolver            orbResolver
+	orbPrefix              string
+	orbUnpublishedDIDLabel string
+
+	domain *url.URL
+
+	metrics metricsProvider
+}
+
+// Orb resolver resolves Orb documents.
+type orbResolver interface {
+	ResolveDocument(id string) (*document.ResolutionResult, error)
+}
+
+type metricsProvider interface {
+	WebDocumentResolveTime(duration time.Duration)
+}
+
+// NewResolveHandler returns a new document resolve handler.
+func NewResolveHandler(domain *url.URL, orbPrefix, orbUnpublishedLabel string, resolver orbResolver,
+	metrics metricsProvider) *ResolveHandler {
+	rh := &ResolveHandler{
+		domain:                 domain,
+		orbPrefix:              orbPrefix,
+		orbResolver:            resolver,
+		metrics:                metrics,
+		orbUnpublishedDIDLabel: orbUnpublishedLabel,
+	}
+
+	return rh
+}
+
+// ResolveDocument resolves a document.
+func (r *ResolveHandler) ResolveDocument(id string) (*document.ResolutionResult, error) {
+	startTime := time.Now()
+
+	defer func() {
+		r.metrics.WebDocumentResolveTime(time.Since(startTime))
+	}()
+
+	unpublishedOrbDID := r.orbPrefix + docutil.NamespaceDelimiter +
+		r.orbUnpublishedDIDLabel + docutil.NamespaceDelimiter + id
+
+	localResponse, err := r.orbResolver.ResolveDocument(unpublishedOrbDID)
+	if err != nil {
+		if strings.Contains(err.Error(), "not found") {
+			return nil, ErrDocumentNotFound
+		}
+
+		return nil, fmt.Errorf("failed to resolve document for id[%s]: %w", id, err)
+	}
+
+	alsoKnownAs := getAlsoKnownAs(localResponse.Document)
+
+	webDID := fmt.Sprintf("did:web:%s:identity:%s", r.domain.Host, id)
+
+	if !contains(alsoKnownAs, webDID) {
+		// TODO: is this legit error message (should we allow it even if it is not in also known as)
+		return nil, fmt.Errorf("id[%s] not found in alsoKnownAs", webDID)
+	}
+
+	didWebDoc, err := transformToDIDWeb(id, localResponse.Document)
+	if err != nil {
+		return nil, err
+	}
+
+	logger.Debugf("resolved id: %s", id)
+
+	return &document.ResolutionResult{Document: didWebDoc}, nil
+}
+
+func transformToDIDWeb(id string, doc document.Document) (document.Document, error) {
+	docBytes, err := doc.Bytes()
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal document for id[%s]: %w", id, err)
+	}
+
+	// replace all occurrences of did:orb ID with did:web ID
+	didWebDocStr := strings.ReplaceAll(string(docBytes), doc.ID(), id)
+
+	var didWebDoc document.Document
+
+	err = json.Unmarshal([]byte(didWebDocStr), &didWebDoc)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal document for id[%s]: %w", id, err)
+	}
+
+	return didWebDoc, nil
+}
+
+func getAlsoKnownAs(doc document.Document) []string {
+	didDoc := document.DidDocumentFromJSONLDObject(doc)
+
+	return didDoc.AlsoKnownAs()
+}
+
+func contains(values []string, value string) bool {
+	for _, v := range values {
+		if v == value {
+			return true
+		}
+	}
+
+	return false
+}

pkg/document/webresolver/resolvehandler_test.go

@@ -0,0 +1,119 @@
+/*
+Copyright SecureKey Technologies Inc. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package webresolver
+
+//go:generate counterfeiter -o ./mocks/orbresolver.gen.go --fake-name OrbResolver . orbResolver
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/trustbloc/sidetree-core-go/pkg/document"
+
+	"github.com/trustbloc/orb/pkg/document/webresolver/mocks"
+	orbmocks "github.com/trustbloc/orb/pkg/mocks"
+)
+
+const (
+	orbPrefix           = "did:orb"
+	orbUnpublishedLabel = "uAAA"
+
+	testDomain = "https://example.com"
+	testSuffix = "suffix"
+)
+
+func TestResolveHandler_Resolve(t *testing.T) {
+	testDomainURL, err := url.Parse(testDomain)
+	require.NoError(t, err)
+
+	t.Run("success", func(t *testing.T) {
+		testDoc, err := getTestDoc()
+		require.NoError(t, err)
+
+		orbResolver := &mocks.OrbResolver{}
+		orbResolver.ResolveDocumentReturns(&document.ResolutionResult{Document: testDoc}, nil)
+
+		handler := NewResolveHandler(testDomainURL,
+			orbPrefix, orbUnpublishedLabel, orbResolver,
+			&orbmocks.MetricsProvider{})
+
+		response, err := handler.ResolveDocument(testSuffix)
+		require.NoError(t, err)
+		require.NotNil(t, response)
+	})
+
+	t.Run("error - domain not in alsoKnownAs", func(t *testing.T) {
+		testDoc, err := getTestDoc()
+		require.NoError(t, err)
+
+		orbResolver := &mocks.OrbResolver{}
+		orbResolver.ResolveDocumentReturns(&document.ResolutionResult{Document: testDoc}, nil)
+
+		otherDomainURL, err := url.Parse("https://other.com")
+		require.NoError(t, err)
+
+		handler := NewResolveHandler(otherDomainURL,
+			orbPrefix, orbUnpublishedLabel, orbResolver,
+			&orbmocks.MetricsProvider{})
+
+		response, err := handler.ResolveDocument("suffix")
+		require.Error(t, err)
+		require.Nil(t, response)
+		require.Contains(t, err.Error(), "id[did:web:other.com:identity:suffix] not found in alsoKnownAs")
+	})
+
+	t.Run("error - orb resolver error", func(t *testing.T) {
+		orbResolver := &mocks.OrbResolver{}
+		orbResolver.ResolveDocumentReturns(nil, fmt.Errorf("orb resolver error"))
+
+		handler := NewResolveHandler(testDomainURL,
+			orbPrefix, orbUnpublishedLabel, orbResolver,
+			&orbmocks.MetricsProvider{})
+
+		response, err := handler.ResolveDocument(testSuffix)
+		require.Error(t, err)
+		require.Nil(t, response)
+		require.Contains(t, err.Error(), "orb resolver error")
+	})
+
+	t.Run("error - orb resolver not found error", func(t *testing.T) {
+		orbResolver := &mocks.OrbResolver{}
+		orbResolver.ResolveDocumentReturns(nil, fmt.Errorf("not found"))
+
+		handler := NewResolveHandler(testDomainURL,
+			orbPrefix, orbUnpublishedLabel, orbResolver,
+			&orbmocks.MetricsProvider{})
+
+		response, err := handler.ResolveDocument(testSuffix)
+		require.Error(t, err)
+		require.Nil(t, response)
+		require.Contains(t, err.Error(), "document not found")
+	})
+}
+
+func getTestDoc() (document.Document, error) {
+	didDoc := make(document.Document)
+	didDoc["alsoKnownAs"] = []string{"did:web:example.com:identity:suffix"}
+	didDoc["id"] = "did:orb:cid:suffix"
+
+	didDocBytes, err := didDoc.Bytes()
+	if err != nil {
+		return nil, err
+	}
+
+	var expected document.Document
+
+	err = json.Unmarshal(didDocBytes, &expected)
+	if err != nil {
+		return nil, err
+	}
+
+	return expected, nil
+}

pkg/mocks/metricsprovider.go

@@ -122,6 +122,10 @@ func (m *MetricsProvider) DocumentCreateUpdateTime(value time.Duration) {
 func (m *MetricsProvider) DocumentResolveTime(value time.Duration) {
 }
 
+// WebDocumentResolveTime records the time it takes the REST handler to resolve a web document.
+func (m *MetricsProvider) WebDocumentResolveTime(value time.Duration) {
+}
+
 // OutboxIncrementActivityCount increments the number of activities of the given type posted to the outbox.
 func (m *MetricsProvider) OutboxIncrementActivityCount(activityType string) {
 }