#zope.interface

[junya-hayashi-blog]

Domain Layer as a specification

Thesedays, I'm writing application using Hexagonal Architecture with python and feel that "domain layer seems to be behaving as a specification". Let me explain about that here.

Example: TagService

For explanation, let's use a simple example, "TagService".

I'll define ITagService interface on domain layer, implement it on infrastructure layer and use it on application layer. The application is writen by python, so interfaces are defined with zope.interface package (zope.interface is useful for Hexagonal Architecture in Python).

Domain Layer

from zope.interface import Interface class ITagService(Interface): # specification u""" Tag management domain service """ def add_tag(post, tag): u""" add tag to a post """ def remove_tag(post, tag): u""" remove tag from a post """

Infrastructure Layer

from zope.interface import implementer from .domain.model import ITagService @implementer(ITagService) # implement TagService as described in ITagService class TagService(object): u""" TagService using xxx """ def add_tag(self, post, tag): u""" add tag to a post """ # do some actual staff def remove_tag(self, post, tag): u""" remove tag from a post """ # do some actual staff

Application Layer

from .infrastructure import TagService def add_tag(post, tag): srv = TagService() srv.add_tag(post, tag) # use TagService as described in ITagService

The point is that ITagService defined in Domain Layer behaves as a bridge between application layer and infrastructure layer. In other words, ITagService behaves as a specification for both application and infrastructure layer.

browser implementation analogy

Let's think about these relationships using an analogy of browser implementation. (Or if you want, you can use C++ compiler implementation analogy or else instead.)

EcmaScript Specification behaves like a domain layer

Google Chrome implements EcmaScript Specification, like an infrastructure layer

Application Developer uses EcmaScript Specification, like an application layer

By defining EcmaScript specification, Chrome developer can implement features without knowing actual usage of application developers, and application developer can use JavaScript features without knowing Chrome's detailed implementation.

After I have adopted Hexagonal Architecture rather than Layered Architecture, responsibilities of each layer have been getting clearer.

[junya-hayashi-blog]

zope.interface is useful for Hexagonal Architecture in Python

When you use Hexagonal Architecture with DDD, interfaces for Repositories and Domain Services would be put on Domain layer. In such case, zope.interface is really useful for defining an interface, which helps you to write a simple code without multi-inheritance.

Here is an example.

domain layer

from abc import ABCMeta from zope.interface import Interface class Entity(object): """ Base class for Entity """ __metaclass__ = ABCMeta class IRepository(Interface): """ Interafce for Repository """ class IDomainService(Interface): """ Interface for Domain Service """ class Blog(Entity): def __init__(self, identity, title): self._identity = identity self._title = title class IBlogRepository(IRepository): """ Blog repository Interface """ def add_entity(blog): """ add blog """ def get_by(identity): """ get blog by identity """ class IBlogProvisioningService(IDomainService): """ Blog provisioning service interface """ def provision_blog(title): """ provision blog with title. returns Blog object """

infrastructure layer

import uuid from abc import ABCMeta from zope.interface import implementer from domain import Blog, IBlogRepository, IBlogProvisioningService class MySQLRepository(object): """ MySQL based repository """ __metaclass__ = ABCMeta class MemoryRepository(object): """ memory based repository """ __metaclass__ = ABCMeta @implementer(IBlogRepository) class BlogRepository(MySQLRepository): def add_entity(self, blog): # do some stuff pass def get_by(self, identity): # do some stuff return Blog(identity, "some stored title") @implementer(IBlogRepository) class BlogMemoryRepository(MemoryRepository): def add_entity(self, blog): # do some stuff pass def get_by(self, identity): # do some stuff return Blog(identity, "some stored title") @implementer(IBlogProvisioningService) class BlogProvisioningService(object): def __init__(self, repo): self._repo = repo def provision_blog(self, title): entity = Blog(uuid.uuid4().hex, title) self._repo.add_entity(entity)

test

import pytest from zope.interface.verify import verifyClass from domain import Blog, IBlogRepository, IBlogProvisioningService from infra import BlogRepository, BlogMemoryRepository, BlogProvisioningService def test_class_interface(): assert verifyClass(IBlogRepository, BlogRepository) assert verifyClass(IBlogRepository, BlogMemoryRepository) assert verifyClass(IBlogProvisioningService, BlogProvisioningService)