[CLD-781]: fix(datstore): change datastore type to enum (#534)

Instead of using string , we use enum to represent the location of the
datastore data.

Also exposes the location in the field of the Config struct so it can be
used to select the right client to load.

JIRA: https://smartcontract-it.atlassian.net/browse/CLD-781

Author: graham-chainlink

.changeset/good-chairs-allow.md

@@ -0,0 +1,5 @@
+---
+"chainlink-deployments-framework": patch
+---
+
+fix(catalog): use enum instead of string

engine/cld/config/config.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/smartcontractkit/chainlink-deployments-framework/pkg/logger"
 
+	cfgdomain "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/domain"
 	cfgenv "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/env"
 	cfgjira "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/jira"
 	cfgnet "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/network"
@@ -29,6 +30,9 @@ type Config struct {
 	// Jira contains JIRA integration configuration including connection details
 	// and field mappings for using JIRA in resolvers.
 	Jira *cfgjira.Config
+
+	// DatastoreType specifies the type of datastore to use (either "file" or "catalog").
+	DatastoreType cfgdomain.DatastoreType
 }
 
 // Load loads and consolidates all configuration required for a domain environment, including
@@ -54,9 +58,15 @@ func Load(dom fdomain.Domain, env string, lggr logger.Logger) (*Config, error) {
 		}
 	}
 
+	datastoreType, err := LoadDatastoreType(dom, env)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load datastore type config: %w", err)
+	}
+
 	return &Config{
-		Networks: networks,
-		Env:      envCfg,
-		Jira:     jiraCfg,
+		Networks:      networks,
+		Env:           envCfg,
+		Jira:          jiraCfg,
+		DatastoreType: datastoreType,
 	}, nil
 }

engine/cld/config/config_test.go

@@ -71,6 +71,7 @@ func Test_Load(t *testing.T) {
 				require.NoError(t, err)
 				require.NotEmpty(t, got.Networks)
 				require.NotNil(t, got.Env)
+				require.NotEmpty(t, got.DatastoreType, "DatastoreType should be loaded")
 			}
 		})
 	}

engine/cld/config/domain/domain.go

@@ -9,10 +9,30 @@ import (
 	"github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/jira"
 )
 
+// DatastoreType represents the type of datastore to use for persisting deployment data.
+type DatastoreType string
+
+const (
+	// DatastoreTypeFile indicates data should be persisted to local JSON files (default behavior).
+	DatastoreTypeFile DatastoreType = "file"
+	// DatastoreTypeCatalog indicates data should be persisted to the remote catalog service.
+	DatastoreTypeCatalog DatastoreType = "catalog"
+)
+
+// String returns the string representation of the DatastoreType.
+func (d DatastoreType) String() string {
+	return string(d)
+}
+
+// IsValid checks if the DatastoreType is a valid value.
+func (d DatastoreType) IsValid() bool {
+	return d == DatastoreTypeFile || d == DatastoreTypeCatalog
+}
+
 // Environment represents a single environment configuration.
 type Environment struct {
-	NetworkTypes []string `mapstructure:"network_types" yaml:"network_types"`
-	Datastore    string   `mapstructure:"datastore" yaml:"datastore"`
+	NetworkTypes []string      `mapstructure:"network_types" yaml:"network_types"`
+	Datastore    DatastoreType `mapstructure:"datastore" yaml:"datastore"`
 }
 
 // validate validates the environment configuration.
@@ -38,8 +58,8 @@ func (e *Environment) validate() error {
 	}
 
 	// Validate datastore field if provided
