Skip to content

Latest commit

 

History

History
241 lines (226 loc) · 18.4 KB

tech-stack.md

File metadata and controls

241 lines (226 loc) · 18.4 KB

Tech Stack

Backend

Main Dependencies

  • ext-ctype (installed by symfony/skeleton):
    • A PHP extension required by Symfony for character type checks.
  • ext-iconv (installed by symfony/skeleton):
    • A PHP extension required by Symfony for string encoding and conversion.
  • api-platform/doctrine-orm (installed by api-platform/api-pack):
    • Provides integration of API Platform with the Doctrine ORM, allowing you to create RESTful APIs automatically from Doctrine entities.
  • api-platform/symfony (installed by api-platform/api-pack):
    • The main Symfony integration for API Platform, providing configuration and customizations for your API.
  • doctrine/dbal (installed by api-platform/api-pack):
    • The database abstraction layer for Doctrine. Provides database interaction, schema introspection, and SQL building capabilities.
  • doctrine/doctrine-bundle (installed by api-platform/api-pack):
    • Symfony bundle for integrating Doctrine ORM into the framework, offering configuration, console commands, etc.
  • doctrine/doctrine-migrations-bundle (installed by api-platform/api-pack):
    • Adds database migrations functionality to Symfony, enabling version control for database schemas.
  • doctrine/orm (installed by api-platform/api-pack):
    • The Doctrine ORM (Object-Relational Mapper). Mainly used for mapping database tables/entities to PHP classes.
  • ecotone/jms-converter (supplements ecotone/symfony-bundle):
    • Allows serialization and deserialization of messages in a standardized format, enabling communication between different systems or components.
  • ecotone/pdo-event-sourcing (supplements ecotone/symfony-bundle):
    • Implements event sourcing using PDO (PHP Data Objects).
    • Helps in persisting domain events in relational databases and recreating the application's state by replaying those events.
    • It's widely used in event-driven architectures to handle event streams efficiently.
  • ecotone/symfony-bundle:
    • A Symfony bundle for integrating Ecotone into Symfony projects.
    • Simplifies the setup of messaging, event sourcing, and other Ecotone functionalities within the Symfony framework.
    • Enables developers to use Ecotone seamlessly within their Symfony-based applications.
  • eqs/health-check-provider:
    • Enables integrating health checks to ensure the application and its components (e.g., database or external dependencies) are functioning correctly and accessible.
  • nelmio/cors-bundle (installed by api-platform/api-pack):
    • Simplifies managing CORS (Cross-Origin Resource Sharing) headers, crucial for APIs that may be accessed from different origins.
  • nyholm/psr (supplements eqs/health-check-provider):
    • A lightweight and fast implementation of the PSR-7 (HTTP Message Interface) standard.
    • Provides classes for representing HTTP requests, responses, streams, URIs, and uploaded files, enabling interoperability between different libraries and frameworks that adhere to the PSR-7 standard.
    • This package is commonly used in applications to manage HTTP messages in a standardized way.
  • phpdocumentor/reflection-docblock (installed by api-platform/api-pack):
    • Library for parsing PHP docblocks and annotations, useful for documenting your code.
  • phpstan/phpdoc-parser (installed by api-platform/api-pack):
    • A parser for PHPDoc comments to improve typing or integration with static analysis tools.
  • runtime/frankenphp-symfony (installed by symfony/skeleton):
    • This package helps Symfony applications integrate seamlessly with FrankenPHP, which is a fast PHP application server.
  • symfony/asset (installed by api-platform/api-pack):
    • Provides features for managing web assets such as CSS, JS, or images in Symfony applications.
  • symfony/console (installed by symfony/skeleton):
    • Provides Symfony's user-friendly console commands for managing applications from the command line.
  • symfony/dotenv (installed by symfony/skeleton):
    • Allows loading environment variables from a .env file to configure the application.
  • symfony/expression-language (installed by api-platform/api-pack):
    • Adds support for a dynamic expression language, often used in security and workflow rules.
  • symfony/flex (installed by symfony/skeleton):
    • A Composer plugin that simplifies managing Symfony projects by automating certain configurations and dependencies.
  • symfony/framework-bundle (installed by symfony/skeleton):
    • Core Symfony framework tools, providing services like routing, HTTP handling, and other foundational capabilities.
  • symfony/messenger:
    • Provides tools to manage message-driven architectures in your application.
  • symfony/monolog-bundle (installed by symfony/debug-pack):
    • Enables logging in Symfony applications using Monolog, a powerful logging library.
    • Lets you send logs to files, databases, emails, or third-party services (e.g., Slack or Loggly), which is especially useful during debugging.
  • symfony/property-access (installed by api-platform/api-pack):
    • Handles access to object properties dynamically, often used in forms and serialization.
  • symfony/property-info (installed by api-platform/api-pack):
    • Offers introspection of object properties, such as determining their type for validation or serialization.
  • symfony/runtime (installed by symfony/skeleton):
    • Manages runtime settings and optimizes bootstrapping for Symfony applications.
  • symfony/security-bundle (installed by api-platform/api-pack):
    • A bundle for implementing various security features like authentication, roles, and firewalls.
  • symfony/serializer (installed by api-platform/api-pack):
    • Provides serialization and deserialization of objects into formats like JSON or XML.
  • symfony/twig-bundle (installed by api-platform/api-pack):
    • Integrates the Twig templating engine into Symfony applications.
  • symfony/validator (installed by api-platform/api-pack):
    • Validates objects or data values using Symfony's validation component based on constraints.
  • symfony/yaml (installed by symfony/skeleton):
    • Offers tools to parse, dump, and use YAML configuration files.
  • symfonycasts/micro-mapper (supplements api-platform/api-pack):
    • A lightweight object mapper designed to simplify mapping data from one structure to another.
    • It can be used for tasks like mapping arrays or DTOs (Data Transfer Objects) to entities and vice versa, making the handling of complex data transformation more intuitive and concise.
  • webmozart/assert:
    • A lightweight PHP library used for making assertions in your application.

