prooph/proophessor-do

This system is an event-sourced task management application built on the Prooph framework and Zend Expressive. It manages user accounts and todo items by persisting state changes as domain events, which are then projected into read models for efficient querying. The application supports core workflows such as creating tasks, setting deadlines and reminders, and sending email notifications, while providing an HTTP API and a management UI for inspecting the underlying event store.

34 changes.

The project migrated its infrastructure and core framework from Zend Framework 2 to Zend Expressive 3.0, establishing a modern middleware-based architecture with PSR-11 and PSR-15 standards. This period focused on implementing a robust event-sourcing domain model for users and todos, complete with value objects, strict typing, and read projections, while replacing legacy database migrations with event store persistence.

19 changes.

The project implemented core event-sourcing infrastructure, including process managers for email notifications, MongoDB factories, and read-model projections. Concurrently, the application was migrated to Zend Expressive and enriched with a Riot.js-based user interface for managing users and todos with deadlines and reminders.

5 changes.

This period focused on implementing the Event Store Management UI and adding a JSON response transformer for the Event Store HTTP API. Significant effort was also dedicated to increasing test coverage for various model commands, container factories, and process managers.

The public/mgmt-ui directory now includes the compiled frontend assets (CSS, JavaScript, fonts, and images) for the Event Store Management UI, establishing the visual interface for this feature. The UI is styled using Semantic UI 2.2.13 and includes specific styling for event store and watcher components, such as color-coded dividers and menu items.

public/mgmt-ui · high confidence

A new JsonTransformer class has been added to the EventStoreHttpApi infrastructure layer. This component implements the Transformer interface from the prooph event-store-http-middleware, enabling the system to convert internal result arrays into standardized JSON HTTP responses using Zend Diactoros.

src/Infrastructure/EventStoreHttpApi · high confidence

The application now includes a new layout template that defines the main page structure, including a fixed-top navigation bar with the prooph logo and links to the home screen, todo management, and the new Event Store Management UI. The layout features a responsive design with a left sidebar for navigation and a right sidebar for additional content, ensuring a consistent user experience across different screen sizes.

templates/layout · high confidence

Users can now select dates and times using the bootstrap-datetimepicker (v4.17.37) widget, which relies on Moment.js (v2.10.6) for parsing and formatting. This addition enables precise date-time input with support for ISO8601 formats, timezone handling, and granular time selection (hours, minutes, seconds).

public/js · high confidence

Two new middleware components have been introduced to the application pipeline. The JsonPayload middleware automatically parses incoming JSON request bodies and attaches the decoded data to the request object, throwing a 400 error for malformed JSON. The JsonError middleware intercepts exceptions during request handling and returns structured JSON error responses (including stack traces in development mode) for requests expecting JSON content, improving API error visibility.

src/Middleware · high confidence

A new MongoClientFactory has been introduced in the container layer to handle the creation of MongoDB client instances. This factory integrates with the Interop Config standard (specifically version 2.0.1) to retrieve connection URIs and driver options from the application configuration, allowing users to configure MongoDB connection details via standard config arrays rather than hardcoding them.

src/Container · high confidence

A new Psr4ClassInfoFactory has been added to the console container to provide a Psr4Info instance. This factory configures the PSR-4 autoloading information by specifying the 'src' directory, the 'Prooph\\ProophessorDo\\' namespace prefix, and a specific docblock header, enabling the console component to correctly identify and process classes within the project structure.

src/Container/Console · high confidence

New executable scripts have been added to the bin directory to manage event-sourced read models and snapshots. todo\_projection.php and user\_projection.php now handle read-model projections for the todo and user aggregates respectively, with the user projection also listening to todo events to track assignee status. A new todo\_reminder\_projection.php script manages the reminder read model, handling insertion and status updates for todo reminders. Additionally, todo\_snapshotter.php and user\_snapshotter.php scripts have been introduced to create stream snapshot projections for the TodoList and UserCollection aggregates, enabling efficient state restoration.

