Best practices for branching in the graph

[abhinav]

Problem

Suppose a program has a Store interface with two implementations: a memory-backed version and a Redis-backed version.

type Store interface {
	Get(k string) (v string, error)
	Set(k, v string) error
}

type MemoryStore struct{ m map[string]string }

func NewMemoryStore() *MemoryStore

type RedisStore struct{ /* ... */ }

func NewRedisStore(*redis.Client) *RedisStore

The memory store has no dependencies, while the Redis store depends on a Redis client.

flowchart LR
  MemoryStore
  RedisStore -->|NewRedisStore| RedisClient[*redis.Client]

The application wants to pick between the two implementations based on a configuration parameter.
Imagine:

func NewStore(cfg Config, memStore *MemoryStore, rediStore *RedisStore) Store {
	if cfg.Development {
		return memStore
	}
	return redisStore
}

However, as a result of this, NewStore has a hard transitive dependency on the Redis client, even if the Redis store won't be used.

flowchart LR
  MemoryStore
  RedisStore -->|NewRedisStore| RedisClient[*redis.Client]
  Store -->|NewStore| Config & MemoryStore & RedisStore
  Store -.-> RedisClient

Ideally, NewStore should be able to specify which dependency set it wants to use after looking at the configuration.

Is this something that is possible today with Fx? Perhaps with fx.Replace?
Would the dependency on *redis.Client be completely disconnected in development with the use of fx.Replace?

[abhinav]

As of writing this, it does not look like it's possible to severe the dependency between Store and *redis.Client conditionally.

Because the change is conditional, we have to use fx.Decorate, not fx.Replace, which results in:

fx.Decorate(
	func(s Store, c *Config) Store {
		if c.Development {
			return s
		}
		return NewMemoryStore()
	},
)

This will still have a dependency on the Redis store.