feat: add account/egress/get capability

capabilities/account/egress/egress.ipldsch

@@ -0,0 +1,29 @@
+type GetCaveats struct {
+	spaces optional [DID]
+	period optional Period
+}
+
+type Period struct {
+	from ISO8601Date
+	to ISO8601Date
+}
+
+type GetOk struct {
+	total Int
+	spaces {DID:SpaceEgress}
+}
+
+type SpaceEgress struct {
+	total Int
+	dailyStats [DailyStat]
+}
+
+type DailyStat struct {
+	date ISO8601Date
+	egress Int
+}
+
+type GetError struct {
+	errorName String (rename "name")
+	message String
+}

capabilities/account/egress/get.go

@@ -0,0 +1,144 @@
+package egress
+
+import (
+	"fmt"
+	"slices"
+	"time"
+
+	"github.com/ipld/go-ipld-prime/datamodel"
+	"github.com/storacha/go-ucanto/core/ipld"
+	"github.com/storacha/go-ucanto/core/receipt"
+	"github.com/storacha/go-ucanto/core/result/failure"
+	"github.com/storacha/go-ucanto/core/schema"
+	"github.com/storacha/go-ucanto/did"
+	"github.com/storacha/go-ucanto/ucan"
+	"github.com/storacha/go-ucanto/validator"
+
+	"github.com/storacha/go-libstoracha/capabilities/types"
+)
+
+const GetAbility = "account/egress/get"
+
+type Period struct {
+	From time.Time
+	To   time.Time
+}
+
+type GetCaveats struct {
+	Spaces []did.DID
+	Period *Period
+}
+
+func (gc GetCaveats) ToIPLD() (datamodel.Node, error) {
+	return ipld.WrapWithRecovery(&gc, GetCaveatsType(), types.Converters...)
+}
+
+var GetCaveatsReader = schema.Struct[GetCaveats](GetCaveatsType(), nil, types.Converters...)
+
+type DailyStats struct {
+	Date   time.Time
+	Egress uint64
+}
+
+type SpaceEgress struct {
+	Total      uint64
+	DailyStats []DailyStats
+}
+
+type SpacesModel struct {
+	Keys   []did.DID
+	Values map[did.DID]SpaceEgress
+}
+
+type GetOk struct {
+	Total  uint64
+	Spaces SpacesModel
+}
+
+func (gok GetOk) ToIPLD() (datamodel.Node, error) {
+	return ipld.WrapWithRecovery(&gok, GetOkType(), types.Converters...)
+}
+
+type GetError struct {
+	ErrorName string
+	Message   string
+}
+
+const AccountNotFoundErrorName = "AccountNotFoundError"
+
+func NewAccountNotFoundError(msg string) GetError {
+	return GetError{
+		ErrorName: AccountNotFoundErrorName,
+		Message:   msg,
+	}
+}
+
+func (ge GetError) Name() string {
+	return ge.ErrorName
+}
+
+func (ge GetError) Error() string {
+	return ge.Message
+}
+
+func (ge GetError) ToIPLD() (datamodel.Node, error) {
+	return ipld.WrapWithRecovery(&ge, GetErrorType(), types.Converters...)
+}
+
+var GetErrorReader = schema.Mapped(
+	schema.Struct[GetError](GetErrorType(), nil, types.Converters...),
+	func(ge GetError) (GetError, failure.Failure) {
+		if ge.Name() != AccountNotFoundErrorName {
+			return GetError{}, failure.FromError(fmt.Errorf("incorrect name: %s, expected: %s", ge.Name(), AccountNotFoundErrorName))
+		}
+		return ge, nil
+	},
+)
+
+type GetReceipt receipt.Receipt[GetOk, GetError]
+type GetReceiptReader receipt.ReceiptReader[GetOk, GetError]
+
+func NewGetReceiptReader() (GetReceiptReader, error) {
+	return receipt.NewReceiptReaderFromTypes[GetOk, GetError](GetOkType(), GetErrorType(), types.Converters...)
+}
+
+var GetOkReader = schema.Struct[GetOk](GetOkType(), nil, types.Converters...)
+
+var Get = validator.NewCapability(
+	GetAbility,
+	schema.DIDString(),
+	GetCaveatsReader,
+	getDerives,
+)
+
+func getDerives(claimed, delegated ucan.Capability[GetCaveats]) failure.Failure {
+	if claimed.With() != delegated.With() {
+		return failure.FromError(fmt.Errorf("can not derive %s with %s from %s", claimed.Can(), claimed.With(), delegated.With()))
+	}
+
+	if delegated.Nb().Spaces != nil {
+		if claimed.Nb().Spaces == nil {
+			return failure.FromError(fmt.Errorf("constraint violation: violates imposed spaces constraint %v because it asks for all spaces", delegated.Nb().Spaces))
+		}
+
+		for _, s := range claimed.Nb().Spaces {
+			if !slices.Contains(delegated.Nb().Spaces, s) {
+				return failure.FromError(fmt.Errorf("constraint violation: violates imposed spaces constraint %v because it asks for space %s", delegated.Nb().Spaces, s))
+			}
+		}
+	}
+
+	if delegated.Nb().Period != nil {
+		if claimed.Nb().Period == nil {
+			return failure.FromError(fmt.Errorf("constraint violation: violates imposed period constraint %v because it doesn't have a period constraint", delegated.Nb().Period))
+		}
+		if claimed.Nb().Period.From.Before(delegated.Nb().Period.From) {
+			return failure.FromError(fmt.Errorf("constraint violation: violates imposed period constraint because it requests dates before %s", delegated.Nb().Period.From))
+		}
+		if claimed.Nb().Period.To.After(delegated.Nb().Period.To) {
+			return failure.FromError(fmt.Errorf("constraint violation: violates imposed period constraint because it requests dates after %s", delegated.Nb().Period.To))
+		}
+	}
+
+	return nil
+}