bin · high confidence

New factory classes have been added to the container layer to instantiate the SendTodoDeadlineExpiredMailProcessManager and SendTodoReminderMailProcessManager. These factories resolve the CommandBus from the container and pass it to the respective process managers, enabling dependency injection for these specific process manager components.

src/Container/ProcessManager · high confidence

Two new process managers have been introduced to handle email notifications for todo items. The SendTodoReminderMailProcessManager listens for the TodoAssigneeWasReminded event and dispatches a command to send a reminder mail, while the SendTodoDeadlineExpiredMailProcessManager listens for the TodoWasMarkedAsExpired event to trigger an expiration notification. These components bridge domain events to command execution via the service bus.

src/ProcessManager · high confidence

This change introduces the infrastructure for tracking todos and their reminders in the application's read store. It adds two new database tables, \read\_todo\ and \read\_todo\_reminder\, managed by \TodoReadModel\ and \TodoReminderReadModel\ respectively. These models handle the creation, initialization, and lifecycle management of the tables. Additionally, \TodoFinder\ and \TodoReminderFinder\ classes are provided to query these tables, enabling the system to retrieve todo items by ID, assignee, or status, and to identify reminders that are due or past their deadline.

src/Projection/Todo · high confidence

The new \src/Response/JsonResponse\ class now includes a \withStatus\ method, allowing users to specify an HTTP status code (defaulting to 200) when creating a JSON response. This enables more precise control over response semantics, such as returning 201 for created resources or 404 for not found, while still ensuring the response body is correctly formatted as JSON.

src/Response · high confidence

The application now supports adding deadlines, setting reminders, marking todos as done or expired, and reopening todos. This change introduces the dependency-injection factories required to wire the corresponding command and event handlers (AddDeadlineToTodo, AddReminderToTodo, MarkTodoAsDone, MarkTodoAsExpired, ReopenTodo, and SendTodoReminderMail) into the container, ensuring these new capabilities are available to the rest of the system.

src/Container/Model/Todo · high confidence

This release establishes the foundational structure for the Proophessor Do application, introducing a complete development environment via Docker and Vagrant configurations (including docker-compose.yml and Vagrantfile) alongside CI/CD pipelines (Travis CI, Coveralls). It sets up the testing framework with PHPUnit and code style enforcement via PHP-CS-Fixer, while migrating the codebase from a Zend Framework 2 skeleton (removing init\_autoloader.php) to a modern Composer-based autoloading setup.

(repo-wide) · high confidence

This change introduces the foundational components for the user projection within the application. It adds a \UserReadModel\ that manages the user database table schema (including fields for name, email, and todo counts) and handles event-driven updates to track open, done, and expired todos. Additionally, a \UserFinder\ class is provided to query user data, supporting lookups by ID, email address, and association with specific todos.

src/Projection/User · high confidence

Added three new exception classes—InvalidName, UserAlreadyExists, and UserNotFound—to the user model layer. These exceptions provide specific error handling for invalid user names, duplicate registration attempts, and missing user lookups, replacing generic error handling with distinct types that include contextual details like the user ID.

src/Model/User/Exception · high confidence

The model layer now includes three new foundational components: the Entity interface, which defines identity comparison via sameIdentityAs; the ValueObject interface, which defines value equality via sameValueAs; and an abstract Enum class that extends MabeEnum to provide serialization support and implement the ValueObject interface. These additions establish a stricter type contract for domain objects and enable enums to be treated as value objects with consistent comparison and serialization behavior.

src/Model · high confidence

This change introduces a set of new command objects in the Todo model to support richer todo management capabilities. Users can now attach deadlines to existing todos via the new AddDeadlineToTodo command and set reminders through AddReminderToTodo. The system also gains explicit commands to manage the todo lifecycle, including MarkTodoAsDone, ReopenTodo, and MarkTodoAsExpired. Additionally, internal process commands like RemindTodoAssignee and SendTodoReminderMail have been added to handle the notification flow for reminders and expired items, while PostTodo remains the entry point for creating new todos.

