DRAFT feat(domains): api domain options

src/pkg/common/schemas/validation.json

@@ -362,8 +362,45 @@
                             "url": {
                                 "type": "string",
                                 "format": "uri"
+                            },
+                            "method": {
+                                "type": "string",
+                                "enum": ["Get", "Head", "Post", "PostForm"],
+                                "default": "Get"
+                            },
+                            "body": {
+                                "type": "string"
+                            },
+                            "parameters": {
+                                "type": "object",
+                                "additionalProperties": { "type": "string"}
+                            },
+                            "options": {
+                                "$ref": "#/definitions/api-options"
                             }
                         }
+                    },
+                    "required": ["name", "url"]
+                },
+                "options": {
+                    "$ref": "#/definitions/api-options"
+                }
+            },
+            "required": ["requests"]
+        },
+        "api-options": {
+            "type": "object",
+            "properties": {
+                "timeout": {
+                    "type": "integer"
+                },
+                "proxy": {
+                    "type": "string"
+                },
+                "headers": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
                     }
                 }
             }

src/pkg/domains/api/api.go

@@ -2,22 +2,44 @@
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
+	"time"
 
 	"github.com/defenseunicorns/lula/src/types"
 )
 
-func MakeRequests(Requests []Request) (types.DomainResources, error) {
+func (a ApiDomain) makeRequests(_ context.Context) (types.DomainResources, error) {
 	collection := make(map[string]interface{}, 0)
 
-	for _, request := range Requests {
-		transport := &http.Transport{}
-		client := &http.Client{Transport: transport}
+	var defaultOpts *ApiOpts
+	if a.Spec.Options == nil {
+		defaultOpts = new(ApiOpts)
+	} else {
+		defaultOpts = a.Spec.Options
+	}
+
+	// configure the default HTTP client using any top-level Options. Individual requests with overrides will get bespoke clients.
+	transport := &http.Transport{}
+	if defaultOpts.Proxy != "" {
+		proxy, err := url.Parse(a.Spec.Options.Proxy)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing proxy url: %s", err)
+		}
+		transport.Proxy = http.ProxyURL(proxy)
+	}
+
+	defaultClient := &http.Client{Transport: transport}
+	if defaultOpts.Timeout != 0 {
+		defaultClient.Timeout = time.Duration(defaultOpts.Timeout) * time.Second
+	}
 
-		resp, err := client.Get(request.URL)
+	for _, request := range a.Spec.Requests {
+		resp, err := defaultClient.Get(request.URL)
 		if err != nil {
 			return nil, err
 		}

src/pkg/domains/api/spec.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"errors"
+	"fmt"
+)
+
+func validateSpec(spec *ApiSpec) error {
+	if spec == nil {
+		return errors.New("spec is required")
+	}
+	if len(spec.Requests) == 0 {
+		return errors.New("some requests must be specified")
+	}
+	for _, request := range spec.Requests {
+		if request.Name == "" {
+			return errors.New("request name cannot be empty")
+		}
+		if request.URL == "" {
+			return errors.New("request url cannot be empty")
+		}
+		if request.Method != "" {
+			if request.Method != "Get" && request.Method != "Head" && request.Method != "Post" && request.Method != "PostForm" {
+				return fmt.Errorf("unsupported method: %s", request.Method)
+			}
+		}
+	}
+	return nil
+}

src/pkg/domains/api/types.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/defenseunicorns/lula/src/types"
 )
@@ -15,29 +14,18 @@ type ApiDomain struct {
 
 func CreateApiDomain(spec *ApiSpec) (types.Domain, error) {
 	// Check validity of spec
-	if spec == nil {
-		return nil, fmt.Errorf("spec is nil")
-	}
-
-	if len(spec.Requests) == 0 {
-		return nil, fmt.Errorf("some requests must be specified")
-	}
-	for _, request := range spec.Requests {
-		if request.Name == "" {
-			return nil, fmt.Errorf("request name cannot be empty")
-		}
-		if request.URL == "" {
-			return nil, fmt.Errorf("request url cannot be empty")
-		}
+	err := validateSpec(spec)
+	if err != nil {
+		return nil, err
 	}
 
 	return ApiDomain{
 		Spec: spec,
 	}, nil
 }
 
-func (a ApiDomain) GetResources(_ context.Context) (types.DomainResources, error) {
-	return MakeRequests(a.Spec.Requests)
+func (a ApiDomain) GetResources(ctx context.Context) (types.DomainResources, error) {
+	return a.makeRequests(ctx)
 }
 
 func (a ApiDomain) IsExecutable() bool {
@@ -48,10 +36,25 @@ func (a ApiDomain) IsExecutable() bool {
 // ApiSpec contains a list of API requests
 type ApiSpec struct {
 	Requests []Request `mapstructure:"requests" json:"requests" yaml:"requests"`
+	// Opts will be applied to all requests, except those which have their own specified ApiOpts
+	Options *ApiOpts `mapstructure:"options" json:"options,omitempty" yaml:"options,omitempty"`
 }
 
 // Request is a single API request
 type Request struct {
-	Name string `json:"name" yaml:"name"`
-	URL  string `json:"url" yaml:"url"`
+	Name         string            `json:"name" yaml:"name"`
+	URL          string            `json:"url" yaml:"url"`
+	Method       string            `json:"method,omitempty" yaml:"method,omitempty"`
+	IsExecutable bool              `json:"executable,omitempty" yaml:"executable,omitempty"`
+	Body         string            `json:"body,omitempty" yaml:"body,omitempty"`
+	Params       map[string]string `json:"parameters,omitempty" yaml:"parameters,omitempty"`
+	// ApiOpts specific to this request
+	Options *ApiOpts `json:"options,omitempty" yaml:"options,omitempty"`
+}
+
+type ApiOpts struct {
+	// Timeout in seconds
+	Timeout string   `json:"timeout,omitempty" yaml:"timeout,omitempty"`
+	Proxy   string   `json:"proxy,omitempty" yaml:"proxy,omitempty"`
+	Headers []string `json:"headers,omitempty" yaml:"headers,omitempty"`
 }