proophsoftware/event-machine-skeleton

This system is a PHP-based Event Machine framework built on the Prooph ecosystem, designed for event-driven architecture with PostgreSQL persistence. It provides core infrastructure for managing commands, events, and queries, including automated projection handling and message bus routing. The application also features a real-time notification system via WebSockets and exposes a comprehensive OpenAPI v3 documentation interface for its API endpoints.

10 changes.

This period marks the initial creation of the Prooph Event Machine skeleton, establishing a complete Dockerized development environment with PHP 7.1 and Zend Framework components. The work focused on configuring core infrastructure, including Postgres and RabbitMQ integration, service buses, and WebSocket-based real-time notifications. Additionally, the project introduced OpenAPI v3 documentation and automated event stream initialization scripts to support the application's event-driven architecture.

5 changes.

This period focused on implementing the core event machine architecture, including API description classes and executable scripts for managing projections. Simultaneously, the project migrated its data persistence layer to PostgreSQL and established a new test infrastructure to support these changes.

Added a new public-facing UI that connects to a RabbitMQ queue via WebSocket (STOMP protocol) to display real-time notifications. The entry includes the main entry point (index.php) which sets up the Zend Stratigility middleware pipeline, registers the ProblemDetails middleware, and configures routing for the /api and / paths. It also adds the stomp.min.js library for WebSocket communication and a ws.html page that uses jQuery and the notify.js library to show toast notifications when new messages arrive on the 'ui-queue'.

public · medium confidence

The environment now includes database schema files for 'event\_streams' and 'projections' tables in Postgres, enabling event sourcing and state tracking. Additionally, RabbitMQ is configured with a 'ui-queue' and 'ui-exchange' (fanout) in the '/event-machine' vhost, with SSL enabled for the management interface and STOMP/WebSocket support on port 15691.

env · high confidence

The application now serves a static Swagger UI interface for API documentation. This is achieved by adding new static files in the public/swagger directory, including an HTML entry point (index.html) that loads the Swagger UI bundle and styles, along with an OAuth2 redirect handler (oauth2-redirect.html) to support authentication flows.

public/swagger · high confidence

New files were added to the infrastructure layer to support error logging, command/query/event bus handling, and system health monitoring. Specifically, PsrErrorLogger was introduced to log request details and errors via PSR-3. Custom CommandBus, QueryBus, and EventBus classes were added to extend Prooph's service bus implementations, enabling specific message name resolution for GenericJsonSchemaMessage instances. An ErrorHandler plugin was created to manage exception handling within the message bus lifecycle. Additionally, a UiExchange marker interface and a HealthCheckResolver were added to support UI-related messaging and system health status resolution.

src/Infrastructure · high confidence

Users can now access a dynamic OpenAPI v3 schema for the application's message box, exposing all commands, events, and queries as documented endpoints. The new MessageSchemaMiddleware generates an OpenAPI 3.0.0 specification in JSON format, mapping each message type to specific paths and response codes (200 for queries, 202 for commands and events). This replaces the previous approach of returning individual message schemas, providing a unified view of the API's capabilities.

src/Http · high confidence

A new PHP script, create\_event\_stream.php, has been added to the scripts directory. This script initializes the 'event\_stream' in the event store by retrieving the EventStore from the container and creating a new stream, allowing users to set up the necessary infrastructure for event storage.

scripts · high confidence

Two new executable scripts have been added to the bin directory: event\_machine\_projection.php, which runs projections in a loop, and reset.php, which resets the current version's projection. These scripts bootstrap the Prooph EventMachine and interact with the projection manager to manage event processing tasks.

bin · high confidence

The application is now configured with a new routing structure that maps POST requests to the MessageBox controller and GET requests to the message schema middleware. Additionally, the service container is set up to wire up key components like the event store, command bus, and event bus, while the configuration aggregator is initialized to load environment-specific settings and enable debug mode in development.

config · high confidence

The application now includes a global configuration file that defines database (PDO) and RabbitMQ connection settings, alongside a list of API class descriptions (Type, Command, Event, Query, Aggregate, Projection, Listener) for the event machine. This establishes the foundational setup for the application's core components.

config/autoload · high confidence

The repository is initialized with a complete Dockerized development environment for the prooph software Event Machine. This includes configuration files (\.gitignore\, \app.env\, \docker-compose.yml\, \phpunit.xml.dist\) and a detailed \README.md\ that documents the setup, including Postgres and RabbitMQ integration, WebSocket support, and instructions for running the demo and tests.

(repo-wide) · high confidence

The src/Api directory now contains a set of new PHP classes (Aggregate, Command, Event, Listener, Metadata, Payload, Projection, Query, Schema, and Type) that implement the EventMachineDescription interface. These classes provide the structural definitions for the application's API, including command and event schemas, query resolvers, and type registrations, enabling the event machine to validate payloads and resolve queries.

src/Api · high confidence

A .gitkeep file was added to the data directory, ensuring the directory is tracked by version control and remains empty as a placeholder.

data · high confidence

The service factory now instantiates the event store and document store using Postgres-backed implementations (PostgresEventStore and PostgresDocumentStore) instead of previous storage backends. This change updates the underlying data persistence layer for event sourcing and document storage to use PostgreSQL, requiring a Postgres connection in the application configuration.

src/Service · high confidence

Added new test helper classes, including a \BaseTestCase\ that initializes the \EventMachine\ with a \PrototypingFlavour\ and provides utility methods like \assertRecordedEvent\ and \assertNotRecordedEvent\ to verify recorded events in tests.

tests · high confidence

The project is initialized as a Dockerized skeleton for the Prooph Event Machine, establishing the core PHP dependencies for building event-driven applications. The configuration pins the 'proophsoftware/event-machine' library (alongside supporting packages like 'prooph/pdo-event-store' and 'prooph/humus-amqp-producer') and introduces 'proophsoftware/postgres-document-store' to enable PostgreSQL-based document storage. The environment is set to PHP 7.1 with Zend Framework components for routing and aggregation.

(dependencies) · medium confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 43 → 42 (-1.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 99 (+0.5)
• Architecture 69 → 66 (-3.3)
• Maturity 50 → 50 (+0.0)
• Readiness 17 → 18 (+0.3)
• Security 98 → 87 (-10.7)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High CVE: [GHSA redacted] (composer.lock)
• No exposed public API
• Test reliability not included
• The 'Database' section describes a single Postgres database but does not mention RabbitMQ integration or event-sourced write model behavior. (README.md)
• dormant codebase — no living knowledge left to concentrate

• Abandoned package: zendframework/zend-config-aggregator
• Abandoned package: zendframework/zend-expressive-helpers
• Abandoned package: zendframework/zend-problem-details
• Abandoned package: zendframework/zend-stdlib
• Abandoned package: zendframework/zend-stratigility
• Coverage not measured — no coverage collector is wired up
• Documentation: no architecture or design documentation (README.md)
• High CVE: [GHSA redacted] (composer.lock)
• High IaC: WD-COMPOSE-0002 (docker-compose.yml)
• Leaked secret: high-entropy-secret (env/rabbit/broker_definitions.json)
• Medium IaC: WD-COMPOSE-0002 (docker-compose.yml)
• Medium IaC: WD-COMPOSE-0002 (docker-compose.yml)
• Medium IaC: WD-COMPOSE-0002 (docker-compose.yml)
• Medium IaC: WD-COMPOSE-0002 (docker-compose.yml)
• Medium: security finding (details withheld)
• Outdated: nikic/fast-route
• Outdated: prooph/pdo-event-store
• Outdated: psr/http-server-middleware

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

proophsoftware/event-machine-skeleton was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.