refactor: many tweaks

Author: alanshaw

client/client.go

@@ -30,14 +30,11 @@ func (c *Client[Req, Res]) Execute(execRequest execution.Request) (execution.Res
 		delegations = append(delegations, execRequest.Metadata().Delegations()...)
 		receipts = append(receipts, execRequest.Metadata().Receipts()...)
 	}
-	reqContainer, err := container.New(
+	reqContainer := container.New(
 		container.WithInvocations(invocations...),
 		container.WithDelegations(delegations...),
 		container.WithReceipts(receipts...),
 	)
-	if err != nil {
-		return nil, fmt.Errorf("creating request container: %w", err)
-	}
 	request, err := c.Codec.Encode(reqContainer)
 	if err != nil {
 		return nil, fmt.Errorf("encoding container: %w", err)

client/http.go

@@ -1,6 +1,7 @@
 package client
 
 import (
+	"fmt"
 	"net/http"
 	"net/url"
 
@@ -26,7 +27,19 @@ func NewHTTP(serviceURL *url.URL, options ...HTTPOption) (*HTTPClient, error) {
 }
 
 func (c *HTTPClient) Execute(execRequest execution.Request) (execution.Response, error) {
-	return c.Client.Execute(execRequest)
+	res, err := c.Client.Execute(execRequest)
+	if err != nil {
+		return nil, fmt.Errorf("executing request: %w", err)
+	}
+	httpMeta, ok := res.Metadata().(*transport.HTTPResponseContainer)
+	if !ok {
+		return nil, fmt.Errorf("expected HTTPResponseContainer, got %T", res.Metadata())
+	}
+	err = httpMeta.Response.Body.Close()
+	if err != nil {
+		return nil, fmt.Errorf("closing body: %w", err)
+	}
+	return res, nil
 }
 
 type httpTransport struct {

examples/capability_definition_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/alanshaw/ucantone/examples/types"
-	"github.com/alanshaw/ucantone/ipld/datamodel"
+	"github.com/alanshaw/ucantone/ipld"
 	"github.com/alanshaw/ucantone/principal/ed25519"
 	"github.com/alanshaw/ucantone/ucan/delegation/policy"
 	"github.com/alanshaw/ucantone/ucan/invocation"
@@ -41,7 +41,7 @@ func TestCapabilityDefinition(t *testing.T) {
 		panic(err)
 	}
 
-	args := datamodel.Map{
+	args := ipld.Map{
 		"to":      []string{"bob@example.com"},
 		"subject": "Hello!",
 		"message": "Hello Bob, How do you do?",

examples/container_test.go

@@ -57,13 +57,10 @@ func TestContainer(t *testing.T) {
 	}
 	fmt.Println("Invocation:", inv.Link())
 
-	ct, err := container.New(
+	ct := container.New(
 		container.WithDelegations(dlg),
 		container.WithInvocations(inv),
 	)
-	if err != nil {
-		panic(err)
-	}
 
 	buf, err := container.Encode(container.Base64Gzip, ct)
 	if err != nil {

examples/server_test.go

@@ -0,0 +1,108 @@
+package examples
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/alanshaw/ucantone/client"
+	"github.com/alanshaw/ucantone/execution"
+	"github.com/alanshaw/ucantone/ipld"
+	"github.com/alanshaw/ucantone/principal/ed25519"
+	"github.com/alanshaw/ucantone/result"
+	"github.com/alanshaw/ucantone/server"
+	"github.com/alanshaw/ucantone/ucan/invocation"
+	"github.com/alanshaw/ucantone/validator/capability"
+)
+
+func TestServer(t *testing.T) {
+	echoCapability, err := capability.New("/example/echo")
+	if err != nil {
+		panic(err)
+	}
+
+	serviceID, err := ed25519.Generate()
+	if err != nil {
+		panic(err)
+	}
+
+	ucanSrv := server.NewHTTP(serviceID)
+
+	// Register an echo handler that returns the invocation arguments as the result
+	ucanSrv.Handle(echoCapability, func(req execution.Request) (execution.Response, error) {
+		return execution.NewResponse(execution.WithSuccess(req.Invocation().Arguments()))
+	})
+
+	// Start the server on a random available port
+	listener, err := net.Listen("tcp", ":0")
+	if err != nil {
+		panic(err)
+	}
+
+	httpSrv := http.Server{Handler: ucanSrv}
+
+	go func() {
+		err := httpSrv.Serve(listener)
+		if err != nil && err != http.ErrServerClosed {
+			panic(err)
+		}
+	}()
+
+	serviceURL, err := url.Parse("http://" + listener.Addr().String())
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("UCAN Server is running at %s\n", serviceURL.String())
+
+	// Server is now running and can accept invocations!
+
+	alice, err := ed25519.Generate()
+	if err != nil {
+		panic(err)
+	}
+
+	// Allow alice to invoke the echo capability
+	dlg, err := echoCapability.Delegate(serviceID, alice, serviceID)
+	if err != nil {
+		panic(err)
+	}
+
+	inv, err := echoCapability.Invoke(
+		alice,
+		serviceID,
+		ipld.Map{"message": "Hello, UCAN!"},
+		invocation.WithProofs(dlg.Link()),
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	// create a client to send the invocation to the server
+	c, err := client.NewHTTP(serviceURL)
+	if err != nil {
+		panic(err)
+	}
+
+	resp, err := c.Execute(execution.NewRequest(context.Background(), inv, execution.WithProofs(dlg)))
+	if err != nil {
+		panic(err)
+	}
+
+	result.MatchResultR0(
+		resp.Result(),
+		func(o ipld.Any) {
+			fmt.Printf("Echo response: %v\n", o)
+		},
+		func(x ipld.Any) {
+			fmt.Printf("Invocation failed: %v\n", x)
+		},
+	)
+
+	err = httpSrv.Shutdown(context.Background())
+	if err != nil {
+		panic(err)
+	}
+}

execution/bindexec/handler.go

@@ -19,14 +19,39 @@ type Success interface {
 }
 
 type requestConfig struct {
-	metadata ucan.Container
+	invocations []ucan.Invocation
+	delegations []ucan.Delegation
+	receipts    []ucan.Receipt
 }
 
 type RequestOption = func(cfg *requestConfig)
 
-func WithRequestMetadata(meta ucan.Container) RequestOption {
+// WithProofs adds delegations to the execution request. They should be linked
+// from the invocation to be executed.
+func WithProofs(delegations ...ucan.Delegation) RequestOption {
 	return func(cfg *requestConfig) {
-		cfg.metadata = meta
+		cfg.delegations = append(cfg.delegations, delegations...)
+	}
+}
+
+// WithDelegations adds delegations to the execution request.
+func WithDelegations(delegations ...ucan.Delegation) RequestOption {
+	return func(cfg *requestConfig) {
+		cfg.delegations = append(cfg.delegations, delegations...)
+	}
+}
+
+// WithReceipts adds receipts to the execution request.
+func WithReceipts(receipts ...ucan.Receipt) RequestOption {
+	return func(cfg *requestConfig) {
+		cfg.receipts = append(cfg.receipts, receipts...)
+	}
+}
+
+// WithInvocations adds additional invocations to the execution request.
+func WithInvocations(invocations ...ucan.Invocation) RequestOption {
+	return func(cfg *requestConfig) {
+		cfg.invocations = append(cfg.invocations, invocations...)
 	}
 }
 
@@ -40,7 +65,15 @@ func NewRequest[A Arguments](ctx context.Context, inv ucan.Invocation, options .
 	for _, opt := range options {
 		opt(&cfg)
 	}
-	return Request[A]{Request: execution.NewRequest(ctx, inv, execution.WithRequestMetadata(cfg.metadata))}
+	return Request[A]{
+		Request: execution.NewRequest(
+			ctx,
+			inv,
+			execution.WithInvocations(cfg.invocations...),
+			execution.WithDelegations(cfg.delegations...),
+			execution.WithReceipts(cfg.receipts...),
+		),
+	}
 }
 
 func (r *Request[A]) Task() *Task[A] {

execution/dispatcher/dispatcher.go

@@ -42,6 +42,9 @@ func (d *Dispatcher) Handle(capability validator.Capability, fn execution.Handle
 
 func (d *Dispatcher) Execute(req execution.Request) (execution.Response, error) {
 	aud := req.Invocation().Audience()
+	if aud == nil {
+		aud = req.Invocation().Subject()
+	}
 	if aud.DID() != d.authority.DID() {
 		return execution.NewResponse(
 			execution.WithFailure(execution.NewInvalidAudienceError(d.authority, aud)),
@@ -54,12 +57,17 @@ func (d *Dispatcher) Execute(req execution.Request) (execution.Response, error)
 		return execution.NewResponse(execution.WithFailure(NewHandlerNotFoundError(cmd)))
 	}
 
+	opts := append([]validator.Option{}, d.validationOpts...)
+	if req.Metadata() != nil {
+		opts = append(opts, validator.WithProofs(req.Metadata().Delegations()...))
+	}
+
 	_, err := validator.Access(
 		req.Context(),
 		d.authority,
 		handler.Capability,
 		req.Invocation(),
-		d.validationOpts...,
+		opts...,
 	)
 	if err != nil {
 		return execution.NewResponse(execution.WithFailure(err))

execution/dispatcher/dispatcher_test.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/alanshaw/ucantone/errors"
 	"github.com/alanshaw/ucantone/execution"
 	"github.com/alanshaw/ucantone/execution/dispatcher"
 	"github.com/alanshaw/ucantone/ipld"
@@ -90,9 +89,7 @@ func TestDispatcher(t *testing.T) {
 		require.NotNil(t, x)
 		t.Log(x)
 
-		namedErr, ok := x.(errors.Named)
-		require.True(t, ok)
-		require.Equal(t, dispatcher.HandlerNotFoundErrorName, namedErr.Name())
+		require.Equal(t, dispatcher.HandlerNotFoundErrorName, x.(ipld.Map)["name"])
 	})
 
 	t.Run("invalid audience", func(t *testing.T) {
@@ -114,9 +111,7 @@ func TestDispatcher(t *testing.T) {
 		require.NotNil(t, x)
 		t.Log(x)
 
-		namedErr, ok := x.(errors.Named)
-		require.True(t, ok)
-		require.Equal(t, execution.InvalidAudienceErrorName, namedErr.Name())
+		require.Equal(t, execution.InvalidAudienceErrorName, x.(ipld.Map)["name"])
 	})
 
 	t.Run("handler execution error", func(t *testing.T) {
@@ -142,9 +137,7 @@ func TestDispatcher(t *testing.T) {
 		require.NotNil(t, x)
 		t.Log(x)
 
-		namedErr, ok := x.(errors.Named)
-		require.True(t, ok)
-		require.Equal(t, execution.HandlerExecutionErrorName, namedErr.Name())
+		require.Equal(t, execution.HandlerExecutionErrorName, x.(ipld.Map)["name"])
 	})
 
 	t.Run("validation error", func(t *testing.T) {
@@ -169,8 +162,6 @@ func TestDispatcher(t *testing.T) {
 		require.NotNil(t, x)
 		t.Log(x)
 
-		namedErr, ok := x.(errors.Named)
-		require.True(t, ok)
-		require.Equal(t, verrs.InvalidClaimErrorName, namedErr.Name())
+		require.Equal(t, verrs.InvalidClaimErrorName, x.(ipld.Map)["name"])
 	})
 }