fix(cli): reduce number of api calls for suga build (#112)

Author: tjholm

cli/internal/api/build.go

@@ -0,0 +1,75 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/url"
+
+	"github.com/nitrictech/suga/cli/internal/version"
+	"github.com/nitrictech/suga/engines/terraform"
+)
+
+// GetBuildManifest fetches the platform and all its plugins in a single call
+func (c *SugaApiClient) GetBuildManifest(team, platform string, revision int) (*terraform.PlatformSpec, map[string]map[string]any, error) {
+	response, err := c.get(fmt.Sprintf("/api/teams/%s/platforms/%s/revisions/%d/build-manifest", url.PathEscape(team), url.PathEscape(platform), revision), true)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != 200 {
+		if response.StatusCode == 404 {
+			return nil, nil, ErrNotFound
+		}
+
+		if response.StatusCode == 401 {
+			return nil, nil, ErrUnauthenticated
+		}
+
+		return nil, nil, fmt.Errorf("received non 200 response from %s build manifest endpoint: %d", version.ProductName, response.StatusCode)
+	}
+
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to read response from %s build manifest endpoint: %v", version.ProductName, err)
+	}
+
+	var buildManifest GetBuildManifestResponse
+	err = json.Unmarshal(body, &buildManifest)
+	if err != nil {
+		return nil, nil, fmt.Errorf("unexpected response from %s build manifest endpoint: %v", version.ProductName, err)
+	}
+
+	return buildManifest.Platform, buildManifest.Plugins, nil
+}
+
+// GetPublicBuildManifest fetches the platform and all its plugins for a public platform
+func (c *SugaApiClient) GetPublicBuildManifest(team, platform string, revision int) (*terraform.PlatformSpec, map[string]map[string]any, error) {
+	response, err := c.get(fmt.Sprintf("/api/public/platforms/%s/%s/revisions/%d/build-manifest", url.PathEscape(team), url.PathEscape(platform), revision), true)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != 200 {
+		if response.StatusCode == 404 {
+			return nil, nil, ErrNotFound
+		}
+
+		return nil, nil, fmt.Errorf("received non 200 response from %s public build manifest endpoint: %d", version.ProductName, response.StatusCode)
+	}
+
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to read response from %s public build manifest endpoint: %v", version.ProductName, err)
+	}
+
+	var buildManifest GetBuildManifestResponse
+	err = json.Unmarshal(body, &buildManifest)
+	if err != nil {
+		return nil, nil, fmt.Errorf("unexpected response from %s public build manifest endpoint: %v", version.ProductName, err)
+	}
+
+	return buildManifest.Platform, buildManifest.Plugins, nil
+}

cli/internal/api/models.go

@@ -195,6 +195,12 @@ type GetPluginManifestResponse struct {
 	Manifest map[string]interface{} `json:"manifest"`
 }
 
