model consumption in path expansion

pkg/engine2/engine.go

@@ -30,7 +30,7 @@ func NewEngine(kb knowledgebase.TemplateKB) *Engine {
 
 func (e *Engine) Run(context *EngineContext) error {
 	solutionCtx := NewSolutionContext(e.Kb)
-	solutionCtx.constraints = context.Constraints
+	solutionCtx.constraints = &context.Constraints
 	err := solutionCtx.LoadGraph(context.InitialState)
 	if err != nil {
 		return err

pkg/engine2/operational_eval/vertex_path_expand.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/dominikbraun/graph"
 	construct "github.com/klothoplatform/klotho/pkg/construct2"
+	"github.com/klothoplatform/klotho/pkg/engine2/constraints"
 	"github.com/klothoplatform/klotho/pkg/engine2/operational_rule"
 	"github.com/klothoplatform/klotho/pkg/engine2/path_selection"
 	"github.com/klothoplatform/klotho/pkg/engine2/solution_context"
@@ -168,7 +169,24 @@ func (v *pathExpandVertex) runExpansion(eval *Evaluator, expansion path_selectio
 	if err := eval.AddEdges(result.Edges...); err != nil {
 		return err
 	}
-	return eval.AddEdges(edges...)
+	if err := eval.AddEdges(edges...); err != nil {
+		return err
+	}
+	delays, err := knowledgebase.ConsumeFromResource(expansion.Dep.Source, expansion.Dep.Target, solution_context.DynamicCtx(eval.Solution))
+	if err != nil {
+		return err
+	}
+	// we add constrains for the delayed consumption here since their property has not yet been evaluated
+	c := eval.Solution.Constraints()
+	for _, delay := range delays {
+		c.Resources = append(c.Resources, constraints.ResourceConstraint{
+			Operator: constraints.AddConstraintOperator,
+			Target:   delay.Resource,
+			Property: delay.PropertyPath,
+			Value:    delay.Value,
+		})
+	}
+	return nil
 }
 
 func (v *pathExpandVertex) getExpansionsToRun(eval *Evaluator) ([]path_selection.ExpansionInput, error) {

pkg/engine2/path_selection/edge_validity.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"strings"
 
 	"github.com/dominikbraun/graph"
 	"github.com/klothoplatform/klotho/pkg/collectionutil"
@@ -64,6 +65,11 @@ func checkProperties(ctx solution_context.SolutionContext, resource, toCheck *co
 	if err != nil || template == nil {
 		return false, fmt.Errorf("error getting resource template for resource %s: %w", resource.ID, err)
 	}
+
+	if strings.Contains(resource.ID.Name, PHANTOM_PREFIX) {
+		return true, nil
+	}
+
 	explicitlyNotValid := false
 	explicitlyValid := false
 	err = template.LoopProperties(resource, func(prop *knowledgebase.Property) error {
@@ -95,7 +101,7 @@ func checkProperties(ctx solution_context.SolutionContext, resource, toCheck *co
 						return knowledgebase.ErrStopWalk
 					}
 				} else {
-					loneDep, err := checkIfLoneDependency(ctx, resource.ID, toCheck.ID, direction)
+					loneDep, err := checkIfLoneDependency(ctx, resource.ID, toCheck.ID, direction, selector)
 					if err != nil {
 						return err
 					}
@@ -155,7 +161,9 @@ func checkIfPropertyContainsResource(property interface{}, resource construct.Re
 	return false
 }
 
-func checkIfLoneDependency(ctx solution_context.SolutionContext, resource, toCheck construct.ResourceId, direction knowledgebase.Direction) (bool, error) {
+func checkIfLoneDependency(ctx solution_context.SolutionContext,
+	resource, toCheck construct.ResourceId, direction knowledgebase.Direction,
+	selector knowledgebase.ResourceSelector) (bool, error) {
 	var resources []construct.ResourceId
 	var err error
 	// we are going to check if the resource was created as a unique resource by any of its direct dependents. if it was and that
@@ -177,8 +185,24 @@ func checkIfLoneDependency(ctx solution_context.SolutionContext, resource, toChe
 		return true, nil
 	} else if len(resources) == 1 && resources[0].Matches(toCheck) {
 		return true, nil
+	} else {
+		for _, res := range resources {
+			depRes, err := ctx.RawView().Vertex(res)
+			if err != nil {
+				return false, err
+			}
+			data := knowledgebase.DynamicValueData{Resource: resource}
+			dynCtx := solution_context.DynamicCtx(ctx)
+			canUse, err := selector.CanUse(dynCtx, data, depRes)
+			if err != nil {
+				return false, err
+			}
+			if canUse {
+				return false, nil
+			}
+		}
+		return true, nil
 	}
-	return false, nil
 }
 
 // checkIfCreatedAsUnique checks if the resource was created as a unique resource by any of its direct dependents. if it was and that

pkg/engine2/solution_context.go

@@ -19,7 +19,7 @@ type (
 		decisions       solution_context.DecisionRecords
 		stack           []solution_context.KV
 		mappedResources map[construct.ResourceId]construct.ResourceId
-		constraints     constraints.Constraints
+		constraints     *constraints.Constraints
 		propertyEval    *property_eval.Evaluator
 	}
 )
@@ -70,7 +70,7 @@ func (ctx solutionContext) KnowledgeBase() knowledgebase.TemplateKB {
 }
 
 func (ctx solutionContext) Constraints() *constraints.Constraints {
-	return &ctx.constraints
+	return ctx.constraints
 }
 
 func (ctx solutionContext) LoadGraph(graph construct.Graph) error {

pkg/engine2/visualizer.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/dominikbraun/graph"
+	"github.com/klothoplatform/klotho/pkg/collectionutil"
 	construct "github.com/klothoplatform/klotho/pkg/construct2"
 	"github.com/klothoplatform/klotho/pkg/engine2/operational_eval"
 	"github.com/klothoplatform/klotho/pkg/engine2/path_selection"
@@ -126,25 +127,27 @@ func (e *Engine) GetViewsDag(view View, ctx solution_context.SolutionContext) (c
 			dstTag := e.GetResourceVizTag(string(DataflowView), dst)
 			switch dstTag {
 			case ParentIconTag:
-				hasPath, err := HasParent(topo, ctx, src, dst)
-				if err != nil {
-					errs = errors.Join(errs, err)
-				}
-				if node.Parent.IsZero() && hasPath {
-					node.Parent = dst
-				}
-			case BigIconTag:
-				hasPath, err := HasPath(topo, ctx, src, dst)
-				if err != nil {
-					errs = errors.Join(errs, err)
-				}
-				if hasPath {
-					edge := construct.SimpleEdge{
-						Source: src,
-						Target: dst,
+				if node.Parent.IsZero() {
+					template, err := e.Kb.GetResourceTemplate(dst)
+					if err != nil {
+						errs = errors.Join(errs, err)
+						continue
+					}
+					if collectionutil.Contains(template.Classification.Is, "cluster") ||
+						collectionutil.Contains(template.Classification.Is, "network") {
+						hasPath, err := HasParent(topo, ctx, src, dst)
+						if err != nil {
+							errs = errors.Join(errs, err)
+						}
+						if node.Parent.IsZero() && hasPath {
+							node.Parent = dst
+						}
+					} else {
+						errs = errors.Join(errs, createEdgeIfPath(topo, ctx, src, dst, path))
 					}
-					topo.Edges[edge] = path[1 : len(path)-1]
 				}
+			case BigIconTag:
+				errs = errors.Join(errs, createEdgeIfPath(topo, ctx, src, dst, path))
 			case SmallIconTag:
 				if seenSmall.Contains(dst) {
 					continue
@@ -231,6 +234,25 @@ func (e *Engine) GetViewsDag(view View, ctx solution_context.SolutionContext) (c
 	return viewDag, nil
 }
 
+func createEdgeIfPath(topo Topology,
+	ctx solution_context.SolutionContext,
+	src, dst construct.ResourceId,
+	path construct.Path,
+) error {
+	hasPath, err := HasPath(topo, ctx, src, dst)
+	if err != nil {
+		return err
+	}
+	if hasPath {
+		edge := construct.SimpleEdge{
+			Source: src,
+			Target: dst,
+		}
+		topo.Edges[edge] = path[1 : len(path)-1]
+	}
+	return nil
+}
+
 func (e *Engine) getParentFromNamespace(resource construct.ResourceId, resources []construct.ResourceId) construct.ResourceId {
 	if resource.Namespace != "" {
 		for _, potentialParent := range resources {

pkg/infra/iac3/templates/aws/cloudfront_distribution/factory.ts

@@ -26,3 +26,13 @@ function create(args: Args): aws.cloudfront.Distribution {
         //TMPL {{- end }}
     })
 }
+
+function infraExports(
+    object: ReturnType<typeof create>,
+    args: Args,
+    props: ReturnType<typeof properties>
+) {
+    return {
+        Domain: object.domainName,
+    }
+}

pkg/infra/iac3/templates/aws/s3_bucket/factory.ts

@@ -41,3 +41,13 @@ function properties(object: aws.s3.Bucket, args: Args) {
         BucketName: object.bucket,
     }
 }
+
+function infraExports(
+    object: ReturnType<typeof create>,
+    args: Args,
+    props: ReturnType<typeof properties>
+) {
+    return {
+        BucketName: object.bucket,
+    }
+}

pkg/knowledge_base2/embed.go

@@ -12,7 +12,12 @@ import (
 
 func NewKBFromFs(resources, edges, models fs.FS) (*KnowledgeBase, error) {
 	kb := NewKB()
-	templates, err := TemplatesFromFs(resources, models)
+	kbModels, err := ModelsFromFS(models)
+	if err != nil {
+		return nil, err
+	}
+	kb.models = kbModels
+	templates, err := TemplatesFromFs(resources, kbModels)
 	if err != nil {
 		return nil, err
 	}
@@ -72,13 +77,9 @@ func ModelsFromFS(dir fs.FS) (map[string]*Model, error) {
 	return models, err
 }
 
-func TemplatesFromFs(dir, modelDir fs.FS) (map[construct.ResourceId]*ResourceTemplate, error) {
+func TemplatesFromFs(dir fs.FS, models map[string]*Model) (map[construct.ResourceId]*ResourceTemplate, error) {
 	templates := map[construct.ResourceId]*ResourceTemplate{}
-	models, err := ModelsFromFS(modelDir)
-	if err != nil {
-		return nil, err
-	}
-	terr := fs.WalkDir(dir, ".", func(path string, d fs.DirEntry, nerr error) error {
+	err := fs.WalkDir(dir, ".", func(path string, d fs.DirEntry, nerr error) error {
 		zap.S().Debug("Loading resource template: ", path)
 		if d.IsDir() {
 			return nil
@@ -107,7 +108,6 @@ func TemplatesFromFs(dir, modelDir fs.FS) (map[construct.ResourceId]*ResourceTem
 		templates[id] = resTemplate
 		return nil
 	})
-	err = errors.Join(err, terr)
 	return templates, err
 }