├── Application
    ├── Assembler
    │   ├── Assembler.php
    │   ├── CollectionAssembler.php
    │   ├── DefaultAssembler.php
    │   └── DefaultCollectionAssembler.php
    └── Dto
    │   ├── DefaultDto.php
    │   └── Dto.php
├── Domain
    ├── Collection
    │   ├── ArrayCollection.php
    │   └── Collection.php
    ├── Contract
    │   ├── HasClassName.php
    │   ├── HasEqualsTo.php
    │   ├── HasId.php
    │   ├── HasSameTypeAs.php
    │   └── HasTypeOf.php
    ├── Event
    │   ├── DefaultEvent.php
    │   ├── DefaultMessage.php
    │   ├── DefaultStream.php
    │   ├── Event.php
    │   ├── Message.php
    │   ├── Metadata.php
    │   └── Stream.php
    ├── Exception
    │   ├── InvalidArgumentException.php
    │   └── NotMatchTypeException.php
    ├── Model
    │   ├── AggregateRoot.php
    │   ├── DefaultEntity.php
    │   ├── DefaultValueObject.php
    │   ├── Entity.php
    │   ├── Id
    │   │   └── Id.php
    │   └── ValueObject.php
    ├── Object
    │   ├── DefaultObject.php
    │   └── Object.php
    ├── Repository
    │   ├── ReadRepository.php
    │   └── Repository.php
    ├── Service
    │   ├── IdentityGenerator
    │   │   └── IdentityGenerator.php
    │   ├── MessageSerializer
    │   │   ├── Message.php
    │   │   ├── MessageSerializer.php
    │   │   └── MessageSerializerData.php
    │   ├── Serializer
    │   │   └── Serializer.php
    │   └── Service.php
    └── Traits
    │   ├── ClassName.php
    │   ├── SameTypeAs.php
    │   └── TypeOf.php
├── Infrastructure
    ├── Repository
    │   ├── MemoryReadRepository.php
    │   └── MemoryRepository.php
    └── Service
    │   ├── IdentityGenerator
    │       ├── CombUuid4Generator.php
    │       ├── RandomUuidGenerator.php
    │       └── Uuid4Generator.php
    │   └── MessageSerializer
    │       └── MessageSerializer.php
├── LICENSE
├── composer.json
└── readme.md


/Application/Assembler/Assembler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Application\Assembler;
 4 | 
 5 | use Zelenin\Ddd\Core\Application\Dto\Dto;
 6 | use Zelenin\Ddd\Core\Domain\Model\Entity;
 7 | 
 8 | interface Assembler
 9 | {
10 |     /**
11 |      * @param Entity $entity
12 |      *
13 |      * @return Dto
14 |      */
15 |     public function toDto(Entity $entity);
16 | 
17 |     /**
18 |      * @param Dto $dto
19 |      *
20 |      * @return Entity
21 |      */
22 |     public function toEntity(Dto $dto);
23 | }
24 | 


--------------------------------------------------------------------------------
/Application/Assembler/CollectionAssembler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Application\Assembler;
 4 | 
 5 | use Zelenin\Ddd\Core\Application\Dto\Dto;
 6 | use Zelenin\Ddd\Core\Domain\Model\Entity;
 7 | 
 8 | interface CollectionAssembler
 9 | {
10 |     /**
11 |      * @param Entity[] $entities
12 |      *
13 |      * @return Dto[]
14 |      */
15 |     public function toDto(array $entities);
16 | 
17 |     /**
18 |      * @param Dto[] $dtos
19 |      *
20 |      * @return Entity[]
21 |      */
22 |     public function toEntity(array $dtos);
23 | }
24 | 


--------------------------------------------------------------------------------
/Application/Assembler/DefaultAssembler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Application\Assembler;
 4 | 
 5 | use Zelenin\Ddd\Core\Application\Dto\Dto;
 6 | use Zelenin\Ddd\Core\Domain\Model\Entity;
 7 | use Zelenin\Ddd\Core\Domain\Object\DefaultObject;
 8 | 
 9 | abstract class DefaultAssembler extends DefaultObject implements Assembler
10 | {
11 |     /**
12 |      * @param Entity $entity
13 |      *
14 |      * @return Dto
15 |      */
16 |     abstract public function toDto(Entity $entity);
17 | 
18 |     /**
19 |      * @param Dto $dto
20 |      *
21 |      * @return Entity
22 |      */
23 |     abstract public function toEntity(Dto $dto);
24 | }
25 | 