src/Model/Todo/Command · high confidence

This change introduces a suite of new command and query handlers in the Todo model layer, enabling users to add deadlines and reminders to tasks, mark them as done or expired, and reopen them. It also adds handlers to notify users via email when a todo expires or when a scheduled reminder is triggered, as well as query handlers to retrieve specific todos by ID or list todos assigned to a user. The existing PostTodo handler has been refactored to use the new \TodoList::save\ method and updated namespaces.

src/Model/Todo/Handler · high confidence

The scripts directory now includes a suite of PHP utilities for testing and maintaining the proophessor-do application. These scripts allow users to seed the event store with test data (create\_event\_streams, user\_todo\_open\_close), manage snapshots (take\_todo\_snapshot, load\_todo\_with\_snapshot, load\_todo\_without\_snapshot), replay projections (history\_replay.php), and handle business logic tasks such as adding deadlines (add\_deadlines.php), marking expired todos (mark\_expired\_todos.php), and sending reminder notifications (send\_reminder\_notification.php).

scripts · high confidence

The Riot-based template layer now provides complete interfaces for user registration and todo management. Users can register via a new form that validates username and email, and manage todos through a dedicated list and creation form. Individual todo items now support setting deadlines with visual warnings for upcoming or expired dates, and users can add email reminders to specific tasks. The interface also allows toggling todo status between open and done, integrating with backend commands for registration, todo creation, deadline/reminder assignment, and status changes.

templates/riot · high confidence

Added two new view helpers to the application: \RiotTag\, which compiles Riot.js templates by extracting JavaScript functions and sanitizing HTML for use in views, and \Url\, which wraps the Expressive router to generate URIs from route names. These helpers provide a dedicated way to integrate Riot components and handle routing within the Zend View layer.

src/App/View · high confidence

The action classes in src/App/Action (Home, UserList, UserRegistration, UserTodoForm, UserTodoList) now implement the PSR-15 RequestHandlerInterface instead of the previous Expressive-specific interface. This change aligns the application with the PSR-15 standard for HTTP server request handlers, ensuring compatibility with modern middleware stacks and simplifying the handler contract across different HTTP frameworks.

src/App/Action · high confidence

The application now includes dedicated view templates for handling HTTP errors. A new 404 Not Found page provides a user-friendly message with a link back to the home page, while a general error template displays the specific HTTP status and reason, showing detailed error information for non-404 errors to aid in debugging.

templates/error · high confidence

The application now includes styling for the Bootstrap Datetimepicker widget (version 4.17.37), enabling users to select dates and times via a dropdown interface. Simultaneously, the previous 'Paper' theme (Bootstrap v3.3.1) has been removed, meaning the custom Material Design-inspired appearance provided by that theme is no longer applied to the UI.

public/css · high confidence

A new shell script (.docker/wait\_for\_sql.sh) has been added to the Docker setup to handle service dependencies. This script waits for the MySQL service to become available on port 3306 before executing subsequent commands, ensuring that the application does not start before the database is ready. It includes a timeout mechanism (20 seconds) to prevent indefinite hanging if the database fails to start.

.docker · high confidence

The application now uses a dedicated factory to configure the Zend View HelperPluginManager, aligning with the Zend Expressive v0.3 rework. This factory reads plugin mappings from the 'templates.plugins' configuration section and registers them using the PSR-11 container, replacing the previous custom ViewHelperManager approach to ensure helpers are resolved correctly through the standard dependency injection container.

src/Container/App/View · high confidence

The system now verifies that a user's email address is unique by querying the UserFinder read model instead of relying on the application repository. This change introduces a new ChecksUniqueUsersEmailAddressFromReadModel service that returns the existing user ID if the email is already in use, or null if it is available, ensuring registration attempts with duplicate emails are caught at the service layer.

src/Infrastructure/Service · high confidence