-	if e.Datastore != "" && !isValidDatastore(e.Datastore) {
-		return errors.New("invalid datastore value: " + e.Datastore + " (must be 'file' or 'catalog')")
+	if e.Datastore != "" && !e.Datastore.IsValid() {
+		return fmt.Errorf("invalid datastore value: %s (must be 'file' or 'catalog')", e.Datastore)
 	}
 
 	return nil
@@ -50,11 +70,6 @@ func isValidNetworkType(networkType string) bool {
 	return networkType == "mainnet" || networkType == "testnet"
 }
 
-// isValidDatastore checks if the datastore value is valid.
-func isValidDatastore(datastore string) bool {
-	return datastore == "file" || datastore == "catalog"
-}
-
 // DomainConfig represents the parsed and validated domain configuration.
 type DomainConfig struct {
 	Environments map[string]Environment `mapstructure:"environments" yaml:"environments"`
@@ -101,7 +116,7 @@ func Load(filePath string) (*DomainConfig, error) {
 	// Apply defaults to environments
 	for name, env := range cfg.Environments {
 		if env.Datastore == "" {
-			env.Datastore = "file" // Default to file if not specified
+			env.Datastore = DatastoreTypeFile // Default to file if not specified
 			cfg.Environments[name] = env
 		}
 	}

engine/cld/config/domain/domain_test.go

@@ -48,32 +48,32 @@ func TestIsValidNetworkType(t *testing.T) {
 	}
 }
 
-func TestIsValidDatastore(t *testing.T) {
+func TestDatastoreType_IsValid(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
 		name      string
-		datastore string
+		datastore DatastoreType
 		expected  bool
 	}{
 		{
 			name:      "file is valid",
-			datastore: "file",
+			datastore: DatastoreTypeFile,
 			expected:  true,
 		},
 		{
 			name:      "catalog is valid",
-			datastore: "catalog",
+			datastore: DatastoreTypeCatalog,
 			expected:  true,
 		},
 		{
 			name:      "invalid value",
-			datastore: "invalid",
+			datastore: DatastoreType("invalid"),
 			expected:  false,
 		},
 		{
 			name:      "empty value",
-			datastore: "",
+			datastore: DatastoreType(""),
 			expected:  false,
 		},
 	}
@@ -82,7 +82,7 @@ func TestIsValidDatastore(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			assert.Equal(t, tt.expected, isValidDatastore(tt.datastore))
+			assert.Equal(t, tt.expected, tt.datastore.IsValid())
 		})
 	}
 }
@@ -121,15 +121,15 @@ func TestEnvironment_Validate(t *testing.T) {
 			name: "valid environment with file datastore",
 			environment: Environment{
 				NetworkTypes: []string{"testnet"},
-				Datastore:    "file",
+				Datastore:    DatastoreTypeFile,
 			},
 			wantErr: false,
 		},
 		{
 			name: "valid environment with catalog datastore",
 			environment: Environment{
 				NetworkTypes: []string{"mainnet"},
-				Datastore:    "catalog",
+				Datastore:    DatastoreTypeCatalog,
 			},
 			wantErr: false,
 		},
@@ -177,7 +177,7 @@ func TestEnvironment_Validate(t *testing.T) {
 			name: "invalid datastore value",
 			environment: Environment{
 				NetworkTypes: []string{"testnet"},
-				Datastore:    "invalid",
+				Datastore:    DatastoreType("invalid"),
 			},
 			wantErr:     true,
 			errContains: "invalid datastore value: invalid",
@@ -231,27 +231,27 @@ func TestLoad(t *testing.T) {
 				// Test specific environment configurations
 				dev := config.Environments["development"]
 				assert.Equal(t, []string{"testnet"}, dev.NetworkTypes)
-				assert.Equal(t, "file", dev.Datastore)
+				assert.Equal(t, DatastoreTypeFile, dev.Datastore)
 
 				staging := config.Environments["staging"]
 				assert.ElementsMatch(t, []string{"testnet", "mainnet"}, staging.NetworkTypes)
-				assert.Equal(t, "catalog", staging.Datastore)
+				assert.Equal(t, DatastoreTypeCatalog, staging.Datastore)
 
 				prod := config.Environments["production"]
 				assert.Equal(t, []string{"mainnet"}, prod.NetworkTypes)
-				assert.Equal(t, "catalog", prod.Datastore)
+				assert.Equal(t, DatastoreTypeCatalog, prod.Datastore)
 
 				local := config.Environments["local"]
 				assert.Equal(t, []string{"testnet"}, local.NetworkTypes)
-				assert.Equal(t, "file", local.Datastore)
+				assert.Equal(t, DatastoreTypeFile, local.Datastore)
 
 				dudeenv := config.Environments["dudeenv"]
 				assert.Equal(t, []string{"testnet"}, dudeenv.NetworkTypes)
-				assert.Equal(t, "file", dudeenv.Datastore) // Not set in YAML, should default to "file"
+				assert.Equal(t, DatastoreTypeFile, dudeenv.Datastore) // Not set in YAML, should default to "file"
 
 				testtest := config.Environments["testtest"]
 				assert.Equal(t, []string{"mainnet"}, testtest.NetworkTypes)
-				assert.Equal(t, "catalog", testtest.Datastore)
+				assert.Equal(t, DatastoreTypeCatalog, testtest.Datastore)
 			},
 		},
 		{
@@ -283,7 +283,7 @@ func TestLoad(t *testing.T) {
 
 				// dudeenv doesn't have datastore specified in YAML, should default to "file"
 				dudeenv := config.Environments["dudeenv"]
-				assert.Equal(t, "file", dudeenv.Datastore)
+				assert.Equal(t, DatastoreTypeFile, dudeenv.Datastore)
 			},
 		},
 	}

