direct: refactor: Group resources settings in a single struct (#3334)

## Why

The number of settings have grown and will continue to grow, this give
better overview.

Author: denik

bundle/terranova/apply.go

@@ -258,7 +258,7 @@ func (d *Deployer) Update(ctx context.Context, resource tnresources.IResource, o
 		return fmt.Errorf("saving state id=%s: %w", oldID, err)
 	}
 
-	if oldID != newID && !tnresources.UpdateableIDResource[d.group] {
+	if oldID != newID && !tnresources.SupportedResources[d.group].UpdateUpdatesID {
 		return fmt.Errorf("internal error, unexpected change of ID from %#v to %#v", oldID, newID)
 	}
 

bundle/terranova/tnresources/resource.go

@@ -11,52 +11,60 @@ import (
 	"github.com/databricks/databricks-sdk-go"
 )
 
-const (
-	_jobs           = "jobs"
-	_pipelines      = "pipelines"
-	_schemas        = "schemas"
-	_volumes        = "volumes"
-	_apps           = "apps"
-	_sql_warehouses = "sql_warehouses"
-)
+type DeleteResourceFN = func(ctx context.Context, client *databricks.WorkspaceClient, oldID string) error
 
-var supportedResources = map[string]reflect.Value{
-	_jobs:           reflect.ValueOf(NewResourceJob),
-	_pipelines:      reflect.ValueOf(NewResourcePipeline),
-	_schemas:        reflect.ValueOf(NewResourceSchema),
-	_volumes:        reflect.ValueOf(NewResourceVolume),
-	_apps:           reflect.ValueOf(NewResourceApp),
-	_sql_warehouses: reflect.ValueOf(NewResourceSqlWarehouse),
-}
+type ResourceSettings struct {
+	// Method to call to create new resource
+	// First argument must be client* databricks.Workspace and second argument is *resource.<Resource> from bundle config
+	// where Resource is appropriate resource e.g. resource.Job.
+	New reflect.Value
 
-// This types matches what Config() returns and should match 'config' field in the resource struct
-var supportedResourcesTypes = map[string]reflect.Type{
-	_jobs:           reflect.TypeOf(ResourceJob{}.config),
-	_pipelines:      reflect.TypeOf(ResourcePipeline{}.config),
-	_schemas:        reflect.TypeOf(ResourceSchema{}.config),
-	_volumes:        reflect.TypeOf(ResourceVolume{}.config),
-	_apps:           reflect.TypeOf(ResourceApp{}.config),
-	_sql_warehouses: reflect.TypeOf(ResourceSqlWarehouse{}.config),
-}
+	// Type of the stored config state
+	ConfigType reflect.Type
 
-type DeleteResourceFN = func(ctx context.Context, client *databricks.WorkspaceClient, oldID string) error
+	// Function to delete a resource of this type
+	DeleteFN DeleteResourceFN
 
-var deletableResources = map[string]DeleteResourceFN{
-	_jobs:           DeleteJob,
-	_pipelines:      DeletePipeline,
-	_schemas:        DeleteSchema,
-	_volumes:        DeleteVolume,
-	_apps:           DeleteApp,
-	_sql_warehouses: DeleteSqlWarehouse,
+	// true if Update() method can return a different ID than that was passed in
+	// If ID changes during Update and UpdateUpdatesID is false, deployment of that resource will fail with internal error.
+	// This allows to make assumptions about references stability (${resources.jobs.foo.id}) when we see that
+	// operation is going to be "update" & ID is guarantee not to change.
+	UpdateUpdatesID bool
 }
 
-// UpdateableIDResource configures whether the resource is allowed to change ID in Update operation. Default is false.
-// If ID changes during Update and it is not allowed, deployment of that resource will fail with internal error.
-// This allows to make assumptions about references stability (${resources.jobs.foo.id}) when we see that
-// operation is going to be "update" & ID is guarantee not to change.
-var UpdateableIDResource = map[string]bool{
-	_schemas: true,
-	_volumes: true,
+var SupportedResources = map[string]ResourceSettings{
+	"jobs": {
+		New:        reflect.ValueOf(NewResourceJob),
+		ConfigType: reflect.TypeOf(ResourceJob{}.config),
+		DeleteFN:   DeleteJob,
+	},
+	"pipelines": {
+		New:        reflect.ValueOf(NewResourcePipeline),
+		ConfigType: reflect.TypeOf(ResourcePipeline{}.config),
+		DeleteFN:   DeletePipeline,
+	},
+	"schemas": {
+		New:             reflect.ValueOf(NewResourceSchema),
+		ConfigType:      reflect.TypeOf(ResourceSchema{}.config),
+		DeleteFN:        DeleteSchema,
+		UpdateUpdatesID: true,
+	},
+	"volumes": {
+		New:             reflect.ValueOf(NewResourceVolume),
+		ConfigType:      reflect.TypeOf(ResourceVolume{}.config),
+		DeleteFN:        DeleteVolume,
+		UpdateUpdatesID: true,
+	},
+	"apps": {
+		New:        reflect.ValueOf(NewResourceApp),
+		ConfigType: reflect.TypeOf(ResourceApp{}.config),
+		DeleteFN:   DeleteApp,
+	},
+	"sql_warehouses": {
+		New:        reflect.ValueOf(NewResourceSqlWarehouse),
+		ConfigType: reflect.TypeOf(ResourceSqlWarehouse{}.config),
+		DeleteFN:   DeleteSqlWarehouse,
+	},
 }
 
 type IResource interface {
@@ -67,7 +75,7 @@ type IResource interface {
 
 	// Update the resource. Returns id of the resource.
 	// Usually returns the same id as oldId but can also return a different one (e.g. schemas and volumes when certain fields are changed)
-	// Note, UpdateableIDResource[group] must be true for this group if ID can be changed. Otherwise function must return the same ID.
+	// Note, SupportedResources[group].UpdateUpdatesID must be true for this group if ID can be changed. Otherwise function must return the same ID.
 	DoUpdate(ctx context.Context, oldID string) (string, error)
 
 	WaitAfterCreate(ctx context.Context) error
@@ -114,12 +122,7 @@ func invokeConstructor(ctor reflect.Value, client *databricks.WorkspaceClient, c
 }
 
 func New(client *databricks.WorkspaceClient, group, name string, config any) (IResource, reflect.Type, error) {
-	ctor, ok := supportedResources[group]
-	if !ok {
-		return nil, nil, fmt.Errorf("unsupported resource type: %s", group)
-	}
-
-	cfgType, ok := supportedResourcesTypes[group]
+	settings, ok := SupportedResources[group]
 	if !ok {
 		return nil, nil, fmt.Errorf("unsupported resource type: %s", group)
 	}
@@ -139,18 +142,18 @@ func New(client *databricks.WorkspaceClient, group, name string, config any) (IR
 		}
 	}
 
-	result, err := invokeConstructor(ctor, client, config)
+	result, err := invokeConstructor(settings.New, client, config)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return result, cfgType, nil
+	return result, settings.ConfigType, nil
 }
 
 func DeleteResource(ctx context.Context, client *databricks.WorkspaceClient, group, id string) error {
-	fn, ok := deletableResources[group]
+	settings, ok := SupportedResources[group]
 	if !ok {
 		return fmt.Errorf("cannot delete %s", group)
 	}
-	return fn(ctx, client, id)
+	return settings.DeleteFN(ctx, client, id)
 }