refactor: refactor network url transformer (#259)

This refactor changes the URL Transform Load Option to accept a simple
transform function, and moves the logic of which URLs to transform to
the config itself.

This simplifies the caller's API and avoids exposing the internal config
structure to the caller.

Author: jkongie

.changeset/cute-tigers-smell.md

@@ -0,0 +1,5 @@
+---
+"chainlink-deployments-framework": minor
+---
+
+[BREAKING] The Load function of Network Config has been changed to simplify the URL transformation option

engine/cld/config/network/config.go

@@ -134,6 +134,32 @@ func ChainFamilyFilter(chainFamily string) NetworkFilter {
 	}
 }
 
+// transformRPCURLs transforms the RPC URLs of the networks in the config.
+func (c *Config) transformRPCURLs(transform URLTransformer) {
+	for k, n := range c.networks {
+		// Transform the RPC URLS
+		for i, rpc := range n.RPCs {
+			rpc.HTTPURL = transform(rpc.HTTPURL)
+			rpc.WSURL = transform(rpc.WSURL)
+
+			n.RPCs[i] = rpc
+		}
+
+		// Transform EVM Metadata URLs
+		md, err := DecodeMetadata[EVMMetadata](n.Metadata)
+		if err != nil {
+			continue // skip this network since metadata cannot be decoded
+		}
+
+		md.AnvilConfig.ArchiveHTTPURL = transform(md.AnvilConfig.ArchiveHTTPURL)
+		n.Metadata = md
+
+		// Update the network with the modifications. We need to do this the network is a value
+		// type, so we need to update the map with the new network.
+		c.networks[k] = n
+	}
+}
+
 // Load loads configuration from the specified file paths, and merges them into a single Config.
 //
 // It accepts load options to customize the loading behavior.
@@ -162,8 +188,8 @@ func Load(filePaths []string, opts ...LoadOption) (*Config, error) {
 	}
 
 	// Apply the URL transformer if one is provided.
-	if loadCfg.URLTransformer != nil {
-		loadCfg.URLTransformer(cfg)
+	if loadCfg.RPCURLTransformer != nil {
+		cfg.transformRPCURLs(loadCfg.RPCURLTransformer)
 	}
 
 	return cfg, nil
@@ -172,17 +198,18 @@ func Load(filePaths []string, opts ...LoadOption) (*Config, error) {
 // LoadOption defines a function that modifies the load configuration.
 type LoadOption func(*loadConfig)
 
-// URLTransformer is a function that transforms the URLs in the Config.
-type URLTransformer func(*Config)
-
 // loadConfig holds the configuration for loading the config.
 type loadConfig struct {
-	URLTransformer URLTransformer
+	RPCURLTransformer URLTransformer
 }
 
-// WithURLTransform allows setting a custom URL transformer for the config.
-func WithURLTransform(t URLTransformer) func(opts *loadConfig) {
+// URLTransformer is a function that transforms a URL.
+type URLTransformer func(string) string
+
+// WithRPCURLTransformer is a load option that transforms the RPC URLs of the networks in the
+// config.
+func WithRPCURLTransformer(t URLTransformer) LoadOption {
 	return func(opts *loadConfig) {
-		opts.URLTransformer = t
+		opts.RPCURLTransformer = t
 	}
 }

engine/cld/config/network/config_test.go

@@ -686,43 +686,70 @@ networks:
 - type: "mainnet"
   chain_selector: 1
   rpcs:
-  - rpc_name: "test_rpc"
-    preferred_url_scheme: "http"
-    http_url: "https://test.rpc"
-    ws_url: "wss://test.rpc"`
+    - rpc_name: "test_rpc"
+      preferred_url_scheme: "http"
+      http_url: "https://test.rpc"
+      ws_url: "wss://test.rpc"
+  metadata:
+    anvil_config:
+      archive_http_url: "https://test.archive.rpc"
+`
 
 	tmpFile := filepath.Join(tmpDir, "test.yaml")
 	err := os.WriteFile(tmpFile, []byte(yamlContent), 0600)
 	require.NoError(t, err, "Failed to create test file")
 
-	// Test URL transformer
-	transformer := func(cfg *Config) {
-		for _, network := range cfg.Networks() {
-			for j, rpc := range network.RPCs {
-				rpc.HTTPURL = strings.Replace(rpc.HTTPURL, "test", "test2", 1)
-				rpc.WSURL = strings.Replace(rpc.WSURL, "test", "test2", 1)
-				network.RPCs[j] = rpc
-			}
-		}
+	// Simple URL transformer
+	transformFunc := func(url string) string {
+		return strings.Replace(url, "test", "test2", 1)
 	}
 
-	got, err := Load([]string{tmpFile}, WithURLTransform(transformer))
-	require.NoError(t, err, "Load() should not return an error")
-
-	want := NewConfig([]Network{
+	tests := []struct {
+		name               string
+		givePath           string
+		giveURLTransformer URLTransformer
+		want               *Config
+		wantErr            string
+	}{
 		{
-			Type:          "mainnet",
-			ChainSelector: 1,
-			RPCs: []RPC{
+			name:               "transform RPC URLs",
+			givePath:           tmpFile,
+			giveURLTransformer: transformFunc,
+			want: NewConfig([]Network{
 				{
-					RPCName:            "test_rpc",
-					PreferredURLScheme: "http",
-					HTTPURL:            "https://test2.rpc",
-					WSURL:              "wss://test2.rpc",
+					Type:          "mainnet",
+					ChainSelector: 1,
+					RPCs: []RPC{
+						{
+							RPCName:            "test_rpc",
+							PreferredURLScheme: "http",
+							HTTPURL:            "https://test2.rpc",
+							WSURL:              "wss://test2.rpc",
+						},
+					},
+					Metadata: EVMMetadata{
+						AnvilConfig: &AnvilConfig{
+							ArchiveHTTPURL: "https://test2.archive.rpc",
+						},
+					},
 				},
-			},
+			}),
 		},
-	})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := Load([]string{tt.givePath}, WithRPCURLTransformer(tt.giveURLTransformer))
+			require.NoError(t, err)
 
-	assert.Equal(t, want, got)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.want, got)
+			}
+		})
+	}
 }