github.com/storacha/go-ucanto@v0.7.2/validator/authorization.go (about)

     1  package validator
     2  
     3  import (
     4  	"github.com/storacha/go-ucanto/core/delegation"
     5  	"github.com/storacha/go-ucanto/ucan"
     6  )
     7  
     8  type Authorization[Caveats any] interface {
     9  	Audience() ucan.Principal
    10  	Capability() ucan.Capability[Caveats]
    11  	Delegation() delegation.Delegation
    12  	Issuer() ucan.Principal
    13  	Proofs() []Authorization[Caveats]
    14  }
    15  
    16  type authorization[Caveats any] struct {
    17  	match  Match[Caveats]
    18  	proofs []Authorization[Caveats]
    19  }
    20  
    21  func (a authorization[Caveats]) Audience() ucan.Principal {
    22  	return a.Delegation().Audience()
    23  }
    24  
    25  func (a authorization[Caveats]) Capability() ucan.Capability[Caveats] {
    26  	return a.match.Value()
    27  }
    28  
    29  func (a authorization[Caveats]) Delegation() delegation.Delegation {
    30  	return a.match.Source()[0].Delegation()
    31  }
    32  
    33  func (a authorization[Caveats]) Issuer() ucan.Principal {
    34  	return a.Delegation().Issuer()
    35  }
    36  
    37  func (a authorization[Caveats]) Proofs() []Authorization[Caveats] {
    38  	return a.proofs
    39  }
    40  
    41  func NewAuthorization[Caveats any](match Match[Caveats], proofs []Authorization[Caveats]) Authorization[Caveats] {
    42  	return authorization[Caveats]{match, proofs}
    43  }
    44  
    45  type unknownauth[C any] struct {
    46  	auth Authorization[C]
    47  }
    48  
    49  func (a unknownauth[C]) Audience() ucan.Principal {
    50  	return a.auth.Audience()
    51  }
    52  
    53  func (a unknownauth[C]) Capability() ucan.Capability[any] {
    54  	cap := a.auth.Capability()
    55  	return ucan.NewCapability[any](cap.Can(), cap.With(), cap.Nb())
    56  }
    57  
    58  func (a unknownauth[C]) Delegation() delegation.Delegation {
    59  	return a.auth.Delegation()
    60  }
    61  
    62  func (a unknownauth[C]) Issuer() ucan.Principal {
    63  	return a.Delegation().Issuer()
    64  }
    65  
    66  func (a unknownauth[C]) Proofs() []Authorization[any] {
    67  	var prf []Authorization[any]
    68  	for _, p := range a.auth.Proofs() {
    69  		prf = append(prf, ConvertUnknownAuthorization(p))
    70  	}
    71  	return prf
    72  }
    73  
    74  // ConvertUnknownAuthorization converts an Authorization[Caveats] to Authorization[any]
    75  func ConvertUnknownAuthorization[Caveats any](auth Authorization[Caveats]) Authorization[any] {
    76  	return unknownauth[Caveats]{auth}
    77  }