Read lifecycle.depends_on from typed config instead of dyn

Co-authored-by: Isaac <no-reply@databricks.com>

Author: denik

acceptance/bundle/lifecycle/depends-on-validation/databricks.yml

@@ -14,3 +14,12 @@ resources:
       lifecycle:
         depends_on:
           - resource: a.b.c
+  # lifecycle is a separate type on job_runs.
+  job_runs:
+    a_run:
+      job_id: ${resources.jobs.b_job.id}
+      lifecycle:
+        triggers:
+          - on_bundle_deploy: true
+        depends_on:
+          - resource: missing_for_run

acceptance/bundle/lifecycle/depends-on-validation/output.txt

@@ -1,19 +1,23 @@
+Error: invalid lifecycle.depends_on: no such resource: missing_for_run
+  at resources.job_runs.a_run.lifecycle.depends_on[0].resource
+  in databricks.yml:25:23
+
 Error: invalid lifecycle.depends_on: resource "a_job" cannot depend on itself
   at resources.jobs.a_job.lifecycle.depends_on[0].resource
-  in databricks.yml:10:13
+  in databricks.yml:10:23
 
 Error: invalid lifecycle.depends_on: no such resource: missing
   at resources.jobs.a_job.lifecycle.depends_on[1].resource
-  in databricks.yml:11:13
+  in databricks.yml:11:23
 
 Error: invalid lifecycle.depends_on: no such resource: a.b.c
   at resources.jobs.b_job.lifecycle.depends_on[0].resource
-  in databricks.yml:16:13
+  in databricks.yml:16:23
 
 Name: test-bundle
 Target: default
 Workspace:
   User: [USERNAME]
   Path: /Workspace/Users/[USERNAME]/.bundle/test-bundle/default
 
-Found 3 errors
+Found 4 errors

bundle/config/resources/job_run.go

@@ -123,6 +123,15 @@ func (r *JobRun) ResourceDescription() ResourceDescription {
 	}
 }
 
+// GetLifecycle returns the lifecycle settings. Lifecycle shadows BaseResource.Lifecycle,
+// which therefore stays empty.
+func (r *JobRun) GetLifecycle() LifecycleConfig {
+	if r.Lifecycle == nil {
+		return Lifecycle{}
+	}
+	return r.Lifecycle.Lifecycle
+}
+
 // GetName returns the in-product name, which is empty: a run has no name.
 func (r *JobRun) GetName() string {
 	return ""

bundle/config/resources/lifecycle.go

@@ -3,6 +3,7 @@ package resources
 // LifecycleConfig is implemented by Lifecycle and LifecycleWithStarted.
 type LifecycleConfig interface {
 	HasPreventDestroy() bool
+	GetDependsOn() []DependsOn
 }
 
 // Lifecycle contains base lifecycle settings supported by all resources.
@@ -31,6 +32,11 @@ func (l Lifecycle) HasPreventDestroy() bool {
 	return l.PreventDestroy
 }
 
+// GetDependsOn returns the lifecycle.depends_on entries.
+func (l Lifecycle) GetDependsOn() []DependsOn {
+	return l.DependsOn
+}
+
 // LifecycleWithStarted contains lifecycle settings for resources that support lifecycle.started.
 // It is used by apps, clusters, and sql_warehouses.
 type LifecycleWithStarted struct {

bundle/config/resources/lifecycle_test.go

@@ -0,0 +1,31 @@
+package resources
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// Resources that shadow BaseResource.Lifecycle must return their own settings.
+func TestGetLifecycleDependsOn(t *testing.T) {
+	deps := []DependsOn{{Resource: "foo"}}
+
+	tests := []struct {
+		name     string
+		resource interface{ GetLifecycle() LifecycleConfig }
+	}{
+		{"base", &Job{Lifecycle: Lifecycle{DependsOn: deps}}},
+		{"with_started", &App{Lifecycle: &LifecycleWithStarted{DependsOn: deps}}},
+		{"job_run", &JobRun{Lifecycle: &JobRunLifecycle{DependsOn: deps}}},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			assert.Equal(t, deps, tc.resource.GetLifecycle().GetDependsOn())
+		})
+	}
+}
+
+func TestJobRunGetLifecycleNil(t *testing.T) {
+	assert.Empty(t, (&JobRun{}).GetLifecycle().GetDependsOn())
+}

bundle/config/validate/lifecycle_depends_on.go

@@ -4,11 +4,12 @@ import (
 	"cmp"
 	"context"
 	"fmt"
+	"reflect"
 	"slices"
 
 	"github.com/databricks/cli/bundle"
 	"github.com/databricks/cli/libs/diag"
-	"github.com/databricks/cli/libs/dyn"
+	"github.com/databricks/cli/libs/structs/structpath"
 )
 
 type lifecycleDependsOn struct{}