Dev Dependencies

  • captainhook/captainhook-phar:
    • A PHP tool for managing Git hooks.
    • Automates the setup and execution of Git hooks, allowing developers to define custom actions, such as code quality checks, tests, or formatting fixes, that run during Git events like commit or push.
  • coduo/php-matcher (supplements symfony/test-pack):
    • Used for matching patterns in more flexible ways.
    • It's often employed in testing to verify if a certain structure or data matches some predefined format, especially when exact values aren't required.
    • It's useful for validating JSON or other complex data structures.
  • dama/doctrine-test-bundle (supplements symfony/test-pack):
    • Simplifies database testing by wrapping Doctrine's DBAL Connection in a transactional mode.
    • Prevents database changes from persisting between tests, ensuring a clean and isolated database state for every test run, significantly improving testing speed.
  • justinrainbow/json-schema (supplements symfony/test-pack):
    • A PHP library for validating JSON data against a schema.
    • This can be useful for ensuring that your data conforms to predefined structures, especially when working with APIs where data format validation is critical.
  • mikelgoig/easy-coding-standard-rules (supplements symplify/easy-coding-standard):
    • Provides a collection of custom rules for use with Symplify's Easy Coding Standard (ECS).
    • These rules help enforce specific code quality and consistency standards in a PHP codebase, extending the functionality of ECS with additional checks and fixes tailored to improve code style and maintainability.
  • phpstan/extension-installer (supplements phpstan/phpstan):
    • A composer plugin designed to simplify the installation and configuration of PHPStan extensions.
    • Automatically registers installed extensions, eliminating the need for manual configuration in PHPStan's settings.
  • phpstan/phpstan:
    • A popular static analysis tool for PHP.
    • Helps developers identify potential bugs, type errors, and other code issues without running the application.
    • By analyzing the codebase based on defined rules and type hints, PHPStan enforces stricter type safety and improves overall code quality.
  • phpstan/phpstan-deprecation-rules (supplements phpstan/phpstan):
    • Provides a set of PHPStan rules specifically designed to detect and report the usage of deprecated code in a project.
    • Helps developers identify and replace deprecated classes, methods, or functions, ensuring the code remains up-to-date and compatible with future dependencies or PHP versions.
  • phpstan/phpstan-doctrine (supplements phpstan/phpstan):
    • Adds specific PHPStan rules and features to analyze projects using Doctrine ORM and DBAL.
    • Provides deeper insights into Doctrine entities, repositories, and queries, helping to detect issues with annotations, mappings, repositories, and database interactions.
  • phpstan/phpstan-phpunit (supplements phpstan/phpstan):
    • Provides a PHPStan integration with PHPUnit.
    • Helps by analyzing PHPUnit-specific code and test cases written in your application, identifying potential bugs or inconsistencies in your tests.
  • phpstan/phpstan-strict-rules (supplements phpstan/phpstan):
    • Introduces strict rules for PHPStan, aiming to enforce stricter coding standards and reduce potential bugs.
    • Detects issues like redundant code, risky type assumptions, and enforces rigorous type safety, ensuring more robust and clean code.
  • phpstan/phpstan-symfony (supplements phpstan/phpstan):
    • Integrates PHPStan with Symfony projects to provide a deeper understanding of Symfony-specific components, like services, controllers, and configuration files.
    • Helps uncover issues specific to Symfony applications, such as incorrect service definitions or misconfigurations.
  • phpstan/phpstan-webmozart-assert (supplements phpstan/phpstan):
    • Provides PHPStan rules for analyzing and validating the proper usage of the webmozart/assert assertions library.
    • Ensures that assertions in the code are used correctly (e.g., proper types, arguments, and logic).
  • phpunit/phpunit (installed by symfony/test-pack):
    • The most popular PHP testing framework.
    • It's integral for creating and executing unit tests, allowing you to write assertions to validate the behavior of your application's code and ensure stability throughout development.
  • ramsey/conventional-commits:
    • Helps validate and enforce the Conventional Commits specification in a project.
    • It's typically used to ensure that commit messages follow a structured format, making it easier to generate changelogs and maintain consistent versioning.
  • symfony/browser-kit (installed by symfony/test-pack):
    • A Symfony component that simulates a web browser for testing purposes.
    • It's often used in integration or functional testing, allowing you to programmatically navigate web pages and interact with forms, links, etc.
  • symfony/debug-bundle (installed by symfony/debug-pack):
    • Integrates debugging tools with Symfony's services in the framework.
    • Provides features like setting up a debug container and additional diagnostics.
  • symfony/http-client (supplements symfony/test-pack):
    • A robust HTTP client provided by Symfony for making HTTP requests.
    • Supports features like asynchronous requests, HTTP/2, and handling responses, making integrations with APIs and external services easier and more efficient.
  • symfony/maker-bundle:
    • Simplifies the process of generating common code and features.
    • Provides interactive commands that developers can use to scaffold different parts of the application, such as controllers, entities, form classes, tests, and more.
  • symfony/phpunit-bridge (installed by symfony/test-pack):
    • A Symfony tool that enhances PHPUnit by providing better integration with Symfony applications.
    • Includes features like deprecation warnings during tests, autoconfiguration of the testing environment, and easier PHPUnit version upgrades.
  • symfony/stopwatch (installed by symfony/debug-pack):
    • Measures the performance or execution time of your application code.
    • It is useful for profiling and debugging code sections to determine their duration and performance impact.
  • symfony/web-profiler-bundle (installed by symfony/debug-pack):
    • Displays the Web Debug Toolbar and integrates the Symfony Profiler.
    • Provides insight into routes, queries, logs, and more during development.
  • symplify/easy-coding-standard:
    • A tool for managing and running automated code style checks and fixes in PHP projects.
    • Integrates popular tools like PHP_CodeSniffer and PHP-CS-Fixer, providing a streamlined way to enforce and fix coding standards across a codebase.
  • symplify/phpstan-rules (supplements phpstan/phpstan):
    • Provides a set of custom PHPStan rules aimed at improving code quality and maintaining best practices.
    • Adds additional checks for cleaner, more robust, and maintainable PHP code.
  • zenstruck/foundry (supplements symfony/test-pack):
    • A library for generating and managing objects using factories.
    • It's typically used to seed test databases or simplify test setup by creating entities, DTOs, or any objects with predefined or randomized attributes.
    • Great for functional or integration testing in Symfony projects.

DevOps

Tools and Utilities

Rationale for Choices

  • PHP and Symfony: Chosen for robustness and rich ecosystem for backend development.
  • API Platform: Provides a powerful and flexible framework for building APIs, offering features like serialization, validation, and OpenAPI documentation out of the box.
  • Ecotone: Enables messaging and event-driven architecture with support for event sourcing, CQRS, and asynchronous processing, enhancing system scalability and maintainability.
  • RabbitMQ: Supports reliable message processing in a distributed system.
  • Docker: Simplifies environment setup and ensures consistency across development and production.