Merge pull request #194 from planetlabs/auth

Add support for the authentication extension

Author: tschaub

catalog.go

@@ -34,12 +34,12 @@ func GetCatalogExtension(uri string) Extension {
 }
 
 func (catalog Catalog) MarshalJSON() ([]byte, error) {
-	collectionMap := map[string]any{
+	catalogMap := map[string]any{
 		"type": "Catalog",
 	}
 	decoder, decoderErr := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
 		TagName: "json",
-		Result:  &collectionMap,
+		Result:  &catalogMap,
 	})
 	if decoderErr != nil {
 		return nil, decoderErr
@@ -54,10 +54,10 @@ func (catalog Catalog) MarshalJSON() ([]byte, error) {
 	lookup := map[string]bool{}
 
 	for _, extension := range catalog.Extensions {
-		if err := extension.Encode(collectionMap); err != nil {
+		if err := extension.Encode(catalogMap); err != nil {
 			return nil, err
 		}
-		uris, err := GetExtensionUris(collectionMap)
+		uris, err := GetExtensionUris(catalogMap)
 		if err != nil {
 			return nil, err
 		}
@@ -70,13 +70,26 @@ func (catalog Catalog) MarshalJSON() ([]byte, error) {
 		}
 	}
 
-	SetExtensionUris(collectionMap, extensionUris)
-	return json.Marshal(collectionMap)
+	links, linkExtensionUris, err := EncodeLinks(catalog.Links)
+	if err != nil {
+		return nil, err
+	}
+	catalogMap["links"] = links
+
+	for _, uri := range linkExtensionUris {
+		if !lookup[uri] {
+			extensionUris = append(extensionUris, uri)
+			lookup[uri] = true
+		}
+	}
+
+	SetExtensionUris(catalogMap, extensionUris)
+	return json.Marshal(catalogMap)
 }
 
 func (catalog *Catalog) UnmarshalJSON(data []byte) error {
-	collectionMap := map[string]any{}
-	if err := json.Unmarshal(data, &collectionMap); err != nil {
+	catalogMap := map[string]any{}
+	if err := json.Unmarshal(data, &catalogMap); err != nil {
 		return err
 	}
 
@@ -88,11 +101,11 @@ func (catalog *Catalog) UnmarshalJSON(data []byte) error {
 		return decoderErr
 	}
 
-	if err := decoder.Decode(collectionMap); err != nil {
+	if err := decoder.Decode(catalogMap); err != nil {
 		return err
 	}
 
-	extensionUris, err := GetExtensionUris(collectionMap)
+	extensionUris, err := GetExtensionUris(catalogMap)
 	if err != nil {
 		return err
 	}
@@ -102,11 +115,15 @@ func (catalog *Catalog) UnmarshalJSON(data []byte) error {
 		if extension == nil {
 			continue
 		}
-		if err := extension.Decode(collectionMap); err != nil {
+		if err := extension.Decode(catalogMap); err != nil {
 			return fmt.Errorf("decoding error for %s: %w", uri, err)
 		}
 		catalog.Extensions = append(catalog.Extensions, extension)
 	}
 
+	if err := decodeExtendedLinks(catalogMap, catalog.Links, extensionUris); err != nil {
+		return err
+	}
+
 	return nil
 }

collection.go

@@ -95,6 +95,19 @@ func (collection Collection) MarshalJSON() ([]byte, error) {
 		}
 	}
 
+	links, linkExtensionUris, err := EncodeLinks(collection.Links)
+	if err != nil {
+		return nil, err
+	}
+	collectionMap["links"] = links
+
+	for _, uri := range linkExtensionUris {
+		if !lookup[uri] {
+			extensionUris = append(extensionUris, uri)
+			lookup[uri] = true
+		}
+	}
+
 	SetExtensionUris(collectionMap, extensionUris)
 	return json.Marshal(collectionMap)
 }
@@ -132,6 +145,10 @@ func (collection *Collection) UnmarshalJSON(data []byte) error {
 		collection.Extensions = append(collection.Extensions, extension)
 	}
 
+	if err := decodeExtendedLinks(collectionMap, collection.Links, extensionUris); err != nil {
+		return err
+	}
+
 	return nil
 }
 

extension.go

@@ -1,6 +1,7 @@
 package stac
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"slices"
@@ -141,24 +142,93 @@ func DecodeExtendedItemProperties(itemExtension Extension, itemMap map[string]an
 	return nil
 }
 
-func EncodeExtendedAsset(assetExtension Extension, assetMap map[string]any) error {
+func EncodeExtendedMap(extension Extension, data map[string]any) error {
 	encoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
 		TagName: "json",
-		Result:  &assetMap,
+		Result:  &data,
 	})
 	if err != nil {
 		return err
 	}
-	return encoder.Decode(assetExtension)
+	return encoder.Decode(extension)
 }
 
-func DecodeExtendedAsset(assetExtension Extension, assetMap map[string]any) error {
+func DecodeExtendedMap(extension Extension, data map[string]any) error {
 	decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
 		TagName: "json",
-		Result:  assetExtension,
+		Result:  extension,
 	})
 	if err != nil {
 		return err
 	}
-	return decoder.Decode(assetMap)
+	return decoder.Decode(data)
 }