@@ -26,37 +27,33 @@ func (*lifecycleDependsOn) Name() string {
 func (*lifecycleDependsOn) Apply(_ context.Context, b *bundle.Bundle) diag.Diagnostics {
 	var diags diag.Diagnostics
 
-	pattern := dyn.NewPattern(dyn.Key("resources"), dyn.AnyKey(), dyn.AnyKey(), dyn.Key("lifecycle"), dyn.Key("depends_on"))
-	_, err := dyn.MapByPattern(b.Config.Value(), pattern, func(p dyn.Path, v dyn.Value) (dyn.Value, error) {
-		seq, ok := v.AsSequence()
-		if !ok {
-			return v, nil
-		}
-		self := p[:3].String()
-		for i, item := range seq {
-			ref, ok := item.Get("resource").AsString()
-			if !ok {
+	for _, group := range b.Config.Resources.AllResources() {
+		for key, resource := range group.Resources {
+			// Python-generated configs can contain null resource entries.
+			if reflect.ValueOf(resource).IsNil() {
 				continue
 			}
-			res, key, err := b.Config.Resources.ResolveKey(ref)
-			if err == nil && "resources."+res.ResourceDescription().PluralName+"."+key == self {
-				err = fmt.Errorf("resource %q cannot depend on itself", ref)
-			}
-			if err != nil {
-				diags = diags.Append(diag.Diagnostic{
-					Severity:  diag.Error,
-					Summary:   "invalid lifecycle.depends_on: " + err.Error(),
-					Locations: item.Locations(),
-					Paths:     dyn.ToStructPaths(p.Append(dyn.Index(i), dyn.Key("resource"))),
-				})
+
+			self := group.Description.PluralName + "." + key
+			for i, dep := range resource.GetLifecycle().GetDependsOn() {
+				target, targetKey, err := b.Config.Resources.ResolveKey(dep.Resource)
+				if err == nil && target.ResourceDescription().PluralName+"."+targetKey == self {
+					err = fmt.Errorf("resource %q cannot depend on itself", dep.Resource)
+				}
+				if err != nil {
+					path := structpath.NewPath(nil, "resources", group.Description.PluralName, key, "lifecycle", "depends_on", i, "resource")
+					diags = diags.Append(diag.Diagnostic{
+						Severity:  diag.Error,
+						Summary:   "invalid lifecycle.depends_on: " + err.Error(),
+						Locations: b.Config.GetLocationsOf(path),
+						Paths:     []*structpath.PathNode{path},
+					})
+				}
 			}
 		}
-		return v, nil
-	})
-	if err != nil {
-		diags = diags.Extend(diag.FromErr(err))
 	}
-	// MapByPattern visits resources in random order.
+
+	// Resources are visited in random order.
 	slices.SortStableFunc(diags, func(a, b diag.Diagnostic) int {
 		return cmp.Compare(a.Paths[0].String(), b.Paths[0].String())
 	})

bundle/direct/bundle_plan.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/databricks/cli/bundle/config"
+	"github.com/databricks/cli/bundle/config/resources"
 	"github.com/databricks/cli/bundle/deployplan"
 	"github.com/databricks/cli/bundle/direct/dresources"
 	"github.com/databricks/cli/bundle/direct/dstate"
@@ -1285,7 +1286,7 @@ func (b *DeploymentBundle) makePlan(ctx context.Context, configRoot *config.Root
 			}
 		}
 
-		lifecycleDeps, err := LifecycleDependsOn(configRoot, node)
+		lifecycleDeps, err := LifecycleDependsOn(configRoot, inputConfig)
 		if err != nil {
 			return nil, fmt.Errorf("%s: %w", prefix, err)
 		}
@@ -1450,35 +1451,20 @@ func (b *DeploymentBundle) getAdapterForKey(resourceKey string) (*dresources.Ada
 
 const lifecycleDependsOnLabel = "depends_on"
 
-// LifecycleDependsOn returns the edges declared in lifecycle.depends_on of the given node.
-func LifecycleDependsOn(configRoot *config.Root, node string) ([]deployplan.DependsOnEntry, error) {
-	nodePath, err := dyn.NewPathFromString(node)
-	if err != nil {
-		return nil, err
-	}
-	// permissions and grants are separate nodes without lifecycle.
-	if len(nodePath) != 3 {
-		return nil, nil
-	}
-	entries, err := dyn.GetByPath(configRoot.Value(), nodePath.Append(dyn.Key("lifecycle"), dyn.Key("depends_on")))
-	if dyn.IsNoSuchKeyError(err) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	seq, isSeq := entries.AsSequence()
-	if !isSeq {
+// LifecycleDependsOn returns the edges declared in lifecycle.depends_on of a resource,
+// given its config as returned by [config.Root.GetResourceConfig].
+func LifecycleDependsOn(configRoot *config.Root, inputConfig any) ([]deployplan.DependsOnEntry, error) {
+	// Not every node has a lifecycle, e.g. permissions and grants.
+	resource, ok := inputConfig.(interface {
+		GetLifecycle() resources.LifecycleConfig
+	})
+	if !ok {
 		return nil, nil
 	}
 
 	var result []deployplan.DependsOnEntry
-	for _, item := range seq {
-		ref, isStr := item.Get("resource").AsString()
-		if !isStr {
-			continue
-		}
-		res, key, err := configRoot.Resources.ResolveKey(ref)
+	for _, dep := range resource.GetLifecycle().GetDependsOn() {
+		res, key, err := configRoot.Resources.ResolveKey(dep.Resource)
 		if err != nil {
 			return nil, fmt.Errorf("lifecycle.depends_on: %w", err)
 		}

bundle/migrate/build_state.go

@@ -152,7 +152,7 @@ func BuildStateFromTF(
 				}
 			}
 		}
-		lifecycleDeps, err := direct.LifecycleDependsOn(configRoot, node)
+		lifecycleDeps, err := direct.LifecycleDependsOn(configRoot, inputConfig)
 		if err != nil {
 			return warningsSeen, fmt.Errorf("%s: %w", node, err)
 		}