capabilities/account/egress/get_test.go

@@ -0,0 +1,91 @@
+package egress_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/storacha/go-libstoracha/capabilities/account/egress"
+	"github.com/storacha/go-libstoracha/testutil"
+	"github.com/storacha/go-ucanto/did"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestRoundTripGetCaveats(t *testing.T) {
+	t.Run("marshals and unmarshals correctly", func(t *testing.T) {
+		space1 := testutil.RandomDID(t)
+		space2 := testutil.RandomDID(t)
+
+		nb := egress.GetCaveats{
+			Spaces: []did.DID{space1, space2},
+			Period: &egress.Period{
+				From: time.UnixMilli(123000).UTC(),
+				To:   time.UnixMilli(456000).UTC(),
+			},
+		}
+
+		node, err := nb.ToIPLD()
+		require.NoError(t, err)
+
+		rnb, err := egress.GetCaveatsReader.Read(node)
+		require.NoError(t, err)
+		require.Equal(t, nb.Spaces[0].String(), rnb.Spaces[0].String())
+		require.Equal(t, nb.Spaces[1].String(), rnb.Spaces[1].String())
+		require.True(t, nb.Period.From.Equal(rnb.Period.From))
+		require.True(t, nb.Period.To.Equal(rnb.Period.To))
+	})
+
+	t.Run("properties are optional", func(t *testing.T) {
+		nb := egress.GetCaveats{}
+
+		node, err := nb.ToIPLD()
+		require.NoError(t, err)
+
+		rnb, err := egress.GetCaveatsReader.Read(node)
+		require.NoError(t, err)
+		require.Nil(t, rnb.Spaces)
+		require.Nil(t, rnb.Period)
+	})
+}
+
+func TestNewGetReceiptReader(t *testing.T) {
+	_, err := egress.NewGetReceiptReader()
+	require.NoError(t, err)
+}
+
+func TestRoundTripGetOk(t *testing.T) {
+	space1 := testutil.RandomDID(t)
+
+	ok := egress.GetOk{
+		Total: 1000,
+		Spaces: egress.SpacesModel{
+			Keys: []did.DID{space1},
+			Values: map[did.DID]egress.SpaceEgress{
+				space1: {
+					Total: 500,
+					DailyStats: []egress.DailyStats{
+						{
+							Date:   time.Now().Truncate(time.Second).UTC(),
+							Egress: 250,
+						},
+						{
+							Date:   time.Now().Add(-24 * time.Hour).Truncate(time.Second).UTC(),
+							Egress: 250,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	node, err := ok.ToIPLD()
+	require.NoError(t, err)
+
+	rok, err := egress.GetOkReader.Read(node)
+	require.NoError(t, err)
+	require.Equal(t, ok.Total, rok.Total)
+	require.Equal(t, len(ok.Spaces.Keys), len(rok.Spaces.Keys))
+	require.Equal(t, ok.Spaces.Values[space1].Total, rok.Spaces.Values[space1].Total)
+	require.Equal(t, len(ok.Spaces.Values[space1].DailyStats), len(rok.Spaces.Values[space1].DailyStats))
+	require.True(t, ok.Spaces.Values[space1].DailyStats[0].Date.Equal(rok.Spaces.Values[space1].DailyStats[0].Date))
+}

capabilities/account/egress/schema.go

@@ -0,0 +1,34 @@
+package egress
+
+import (
+	_ "embed"
+	"fmt"
+
+	"github.com/ipld/go-ipld-prime/schema"
+	captypes "github.com/storacha/go-libstoracha/capabilities/types"
+)
+
+//go:embed egress.ipldsch
+var egressSchema []byte
+
+var egressTS = mustLoadTS()
+
+func mustLoadTS() *schema.TypeSystem {
+	ts, err := captypes.LoadSchemaBytes(egressSchema)
+	if err != nil {
+		panic(fmt.Errorf("loading egress schema: %w", err))
+	}
+	return ts
+}
+
+func GetCaveatsType() schema.Type {
+	return egressTS.TypeByName("GetCaveats")
+}
+
+func GetOkType() schema.Type {
+	return egressTS.TypeByName("GetOk")
+}
+
+func GetErrorType() schema.Type {
+	return egressTS.TypeByName("GetError")
+}