engine/cld/config/env.go

@@ -4,10 +4,28 @@ import (
 	"fmt"
 	"path/filepath"
 
+	cfgdomain "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/domain"
 	cfgenv "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/env"
 	fdomain "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/domain"
 )
 
+// LoadDatastoreType retrieves the datastore type configuration for a given domain and environment.
+// It loads the domain configuration file and extracts the datastore setting for the specified environment.
+func LoadDatastoreType(dom fdomain.Domain, env string) (cfgdomain.DatastoreType, error) {
+	domainCfgPath := dom.ConfigDomainFilePath()
+	domainCfg, err := cfgdomain.Load(domainCfgPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to load domain config: %w", err)
+	}
+
+	envConfig, exists := domainCfg.Environments[env]
+	if !exists {
+		return "", fmt.Errorf("environment %s not found in domain config", env)
+	}
+
+	return envConfig.Datastore, nil
+}
+
 // LoadEnvConfig retrieves the environment configuration for a given domain and environment.
 //
 // Loading strategy:

engine/cld/config/env_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	cfgenv "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/env"
+	fdomain "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/domain"
 )
 
 func Test_LoadEnvConfig(t *testing.T) { //nolint:paralleltest // These tests are not parallel safe due to setting of env vars
@@ -192,3 +193,104 @@ func Test_LoadEnvConfig(t *testing.T) { //nolint:paralleltest // These tests are
 		})
 	}
 }
+
+func Test_LoadDatastoreType(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		beforeFunc func(t *testing.T, dom fdomain.Domain, envKey string)
+		wantValue  string
+		wantErr    string
+	}{
+		{
+			name: "successfully loads datastore type - file",
+			beforeFunc: func(t *testing.T, dom fdomain.Domain, envKey string) {
+				t.Helper()
+
+				writeConfigDomainFile(t, dom, "domain.yaml")
+			},
+			wantValue: "file",
+		},
+		{
+			name: "successfully loads datastore type - catalog",
+			beforeFunc: func(t *testing.T, dom fdomain.Domain, envKey string) {
+				t.Helper()
+
+				// Create a custom domain.yaml with catalog datastore
+				domainYAML := `environments:
+  staging_testnet:
+    network_types:
+      - testnet
+    datastore: catalog
+`
+				err := os.WriteFile(dom.ConfigDomainFilePath(), []byte(domainYAML), filePerms)
+				require.NoError(t, err)
+			},
+			wantValue: "catalog",
+		},
+		{
+			name: "successfully loads datastore type - defaults to file when not specified",
+			beforeFunc: func(t *testing.T, dom fdomain.Domain, envKey string) {
+				t.Helper()
+
+				// Create a domain.yaml without datastore field
+				domainYAML := `environments:
+  staging_testnet:
+    network_types:
+      - testnet
+`
+				err := os.WriteFile(dom.ConfigDomainFilePath(), []byte(domainYAML), filePerms)
+				require.NoError(t, err)
+			},
+			wantValue: "file",
+		},
+		{
+			name: "fails when domain config file does not exist",
+			beforeFunc: func(t *testing.T, dom fdomain.Domain, envKey string) {
+				t.Helper()
+				// Don't create domain.yaml file
+			},
+			wantErr: "failed to load domain config",
+		},
+		{
+			name: "fails when environment not found in domain config",
+			beforeFunc: func(t *testing.T, dom fdomain.Domain, envKey string) {
+				t.Helper()
+
+				// Create a domain.yaml with a different environment
+				domainYAML := `environments:
+  production:
+    network_types:
+      - mainnet
+    datastore: file
+`
+				err := os.WriteFile(dom.ConfigDomainFilePath(), []byte(domainYAML), filePerms)
+				require.NoError(t, err)
+			},
+			wantErr: "environment staging_testnet not found in domain config",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			dom, envKey := setupConfigDirs(t)
+
+			if tt.beforeFunc != nil {
+				tt.beforeFunc(t, dom, envKey)
+			}
+
+			got, err := LoadDatastoreType(dom, envKey)
+
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				require.ErrorContains(t, err, tt.wantErr)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.wantValue, got.String())
+			}
+		})
+	}
+}