Abstract Factory Design Pattern

public interface Storage { void put(String key, byte[] data); }
public interface Queue   { void publish(Message m); }
public interface Secrets { String get(String name); }

// The abstract factory: one creation method per product in the family.
public interface InfraFactory {
    Storage createStorage();
    Queue   createQueue();
    Secrets createSecrets();
}

public final class AwsFactory implements InfraFactory {
    public Storage createStorage() { return new S3Storage(region); }
    public Queue   createQueue()   { return new SqsQueue(region); }
    public Secrets createSecrets() { return new SecretsManagerSecrets(region); }
}

public final class LocalFactory implements InfraFactory {
    public Storage createStorage() { return new MinioStorage("http://localhost:9000"); }
    public Queue   createQueue()   { return new InMemoryQueue(); }
    public Secrets createSecrets() { return new DotEnvSecrets(Path.of(".env")); }
}

// Chosen ONCE, at the edge of the application:
InfraFactory infra = switch (env) {
    case "prod"  -> new AwsFactory();
    case "local" -> new LocalFactory();
    default      -> throw new IllegalArgumentException(env);
};

var app = new App(infra.createStorage(), infra.createQueue(), infra.createSecrets());

// App only ever sees Storage, Queue and Secrets. There is no expression
// anywhere in the codebase that yields S3Storage next to an InMemoryQueue.

from typing import Protocol


class Storage(Protocol):
    def put(self, key: str, data: bytes) -> None: ...


class Queue(Protocol):
    def publish(self, message: Message) -> None: ...


class Secrets(Protocol):
    def get(self, name: str) -> str: ...


class InfraFactory(Protocol):
    def create_storage(self) -> Storage: ...
    def create_queue(self) -> Queue: ...
    def create_secrets(self) -> Secrets: ...


class AwsFactory:
    def __init__(self, region: str) -> None:
        self._region = region

    def create_storage(self) -> Storage:
        return S3Storage(self._region)

    def create_queue(self) -> Queue:
        return SqsQueue(self._region)

    def create_secrets(self) -> Secrets:
        return SecretsManagerSecrets(self._region)


# Python doesn't need `implements`: AwsFactory satisfies InfraFactory
# structurally. A NamedTuple bundle is often even more direct, since the
# "factory" here has no behaviour beyond construction:
#
#     class Infra(NamedTuple):
#         storage: Storage
#         queue: Queue
#         secrets: Secrets
#
#     def aws(region: str) -> Infra:
#         return Infra(S3Storage(region), SqsQueue(region), SecretsManagerSecrets(region))
#
# Same guarantee — you still can't build a mixed family — with one function
# per environment instead of one class.

#include <memory>

struct Storage { virtual ~Storage() = default; virtual void put(std::string_view, std::span<const std::byte>) = 0; };
struct Queue   { virtual ~Queue()   = default; virtual void publish(const Message&) = 0; };
struct Secrets { virtual ~Secrets() = default; virtual std::string get(std::string_view) = 0; };

struct InfraFactory {
    virtual ~InfraFactory() = default;
    virtual std::unique_ptr<Storage> create_storage() = 0;
    virtual std::unique_ptr<Queue>   create_queue()   = 0;
    virtual std::unique_ptr<Secrets> create_secrets() = 0;
};

class AwsFactory final : public InfraFactory {
public:
    explicit AwsFactory(std::string region) : region_(std::move(region)) {}

    std::unique_ptr<Storage> create_storage() override {
        return std::make_unique<S3Storage>(region_);
    }
    std::unique_ptr<Queue> create_queue() override {
        return std::make_unique<SqsQueue>(region_);
    }
    std::unique_ptr<Secrets> create_secrets() override {
        return std::make_unique<SecretsManagerSecrets>(region_);
    }

private:
    std::string region_;
};

// std::unique_ptr everywhere: the factory hands over ownership, and each
// abstract product needs its virtual destructor or deleting through the base
// pointer is undefined behaviour.

public interface IStorage { Task PutAsync(string key, byte[] data); }
public interface IQueue   { Task PublishAsync(Message message); }
public interface ISecrets { Task<string> GetAsync(string name); }

public interface IInfraFactory
{
    IStorage CreateStorage();
    IQueue   CreateQueue();
    ISecrets CreateSecrets();
}

public sealed class AwsFactory(string region) : IInfraFactory
{
    public IStorage CreateStorage() => new S3Storage(region);
    public IQueue   CreateQueue()   => new SqsQueue(region);
    public ISecrets CreateSecrets() => new SecretsManagerSecrets(region);
}