The application now uses event-sourcing-based repositories to persist and retrieve TodoList and UserCollection aggregates. Specifically, EventStoreTodoList and EventStoreUserCollection have been added in the Infrastructure layer, extending AggregateRepository to handle saving and fetching Todo and User entities via their respective IDs, replacing previous persistence mechanisms.

src/Infrastructure/Repository · high confidence

The RegisterUser command now enforces strict types and utilizes specific value objects (UserId, UserName, EmailAddress) instead of raw strings. This change improves data integrity by validating email addresses and UUIDs at the command level, ensuring that user registration data is correctly structured and type-safe before processing.

src/Model/User/Command · high confidence

A new TransportFactory has been introduced to manage the creation of mail transport instances. This factory supports both 'in\_memory' and 'smtp' transport modes, with 'in\_memory' set as the default. It utilizes the Interop Config library to handle configuration options, allowing users to switch between transport types via configuration settings.

src/Container/App/Mail · high confidence

The projection factories for Todo, TodoReminder, and User finders have been updated to implement the PSR-11 ContainerInterface (\_\_invoke method) instead of the previous Zend Expressive container contract. This change ensures that these services are resolved using the standard PSR-11 interface, aligning the container wiring with modern PHP container standards.

src/Container/Projection · high confidence

The application's view layer has been restructured to support Zend Expressive 1.0.0, moving the home page template from the legacy ZF2 module path to the new templates/action directory and updating its text to reflect the new framework. Additionally, new templates have been introduced for user management and todo operations: user-list.phtml displays registered users with their todo counts, user-registration-form.phtml and user-todo-form.phtml provide forms for creating users and todos via Riot.js components, and user-todo-list.phtml renders the todo list for a specific user. These changes align the UI with the updated backend projections and framework version.

templates/action · high confidence

The application's dependency injection wiring for the Home, UserList, UserRegistration, UserTodoForm, and UserTodoList actions has been updated to use the PSR-11 \ContainerInterface\. These factory classes now resolve dependencies such as \TemplateRendererInterface\ and \QueryBus\ via the standard container contract, aligning the codebase with the PSR-11 standard and Zend Expressive 1.0.0 requirements.

src/Container/App/Action · high confidence

The public/index.php entry point has been rewritten to bootstrap the application using the Zend Expressive framework instead of the previous Zend MVC stack. This change updates the runtime behavior by loading the container and application instances from configuration files, explicitly executing middleware pipelines and routing definitions (including new event-store HTTP API routes), and enforcing strict types. It also adjusts error handling by suppressing PHP notices during execution and updates the autoloader path to vendor/autoload.php.

public · high confidence

The application's configuration structure has been completely reworked to support the Zend Expressive 3.0 framework. The legacy \application.config.php\ module-based configuration has been removed and replaced with a new \config.php\ that uses \ConfigAggregator\ to merge providers from Zend Expressive and related components. New configuration files define the middleware pipeline (\pipeline.php\), application routes (\routes.php\), and service container setup (\container.php\). Additionally, an \event\_store\_http\_api.php\ configuration file has been added to expose event store and projection manager endpoints via HTTP middleware.

config · high confidence

The application configuration has been restructured to support the Zend Expressive 3.0 framework and updated Prooph components. This change introduces a new modular config structure in \config/autoload\ with dedicated files for dependencies, middleware pipelines, routes, and templates, replacing the previous monolithic \global.php\ and \local.php.dist\ files. It adds support for multiple event-store backends (MySQL, MariaDB, PostgreSQL) and snapshot stores (MongoDB, PDO) via specific local config files, and configures the Prooph service bus with command, event, and query routing for todo and user management features.

config/autoload · high confidence

Added two new factory classes in the Container/Infrastructure layer to support the Zend Expressive rework. DoctrineDbalConnectionFactory now creates Doctrine DBAL connections using the Interop Config interface, replacing previous instantiation methods. UrlHelperFactory provides an adapter that wraps Zend Expressive's UrlHelper to implement the Prooph Event Store HTTP middleware's UrlHelper interface, enabling URL generation within the middleware stack.