+// Build manifest DTOs
+type GetBuildManifestResponse struct {
+	Platform *terraform.PlatformSpec       `json:"platform"`
+	Plugins  map[string]map[string]any `json:"plugins"` // key format: "team/library/version/name"
+}
+
 // Team DTOs from backend
 type CreateTeamRequest struct {
 	Name string `json:"name"`

cli/internal/build/build.go

@@ -6,10 +6,10 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strings"
 	"time"
 
 	"github.com/nitrictech/suga/cli/internal/api"
-	"github.com/nitrictech/suga/cli/internal/platforms"
 	"github.com/nitrictech/suga/cli/internal/plugins"
 	"github.com/nitrictech/suga/cli/pkg/schema"
 	"github.com/nitrictech/suga/engines/terraform"
@@ -30,21 +30,29 @@ func sanitizeForFilename(input string) string {
 	return re.ReplaceAllString(input, "_")
 }
 
-
 func (b *BuilderService) BuildProject(appSpec *schema.Application, currentTeam string) (string, error) {
-	platformRepository := platforms.NewPlatformRepository(b.apiClient, currentTeam)
-
 	if appSpec.Target == "" {
 		return "", fmt.Errorf("no target specified in project %s", appSpec.Name)
 	}
 
-	platform, err := terraform.PlatformFromId(b.fs, appSpec.Target, platformRepository)
+	var pluginRepo terraform.PluginRepository = plugins.NewPluginRepository(b.apiClient, currentTeam)
+	var platformRepo terraform.PlatformRepository = nil
+	if !strings.HasPrefix(appSpec.Target, terraform.PlatformReferencePrefix_File) {
+		repo, err := NewRepository(b.apiClient, currentTeam, appSpec.Target)
+		if err != nil {
+			return "", err
+		}
+		// Use the original repositories
+		pluginRepo = repo
+		platformRepo = repo
+	}
+
+	platform, err := terraform.PlatformFromId(b.fs, appSpec.Target, platformRepo)
 	if err != nil {
 		return "", err
 	}
 
-	repo := plugins.NewPluginRepository(b.apiClient, currentTeam)
-	engine := terraform.New(platform, terraform.WithRepository(repo))
+	engine := terraform.New(platform, terraform.WithRepository(pluginRepo))
 
 	stackPath, err := engine.Apply(appSpec)
 	if err != nil {

cli/internal/build/repository.go

@@ -0,0 +1,212 @@
+package build
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+
+	"github.com/nitrictech/suga/cli/internal/api"
+	"github.com/nitrictech/suga/cli/internal/version"
+	"github.com/nitrictech/suga/engines/terraform"
+)
+
+// Repository fetches both platform and plugins in a single API call at construction time
+type Repository struct {
+	apiClient   *api.SugaApiClient
+	currentTeam string
+	// The platform reference this repository was created for
+	platformRef string
+	// Cached platform spec and plugin manifests
+	platformSpec    *terraform.PlatformSpec
+	pluginManifests map[string]map[string]any
+}
+
+var _ terraform.PlatformRepository = (*Repository)(nil)
+var _ terraform.PluginRepository = (*Repository)(nil)
+
+// NewRepository creates a repository and fetches the platform and all its plugins upfront
+func NewRepository(apiClient *api.SugaApiClient, currentTeam, platformRef string) (*Repository, error) {
+	repo := &Repository{
+		apiClient:   apiClient,
+		currentTeam: currentTeam,
+		platformRef: platformRef,
+	}
+
+	// Fetch platform and plugins immediately
+	if err := repo.fetchPlatformAndPlugins(platformRef); err != nil {
+		return nil, err
+	}
+
+	return repo, nil
+}
+
+// GetPlatform validates that the requested platform matches the one this repository was created for
+func (r *Repository) GetPlatform(name string) (*terraform.PlatformSpec, error) {
+	// Validate that the requested platform matches what we fetched
+	if name != r.platformRef {
+		return nil, fmt.Errorf("repository was created for platform %s but %s was requested", r.platformRef, name)
+	}
+
+	return r.platformSpec, nil
+}
+
+// fetchPlatformAndPlugins fetches the platform and all its plugins in a single API call
+func (r *Repository) fetchPlatformAndPlugins(name string) error {
+	// Parse the platform name <team>/<platform>@<revision>
+	re := regexp.MustCompile(`^(?P<team>[a-z][a-z0-9-]*)/(?P<platform>[a-z][a-z0-9-]*)@(?P<revision>\d+)$`)
+	matches := re.FindStringSubmatch(name)
+
+	if matches == nil {
+		return fmt.Errorf("invalid platform name format: %s. Expected format: <team>/<platform>@<revision> e.g. %s/aws@1", name, version.CommandName)
+	}
+
+	team := matches[re.SubexpIndex("team")]
+	platform := matches[re.SubexpIndex("platform")]
+	revisionStr := matches[re.SubexpIndex("revision")]
+
+	revision, err := strconv.Atoi(revisionStr)
+	if err != nil {
+		return fmt.Errorf("invalid revision format: %s. Expected integer", revisionStr)
+	}
+
+	// Smart ordering: try public first if the platform team doesn't match current user's team
+	var platformSpec *terraform.PlatformSpec
+	var plugins map[string]map[string]any
+
+	if team != r.currentTeam {
+		// Try public access first
+		platformSpec, plugins, err = r.apiClient.GetPublicBuildManifest(team, platform, revision)
+		if err == nil {
+			r.platformSpec = platformSpec
+			r.pluginManifests = plugins
+			return nil
+		}
+
+		// If public fails with 404, it's definitely not found
+		if errors.Is(err, api.ErrNotFound) {
+			return terraform.ErrPlatformNotFound
+		}
+
+		// If public fails for other reasons, try authenticated access
+		platformSpec, plugins, err = r.apiClient.GetBuildManifest(team, platform, revision)
+		if err != nil {
+			if errors.Is(err, api.ErrNotFound) {
+				return terraform.ErrPlatformNotFound
+			}
+			if errors.Is(err, api.ErrUnauthenticated) {
+				return terraform.ErrUnauthenticated
+			}
+			return err
+		}
+		r.platformSpec = platformSpec
+		r.pluginManifests = plugins
+		return nil
+	}
+
+	// Try authenticated access first
+	platformSpec, plugins, err = r.apiClient.GetBuildManifest(team, platform, revision)
+	if err != nil {
+		// If authentication failed, try public platform access
+		if errors.Is(err, api.ErrUnauthenticated) || errors.Is(err, api.ErrNotFound) {
+			platformSpec, plugins, err = r.apiClient.GetPublicBuildManifest(team, platform, revision)
+			if err != nil {
+				// If public access also fails with 404, return platform not found
+				if errors.Is(err, api.ErrNotFound) {
+					return terraform.ErrPlatformNotFound
+				}
+				// Return the original authentication error for other public access failures
+				return terraform.ErrUnauthenticated
+			}
+			r.platformSpec = platformSpec
+			r.pluginManifests = plugins
+			return nil
+		}
+
+		// If its a 404, then return platform not found error
+		if errors.Is(err, api.ErrNotFound) {
+			return terraform.ErrPlatformNotFound
+		}
+
+		// return the original error to the engine
+		return err
+	}
+
+	r.platformSpec = platformSpec
+	r.pluginManifests = plugins
+	return nil
+}
+
+// GetResourcePlugin retrieves a cached plugin manifest
+func (r *Repository) GetResourcePlugin(team, libname, version, name string) (*terraform.ResourcePluginManifest, error) {
+	pluginManifest, err := r.getPluginManifest(team, libname, version, name)
+	if err != nil {
+		return nil, err
+	}
+
+	resourcePluginManifest, ok := pluginManifest.(*terraform.ResourcePluginManifest)
+	if !ok {
+		return nil, fmt.Errorf("encountered malformed manifest for plugin %s/%s/%s@%s", team, libname, name, version)
+	}
+
+	return resourcePluginManifest, nil
+}
+
+// GetIdentityPlugin retrieves a cached plugin manifest
+func (r *Repository) GetIdentityPlugin(team, libname, version, name string) (*terraform.IdentityPluginManifest, error) {
+	pluginManifest, err := r.getPluginManifest(team, libname, version, name)
+	if err != nil {
+		return nil, err
+	}
+
+	identityPluginManifest, ok := pluginManifest.(*terraform.IdentityPluginManifest)
+	if !ok {
+		return nil, fmt.Errorf("encountered malformed manifest for plugin %s/%s/%s@%s", team, libname, name, version)
+	}
+
+	return identityPluginManifest, nil
+}
+
+// getPluginManifest retrieves a plugin manifest from the cache
+func (r *Repository) getPluginManifest(team, libname, version, name string) (any, error) {
+	if r.pluginManifests == nil {
+		return nil, fmt.Errorf("no plugin manifests cached. GetPlatform must be called first")
+	}
+
+	key := fmt.Sprintf("%s/%s/%s/%s", team, libname, version, name)
+	manifestData, ok := r.pluginManifests[key]
+	if !ok {
+		return nil, fmt.Errorf("plugin %s not found in build manifest", key)
+	}
+
+	// Check the type field to determine which manifest type to use
+	pluginType, ok := manifestData["type"].(string)
+	if !ok {
+		return nil, fmt.Errorf("plugin manifest missing type field for %s", key)
+	}
+
+	if pluginType == "identity" {
+		var identityManifest terraform.IdentityPluginManifest
+		if err := remapToStruct(manifestData, &identityManifest); err != nil {
+			return nil, fmt.Errorf("failed to parse identity plugin manifest for %s: %w", key, err)
+		}
+		return &identityManifest, nil
+	}
+
+	var resourceManifest terraform.ResourcePluginManifest
+	if err := remapToStruct(manifestData, &resourceManifest); err != nil {
+		return nil, fmt.Errorf("failed to parse resource plugin manifest for %s: %w", key, err)
+	}
+	return &resourceManifest, nil
+}
+
+// remapToStruct is a helper to convert map[string]any to a struct
+// This is a simple implementation using JSON marshaling
+func remapToStruct(m map[string]any, target any) error {
+	bytes, err := json.Marshal(m)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(bytes, target)
+}