+
+func decodeExtendedLinks(data map[string]any, links []*Link, extensionUris []string) error {
+	linksValue, ok := data["links"]
+	if !ok {
+		return nil
+	}
+	linksData, ok := linksValue.([]any)
+	if !ok {
+		return fmt.Errorf("unexpected type for links: %t", linksValue)
+	}
+
+	for i, link := range links {
+		for _, uri := range extensionUris {
+			extension := GetLinkExtension(uri)
+			if extension == nil {
+				continue
+			}
+			linkMap, ok := linksData[i].(map[string]any)
+			if !ok {
+				return fmt.Errorf("unexpected type for %q link: %t", i, linksData[i])
+			}
+			if err := extension.Decode(linkMap); err != nil {
+				if errors.Is(err, ErrExtensionDoesNotApply) {
+					continue
+				}
+				return fmt.Errorf("decoding error for %s: %w", uri, err)
+			}
+			link.Extensions = append(link.Extensions, extension)
+		}
+	}
+
+	return nil
+}
+
+func decodeExtendedAssets(data map[string]any, assets map[string]*Asset, extensionUris []string) error {
+	assetsValue, ok := data["assets"]
+	if !ok {
+		return nil
+	}
+	assetsMap, ok := assetsValue.(map[string]any)
+	if !ok {
+		return fmt.Errorf("unexpected type for assets: %t", assetsValue)
+	}
+
+	for key, asset := range assets {
+		for _, uri := range extensionUris {
+			extension := GetAssetExtension(uri)
+			if extension == nil {
+				continue
+			}
+			assetMap, ok := assetsMap[key].(map[string]any)
+			if !ok {
+				return fmt.Errorf("unexpected type for %q asset: %t", key, assetsMap[key])
+			}
+			if err := extension.Decode(assetMap); err != nil {
+				if errors.Is(err, ErrExtensionDoesNotApply) {
+					continue
+				}
+				return fmt.Errorf("decoding error for %s: %w", uri, err)
+			}
+			asset.Extensions = append(asset.Extensions, extension)
+		}
+	}
+
+	return nil
+}
+
+// ErrExtensionDoesNotApply is returned when decoding JSON and an extension referenced in stac_extensions does not apply to a value.
+var ErrExtensionDoesNotApply = errors.New("extension does not apply")

extensions/auth/auth.go

