Repository navigation
Release/v0.1.0 - #1
Merged
Merged
Conversation
Revised README with the following changes: - Clarified that the `develop` branch is for active integration and ongoing development. - Removed outdated content related to FireHub's general overview and repository purpose, replacing it with development-specific information. - Highlighted stability guarantees (or lack thereof) for contributors and advanced testers. - Added badges for PHPUnit, PHPStan, and Codecov to provide visibility into CI/CD pipelines. - Updated links and references to point to the `develop` branch instead of `master`. These updates align the README with the branch's purpose and contribution workflows.
Introduced the `Application` class as the primary runtime entry point for FireHub projects, encapsulating application lifecycle management through a dedicated `Kernel`. Introduced the `Context` class to define immutable application-wide metadata with an execution environment (`Environment` enum) and a strongly typed `Name`. Updated `composer.json` to include dependencies for the FireHub Core Standard, Foundation, and other essential components. These changes establish the foundational structure for building and managing a FireHub application.
…sal support. Introduced key components to manage the application lifecycle, including initialization and disposal mechanisms: - Added `Disposer` and `Initializer` interfaces to define contracts for application-specific resource management. - Implemented the `State` enum to represent various application lifecycle states. - Enhanced the `Application` class to support initializer/disposer registration, state management, and lifecycle transitions (`initialize` and `dispose` methods). - Added custom exceptions (`ApplicationInitializationException`, `ApplicationDisposalException`, `InvalidApplicationStateException`) to handle lifecycle errors. These changes establish a structured framework for controlling application startup and shutdown processes.
Streamlined `Application` lifecycle management by removing redundant state checks and unused imports. Improved documentation with additional annotations for `Kernel::dependencyBoundary()` utilization. Updated kernel initialization to leverage `dependencyBoundary` for enhanced dependency handling. These changes simplify lifecycle operations and improve integration with the kernel's architecture.
…ization and disposal. Streamlined `Application` lifecycle processes by updating `Engine` to manage state transitions with the new `execute()` method. Replaced explicit state definitions with `State` constants directly, simplifying lifecycle construction. Key improvements: - Updated `initialize()` and `dispose()` methods to leverage `Engine::execute()` for handling callbacks and state changes. - Added state checks to prevent redundant initialization and disposal attempts. - Enhanced annotations for clearer documentation and better insight into lifecycle interactions. These changes improve the readability, robustness, and maintainability of lifecycle management within the `Application` class.
…gement. Expanded inline documentation within the `Application` class by adding detailed usage examples for key lifecycle methods (`initialize`, `dispose`, etc.) and state management. These examples clarify usage patterns and demonstrate how to interact with `Context`, `State`, and the application runtime. Additionally: - Removed unused import `States` from `Lifecycle`. - Improved code readability and developer experience through enhanced documentation. These updates improve developer onboarding and provide better insight into the lifecycle operations of the `Application` class.
Enhanced `Application` functionality by introducing a new `Container` for managing dependencies. Updated the constructor to accept a `ContainerBoundary` instance with a default `Container` implementation, simplifying dependency handling. Added a `container()` method to retrieve the application's DI container. Additional changes: - Updated `composer.json` to include the `Container` package as a dependency. - Refactored the `Kernel` property for clarity by directly initializing it in the constructor. - Removed unnecessary inline `Kernel` assignment for improved readability. These changes improve dependency management and prepare the `Application` for more flexible and modular runtime configurations.
Introduced two new functionalities in `Application`: 1. `dependencyBoundary()`: Provides lifecycle dependency boundary access, enabling dependent runtimes during the application's initialized state. 2. `execute(Closure $callback)`: Allows executing operations within an isolated dependency injection scope while maintaining lifecycle dependency to prevent disposal during execution. Enhanced lifecycle management and isolation ensures safer runtime operations and promotes better dependency control. Removed internal marker from `Boundary` class to make it accessible.
…anagement. Added `Builder` and `Manager` components to enhance modularity and lifecycle orchestration for the `Application` class: 1. **Builder**: - Provides a fluent API for creating and configuring `Application` instances. - Introduced support for custom kernels, containers, initializers, and disposers during application construction. 2. **Manager**: - Manages multiple `Application` instances linked to a shared `Kernel`. - Includes functionality for registering, initializing, disposing, and retrieving applications by identifier. - Ensures lifecycle ordering and consistency across registered applications. 3. **Exceptions**: - Added `ApplicationAlreadyRegisteredException`, `ApplicationKernelMismatchException`, `ApplicationNotFoundException`, and `InvalidApplicationIdentifierException` for robust error handling in application registration and management. Other updates: - Refactored `Application` to align with the `Builder` and `Manager` architecture. - Updated inline documentation with detailed usage examples and improved annotations. - Simplified lambda execution in `Application::execute()` by providing direct `Application` context. These changes establish a modular and scalable foundation for managing the creation and lifecycle of FireHub applications.
…upport. Enhanced `Builder` functionality with support for application modules and dependency order resolution: - **Module registration**: Added `withModule()` method to register application modules with dependency resolution through `ModuleManager`. - **Service registration**: Updated `build()` to register services via `RegistersServices` and enforce compatibility with `Registrar` containers. - Introduced `ContainerRegistrationNotSupportedException` to handle unsupported containers gracefully. Additional updates: - Added `Module` as a composer dependency in `composer.json`. - Improved inline documentation to reflect module-related functionality. These changes extend modularity support, improve service registration handling, and enhance application configurability.
Updated `Builder` to improve module management and enforce immutability: - Cloned `ModuleManager` during application build to isolate changes and ensure thread safety. - Added freezing of `ModuleManager` after successful service registration to prevent further modifications. - Updated inline documentation to reflect the module freezing process and application lifecycle integration. Additional improvements: - Enhanced `Application` constructor to support storing and accessing the module manager. - Added `modules()` method to retrieve the `ModuleManager` instance from the `Application`. These changes reinforce modularity and immutability while streamlining module access in the application lifecycle.
…cope management. Added the `ExecutionContext` class to encapsulate execution-specific state and provide context for application operations. Key features include: - **Scoped Execution**: Introduced `ExecutionContext` with an isolated dependency injection scope, ensuring scoped services are shared within executions and isolated across executions. - **Integration with `Application::execute()`**: Updated `Application::execute()` to create a new `ExecutionContext` per operation, maintaining lifecycle dependency and automatic scope cleanup. - **API Enhancements**: Define accessor methods (`application()` and `scope()`) to retrieve the associated application and execution scope. These changes improve execution isolation, dependency management, and application safety during runtime operations.
…tionality entry in CHANGELOG
dieselxxx
added
the
type: Maintenance
dieselxxx
marked this pull request as ready for review
October 21, 2026 10:01
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
🔖 Release Pull Request
Version
v0.1.0Related Branches
Description
Alpha release
Release Overview
Pre-release Verification
Testing & Validation
System Validation
Release Readiness
Versioning
Semantic Versioning compliance:
Tagging:
v0.1.0will be createdDeployment
Target environment:
Deployment notes:
Checklist
CHANGELOG.mdupdatedREADME.mdupdated (if needed)Risks / Impact
Potential Risks
Breaking changes:
Deployment risks:
Rollback considerations:
Notes
Release Notes
Deployment Instructions
Known Issues