--------------------------------------------------------------------------------
/Application/Assembler/DefaultCollectionAssembler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Application\Assembler;
 4 | 
 5 | use Zelenin\Ddd\Core\Application\Dto\Dto;
 6 | use Zelenin\Ddd\Core\Domain\Model\Entity;
 7 | 
 8 | final class DefaultCollectionAssembler implements CollectionAssembler
 9 | {
10 |     /**
11 |      * @var Assembler
12 |      */
13 |     private $assembler;
14 | 
15 |     /**
16 |      * @param Assembler $assembler
17 |      */
18 |     public function __construct(Assembler $assembler)
19 |     {
20 |         $this->assembler = $assembler;
21 |     }
22 | 
23 |     /**
24 |      * @param Entity[] $entities
25 |      *
26 |      * @return Dto[]
27 |      */
28 |     public function toDto(array $entities)
29 |     {
30 |         return array_map(function (Entity $entity) {
31 |             return $this->assembler->toDto($entity);
32 |         }, $entities);
33 |     }
34 | 
35 |     /**
36 |      * @param Dto[] $dtos
37 |      *
38 |      * @return Entity[]
39 |      */
40 |     public function toEntity(array $dtos)
41 |     {
42 |         return array_map(function (Dto $dto) {
43 |             return $this->assembler->toEntity($dto);
44 |         }, $dtos);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/Application/Dto/DefaultDto.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Application\Dto;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Object\DefaultObject;
 6 | 
 7 | abstract class DefaultDto extends DefaultObject implements Dto
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/Application/Dto/Dto.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Zelenin\Ddd\Core\Application\Dto;
4 | 
5 | interface Dto
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/Domain/Collection/ArrayCollection.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\Ddd\Core\Domain\Collection;
  4 | 
  5 | use ArrayIterator;
  6 | 
  7 | class ArrayCollection implements Collection
  8 | {
  9 |     /**
 10 |      * @var array
 11 |      */
 12 |     private $items = [];
 13 | 
 14 |     /**
 15 |      * @param array $items
 16 |      */
 17 |     public function __construct(array $items = [])
 18 |     {
 19 |         $this->items = $items;
 20 |     }
 21 | 
 22 |     /**
 23 |      * @param $item
 24 |      */
 25 |     public function add($item)
 26 |     {
 27 |         $this->items[] = $item;
 28 |     }
 29 | 
 30 |     /**
 31 |      * @param $key
 32 |      * @param $value
 33 |      */
 34 |     public function set($key, $value)
 35 |     {
 36 |         $this->items[$key] = $value;
 37 |     }
 38 | 
 39 |     /**
 40 |      * @param $key
 41 |      *
 42 |      * @return mixed
 43 |      */
 44 |     public function remove($key)
 45 |     {
 46 |         if (!$this->containsKey($key)) {
 47 |             return null;
 48 |         }
 49 | 
 50 |         $item = $this->items[$key];
 51 |         unset($this->items[$key]);
 52 | 
 53 |         return $item;
 54 |     }
 55 | 
 56 |     /**
 57 |      * @param $item
 58 |      *
 59 |      * @return bool
 60 |      */
 61 |     public function removeItem($item)
 62 |     {
 63 |         $key = array_search($item, $this->items, true);
 64 | 
 65 |         if ($key === false) {
 66 |             return false;
 67 |         }
 68 | 
 69 |         unset($this->items[$key]);
 70 | 
 71 |         return true;
 72 |     }
 73 | 
 74 |     /**
 75 |      * @param $key
 76 |      *
 77 |      * @return mixed
 78 |      */
 79 |     public function get($key)
 80 |     {
 81 |         return $this->containsKey($key) ? $this->items[$key] : null;
 82 |     }
 83 | 
 84 |     public function clear()
 85 |     {
 86 |         $this->items = [];
 87 |     }
 88 | 
 89 |     /**
 90 |      * @return bool
 91 |      */
 92 |     public function isEmpty()
 93 |     {
 94 |         return $this->count() === 0;
 95 |     }
 96 | 
 97 |     /**
 98 |      * @return array
 99 |      */
100 |     public function getKeys()
101 |     {
102 |         return array_keys($this->items);
103 |     }
104 | 
105 |     /**
106 |      * @return array
107 |      */
108 |     public function getValues()
109 |     {
110 |         return array_values($this->items);
111 |     }
112 | 
113 |     /**
114 |      * @return int
115 |      */
116 |     public function count()
117 |     {
118 |         return count($this->items);
119 |     }
120 | 
121 |     /**
122 |      * @param $key
123 |      *
124 |      * @return bool
125 |      */
126 |     public function containsKey($key)
127 |     {
128 |         return array_key_exists($key, $this->items);
129 |     }
130 | 
131 |     /**
132 |      * @return array
133 |      */
134 |     public function toArray()
135 |     {
136 |         return $this->items;
137 |     }
138 | 
139 |     /**
140 |      * @param callable $callback
141 |      *
142 |      * @return static
143 |      */
144 |     public function filter(callable $callback)
145 |     {
146 |         return new static(array_filter($this->items, $callback));
147 |     }
148 | 
149 |     /**
150 |      * @param callable $callback
151 |      *
152 |      * @return static
153 |      */
154 |     public function map(callable $callback)
155 |     {
156 |         return new static(array_map($callback, $this->items));
157 |     }
158 | 
159 |     /**
160 |      * @param callable $keyCallback
161 |      * @param callable $valueCallback
162 |      *
163 |      * @return static
164 |      */
165 |     public function mapWithKeys(callable $keyCallback, callable $valueCallback)
166 |     {
167 |         $keys = array_map($keyCallback, $this->getValues());
168 |         $values = array_map($valueCallback, $this->getValues());
169 |         return new static(array_combine($keys, $values));
170 |     }
171 | 
172 |     /**
173 |      * @return ArrayIterator
174 |      */
175 |     public function getIterator()
176 |     {
177 |         return new ArrayIterator($this->items);
178 |     }
179 | 
180 |     /**
181 |      * @param mixed $offset
182 |      *
183 |      * @return bool
184 |      */
185 |     public function offsetExists($offset)
186 |     {
187 |         return $this->containsKey($offset);
188 |     }
189 | 
190 |     /**
191 |      * @param mixed $offset
192 |      *
193 |      * @return mixed
194 |      */
195 |     public function offsetGet($offset)
196 |     {
197 |         return $this->get($offset);
198 |     }
199 | 
200 |     /**
201 |      * @param mixed $offset
202 |      * @param mixed $value
203 |      */
204 |     public function offsetSet($offset, $value)
205 |     {
206 |         if ($offset === null) {
207 |             $this->add($value);
208 |         } else {
209 |             $this->set($offset, $value);
210 |         }
211 |     }
212 | 
213 |     /**
214 |      * @param mixed $offset
215 |      *
216 |      * @return mixed
217 |      */
218 |     public function offsetUnset($offset)
219 |     {
220 |         return $this->remove($offset);
221 |     }
222 | }
223 | 


--------------------------------------------------------------------------------
/Domain/Collection/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Collection;
 4 | 
 5 | use ArrayAccess;
 6 | use Countable;
 7 | use IteratorAggregate;
 8 | 
 9 | interface Collection extends Countable, IteratorAggregate, ArrayAccess
10 | {
11 |     /**
12 |      * @param $item
13 |      */
14 |     public function add($item);
15 | 
16 |     /**
17 |      * @param $key
18 |      * @param $value
19 |      */
20 |     public function set($key, $value);
21 | 
22 |     /**
23 |      * @param $key
24 |      *
25 |      * @return mixed
26 |      */
27 |     public function remove($key);
28 | 
29 |     /**
30 |      * @param $item
31 |      *
32 |      * @return bool
33 |      */
34 |     public function removeItem($item);
35 | 
36 |     /**
37 |      * @param $key
38 |      *
39 |      * @return mixed
40 |      */
41 |     public function get($key);
42 | 
43 |     public function clear();
44 | 
45 |     /**
46 |      * @return bool
47 |      */
48 |     public function isEmpty();
49 | 
50 |     /**
51 |      * @return array
52 |      */
53 |     public function getKeys();
54 | 
55 |     /**
56 |      * @return array
57 |      */
58 |     public function getValues();
59 | 
60 |     /**
61 |      * @return int
62 |      */
63 |     public function count();
64 | 
65 |     /**
66 |      * @param $key
67 |      *
68 |      * @return bool
69 |      */
70 |     public function containsKey($key);
71 | 
72 |     /**
73 |      * @return array
74 |      */
75 |     public function toArray();
76 | 
77 |     /**
78 |      * @param callable $callback
79 |      *
80 |      * @return static
81 |      */
82 |     public function filter(callable $callback);
83 | 
84 |     /**
85 |      * @param callable $callback
86 |      *
87 |      * @return static
88 |      */
89 |     public function map(callable $callback);
90 | }
91 | 


--------------------------------------------------------------------------------
/Domain/Contract/HasClassName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Contract;
 4 | 
 5 | interface HasClassName
 6 | {
 7 |     /**
 8 |      * @return string
 9 |      */
10 |     public static function className();
11 | }
12 | 


--------------------------------------------------------------------------------
/Domain/Contract/HasEqualsTo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Contract;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Object\Object;
 6 | 
 7 | interface HasEqualsTo
 8 | {
 9 |     /**
10 |      * @param Object $object
11 |      *
12 |      * @return bool
13 |      */
14 |     public function equalsTo(Object $object);
15 | }
16 | 


--------------------------------------------------------------------------------
/Domain/Contract/HasId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Contract;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Model\Id\Id;
 6 | 
 7 | interface HasId
 8 | {
 9 |     /**
10 |      * @return Id
11 |      */
12 |     public function getId();
13 | }
14 | 


--------------------------------------------------------------------------------
/Domain/Contract/HasSameTypeAs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Contract;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Object\Object;
 6 | 
 7 | interface HasSameTypeAs
 8 | {
 9 |     /**
10 |      * @param Object $object
11 |      *
12 |      * @return bool
13 |      */
14 |     public function sameTypeAs(Object $object);
15 | }
16 | 


--------------------------------------------------------------------------------
/Domain/Contract/HasTypeOf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Contract;
 4 | 
 5 | interface HasTypeOf
 6 | {
 7 |     /**
 8 |      * @param string $className
 9 |      *
10 |      * @return bool
11 |      */
12 |     public function typeOf($className);
13 | }
14 | 


--------------------------------------------------------------------------------
/Domain/Event/DefaultEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Event;
 4 | 
 5 | use ReflectionClass;
 6 | use Zelenin\Ddd\Core\Domain\Traits\ClassName;
 7 | 
 8 | abstract class DefaultEvent implements Event
 9 | {
10 |     use ClassName;
11 | 
12 |     /**
13 |      * @return string
14 |      */
15 |     public function name()
16 |     {
17 |         return (new ReflectionClass(static::className()))->getShortName();
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/Domain/Event/DefaultMessage.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zelenin\Ddd\Core\Domain\Event;
  4 | 
  5 | use Zelenin\Ddd\Core\Domain\Model\Id\Id;
  6 | use Zelenin\Ddd\ValueObject\Domain\Model\DateTime\Point\Calendar\DateTimeOfDay;
  7 | 
  8 | final class DefaultMessage implements Message
  9 | {
 10 |     /**
 11 |      * @var string
 12 |      */
 13 |     private $type;
 14 |     /**
 15 |      * @var string
 16 |      */
 17 |     private $name;
 18 | 
 19 |     /**
 20 |      * @return Id
 21 |      */
 22 |     private $aggregateRootId;
 23 | 
 24 |     /**
 25 |      * @var DateTimeOfDay
 26 |      */
 27 |     private $dateTime;
 28 | 
 29 |     /**
 30 |      * @var Metadata
 31 |      */
 32 |     private $metadata;
 33 | 
 34 |     /**
 35 |      * @return Event
 36 |      */
 37 |     private $data;
 38 | 
 39 |     /**
 40 |      * @param $type
 41 |      * @param Id $aggregateRootId
 42 |      * @param Metadata $metadata
 43 |      * @param Event $data
 44 |      */
 45 |     public function __construct($type, Id $aggregateRootId, Metadata $metadata, Event $data)
 46 |     {
 47 |         $this->type = $type;
 48 |         $this->name = $data->name();
 49 |         $this->aggregateRootId = $aggregateRootId;
 50 |         $this->dateTime = DateTimeOfDay::now();
 51 |         $this->metadata = $metadata;
 52 |         $this->data = $data;
 53 |     }
 54 | 
 55 |     /**
 56 |      * @return string
 57 |      */
 58 |     public function type()
 59 |     {
 60 |         return $this->type;
 61 |     }
 62 | 
 63 |     /**
 64 |      * @return string
 65 |      */
 66 |     public function name()
 67 |     {
 68 |         return $this->name;
 69 |     }
 70 | 
 71 |     /**
 72 |      * @return Id
 73 |      */
 74 |     public function aggregateRootId()
 75 |     {
 76 |         return $this->aggregateRootId;
 77 |     }
 78 | 
 79 |     /**
 80 |      * @return DateTimeOfDay
 81 |      */
 82 |     public function dateTime()
 83 |     {
 84 |         return $this->dateTime;
 85 |     }
 86 | 
 87 |     /**
 88 |      * @return Metadata
 89 |      */
 90 |     public function metaData()
 91 |     {
 92 |         return $this->metadata;
 93 |     }
 94 | 
 95 |     /**
 96 |      * @return Event
 97 |      */
 98 |     public function data()
 99 |     {
100 |         return $this->data;
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/Domain/Event/DefaultStream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Event;
 4 | 
 5 | use ArrayIterator;
 6 | 
 7 | final class DefaultStream implements Stream
 8 | {
 9 |     /**
10 |      * @var Message[]
11 |      */
12 |     private $events;
13 | 
14 |     /**
15 |      * @param Message[] $events
16 |      */
17 |     public function __construct(array $events)
18 |     {
19 |         $this->events = $events;
20 |     }
21 | 
22 |     /**
23 |      * @return ArrayIterator
24 |      */
25 |     public function getIterator()
26 |     {
27 |         return new ArrayIterator($this->events);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Domain/Event/Event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Event;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Service\MessageSerializer\Message;
 6 | 
 7 | interface Event extends Message
 8 | {
 9 |     /**
10 |      * @return string
11 |      */
12 |     public function name();
13 | }
14 | 


--------------------------------------------------------------------------------
/Domain/Event/Message.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Event;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Model\Id\Id;
 6 | use Zelenin\Ddd\ValueObject\Domain\Model\DateTime\Point\Calendar\DateTimeOfDay;
 7 | 
 8 | interface Message
 9 | {
10 |     /**
11 |      * @return string
12 |      */
13 |     public function type();
14 | 
15 |     /**
16 |      * @return string
17 |      */
18 |     public function name();
19 | 
20 |     /**
21 |      * @return Id
22 |      */
23 |     public function aggregateRootId();
24 | 
25 |     /**
26 |      * @return DateTimeOfDay
27 |      */
28 |     public function dateTime();
29 | 
30 |     /**
31 |      * @return Metadata
32 |      */
33 |     public function metaData();
34 | 
35 |     /**
36 |      * @return Event
37 |      */
38 |     public function data();
39 | }
40 | 


--------------------------------------------------------------------------------
/Domain/Event/Metadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Event;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Traits\ClassName;
 6 | 
 7 | final class Metadata implements \Zelenin\Ddd\Core\Domain\Service\MessageSerializer\Message
 8 | {
 9 |     use ClassName;
10 | 
11 |     /**
12 |      * @var array
13 |      */
14 |     private $value = [];
15 | 
16 |     /**
17 |      * @param array $value
18 |      */
19 |     public function __construct(array $value = [])
20 |     {
21 |         $this->value = $value;
22 |     }
23 | 
24 |     /**
25 |      * @return array
26 |      */
27 |     public function value()
28 |     {
29 |         return $this->value;
30 |     }
31 | 
32 |     /**
33 |      * @param static $metadata
34 |      *
35 |      * @return static
36 |      */
37 |     public function addMetadata(Metadata $metadata)
38 |     {
39 |         $value = array_merge($this->value(), $metadata->value());
40 | 
41 |         return new static($value);
42 |     }
43 | 
44 |     /**
45 |      * @return array
46 |      */
47 |     public function serialize()
48 |     {
49 |         return $this->value();
50 |     }
51 | 
52 |     /**
53 |      * @param array $data
54 |      *
55 |      * @return self
56 |      */
57 |     public static function deserialize(array $data)
58 |     {
59 |         return new static($data);
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/Domain/Event/Stream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Event;
 4 | 
 5 | use IteratorAggregate;
 6 | 
 7 | interface Stream extends IteratorAggregate
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/Domain/Exception/InvalidArgumentException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Exception;
 4 | 
 5 | class InvalidArgumentException extends \InvalidArgumentException
 6 | {
 7 |     /**
 8 |      * @param string $message
 9 |      * @param int $code
10 |      */
11 |     public function __construct($message = '', $code = 0)
12 |     {
13 |         parent::__construct($message, $code);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/Domain/Exception/NotMatchTypeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Exception;
 4 | 
 5 | use DomainException;
 6 | use Zelenin\Ddd\Core\Domain\Contract\HasClassName;
 7 | 
 8 | class NotMatchTypeException extends DomainException
 9 | {
10 |     /**
11 |      * @param HasClassName $object
12 |      */
13 |     public function __construct(HasClassName $object)
14 |     {
15 |         parent::__construct(sprintf('Not matching type. It should be "%s"', $object::className()));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Domain/Model/AggregateRoot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Model;
 4 | 
 5 | use BadMethodCallException;
 6 | use Zelenin\Ddd\Core\Domain\Event\DefaultMessage;
 7 | use Zelenin\Ddd\Core\Domain\Event\DefaultStream;
 8 | use Zelenin\Ddd\Core\Domain\Event\Event;
 9 | use Zelenin\Ddd\Core\Domain\Event\Message;
10 | use Zelenin\Ddd\Core\Domain\Event\Metadata;
11 | 
12 | abstract class AggregateRoot extends DefaultEntity
13 | {
14 |     /**
15 |      * @var Message[]
16 |      */
17 |     private $unCommittedEvents = [];
18 | 
19 |     /**
20 |      * @return DefaultStream
21 |      */
22 |     public function getUncommittedEvents()
23 |     {
24 |         $stream = new DefaultStream($this->unCommittedEvents);
25 |         $this->unCommittedEvents = [];
26 |         return $stream;
27 |     }
28 | 
29 |     /**
30 |      * @param Event $event
31 |      */
32 |     protected function apply(Event $event)
33 |     {
34 |         $method = sprintf('apply%s', $event->name());
35 | 
36 |         if (!method_exists($this, $method)) {
37 |             throw new BadMethodCallException(sprintf('Method %s::%s is not found.', static::className(), $method));
38 |         }
39 | 
40 |         $this->$method($event);
41 | 
42 |         $this->unCommittedEvents[] = new DefaultMessage(static::className(), $this->getId(), new Metadata(), $event);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/Domain/Model/DefaultEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Model;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Exception\NotMatchTypeException;
 6 | use Zelenin\Ddd\Core\Domain\Model\Id\Id;
 7 | use Zelenin\Ddd\Core\Domain\Object\DefaultObject;
 8 | use Zelenin\Ddd\Core\Domain\Object\Object;
 9 | 
10 | abstract class DefaultEntity extends DefaultObject implements Entity
11 | {
12 |     /**
13 |      * @var Id
14 |      */
15 |     protected $id;
16 | 
17 |     /**
18 |      * @param Object $object
19 |      *
20 |      * @return bool
21 |      */
22 |     public function equalsTo(Object $object)
23 |     {
24 |         if (!$this->sameTypeAs($object)) {
25 |             throw new NotMatchTypeException($this);
26 |         }
27 | 
28 |         return $this->getId()->id() === $object->getId()->id();
29 |     }
30 | 
31 |     /**
32 |      * @return Id
33 |      */
34 |     public function getId()
35 |     {
36 |         return $this->id;
37 |     }
38 | 
39 |     /**
40 |      * @param Id $id
41 |      */
42 |     public function setId(Id $id)
43 |     {
44 |         $this->id = $id;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/Domain/Model/DefaultValueObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Model;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Object\DefaultObject;
 6 | use Zelenin\Ddd\Core\Domain\Object\Object;
 7 | 
 8 | abstract class DefaultValueObject extends DefaultObject implements ValueObject
 9 | {
10 |     /**
11 |      * @param Object $object
12 |      *
13 |      * @return bool
14 |      */
15 |     abstract public function equalsTo(Object $object);
16 | }
17 | 


--------------------------------------------------------------------------------
/Domain/Model/Entity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Model;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Contract\HasEqualsTo;
 6 | use Zelenin\Ddd\Core\Domain\Contract\HasId;
 7 | use Zelenin\Ddd\Core\Domain\Object\Object;
 8 | 
 9 | interface Entity extends Object, HasId, HasEqualsTo
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/Domain/Model/Id/Id.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Model\Id;
 4 | 
 5 | interface Id
 6 | {
 7 |     /**
 8 |      * @return integer|string
 9 |      */
10 |     public function id();
11 | }
12 | 


--------------------------------------------------------------------------------
/Domain/Model/ValueObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Model;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Contract\HasEqualsTo;
 6 | use Zelenin\Ddd\Core\Domain\Object\Object;
 7 | 
 8 | interface ValueObject extends Object, HasEqualsTo
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/Domain/Object/DefaultObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Object;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Traits\ClassName;
 6 | use Zelenin\Ddd\Core\Domain\Traits\SameTypeAs;
 7 | use Zelenin\Ddd\Core\Domain\Traits\TypeOf;
 8 | 
 9 | abstract class DefaultObject implements Object
10 | {
11 |     use ClassName;
12 |     use SameTypeAs;
13 |     use TypeOf;
14 | }
15 | 


--------------------------------------------------------------------------------
/Domain/Object/Object.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Object;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Contract\HasClassName;
 6 | use Zelenin\Ddd\Core\Domain\Contract\HasSameTypeAs;
 7 | use Zelenin\Ddd\Core\Domain\Contract\HasTypeOf;
 8 | 
 9 | interface Object extends HasClassName, HasSameTypeAs, HasTypeOf
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/Domain/Repository/ReadRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Repository;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Contract\HasId;
 6 | use Zelenin\Ddd\Core\Domain\Model\Id\Id;
 7 | 
 8 | interface ReadRepository
 9 | {
10 |     /**
11 |      * @param Id $id
12 |      *
13 |      * @return HasId
14 |      */
15 |     public function get(Id $id);
16 | 
17 |     /**
18 |      * @return HasId[]
19 |      */
20 |     public function getAll();
21 | 
22 |     /**
23 |      * @return int
24 |      */
25 |     public function count();
26 | }
27 | 


--------------------------------------------------------------------------------
/Domain/Repository/Repository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Repository;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Contract\HasId;
 6 | use Zelenin\Ddd\Core\Domain\Model\Id\Id;
 7 | 
 8 | interface Repository extends ReadRepository
 9 | {
10 |     /**
11 |      * @param HasId $object
12 |      */
13 |     public function add(HasId $object);
14 | 
15 |     /**
16 |      * @param HasId $object
17 |      */
18 |     public function remove(HasId $object);
19 | 
20 |     /**
21 |      * @param HasId $object
22 |      */
23 |     public function save(HasId $object);
24 | 
25 |     /**
26 |      * @return Id
27 |      */
28 |     public function nextIdentity();
29 | }
30 | 


--------------------------------------------------------------------------------
/Domain/Service/IdentityGenerator/IdentityGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Service\IdentityGenerator;
 4 | 
 5 | interface IdentityGenerator
 6 | {
 7 |     /**
 8 |      * @return string
 9 |      */
10 |     public function generate();
11 | }
12 | 


--------------------------------------------------------------------------------
/Domain/Service/MessageSerializer/Message.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Service\MessageSerializer;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Contract\HasClassName;
 6 | 
 7 | interface Message extends HasClassName
 8 | {
 9 |     /**
10 |      * @return array
11 |      */
12 |     public function serialize();
13 | 
14 |     /**
15 |      * @param array $data
16 |      *
17 |      * @return self
18 |      */
19 |     public static function deserialize(array $data);
20 | }
21 | 


--------------------------------------------------------------------------------
/Domain/Service/MessageSerializer/MessageSerializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Service\MessageSerializer;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Service\Service;
 6 | 
 7 | interface MessageSerializer extends Service
 8 | {
 9 |     /**
10 |      * @param Message $message
11 |      *
12 |      * @return string
13 |      */
14 |     public function serialize(Message $message);
15 | 
16 |     /**
17 |      * @param $string
18 |      *
19 |      * @return Message
20 |      */
21 |     public function deserialize($string);
22 | }
23 | 


--------------------------------------------------------------------------------
/Domain/Service/MessageSerializer/MessageSerializerData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Service\MessageSerializer;
 4 | 
 5 | final class MessageSerializerData
 6 | {
 7 |     /**
 8 |      * @var string
 9 |      */
10 |     private $className;
11 | 
12 |     /**
13 |      * @var array
14 |      */
15 |     private $data;
16 | 
17 |     /**
18 |      * @param string $className
19 |      * @param array $data
20 |      */
21 |     public function __construct($className, array $data)
22 |     {
23 |         $this->className = $className;
24 |         $this->data = $data;
25 |     }
26 | 
27 |     /**
28 |      * @param array $array
29 |      *
30 |      * @return static
31 |      */
32 |     public static function createFromArray(array $array)
33 |     {
34 |         return new static($array['class'], $array['data']);
35 |     }
36 | 
37 |     /**
38 |      * @return string
39 |      */
40 |     public function className()
41 |     {
42 |         return $this->className;
43 |     }
44 | 
45 |     /**
46 |      * @return array
47 |      */
48 |     public function data()
49 |     {
50 |         return $this->data;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Domain/Service/Serializer/Serializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Service\Serializer;
 4 | 
 5 | interface Serializer
 6 | {
 7 |     /**
 8 |      * @param mixed $data
 9 |      *
10 |      * @return string
11 |      */
12 |     public function serialize($data);
13 | 
14 |     /**
15 |      * @param $string
16 |      *
17 |      * @return mixed
18 |      */
19 |     public function deserialize($string);
20 | }
21 | 


--------------------------------------------------------------------------------
/Domain/Service/Service.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Zelenin\Ddd\Core\Domain\Service;
4 | 
5 | interface Service
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/Domain/Traits/ClassName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Traits;
 4 | 
 5 | trait ClassName
 6 | {
 7 |     /**
 8 |      * @return string
 9 |      */
10 |     final public static function className()
11 |     {
12 |         return static::class;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/Domain/Traits/SameTypeAs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Traits;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Object\Object;
 6 | 
 7 | /**
 8 |  * @method static className()
 9 |  */
10 | trait SameTypeAs
11 | {
12 |     /**
13 |      * @param Object $object
14 |      *
15 |      * @return bool
16 |      */
17 |     final public function sameTypeAs(Object $object)
18 |     {
19 |         return static::className() === $object::className();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Domain/Traits/TypeOf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Domain\Traits;
 4 | 
 5 | /**
 6 |  * @method static className()
 7 |  */
 8 | trait TypeOf
 9 | {
10 |     /**
11 |      * @param string $className
12 |      * @return bool
13 |      */
14 |     final public function typeOf($className)
15 |     {
16 |         return static::className() === $className;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/Infrastructure/Repository/MemoryReadRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Infrastructure\Repository;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Collection\ArrayCollection;
 6 | use Zelenin\Ddd\Core\Domain\Model\Id\Id;
 7 | use Zelenin\Ddd\Core\Domain\Object\DefaultObject;
 8 | use Zelenin\Ddd\Core\Domain\Repository\ReadRepository;
 9 | 
10 | abstract class MemoryReadRepository extends DefaultObject implements ReadRepository
11 | {
12 |     /**
13 |      * @var array|ArrayCollection
14 |      */
15 |     protected $storage;
16 | 
17 |     /**
18 |      * @param array $array
19 |      */
20 |     public function __construct($array = [])
21 |     {
22 |         $this->storage = new ArrayCollection($array);
23 |     }
24 | 
25 |     /**
26 |      * @param Id $id
27 |      *
28 |      * @return mixed
29 |      */
30 |     public function get(Id $id)
31 |     {
32 |         return $this->storage->get($id->id());
33 |     }
34 | 
35 |     /**
36 |      * @return array|ArrayCollection
37 |      */
38 |     public function getAll()
39 |     {
40 |         return $this->storage;
41 |     }
42 | 
43 |     /**
44 |      * @return int
45 |      */
46 |     public function count()
47 |     {
48 |         return $this->storage->count();
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/Infrastructure/Repository/MemoryRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Infrastructure\Repository;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Contract\HasId;
 6 | use Zelenin\Ddd\Core\Domain\Model\Id\Id;
 7 | use Zelenin\Ddd\Core\Domain\Repository\Repository;
 8 | 
 9 | abstract class MemoryRepository extends MemoryReadRepository implements Repository
10 | {
11 |     /**
12 |      * @param HasId $object
13 |      */
14 |     public function add(HasId $object)
15 |     {
16 |         $this->storage->set($object->getId()->id(), $object);
17 |     }
18 | 
19 |     /**
20 |      * @param HasId $object
21 |      */
22 |     public function remove(HasId $object)
23 |     {
24 |         $this->storage->remove($object->getId()->id());
25 |     }
26 | 
27 |     /**
28 |      * @param HasId $object
29 |      */
30 |     public function save(HasId $object)
31 |     {
32 |         $this->add($object);
33 |     }
34 | 
35 |     /**
36 |      * @return Id
37 |      */
38 |     abstract public function nextIdentity();
39 | }
40 | 


--------------------------------------------------------------------------------
/Infrastructure/Service/IdentityGenerator/CombUuid4Generator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Infrastructure\Service\IdentityGenerator;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Object\DefaultObject;
 6 | use Zelenin\Ddd\Core\Domain\Service\IdentityGenerator\IdentityGenerator;
 7 | use Zelenin\Ddd\Core\Domain\Service\Service;
 8 | 
 9 | final class CombUuid4Generator extends DefaultObject implements IdentityGenerator, Service
10 | {
11 |     /**
12 |      * @inheritdoc
13 |      */
14 |     public function generate()
15 |     {
16 |         $bytes = random_bytes(10);
17 |         $bytes[6] = chr((ord($bytes[6]) & 0x0f) | 0x40);
18 |         $bytes[8] = chr((ord($bytes[8]) & 0x3f) | 0x80);
19 | 
20 |         $hex = bin2hex($bytes) . str_pad(dechex($this->getTimestamp()), 6 * 2, '0', STR_PAD_LEFT);
21 | 
22 |         $fields = [
23 |             'time_low' => substr($hex, 0, 8),
24 |             'time_mid' => substr($hex, 8, 4),
25 |             'time_hi_and_version' => substr($hex, 12, 4),
26 |             'clock_seq_hi_and_reserved' => substr($hex, 16, 2),
27 |             'clock_seq_low' => substr($hex, 18, 2),
28 |             'node' => substr($hex, 20, 12),
29 |         ];
30 | 
31 |         return vsprintf(
32 |             '%08s-%04s-%04s-%02s%02s-%012s',
33 |             $fields
34 |         );
35 |     }
36 | 
37 |     /**
38 |      * @return string
39 |      */
40 |     private function getTimestamp()
41 |     {
42 |         $time = explode(' ', microtime(false));
43 | 
44 |         return $time[1] . substr($time[0], 2, 5);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/Infrastructure/Service/IdentityGenerator/RandomUuidGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Infrastructure\Service\IdentityGenerator;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Object\DefaultObject;
 6 | use Zelenin\Ddd\Core\Domain\Service\IdentityGenerator\IdentityGenerator;
 7 | use Zelenin\Ddd\Core\Domain\Service\Service;
 8 | 
 9 | /**
10 |  * @deprecated
11 |  */
12 | final class RandomUuidGenerator extends DefaultObject implements IdentityGenerator, Service
13 | {
14 |     /**
15 |      * @inheritdoc
16 |      */
17 |     public function generate()
18 |     {
19 |         return (new Uuid4Generator())->generate();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Infrastructure/Service/IdentityGenerator/Uuid4Generator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Infrastructure\Service\IdentityGenerator;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Object\DefaultObject;
 6 | use Zelenin\Ddd\Core\Domain\Service\IdentityGenerator\IdentityGenerator;
 7 | use Zelenin\Ddd\Core\Domain\Service\Service;
 8 | 
 9 | final class Uuid4Generator extends DefaultObject implements IdentityGenerator, Service
10 | {
11 |     /**
12 |      * @inheritdoc
13 |      */
14 |     public function generate()
15 |     {
16 |         $bytes = random_bytes(16);
17 |         $bytes[6] = chr((ord($bytes[6]) & 0x0f) | 0x40);
18 |         $bytes[8] = chr((ord($bytes[8]) & 0x3f) | 0x80);
19 |         $hex = bin2hex($bytes);
20 | 
21 |         $fields = [
22 |             'time_low' => substr($hex, 0, 8),
23 |             'time_mid' => substr($hex, 8, 4),
24 |             'time_hi_and_version' => substr($hex, 12, 4),
25 |             'clock_seq_hi_and_reserved' => substr($hex, 16, 2),
26 |             'clock_seq_low' => substr($hex, 18, 2),
27 |             'node' => substr($hex, 20, 12),
28 |         ];
29 | 
30 |         return vsprintf(
31 |             '%08s-%04s-%04s-%02s%02s-%012s',
32 |             $fields
33 |         );
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/Infrastructure/Service/MessageSerializer/MessageSerializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zelenin\Ddd\Core\Infrastructure\Service\MessageSerializer;
 4 | 
 5 | use Zelenin\Ddd\Core\Domain\Service\MessageSerializer\Message;
 6 | use Zelenin\Ddd\Core\Domain\Service\MessageSerializer\MessageSerializerData;
 7 | use Zelenin\Ddd\Core\Domain\Service\Serializer\Serializer;
 8 | 
 9 | final class MessageSerializer implements \Zelenin\Ddd\Core\Domain\Service\MessageSerializer\MessageSerializer
10 | {
11 |     /**
12 |      * @var Serializer
13 |      */
14 |     private $serializer;
15 | 
16 |     /**
17 |      * @param Serializer $serializer
18 |      */
19 |     public function __construct(Serializer $serializer)
20 |     {
21 |         $this->serializer = $serializer;
22 |     }
23 | 
24 |     /**
25 |      * @param Message $message
26 |      *
27 |      * @return string
28 |      */
29 |     public function serialize(Message $message)
30 |     {
31 |         return $this->serializer->serialize($message->serialize());
32 |     }
33 | 
34 |     /**
35 |      * @param $string
36 |      *
37 |      * @return Message
38 |      */
39 |     public function deserialize($string)
40 |     {
41 |         $data = $this->serializer->deserialize($string);
42 |         $messageSerializerData = MessageSerializerData::createFromArray($data);
43 | 
44 |         /** @var Message $className */
45 |         $className = $messageSerializerData->className();
46 | 
47 |         return $className::deserialize($messageSerializerData->data());
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Aleksandr Zelenin
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "zelenin/ddd-core",
 3 |     "description": "Core for DDD concepts",
 4 |     "keywords": [
 5 |         "ddd"
 6 |     ],
 7 |     "homepage": "https://github.com/zelenin/ddd-core",
 8 |     "license": "MIT",
 9 |     "authors": [
10 |         {
11 |             "name": "Aleksandr Zelenin",
12 |             "email": "aleksandr@zelenin.me",
13 |             "homepage": "http://zelenin.me",
14 |             "role": "Developer"
15 |         }
16 |     ],
17 |     "support": {
18 |         "issues": "https://github.com/zelenin/ddd-core/issues",
19 |         "source": "https://github.com/zelenin/ddd-core"
20 |     },
21 |     "require": {
22 |         "php": ">=5.5",
23 |         "zelenin/value-object": "~0.2.0",
24 |         "paragonie/random_compat": "~2"
25 |     },
26 |     "autoload": {
27 |         "psr-4": {
28 |             "Zelenin\\Ddd\\Core\\": ""
29 |         }
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # DDD Core
 2 | 
 3 | Core for [Domain-driven design](https://en.wikipedia.org/wiki/Domain-driven_design) concepts.
 4 | 
 5 | ## Installation
 6 | 
 7 | ### Composer
 8 | 
 9 | The preferred way to install this library is through [Composer](http://getcomposer.org/).
10 | 
11 | Either run
12 | 
13 | ```
14 | composer require zelenin/ddd-core "~0.0"
15 | ```
16 | 
17 | or add
18 | 
19 | ```
20 | "zelenin/ddd-core": "~0.0"
21 | ```
22 | 
23 | to the ```require``` section of your ```composer.json```
24 | 
25 | ## Author
26 | 
27 | [Aleksandr Zelenin](https://github.com/zelenin/), e-mail: [aleksandr@zelenin.me](mailto:aleksandr@zelenin.me)
28 | 


--------------------------------------------------------------------------------