Repository Pattern

The repository pattern is a simplifying Abstraction over data storage; it allows us to decouple our model layer from the data layer by pretending that all of our data is in memory.

Apply Dependency Inversion Principle (DIP) to your ORM. Our domain model should be free of infrastructure concerns, so your ORM should import your model, and not the other way around.

The Repository pattern is a simple abstraction around permanent storage

The repository gives you the illusion of a collection of in-memory objects. It makes it easy to create a FakeRepository for testing and to swap fundamental details of your infrastructure without disrupting your core application. See appendix_csvs for an example.

The simplest version of a Repository in the abstract has two methods: add() and get():

class AbstractRepository(abc.ABC):
    @abc.abstractmethod  #(1)
    def add(self, batch: model.Batch):
        raise NotImplementedError  #(2)
 
    @abc.abstractmethod
    def get(self, reference) -> model.Batch:
        raise NotImplementedError

This means we can then implement a repository for each backend storage, such as:

class SqlAlchemyRepository(AbstractRepository):
    def __init__(self, session):
        self.session = session
 
    def add(self, batch):
        self.session.add(batch)
 
    def get(self, reference):
        return self.session.query(model.Batch).filter_by(reference=reference).one()
 
    def list(self):
        return self.session.query(model.Batch).all()

And allows us to create “fake” repositories for testing:

class FakeRepository(AbstractRepository):
 
    def __init__(self, batches):
        self._batches = set(batches)
 
    def add(self, batch):
        self._batches.add(batch)
 
    def get(self, reference):
        return next(b for b in self._batches if b.reference == reference)
 
    def list(self):
        return list(self._batches)