@@ -0,0 +1,159 @@
+package auth
+
+import (
+	"fmt"
+	"regexp"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/planetlabs/go-stac"
+)
+
+const (
+	extensionUri     = "https://stac-extensions.github.io/authentication/v1.1.0/schema.json"
+	extensionPattern = `https://stac-extensions.github.io/authentication/v1\..*/schema.json`
+	schemesKey       = "auth:schemes"
+	refsKey          = "auth:refs"
+)
+
+func init() {
+	r := regexp.MustCompile(extensionPattern)
+
+	stac.RegisterCollectionExtension(r, func() stac.Extension { return &Collection{} })
+	stac.RegisterCatalogExtension(r, func() stac.Extension { return &Catalog{} })
+	stac.RegisterAssetExtension(r, func() stac.Extension { return &Asset{} })
+	stac.RegisterLinkExtension(r, func() stac.Extension { return &Link{} })
+}
+
+type Collection struct {
+	Schemes map[string]*Scheme
+}
+
+var _ stac.Extension = (*Collection)(nil)
+
+func (*Collection) URI() string {
+	return extensionUri
+}
+
+func (e *Collection) Encode(collectionMap map[string]any) error {
+	collectionMap[schemesKey] = e.Schemes
+	return nil
+}
+
+func (e *Collection) Decode(collectionMap map[string]any) error {
+	schemes, err := decodeSchemes(collectionMap)
+	if err != nil {
+		return err
+	}
+	e.Schemes = schemes
+	return nil
+}
+
+type Catalog struct {
+	Schemes map[string]*Scheme
+}
+
+var _ stac.Extension = (*Catalog)(nil)
+
+func (*Catalog) URI() string {
+	return extensionUri
+}
+
+func (e *Catalog) Encode(catalogMap map[string]any) error {
+	catalogMap[schemesKey] = e.Schemes
+	return nil
+}
+
+func (e *Catalog) Decode(catalogMap map[string]any) error {
+	schemes, err := decodeSchemes(catalogMap)
+	if err != nil {
+		return err
+	}
+	e.Schemes = schemes
+	return nil
+}
+
+func decodeSchemes(data map[string]any) (map[string]*Scheme, error) {
+	schemesValue, ok := data[schemesKey]
+	if !ok {
+		return nil, nil
+	}
+
+	schemesMap, ok := schemesValue.(map[string]any)
+	if !ok {
+		return nil, fmt.Errorf("expected %s to be an map[string]any, got %t", schemesKey, schemesValue)
+	}
+
+	schemes := map[string]*Scheme{}
+	for key, schemeValue := range schemesMap {
+		schemeMap, ok := schemeValue.(map[string]any)
+		if !ok {
+			return nil, fmt.Errorf("expected scheme to be a map[string]any, got %t", schemeValue)
+		}
+		scheme := &Scheme{}
+		decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
+			TagName: "json",
+			Result:  scheme,
+		})
+		if err != nil {
+			return nil, err
+		}
+		if err := decoder.Decode(schemeMap); err != nil {
+			return nil, err
+		}
+
+		schemes[key] = scheme
+	}
+	return schemes, nil
+}
+
+type Scheme struct {
+	Type             string         `json:"type"`
+	Description      string         `json:"description,omitempty"`
+	Name             string         `json:"name,omitempty"`
+	In               string         `json:"in,omitempty"`
+	Scheme           string         `json:"scheme,omitempty"`
+	Flows            map[string]any `json:"flows,omitempty"`
+	OpenIdConnectUrl string         `json:"openIdConnectUrl,omitempty"`
+}
+
+type Asset struct {
+	Refs []string `json:"auth:refs,omitempty"`
+}
+
+var _ stac.Extension = (*Asset)(nil)
+
+func (*Asset) URI() string {
+	return extensionUri
+}
+
+func (e *Asset) Encode(assetMap map[string]any) error {
+	return stac.EncodeExtendedMap(e, assetMap)
+}
+
+func (e *Asset) Decode(assetMap map[string]any) error {
+	if _, ok := assetMap[refsKey]; !ok {
+		return stac.ErrExtensionDoesNotApply
+	}
+	return stac.DecodeExtendedMap(e, assetMap)
+}
+
+type Link struct {
+	Refs []string `json:"auth:refs,omitempty"`
+}
+
+var _ stac.Extension = (*Link)(nil)
+
+func (*Link) URI() string {
+	return extensionUri
+}
+
+func (e *Link) Encode(linkMap map[string]any) error {
+	return stac.EncodeExtendedMap(e, linkMap)
+}
+
+func (e *Link) Decode(linkMap map[string]any) error {
+	if _, ok := linkMap[refsKey]; !ok {
+		return stac.ErrExtensionDoesNotApply
+	}
+	return stac.DecodeExtendedMap(e, linkMap)
+}