⬆️ Upgrade to 1.0

Author: Th3Mouk

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Jérémy Marodon
+Copyright (c) 2018-2020 Jérémy Marodon
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -11,46 +11,51 @@ This repository is the scaffold of the Thunder CLI micro-framework.
 You can use it and modify the structure to adapt on your needs.
 
 ## Philosophy
-Sometimes you just need a very simple deamon, eventloop based, when you're event programming. 
-A small repository for your boundary, with few dependencies, and don't want to 
+Sometimes you just need a very simple deamon, eventloop based, when you're event programming.
+A small repository for your boundary, with few dependencies, and don't want to
 be force to use a library or an other.
 
-All you need is a reaction to an event that has been occurred in your system, 
+All you need is a reaction to an event that has been occurred in your system,
 externally or internally (pub/sub or saga f.e.).
 
-However, this project is born inside a repository using Reactive Programming 
-by default, RabbitMQ consumers, a router, EventStore projections and events, 
+However, this project is born inside a repository using Reactive Programming
+by default, RabbitMQ consumers, a router, EventStore projections and events,
 mysql, Redis connectors, and many more.
 
 Simple but powerful.
 
 ## What built in
 ### Console Component
-The whole concept is base on consoles.
+The whole concept is based on consoles.
 Instead of reinvent the wheel, Thunder use [Silly](https://github.com/mnapoli/silly)
-micro-framework. An `AbstractConsole` is provided by the framework, allowing
-classes extending it to be automatically loaded and usable. 
+micro-framework. A `Console` class being provided by the framework, allowing
+classes that extend it to be automatically loaded and usable.
 
 ### Dependency Injection
-Usage of the dependency injection pattern, ease decoupling your code and quality 
+Usage of the dependency injection pattern, ease decoupling your code and quality
 test writing. [Symfony DI](https://symfony.com/doc/current/components/dependency_injection.html)
 component has been chosen for it many features [](https://symfony.com/doc/current/components/dependency_injection.html#learn-more)
-improving developer experience.   
+improving developer experience.
 
 ### Configuration Component
-This component allows you to use XML, YAML & PHP files. You can access and use 
+This component allows you to use XML, YAML & PHP files. You can access and use
 them directly into constructors through DI.
 
 ### Router
-This component is central in the project, Command Bus and Event Dispatcher 
+This component is central in the project, Command Bus and Event Dispatcher
 pattern aren't adapted to non acknowledge (`nack`) messages.
 
-It force to use [Subjects](http://reactivex.io/documentation/subject.html) in cases 
-where `ack/nack` is necessary on the message.
+It's pretty straight forward, a `Route` can be associated to a `Controller` in a
+MVC schema. The core provide a base class called `Route` that allow to
+automatically load all classes extending it in the `Router`.
 
-It needs some `AbstractRoute` and send an `AbstractSubject` to the right one.
-An `AbstractRoute` can be associated to a `Controller` in traditional software 
-architecture pattern.
+Each route have to define it's constant called `PATH`. It's used to determine
+which `Route` of your application must be invoked.
+
+As we are in an event driven framework, all `Route` must return an `Observable`.
+The different plugins that you will use in your application, are subscribing to
+your `Observable` using `Observers` to determine actions to execute at the end
+of your event chain.
 
 ## Installation
 
@@ -65,31 +70,24 @@ To start the project you need to execute a PHP file available in the vendors, `v
 
 All commands available will be prompted.
 
-### Subject
-When your are consuming a source of data, each message is converted into an
-`AbstractSubject`. This subject is an `Observable` & an `Observer` with some 
-subscribers already plugged.
-
-One of the subscribers is responsible to handle the `acknowledge/non-acknowledge` behavior.
-
-So basically, when the subject is completed, the message is acknowledged, and 
-you will received a new message when available. 
-
 ### Create a new Route
-Just extends the `Th3Mouk\Thunder\Route\AbstractRoute` into `/src` and it will 
+Create a class extending `Th3Mouk\Thunder\Router\Route` into `/src` and it will
 be automatically added to the router.
 
-You can modify the `config/services.php` and `composer.json` autoload if you 
+You can modify the `config/services.php` and `composer.json` autoload if you
 don't want to use `src` folder.
 
+Your `Route` will now be invoked with the corresponding `DataModel` through
+the PATH constant.
+
 #### Extra: Handler concept
 I personally use `src/route` and `src/handler` structure.
 The term `handler` coming from the Command Bus pattern.
 
-An handler here, is a small invokable unit that can be reused in multiple 
+An handler here, is a small invokable unit that can be reused in multiple
 contexts, sagas of events, or here again routes.
-The main advantage of this, is you can decouple your code and test it correctly, 
-because yes, this handler will be automatically injected in the container, 
+The main advantage of this, is you can decouple your code and test it correctly,
+because yes, this handler will be automatically injected in the container,
 and you can use DI in its constructor :tada:.
 
 An example can be:
@@ -98,13 +96,13 @@ An example can be:
 namespace App\Handler;
 
 use Rx\Observable;
-use Th3Mouk\Thunder\Router\AbstractSubject;
+use RxThunder\Core\Model\DataModel;
 
 class PromptHello
 {
-    public function __invoke(AbstractSubject $subject)
+    public function __invoke(DataModel $data_model)
     {
-        return Observable::of($subject)
+        return Observable::of($data_model)
             ->do(function() {
                 echo "hello there". PHP_EOL;
             });
@@ -120,10 +118,10 @@ namespace App\Route;
 
 use App\Handler\PromptHello;
 use Rx\Observable;
-use Th3Mouk\Thunder\Router\AbstractRoute;
-use Th3Mouk\Thunder\Router\AbstractSubject;
+use RxThunder\Core\Model\DataModel;
+use RxThunder\Core\Router\Route;
 
-class Test extends AbstractRoute
+class Test extends Route
 {
     public const PATH = '/test';
 
@@ -135,34 +133,27 @@ class Test extends AbstractRoute
         $this->prompt = $prompt;
     }
 
-    public function __invoke(AbstractSubject $subject)
+    public function __invoke(DataModel $data_model): Observable
     {
-        return Observable::of($subject)
+        return Observable::of($data_model)
             ->do(function () {
                 echo "i'm in /test".PHP_EOL;
             })
             ->flatMap($this->prompt)
             ->do(function () {
                 echo "passed in /test".PHP_EOL;
-            })
-            ->subscribe(function (AbstractSubject $subject) {
-                $subject->onCompleted();
             });
     }
 }
 ```
 
 ### Start consuming
-If you use the RabbitMq consumer you can start with `php console listen:broker:rabbit test default`
-`test` is the name of the queue to consume
-`default` is the name of the connection to use
-
-The connection system and configuration of RabbitMq is not documented yet and 
-probably will be extracted into a plug & play plugin.
+If you use the RabbitMQ plugin you can start consuming a queue with
+`php console rabbit:listen:broker test`
+(`test` is the name of the queue to consume)
 
-Each message received by the queue will be transformed into a `RabbitMq/Subject`
-and the **routing key** is the pattern the router is looking into the collection 
-of routes.
+Each message received by the queue will be transformed into a `DataModel`
+and the **routing key** correspond to the `type()` of it.
 
-For example a message with `/test` routing key in Rabbit will be consumed by 
-the route with `public const PATH = '/test';` 
+For example a message with `/test` routing key in RabbitMQ will be consumed by
+the route with `public const PATH = '/test';`

composer.json

@@ -10,7 +10,7 @@
     }
   ],
   "require": {
-    "rxthunder/core": "^0.6.0"
+    "rxthunder/core": "^1.0"
   },
   "autoload": {
     "psr-4": {