// In .NET the DI container usually plays this role — but note that registering
// the three interfaces separately loses the family guarantee:
//
//     services.AddSingleton<IStorage, S3Storage>();      // nothing stops you
//     services.AddSingleton<IQueue, InMemoryQueue>();    // from mixing here
//
// Registering the FACTORY keeps it:
//
//     services.AddSingleton<IInfraFactory>(_ => env switch {
//         "prod"  => new AwsFactory(region),
//         "local" => new LocalFactory(),
//     });
//     services.AddSingleton(sp => sp.GetRequiredService<IInfraFactory>().CreateStorage());
//
// That's the whole argument for using this pattern alongside a container.

// A factory here is an object of constructor functions — no classes needed.

const awsFactory = region => ({
  createStorage: () => new S3Storage(region),
  createQueue:   () => new SqsQueue(region),
  createSecrets: () => new SecretsManagerSecrets(region),
})

const localFactory = () => ({
  createStorage: () => new MinioStorage('http://localhost:9000'),
  createQueue:   () => new InMemoryQueue(),
  createSecrets: () => new DotEnvSecrets('.env'),
})

const FACTORIES = {
  prod: () => awsFactory(process.env.AWS_REGION),
  local: localFactory,
}

// Chosen once, at the composition root.
const makeInfra = FACTORIES[process.env.APP_ENV]
if (!makeInfra) throw new Error(`unknown APP_ENV: ${process.env.APP_ENV}`)

const factory = makeInfra()
export const infra = {
  storage: factory.createStorage(),
  queue: factory.createQueue(),
  secrets: factory.createSecrets(),
}

// The whole app imports `infra` and gets a consistent set. Nothing in the
// codebase can construct a half-AWS, half-local one.

package infra

// Go's implicit interfaces make the abstract factory a plain interface with no
// declaration ceremony — and because a struct of interfaces is just as good
// here, many Go codebases skip the factory type entirely.

type Storage interface{ Put(key string, data []byte) error }
type Queue interface{ Publish(Message) error }
type Secrets interface{ Get(name string) (string, error) }

type Factory interface {
	Storage() Storage
	Queue() Queue
	Secrets() Secrets
}

type awsFactory struct{ region string }

func AWS(region string) Factory { return awsFactory{region} }

func (f awsFactory) Storage() Storage { return NewS3(f.region) }
func (f awsFactory) Queue() Queue     { return NewSQS(f.region) }
func (f awsFactory) Secrets() Secrets { return NewSecretsManager(f.region) }

// The flatter, very common Go alternative — a single constructor per family
// returning a bundle. Same guarantee, no interface needed:
//
//	type Infra struct {
//		Storage Storage
//		Queue   Queue
//		Secrets Secrets
//	}
//
//	func NewAWS(region string) Infra {
//		return Infra{NewS3(region), NewSQS(region), NewSecretsManager(region)}
//	}
//
// Prefer the interface form only when the family must be swapped at runtime
// rather than chosen once at startup.

interface Storage { put(key: string, data: Uint8Array): Promise<void> }
interface Queue   { publish(message: Message): Promise<void> }
interface Secrets { get(name: string): Promise<string> }

interface InfraFactory {
  createStorage(): Storage
  createQueue(): Queue
  createSecrets(): Secrets
}

class AwsFactory implements InfraFactory {
  constructor(private readonly region: string) {}
  createStorage(): Storage { return new S3Storage(this.region) }
  createQueue(): Queue     { return new SqsQueue(this.region) }
  createSecrets(): Secrets { return new DotEnvSecrets() }
  //                               ^^^^^^^^^^^^^^^^^^ compile error:
  // DotEnvSecrets is not assignable to Secrets in the AWS family — and even
  // when it structurally matches, keeping each family in its own class is what
  // makes a mismatched member reviewable in a diff.
}

const FACTORIES = {
  prod: () => new AwsFactory(process.env.AWS_REGION!),
  local: () => new LocalFactory(),
} satisfies Record<string, () => InfraFactory>

type Env = keyof typeof FACTORIES   // 'prod' | 'local'

export function makeInfra(env: Env) {
  const f = FACTORIES[env]()
  return { storage: f.createStorage(), queue: f.createQueue(), secrets: f.createSecrets() }
}

// `satisfies` keeps Env as a literal union, so an unknown environment name is
// a compile error rather than an undefined at startup.