Download the PHP package macintoshplus/lite-cqrs without Composer

On this page you can find all versions of the php package macintoshplus/lite-cqrs. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.

FAQ

After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

Example:
If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Informations about the package lite-cqrs

LiteCQRS for PHP

Small naming-convention based CQRS library for PHP (loosely based on LiteCQRS for C#) that relies on the Message Bus, Command, Event and Domain Event patterns.

Build Status (1.1)

Terminology

CQS is Command-Query-Separation: A paradigm where read methods never change state and write methods never return data. Build on top, CQRS suggests the separation of read- from write-model and uses the DomainEvent pattern to notify the read model about changes in the write model.

LiteCQRS uses the command pattern and a central message bus service that finds the corresponding handler to execute a command. A command is just a class with some properties describing it, it can optionally implement LiteCQRS\Command.

During the execution of a command, domain events can be triggered. These are again just simple classes with some properties and they can optionally implement LiteCQRS\DomainEvent.

An event queue knows what domain events have been triggered during a command and then publishes them to an event message bus, where many listeners can listen to them.

Changes

From 1.0 to 1.1

Conventions

Examples:

Installation & Requirements

The core library has no dependencies on other libraries. Plugins have dependencies on their specific libraries.

Install with Composer:

{
    "require": {
        "beberlei/lite-cqrs": "dev-master"
    }
}

Workflow

These are the steps that a command regularly takes through the LiteCQRS stack during execution:

  1. You push commands into a CommandBus. Commands are simple objects extending Command created by you.
  2. The CommandBus checks for a handler that can execute your command. Every command has exactly one handler.
  3. The command handler changes state of the domain model. It does that by creating events (that represent state change) and passing them to the AggregateRoot::apply() or DomainEventProvider::raise() method of your domain objects.
  4. When the command is completed, the command bus will check all objects in the identity map for events.
  5. All found events will be passed to the EventMessageBus#publish() method.
  6. The EventMessageBus dispatches all events to observing event handlers.
  7. Event Handlers can create new commands again using the CommandBus.

Command and Event handler execution can be wrapped in handlers that manage transactions. Event handling is always triggered outside of any command transaction. If the command fails with any exception all events created by the command are forgotten/ignored. No event handlers will be triggered in this case.

In the case of InMemory CommandBus and EventMessageBus LiteCQRS makes sure that the execution of command and event handlers is never nested, but in sequential linearized order. This prevents independent transactions for each command from affecting each other.

Examples

See examples/ for some examples:

  1. example1.php shows usage of the Command- and EventMessageBus with one domain object
  2. example2_event.php shows direct usage of the EventMessageBus inside a command
  3. example3_sequential_commands.php demonstrates how commands are processed sequentially.
  4. tictactoe.php implements a tic tac toe game with CQRS.
  5. SymfonyExample.md shows example1.php implemented within the scope of a Symfony2 project.

Setup

  1. In Memory Command Handlers, no event publishing/observing

  2. In Memory Commands and Events Handlers

This uses LiteCQRS\EventProviderInterface instances to trigger domain events.

  1. In Memory Commands + Custom Event Queue

LiteCQRS knows about triggered events by asking LiteCQRS\Bus\EventQueue. Provide your own implementation to be independent of your domain objects having to implement EventProviderInterface.

Usage

To implement a Use Case of your application

  1. Create a command object that receives all the necessary input values. Use public properties and extend LiteCQRS\DefaultCommand to simplify.
  2. Add a new method with the name of the command to any of your services (command handler)
  3. Register the command handler to handle the given command on the CommandBus.
  4. Have your entities implement LiteCQRS\AggregateRoot or LiteCQRS\DomainEventProvider
  5. Use protected method raise(DomainEvent $event) or apply(DomainEvent $event)`` to attach events to your aggregate root objects.

That is all there is for simple use-cases.

If your command triggers events that listeners check for, you should:

  1. Create a domain specific event class. Use public properties to simplify.
  2. Create a event handler(s) or add method(s) to existing event handler(s).

While it seems "complicated" to create commands and events for every use-case. These objects are really dumb and only contain public properties. Using your IDE or editor functionality you can easily generate them in no time. In turn, they will make your code very explicit.

Difference between apply() and raise()

There are two ways to publish events to the outside world.

If you don't use event sourcing then you are fine just using raise() and ignoring apply() altogether.

Automatic Event Publishing from IdentityMap

You have to implement a mechanism to fill the . All aggregate root objects in this Identity Map will have their Events stored and published through EventMessageBus. All other events will be forgotten!

Example: The Doctrine ORM Plugin has an implementation of the `IdentityMapInterface``.

Command/Event Handler Proxies

If you want to wrap the command/event handling inside custom logic, you have to extend the MessageHandlerInterface and pass a proxy factory closure/invokable object into the .

If you want to log all commands:

And register:

Failing Events

The EventMessageBus prevents exceptions from bubbling up. To allow some debugging of failed event handler execution there is a special event "EventExecutionFailed" that you can listen to. You will get passed an instance of LiteCQRS\Bus\EventExecutionFailed with properties $exception, $service and $event to allow analysing failures in your application.

Extension Points

You should implement your own CommandBus or extend the existing to wire the whole process together exactly as you need it to work.

Plugins

Doctrine

Doctrine Plugin ships with transactional wrapper handlers for Commands and Events:

Also to synchronize the events to event message bus you can use the DoctrineIdentityMap:

It also ships with an implementation of DomainEventProviderRepositoryInterface wrapping the EntityManager:

Silex

Silex plugin ships with a CommandBus and a EventMessageBus that knows how to get services out of your Silex application as well as a ServiceProvider. The ServiceProvider adds the most basic services to get LiteCQRS to run.

To enable the service provider register it on your application:

lite_cqrs.commands is automatically injected into the ApplicationCommandBus. So to add Commands to the bus extend the service with:

Remember that the key have to be the Command class and the value must be the service id that have the right handler method implemented.

To add a EventHandler for a specific event it is needed to call registerServices on the lite_cqrs.event_bus service.

The array given to registerServices must look like:

Symfony

Inside symfony you can use LiteCQRS by registering services with lite_cqrs.command_handler or the lite_cqrs.event_handler tag. These services are then autodiscovered for commands and events. You can also add proxy message handler factories for tags. For both commands and events the tags are lite_cqrs.event_proxy_factory and lite_cqrs.command_proxy_factory respectively.

Container Aware implementations of CommandBus and EventMessageBus implement lazy loading of all command- and event handlers for better performance.

To enable the bundle put the following in your Kernel:

You can enable/disable the different plugins by adding the following to your config.yml:

lite_cqrs:
    orm:                    true
    swift_mailer:           true
    monolog:                true
    jms_serializer:         true
    crud:                   true
    dbal_event_store:       true
    couchdb_event_store:    true
    couchdb_odm:            true

Please refer to the SymfonyExample.md document for a full demonstration of using LiteCQRS from within a Symfony2 project.

Swiftmailer

The Swiftmailer Plugin allows you to defer the sending of mails until after a command or event handler has actually finished successfully.

You need a spool transport and a real transport instance for this. The Spool transport queues all messages and the transport handler sends all messages through the real transport, if the command/event handler was executed successfully.

Monolog

A plugin that logs the execution of every command and handler using Monolog. It includes the type and name of the message, its parameters as json and if its execution succeeded or failed.

The Monolog integration into Symfony registers a specific channel lite_cqrs which you can configure differently from the default channels in Symfony. See the Symfony cookbook for more information.

JMS Serializer

WARNING: This plugin does not work with JMS Serializer 0.10 and up, disable it with serializer: false in Symfony.

A plugin that uses JMS Serializer to serialize events to JSON. This is necessary for advanced logging of your events. It uses a custom type handler to convert aggregate root objects in the events into references and fetches them again on reconstruction. This way you don't serialize graphs of data into the event store.

Doctrine CouchDB

A plugin that contains a CouchDB EventStore and Transactional Handler for Doctrine CouchDB ODM.

CRUD

While normally CRUD and CQRS don't match, if you use Doctrine as a primary data-source in the write model then with PHPs dynamic capabilities, you can decently do CRUD with LiteCQRS and this plugin.

Using AggregateResource abstract class or the CrudCreatable, CrudUpdatable and CrudDeletable traits you can implement CRUD functionality. This is possible to three commands:

They have $class, $id and $data properties. On the Create and Update commands, the `$data is applied to the model using mass assignment. You have to make sure this is a safe operation for your models by implementing the apply*() methods yourself instead of relying on the mass assignment.

After processing one of the following three domain events is emitted:


All versions of lite-cqrs with dependencies

PHP Build Version
Package Version
No informations.
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package macintoshplus/lite-cqrs contains the following files

Loading the files please wait ....