src/Container/Infrastructure · high confidence

A new interface, ChecksUniqueUsersEmailAddress, has been added to the user service layer. This interface defines a contract for checking if a user email address is unique, returning the user ID if the email is already in use or null otherwise. This supports the behavioral change of preventing users from registering with existing email addresses.

src/Model/User/Service · high confidence

The user domain events in src/Model/User/Event have been updated to enforce strict types and use dedicated value objects (UserId, UserName, EmailAddress) instead of raw strings. The UserWasRegistered event was moved to this new location, its namespace updated, and the is\_null checks replaced with null === for strict comparison. A new UserWasRegisteredAgain event was added to handle re-registration scenarios, ensuring consistent data handling across user lifecycle events.

src/Model/User/Event · high confidence

The Todo model now enforces stricter state transitions and input validation through a set of new, specific exception classes. Users will encounter clearer error messages when attempting invalid operations, such as reopening a completed Todo, adding deadlines or reminders to non-open tasks, setting past dates, or modifying a Todo that is already done. This change improves data integrity by preventing illegal state changes and ensuring that reminders and deadlines are only applied when appropriate.

src/Model/Todo/Exception · high confidence

The legacy Zend Framework 2 (ZF2) application module has been completely removed from the codebase. This change deletes the \Module.php\ bootstrap class, the \module.config.php\ configuration file (which defined ZF2-specific routing, service manager factories, and proophessor mappings), and all associated view templates (including the layout, user registration, todo posting, and error pages). This cleanup aligns with the broader rework to support new prooph components, indicating a migration away from the ZF2 MVC structure.

module · high confidence

The Application module has removed its entire legacy codebase, including controllers (Todo, UserRegistration, User, Index), their corresponding factories, domain models (User, Todo), command handlers, event-sourced aggregate roots, and database projection classes. This cleanup eliminates the old Zend Framework 2 MVC structure and service manager wiring in preparation for the framework rework.

module/Application · high confidence

The application no longer includes the initial database migration scripts for setting up the event store schema, user table, and todo table. These files, which previously handled the creation of the \users\ and \todos\ tables and the event store schema via Doctrine Migrations, have been deleted, indicating that the database schema management strategy has changed or these initial migrations are no longer required for the current deployment.

data · high confidence

The event classes in the Todo model have been refactored to enforce strict typing and value-object semantics. Existing events like \TodoWasPosted\ now return strongly-typed \TodoId\, \TodoText\, and \TodoStatus\ objects instead of raw strings, and use \null ===\ checks for property initialization. New events have been introduced to support specific todo behaviors: \DeadlineWasAddedToTodo\ and \ReminderWasAddedToTodo\ capture deadline and reminder details, while \TodoWasMarkedAsDone\, \TodoWasMarkedAsExpired\, \TodoWasUnmarkedAsExpired\, and \TodoWasReopened\ explicitly model status transitions with old and new status values. Additionally, \TodoAssigneeWasReminded\ tracks when a reminder is triggered for an assignee.

src/Model/Todo/Event · high confidence

The Todo aggregate now supports setting deadlines and reminders, along with lifecycle states for expiration. Users can add a deadline to an open todo, which automatically clears any existing expired status; attempting to add a deadline to a done todo or one in the past is rejected. Reminders can be attached to open todos, and the assignee can be reminded when the reminder time arrives, provided the reminder is open and in the past. Todos can be explicitly marked as expired if they are open and the deadline has passed, and this expired state can be cleared. All date-time values are handled using DateTimeImmutable in UTC to ensure consistent timezone behavior.

src/Model/Todo · high confidence

The application now uses dedicated factory classes in the \src/Container/Model/User\ directory to instantiate user-related handlers and services. Specifically, factories for \ChecksUniqueUsersEmailAddress\, \GetAllUsersHandler\, \GetUserByIdHandler\, and \RegisterUserHandler\ have been added to resolve dependencies such as \UserFinder\, \UserCollection\, and \ChecksUniqueUsersEmailAddress\ from the container, aligning the user module with the PSR-11 container interface.

