fix(cli): make subtypes conditionally required (#126)

Author: tjholm

cli/pkg/app/suga.go

@@ -465,7 +465,7 @@ func (c *SugaApp) Build() error {
 		return nil
 	}
 
-	appSpec, err := schema.LoadFromFile(c.fs, version.ConfigFileName, true)
+	appSpec, err := schema.LoadFromFile(c.fs, version.ConfigFileName, true, schema.WithRequireSubtypes())
 	if err != nil {
 		return err
 	}

cli/pkg/schema/file.go

@@ -10,7 +10,7 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func LoadFromFile(fs afero.Fs, path string, validate bool) (*Application, error) {
+func LoadFromFile(fs afero.Fs, path string, validate bool, validationOpts ...ValidationOption) (*Application, error) {
 	if exists, err := afero.Exists(fs, path); err != nil {
 		return nil, fmt.Errorf("%s application file could not be loaded at path: %s", version.ProductName, path)
 	} else if !exists {
@@ -46,7 +46,7 @@ func LoadFromFile(fs afero.Fs, path string, validate bool) (*Application, error)
 		validationErrors = append(validationErrors, GetSchemaValidationErrors(results.Errors())...)
 	}
 
-	if appSpecErrors := appSpec.IsValid(); len(appSpecErrors) > 0 {
+	if appSpecErrors := appSpec.IsValid(validationOpts...); len(appSpecErrors) > 0 {
 		validationErrors = append(validationErrors, GetSchemaValidationErrors(appSpecErrors)...)
 	}
 

cli/pkg/schema/schema_test.go

@@ -518,3 +518,85 @@ websites:
 	assert.Contains(t, errString, "main-api:    # <-- entrypoint name main-api must be in snake_case format")
 	assert.Contains(t, errString, "user-db:    # <-- database name user-db must be in snake_case format")
 }
+
+func TestApplication_IsValid_SubtypesOptional(t *testing.T) {
+	app := &Application{
+		Name:   "test-app",
+		Target: "team/platform@1",
+		ServiceIntents: map[string]*ServiceIntent{
+			"api": {
+				Container: Container{
+					Docker: &Docker{Dockerfile: "Dockerfile"},
+				},
+			},
+		},
+		BucketIntents: map[string]*BucketIntent{
+			"storage": {},
+		},
+		EntrypointIntents: map[string]*EntrypointIntent{
+			"main": {
+				Routes: map[string]Route{
+					"/": {TargetName: "api"},
+				},
+			},
+		},
+		DatabaseIntents: map[string]*DatabaseIntent{
+			"users": {EnvVarKey: "DATABASE_URL"},
+		},
+	}
+
+	// Without WithRequireSubtypes, validation should pass
+	violations := app.IsValid()
+	assert.Len(t, violations, 0, "Expected no violations without RequireSubtypes option, got: %v", violations)
+
+	// With WithRequireSubtypes, validation should fail
+	violations = app.IsValid(WithRequireSubtypes())
+	assert.NotEmpty(t, violations, "Expected violations with RequireSubtypes option")
+
+	errString := FormatValidationErrors(GetSchemaValidationErrors(violations))
+	assert.Contains(t, errString, "api:    # <-- service must have a subtype specified for build")
+	assert.Contains(t, errString, "storage:    # <-- bucket must have a subtype specified for build")
+	assert.Contains(t, errString, "main:    # <-- entrypoint must have a subtype specified for build")
+	assert.Contains(t, errString, "users:    # <-- database must have a subtype specified for build")
+}
+
+func TestApplication_IsValid_WithSubtypes(t *testing.T) {
+	app := &Application{
+		Name:   "test-app",
+		Target: "team/platform@1",
+		ServiceIntents: map[string]*ServiceIntent{
+			"api": {
+				Resource: Resource{SubType: "fargate"},
+				Container: Container{
+					Docker: &Docker{Dockerfile: "Dockerfile"},
+				},
+			},
+		},
+		BucketIntents: map[string]*BucketIntent{
+			"storage": {
+				Resource: Resource{SubType: "s3"},
+			},
+		},
+		EntrypointIntents: map[string]*EntrypointIntent{
+			"main": {
+				Resource: Resource{SubType: "alb"},
+				Routes: map[string]Route{
+					"/": {TargetName: "api"},
+				},
+			},
+		},
+		DatabaseIntents: map[string]*DatabaseIntent{
+			"users": {
+				Resource:  Resource{SubType: "postgres"},
+				EnvVarKey: "DATABASE_URL",
+			},
+		},
+	}
+
+	// With subtypes specified, validation should pass with or without RequireSubtypes
+	violations := app.IsValid()
+	assert.Len(t, violations, 0, "Expected no violations without RequireSubtypes option, got: %v", violations)
+
+	violations = app.IsValid(WithRequireSubtypes())
+	assert.Len(t, violations, 0, "Expected no violations with RequireSubtypes option, got: %v", violations)
+}

cli/pkg/schema/validate.go

@@ -9,8 +9,31 @@ import (
 	"github.com/xeipuuv/gojsonschema"
 )
 
+// ValidationOptions defines options for application validation
+type ValidationOptions struct {
+	RequireSubtypes bool
+}
+
+// ValidationOption is a function that modifies ValidationOptions
+type ValidationOption func(*ValidationOptions)
+
+// WithRequireSubtypes enables validation that requires all resources to have subtypes
+func WithRequireSubtypes() ValidationOption {
+	return func(opts *ValidationOptions) {
+		opts.RequireSubtypes = true
+	}
+}
+
 // Perform additional validation checks on the application
-func (a *Application) IsValid() []gojsonschema.ResultError {
+func (a *Application) IsValid(options ...ValidationOption) []gojsonschema.ResultError {
+	opts := &ValidationOptions{
+		RequireSubtypes: false, // default: subtypes are optional
+	}
+
+	for _, option := range options {
+		option(opts)
+	}
+
 	// Check the names of all resources are unique
 	violations := a.checkNoNameConflicts()
 	violations = append(violations, a.checkNoReservedNames()...)
@@ -19,6 +42,10 @@ func (a *Application) IsValid() []gojsonschema.ResultError {
 	violations = append(violations, a.checkAccessPermissions()...)
 	violations = append(violations, a.checkNoRedundantEntrypointRoutes()...)
 
+	if opts.RequireSubtypes {
+		violations = append(violations, a.checkSubtypesRequired()...)
+	}
+
 	return violations
 }
 
@@ -199,3 +226,33 @@ func (a *Application) checkNoRedundantEntrypointRoutes() []gojsonschema.ResultEr
 
 	return violations
 }
+
+func (a *Application) checkSubtypesRequired() []gojsonschema.ResultError {
+	violations := []gojsonschema.ResultError{}
+
+	for name, intent := range a.ServiceIntents {
+		if intent.GetSubType() == "" {
+			violations = append(violations, newValidationError(fmt.Sprintf("services.%s", name), "service must have a subtype specified for build"))
+		}
+	}
+
+	for name, intent := range a.BucketIntents {
+		if intent.GetSubType() == "" {
+			violations = append(violations, newValidationError(fmt.Sprintf("buckets.%s", name), "bucket must have a subtype specified for build"))
+		}
+	}
+
+	for name, intent := range a.EntrypointIntents {
+		if intent.GetSubType() == "" {
+			violations = append(violations, newValidationError(fmt.Sprintf("entrypoints.%s", name), "entrypoint must have a subtype specified for build"))
+		}
+	}
+
+	for name, intent := range a.DatabaseIntents {
+		if intent.GetSubType() == "" {
+			violations = append(violations, newValidationError(fmt.Sprintf("databases.%s", name), "database must have a subtype specified for build"))
+		}
+	}
+
+	return violations
+}