validate fields for property refs and produce config errors repoty

pkg/engine2/cli.go

@@ -287,6 +287,18 @@ func (em *EngineMain) RunEngine(cmd *cobra.Command, args []string) error {
 	},
 	)
 
+	configErrors := em.Engine.getPropertyValidation(context.Solutions[0])
+	if len(configErrors) > 0 {
+		configErrorData, err := json.Marshal(configErrors)
+		if err != nil {
+			return errors.Errorf("failed to marshal config errors: %s", err.Error())
+		}
+		files = append(files, &io.RawFile{
+			FPath:   "config-errors.json",
+			Content: configErrorData,
+		})
+	}
+
 	err = io.OutputTo(files, architectureEngineCfg.outputDir)
 	if err != nil {
 		return errors.Errorf("failed to write output files: %s", err.Error())

pkg/engine2/engine.go

@@ -43,3 +43,16 @@ func (e *Engine) Run(context *EngineContext) error {
 	context.Solutions = append(context.Solutions, solutionCtx)
 	return err
 }
+
+func (e *Engine) getPropertyValidation(ctx solution_context.SolutionContext) []solution_context.PropertyValidationDecision {
+	decisions := ctx.GetDecisions().GetRecords()
+	validationDecisions := make([]solution_context.PropertyValidationDecision, 0)
+	for _, decision := range decisions {
+		if validation, ok := decision.(solution_context.PropertyValidationDecision); ok {
+			if validation.Error != nil {
+				validationDecisions = append(validationDecisions, validation)
+			}
+		}
+	}
+	return validationDecisions
+}

pkg/engine2/enginetesting/mock_solution.go

@@ -31,6 +31,11 @@ func (m *MockSolution) RecordDecision(d solution_context.SolveDecision) {
 	m.Called(d)
 }
 
+func (m *MockSolution) GetDecisions() solution_context.DecisionRecords {
+	args := m.Called()
+	return args.Get(0).(solution_context.DecisionRecords)
+}
+
 func (m *MockSolution) DataflowGraph() construct.Graph {
 	args := m.Called()
 	return args.Get(0).(construct.Graph)

pkg/engine2/enginetesting/test_solution.go

@@ -58,6 +58,10 @@ func (sol *TestSolution) Constraints() *constraints.Constraints {
 
 func (sol *TestSolution) RecordDecision(d solution_context.SolveDecision) {}
 
+func (sol *TestSolution) GetDecisions() solution_context.DecisionRecords {
+	return nil
+}
+
 func (sol *TestSolution) DataflowGraph() construct.Graph {
 	return sol.dataflow
 }

pkg/engine2/operational_eval/vertex_path_expand.go

@@ -268,7 +268,7 @@ func (v *pathExpandVertex) addDepsFromProps(
 				continue
 			}
 			// if this dependency could pass validation for the resources property, consider it as a dependent vertex
-			if err := prop.Validate(resource, dep); err == nil {
+			if err := prop.Validate(resource, dep, solution_context.DynamicCtx(eval.Solution)); err == nil {
 				changes.addEdge(v.Key(), Key{Ref: ref})
 			}
 		}

pkg/engine2/operational_eval/vertex_property.go

@@ -137,6 +137,18 @@ func (v *propertyVertex) Evaluate(eval *Evaluator) error {
 		return eval.AddResources(res)
 	}
 
+	// Now that the vertex is evaluated, we will check it for validity and record our decision
+	val, err := res.GetProperty(v.Ref.Property)
+	if err != nil {
+		return fmt.Errorf("error while validating resource property: could not get property %s on resource %s: %w", v.Ref.Property, v.Ref.Resource, err)
+	}
+	err = v.Template.Validate(res, val, solution_context.DynamicCtx(eval.Solution))
+	eval.Solution.RecordDecision(solution_context.PropertyValidationDecision{
+		Resource: v.Ref.Resource,
+		Property: v.Template,
+		Value:    val,
+		Error:    err,
+	})
 	return nil
 }
 

pkg/engine2/solution_context/decisions.go

@@ -1,6 +1,8 @@
 package solution_context
 
 import (
+	"fmt"
+
 	construct "github.com/klothoplatform/klotho/pkg/construct2"
 	knowledgebase "github.com/klothoplatform/klotho/pkg/knowledge_base2"
 )
@@ -18,6 +20,7 @@ type (
 		// FindDecision(decision SolveDecision) []KV
 		// // FindContext returns the various decisions (the what) for a given context (the why)
 		// FindContext(key string, value any) []SolveDecision
+		GetRecords() []SolveDecision
 	}
 
 	SolveDecision interface {
@@ -50,14 +53,35 @@ type (
 		Value    any
 	}
 
-	ResourceConfigurationError struct {
+	PropertyValidationDecision struct {
 		Resource construct.ResourceId
 		Property knowledgebase.Property
+		Value    any
+		Error    error
 	}
 )
 
-func (d AddResourceDecision) internal()      {}
-func (d AddDependencyDecision) internal()    {}
-func (d RemoveResourceDecision) internal()   {}
-func (d RemoveDependencyDecision) internal() {}
-func (d SetPropertyDecision) internal()      {}
+func (d AddResourceDecision) internal()        {}
+func (d AddDependencyDecision) internal()      {}
+func (d RemoveResourceDecision) internal()     {}
+func (d RemoveDependencyDecision) internal()   {}
+func (d SetPropertyDecision) internal()        {}
+func (d PropertyValidationDecision) internal() {}
+
+func (d PropertyValidationDecision) MarshalJSON() ([]byte, error) {
+	if d.Value != nil {
+		stringVal := `{
+			"resource": "%s",
+			"property": "%s",
+			"value": "%s",
+			"error": "%s"
+		}`
+		return []byte(fmt.Sprintf(stringVal, d.Resource, d.Property.Details().Path, d.Value, d.Error)), nil
+	}
+	stringVal := `{
+		"resource": "%s",
+		"property": "%s",
+		"error": "%s"
+	}`
+	return []byte(fmt.Sprintf(stringVal, d.Resource, d.Property.Details().Path, d.Error)), nil
+}

pkg/engine2/solution_context/interface.go

@@ -14,6 +14,7 @@ type (
 		KnowledgeBase() knowledgebase.TemplateKB
 		Constraints() *constraints.Constraints
 		RecordDecision(d SolveDecision)
+		GetDecisions() DecisionRecords
 
 		DataflowGraph() construct.Graph
 		DeploymentGraph() construct.Graph

pkg/engine2/solution_context/memory_record.go

@@ -14,3 +14,11 @@ type (
 func (m *MemoryRecord) AddRecord(context []KV, decision SolveDecision) {
 	m.records = append(m.records, record{context: context, decision: decision})
 }
+
+func (m *MemoryRecord) GetRecords() []SolveDecision {
+	var decisions []SolveDecision
+	for _, record := range m.records {
+		decisions = append(decisions, record.decision)
+	}
+	return decisions
+}

pkg/knowledge_base2/properties/any_property.go

@@ -1,6 +1,8 @@
 package properties
 
 import (
+	"fmt"
+
 	construct "github.com/klothoplatform/klotho/pkg/construct2"
 	knowledgebase "github.com/klothoplatform/klotho/pkg/knowledge_base2"
 )
@@ -107,7 +109,10 @@ func (a *AnyProperty) Type() string {
 	return "any"
 }
 
-func (a *AnyProperty) Validate(resource *construct.Resource, value any) error {
+func (a *AnyProperty) Validate(resource *construct.Resource, value any, ctx knowledgebase.DynamicContext) error {
+	if a.Required && value == nil {
+		return fmt.Errorf(knowledgebase.ErrRequiredProperty, a.Path, resource.ID)
+	}
 	return nil
 }
 

pkg/knowledge_base2/properties/bool_property.go

@@ -83,7 +83,13 @@ func (b *BoolProperty) Type() string {
 	return "bool"
 }
 
-func (b *BoolProperty) Validate(resource *construct.Resource, value any) error {
+func (b *BoolProperty) Validate(resource *construct.Resource, value any, ctx knowledgebase.DynamicContext) error {
+	if value == nil {
+		if b.Required {
+			return fmt.Errorf(knowledgebase.ErrRequiredProperty, b.Path, resource.ID)
+		}
+		return nil
+	}
 	if _, ok := value.(bool); !ok {
 		return fmt.Errorf("invalid bool value %v", value)
 	}

pkg/knowledge_base2/properties/bool_property_test.go

@@ -4,8 +4,10 @@ import (
 	"testing"
 
 	construct "github.com/klothoplatform/klotho/pkg/construct2"
+	"github.com/klothoplatform/klotho/pkg/engine2/enginetesting"
 	knowledgebase "github.com/klothoplatform/klotho/pkg/knowledge_base2"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
 func Test_SetBoolProperty(t *testing.T) {
@@ -268,10 +270,12 @@ func Test_BoolPropertyType(t *testing.T) {
 
 func Test_BoolPropertyValidate(t *testing.T) {
 	tests := []struct {
-		name     string
-		property *BoolProperty
-		value    any
-		wantErr  bool
+		name          string
+		property      *BoolProperty
+		testResources []*construct.Resource
+		mockKBCalls   []mock.Call
+		value         any
+		wantErr       bool
 	}{
 		{
 			name: "bool property",
@@ -298,7 +302,19 @@ func Test_BoolPropertyValidate(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			assert := assert.New(t)
 			resource := &construct.Resource{}
-			err := tt.property.Validate(resource, tt.value)
+			graph := construct.NewGraph()
+			for _, r := range tt.testResources {
+				graph.AddVertex(r)
+			}
+			mockKB := &enginetesting.MockKB{}
+			for _, call := range tt.mockKBCalls {
+				mockKB.On(call.Method, call.Arguments...).Return(call.ReturnArguments...)
+			}
+			ctx := knowledgebase.DynamicValueContext{
+				Graph:         graph,
+				KnowledgeBase: mockKB,
+			}
+			err := tt.property.Validate(resource, tt.value, ctx)
 			assert.Equal(tt.wantErr, err != nil)
 		})
 	}

pkg/knowledge_base2/properties/float_property.go

@@ -91,7 +91,13 @@ func (f *FloatProperty) Type() string {
 	return "float"
 }
 
-func (f *FloatProperty) Validate(resource *construct.Resource, value any) error {
+func (f *FloatProperty) Validate(resource *construct.Resource, value any, ctx knowledgebase.DynamicContext) error {
+	if value == nil {
+		if f.Required {
+			return fmt.Errorf(knowledgebase.ErrRequiredProperty, f.Path, resource.ID)
+		}
+		return nil
+	}
 	floatVal, ok := value.(float64)
 	if !ok {
 		return fmt.Errorf("invalid int value %v", value)

pkg/knowledge_base2/properties/float_property_test.go

@@ -4,8 +4,11 @@ import (
 	"testing"
 
 	construct "github.com/klothoplatform/klotho/pkg/construct2"
+	"github.com/klothoplatform/klotho/pkg/engine2/enginetesting"
+	knowledgebase "github.com/klothoplatform/klotho/pkg/knowledge_base2"
 	knowledgebase2 "github.com/klothoplatform/klotho/pkg/knowledge_base2"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
 func Test_SetFloatProperty(t *testing.T) {
@@ -196,10 +199,12 @@ func Test_ParseFloatValue(t *testing.T) {
 
 func Test_FloatProperty_Validate(t *testing.T) {
 	tests := []struct {
-		name     string
-		property *FloatProperty
-		value    any
-		wantErr  bool
+		name          string
+		property      *FloatProperty
+		testResources []*construct.Resource
+		mockKBCalls   []mock.Call
+		value         any
+		wantErr       bool
 	}{
 		{
 			name: "float value",
@@ -225,7 +230,19 @@ func Test_FloatProperty_Validate(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			assert := assert.New(t)
 			resource := &construct.Resource{}
-			err := test.property.Validate(resource, test.value)
+			graph := construct.NewGraph()
+			for _, r := range test.testResources {
+				graph.AddVertex(r)
+			}
+			mockKB := &enginetesting.MockKB{}
+			for _, call := range test.mockKBCalls {
+				mockKB.On(call.Method, call.Arguments...).Return(call.ReturnArguments...)
+			}
+			ctx := knowledgebase.DynamicValueContext{
+				Graph:         graph,
+				KnowledgeBase: mockKB,
+			}
+			err := test.property.Validate(resource, test.value, ctx)
 			if test.wantErr {
 				assert.Error(err)
 				return

pkg/knowledge_base2/properties/int_property.go

@@ -84,7 +84,13 @@ func (i *IntProperty) Type() string {
 	return "int"
 }
 
-func (i *IntProperty) Validate(resource *construct.Resource, value any) error {
+func (i *IntProperty) Validate(resource *construct.Resource, value any, ctx knowledgebase.DynamicContext) error {
+	if value == nil {
+		if i.Required {
+			return fmt.Errorf(knowledgebase.ErrRequiredProperty, i.Path, resource.ID)
+		}
+		return nil
+	}
 	intVal, ok := value.(int)
 	if !ok {
 		return fmt.Errorf("invalid int value %v", value)

pkg/knowledge_base2/properties/int_property_test.go

@@ -4,8 +4,11 @@ import (
 	"testing"
 
 	construct "github.com/klothoplatform/klotho/pkg/construct2"
+	"github.com/klothoplatform/klotho/pkg/engine2/enginetesting"
+	knowledgebase "github.com/klothoplatform/klotho/pkg/knowledge_base2"
 	knowledgebase2 "github.com/klothoplatform/klotho/pkg/knowledge_base2"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
 func Test_SetIntPropertyProperty(t *testing.T) {
@@ -188,10 +191,12 @@ func Test_IntProperty_Validate(t *testing.T) {
 	upperBound := 10
 	lowerBound := 0
 	tests := []struct {
-		name     string
-		property *IntProperty
-		value    any
-		wantErr  bool
+		name          string
+		property      *IntProperty
+		testResources []*construct.Resource
+		mockKBCalls   []mock.Call
+		value         any
+		wantErr       bool
 	}{
 		{
 			name: "int property",
@@ -252,7 +257,19 @@ func Test_IntProperty_Validate(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			assert := assert.New(t)
 			resource := &construct.Resource{}
-			err := test.property.Validate(resource, test.value)
+			graph := construct.NewGraph()
+			for _, r := range test.testResources {
+				graph.AddVertex(r)
+			}
+			mockKB := &enginetesting.MockKB{}
+			for _, call := range test.mockKBCalls {
+				mockKB.On(call.Method, call.Arguments...).Return(call.ReturnArguments...)
+			}
+			ctx := knowledgebase.DynamicValueContext{
+				Graph:         graph,
+				KnowledgeBase: mockKB,
+			}
+			err := test.property.Validate(resource, test.value, ctx)
 			if test.wantErr {
 				assert.Error(err)
 				return