src/Container/Model/User · high confidence

The User domain model has been restructured to enforce stricter data integrity and align with Event Sourcing patterns. User identity and attributes (UserId, UserName, EmailAddress) are now encapsulated in dedicated Value Objects that validate input upon creation (e.g., email format, non-empty names). The User entity itself extends AggregateRoot, managing state through domain events like UserWasRegistered and UserWasRegisteredAgain rather than direct property mutation. This change ensures that user registration and re-registration are explicitly modeled as events, improving auditability and consistency within the application's event-driven architecture.

src/Model/User · high confidence

The user module now handles reading user data via new query handlers (GetAllUsersHandler, GetUserByIdHandler) that retrieve data from the UserFinder projection instead of the aggregate repository, and the RegisterUserHandler has been updated to check for existing email addresses using ChecksUniqueUsersEmailAddress, preventing duplicate registrations by throwing UserAlreadyExists when an email is already in use.

src/Model/User/Handler · high confidence

Added base test case class for event sourcing tests; Added test for SendTodoDeadlineExpiredMailProcessManager; Added unit tests for Todo model components; Added unit tests for Todo reminder commands; Added unit tests for User and UserName models; Added unit tests for container factories and process managers; Added unit tests for the Home action; Added unit tests for the mail transport factory.

The application has been upgraded to require PHP 7.1 or higher and migrated from Zend Framework 2 to Zend Expressive 3.0, including the Aura Router integration. This change updates the core framework dependencies (such as \zend-expressive\, \zend-config\, and \zend-validator\) and introduces several new prooph components for event sourcing and service bus functionality. Development tooling has also been updated, including PHPUnit 6, PHP Coveralls 2.0, and the addition of the \roave/security-advisories\ package to monitor for known vulnerabilities.

(dependencies) · high confidence

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

• CAI 62 → 43 (-19.2)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 95 (new)
• Architecture 98 → 96 (-2.1)
• Maturity 49 → 49 (+0.0)
• Readiness 49 → 39 (-10.2)
• Security 100 → 95 (-5.1)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 26 (new)

• Change coupling: load_todo_with_snapshot.php ↔ take_todo_snapshot.php (scripts/load_todo_with_snapshot.php)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• LLM evaluation failed
• No exposed public API
• Test reliability not included
• dormant codebase — no living knowledge left to concentrate

• Abandoned package: zendframework/zend-config
• Abandoned package: zendframework/zend-config-aggregator
• Abandoned package: zendframework/zend-diactoros
• Abandoned package: zendframework/zend-expressive
• Abandoned package: zendframework/zend-expressive-aurarouter
• Abandoned package: zendframework/zend-expressive-helpers
• Abandoned package: zendframework/zend-expressive-zendviewrenderer
• Abandoned package: zendframework/zend-filter
• Abandoned package: zendframework/zend-mail
• Abandoned package: zendframework/zend-servicemanager
• Abandoned package: zendframework/zend-stdlib
• Abandoned package: zendframework/zend-validator
• Duplicated block (10 lines × 2) (src/Model/Todo/Handler/NotifyUserOfExpiredTodoHandler.php)
• Duplicated block (10 lines × 2) (src/Model/Todo/Handler/NotifyUserOfExpiredTodoHandler.php)
• Duplicated block (11 lines × 2) (src/Model/Todo/Event/DeadlineWasAddedToTodo.php)
• Duplicated block (11 lines × 2) (src/Model/Todo/Todo.php)
• Duplicated block (11 lines × 3) (src/Projection/Todo/TodoFinder.php)
• Duplicated block (14 lines × 3) (src/Projection/Todo/TodoReadModel.php)
• Duplicated block (16 lines × 3) (src/Model/Todo/Command/MarkTodoAsDone.php)
• Duplicated block (21 lines × 2) (src/Model/Todo/TodoId.php)
• …and 27 more

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

prooph/proophessor-do 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.