PHPackages silpo-tech/orm-bundle - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Database & ORM](/categories/database) 4. / 5. silpo-tech/orm-bundle ActiveSymfony-bundle[Database & ORM](/categories/database) silpo-tech/orm-bundle ===================== Common ORM bundle helpers v1.1.0(4mo ago)0624↑31.3%MITPHPPHP ^8.2CI passing Since Dec 11Pushed 4mo agoCompare [ Source](https://github.com/silpo-tech/ORMBundle)[ Packagist](https://packagist.org/packages/silpo-tech/orm-bundle)[ RSS](/packages/silpo-tech-orm-bundle/feed)WikiDiscussions main Synced 1mo ago READMEChangelog (2)Dependencies (19)Versions (3)Used By (0) ORM Bundle ========== [](#orm-bundle) [![CI](https://github.com/silpo-tech/ORMBundle/actions/workflows/ci.yml/badge.svg)](https://github.com/silpo-tech/ORMBundle/actions) [![codecov](https://camo.githubusercontent.com/621bbea77c6bd1205ad31f0da89438a5c055d42d74b0bb527d10900d78f95b58/68747470733a2f2f636f6465636f762e696f2f67682f73696c706f2d746563682f4f524d42756e646c652f67726170682f62616467652e737667)](https://codecov.io/gh/silpo-tech/ORMBundle) [![License: MIT](https://camo.githubusercontent.com/fdf2982b9f5d7489dcf44570e714e3a15fce6253e0cc6b5aa61a075aac2ff71b/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c6963656e73652d4d49542d79656c6c6f772e737667)](https://opensource.org/licenses/MIT) About ----- [](#about) The ORM Bundle contains common used ORM classes (e.g. Validators) Installation ------------ [](#installation) Require the bundle and its dependencies with composer: ``` $ composer require silpo-tech/orm-bundle ``` Register the bundle: ``` // app/AppKernel.php public function registerBundles() { $bundles = array( new ORMBundle\ORMBundle(), ); } ``` ### Traits: [](#traits) ``` /** * @ORM\Entity() * @ORM\HasLifecycleCallbacks */ class Entity { // @ORM\HasLifecycleCallbacks is required for @PrePersist, @PreUpdate use UuidIdTrait, CreatedAtTrait, UpdatedAtTrait, UpdatedByTrait, VersionTrait; //.... other properties and methods } ``` Connection Wrappers ------------------- [](#connection-wrappers) The bundle provides connection wrappers that automatically retry failed database operations. **You must configure a wrapper class to enable retry functionality.** ### Available Wrappers [](#available-wrappers) #### Standard Connection Wrapper [](#standard-connection-wrapper) For single database connections: ``` # config/packages/doctrine.yaml doctrine: dbal: connections: default: wrapper_class: 'ORMBundle\Doctrine\ConnectionWrapper' ``` #### Primary-Read Replica Connection Wrapper [](#primary-read-replica-connection-wrapper) For primary-replica database setups: ``` # config/packages/doctrine.yaml doctrine: dbal: connections: default: wrapper_class: 'ORMBundle\Doctrine\PrimaryReadReplicaConnectionWrapper' primary: host: 'primary-db.example.com' # ... other primary config replica: - host: 'replica1-db.example.com' - host: 'replica2-db.example.com' ``` ### Why Use Connection Wrappers? [](#why-use-connection-wrappers) Connection wrappers provide: - **Automatic retry** on connection failures using configurable backoff strategies - **Connection recovery** by closing and reopening failed connections - **Database-agnostic** connection failure detection - **Seamless integration** with existing Doctrine configuration **Without a wrapper class, retry options are ignored and connections will fail immediately on connection errors.** PostgreSQL Timeout Middleware ----------------------------- [](#postgresql-timeout-middleware) For PostgreSQL connections, the bundle provides middleware that automatically sets timeout parameters on connection establishment. ### Configuration [](#configuration) ``` # config/services.yaml services: app.postgres_timeout_service: class: ORMBundle\Doctrine\PostgreSQL\Timeout\TimeoutOptionsService arguments: $statementTimeout: 30000 # 30 seconds (in milliseconds) $idleInTransactionSessionTimeout: 60000 # 60 seconds $lockTimeout: 5000 # 5 seconds app.postgres_timeout_middleware: class: ORMBundle\Doctrine\PostgreSQL\Timeout\Middleware arguments: - '@app.postgres_timeout_service' tags: - { name: doctrine.middleware } ``` To apply middleware only to specific connections: ``` # Apply only to 'default' and 'legacy' connections tags: - { name: doctrine.middleware, connection: default } - { name: doctrine.middleware, connection: legacy } ``` ### Available Parameters [](#available-parameters) - **statement\_timeout**: Maximum execution time for SQL statements (milliseconds) - **idle\_in\_transaction\_session\_timeout**: Maximum idle time for transactions (milliseconds) - **lock\_timeout**: Maximum time to wait for locks (milliseconds) Set parameters to `null` to skip configuration. The middleware works independently of connection wrappers. Connection Retry Configuration ------------------------------ [](#connection-retry-configuration) The bundle automatically retries failed database connections with configurable backoff strategies. ### Default Behavior [](#default-behavior) Without any configuration, the bundle uses a simple fixed-delay retry: - **5 retry attempts** (6 total attempts including initial) - **100ms delay** between retries - Only retries on `ConnectionException` ### Basic Configuration [](#basic-configuration) Customize retry behavior without additional dependencies: ``` # config/packages/doctrine.yaml doctrine: dbal: connections: default: options: backoff_options: max_retries: 10 # Number of retries (default: 5) initial_delay: 200000 # Delay in microseconds (default: 100000) ``` ### Advanced Retry Strategies [](#advanced-retry-strategies) For production environments, install the optional backoff package for advanced strategies: ``` $ composer require code-distortion/backoff ``` Configure a custom backoff factory: ``` # config/services.yaml services: app.backoff_factory: class: ORMBundle\Backoff\Adapter\CodeDistortionBackoffFactory # config/packages/doctrine.yaml doctrine: dbal: connections: default: options: backoff_factory: '@app.backoff_factory' backoff_options: strategy: 'exponential' initial_delay: 100000 max_retries: 10 max_delay: 5000000 ``` ### Available Strategies [](#available-strategies) #### Fixed (default) [](#fixed-default) Constant delay between retries. Simple and predictable. ``` backoff_options: strategy: 'fixed' initial_delay: 100000 # Fixed delay in microseconds between retries (default: 100000 = 100ms) max_retries: 10 # Maximum number of retry attempts (default: 5) ``` **Use case:** Testing, development, or when consistent timing is required. #### Linear [](#linear) Delay increases linearly with each attempt: `initial_delay + (step * attempt_number)` ``` backoff_options: strategy: 'linear' initial_delay: 100000 # Starting delay in microseconds (default: 100000 = 100ms) max_delay: 5000000 # Maximum delay cap in microseconds (optional, default: none) max_retries: 10 # Maximum number of retry attempts (default: 5) step: 100000 # Delay increment per attempt in microseconds (default: same as initial_delay) ``` **Example delays:** 100ms, 200ms, 300ms, 400ms, 500ms... **Use case:** Gradual backoff when you expect quick recovery. #### Exponential (recommended) [](#exponential-recommended) Delay grows exponentially: `initial_delay * factor^attempt_number` ``` backoff_options: strategy: 'exponential' initial_delay: 100000 # Starting delay in microseconds (default: 100000 = 100ms) max_delay: 30000000 # Maximum delay cap in microseconds (optional, default: none) max_retries: 10 # Maximum number of retry attempts (default: 5) factor: 2.0 # Exponential multiplier for each attempt (default: 2.0) ``` **Example delays (factor=2.0):** 100ms, 200ms, 400ms, 800ms, 1.6s, 3.2s... **Use case:** Most production scenarios. Quickly backs off to avoid overwhelming recovering services. #### Polynomial [](#polynomial) Delay grows polynomially: `initial_delay * attempt_number^power` ``` backoff_options: strategy: 'polynomial' initial_delay: 100000 # Base delay in microseconds (default: 100000 = 100ms) max_delay: 10000000 # Maximum delay cap in microseconds (optional, default: none) max_retries: 10 # Maximum number of retry attempts (default: 5) power: 2 # Polynomial exponent (default: 2 = quadratic growth) ``` **Example delays (power=2):** 100ms, 400ms, 900ms, 1.6s, 2.5s... **Use case:** When you need faster backoff than linear but slower than exponential. #### Fibonacci [](#fibonacci) Delay follows Fibonacci sequence: `initial_delay * fibonacci(attempt_number)` ``` backoff_options: strategy: 'fibonacci' initial_delay: 100000 # Base delay in microseconds (default: 100000 = 100ms) max_delay: 10000000 # Maximum delay cap in microseconds (optional, default: none) max_retries: 10 # Maximum number of retry attempts (default: 5) ``` **Example delays:** 100ms, 100ms, 200ms, 300ms, 500ms, 800ms, 1.3s... **Use case:** Natural growth pattern, good balance between aggressive and conservative backoff. #### Decorrelated Jitter [](#decorrelated-jitter) Randomized exponential backoff that prevents thundering herd problem in distributed systems. ``` backoff_options: strategy: 'decorrelated' initial_delay: 100000 # Base delay in microseconds (default: 100000 = 100ms) max_delay: 30000000 # Maximum delay cap in microseconds (optional, default: none) max_retries: 10 # Maximum number of retry attempts (default: 5) ``` **Example delays:** Random values like 150ms, 380ms, 920ms, 2.1s, 5.8s... (each delay is randomized based on previous) **Use case:** Multiple application instances retrying simultaneously. Prevents synchronized retry storms. #### Random [](#random) Random delay within specified range. ``` backoff_options: strategy: 'random' max: 1000000 # Maximum delay in microseconds (default: 500000 = 500ms) min: 100000 # Minimum delay in microseconds (default: 100000 = 100ms) max_retries: 10 # Maximum number of retry attempts (default: 5) ``` **Example delays:** Random values like 347ms, 892ms, 156ms, 723ms, 441ms... (each between min and max) **Use case:** Simple jitter to avoid synchronized retries. #### Sequence [](#sequence) Custom sequence of delays for each attempt. ``` backoff_options: strategy: 'sequence' max_retries: 10 # Maximum number of retry attempts (default: 5) continuation: false # If true, repeats last delay after sequence ends (default: false) delays: [100000, 200000, 500000, 1000000, 5000000] # Array of delays in microseconds ``` **How it works:** - `continuation: false` - Stops when sequence ends or `max_retries` reached (whichever comes first) - `continuation: true` - After sequence ends, repeats last delay until `max_retries` reached **Examples:** - `delays: [100ms, 200ms, 500ms]`, `continuation: false`, `max_retries: 10` → 3 retries (stops at sequence end) - `delays: [100ms, 200ms, 500ms]`, `continuation: true`, `max_retries: 10` → 10 retries (100ms, 200ms, 500ms, 500ms, 500ms...) - `delays: [100ms, 200ms, 500ms]`, `continuation: true`, `max_retries: 2` → 2 retries (100ms, 200ms) **Use case:** When you need precise control over each retry timing. ### Custom Backoff Factory [](#custom-backoff-factory) Implement your own factory for complete control: ``` use ORMBundle\Backoff\BackoffFactoryInterface; use ORMBundle\Backoff\BackoffInterface; class MyBackoffFactory implements BackoffFactoryInterface { public function create(array $options = []): BackoffInterface { // Return your custom BackoffInterface implementation } } ``` Register it: ``` # config/services.yaml services: app.my_backoff_factory: class: App\Backoff\MyBackoffFactory # config/packages/doctrine.yaml doctrine: dbal: connections: default: options: backoff_factory: '@app.my_backoff_factory' ``` ### Health Score 40 — FairBetter than 88% of packages Maintenance77 Regular maintenance activity Popularity19 Limited adoption so far Community6 Small or concentrated contributor base Maturity48 Maturing project, gaining track record Bus Factor1 Top contributor holds 100% of commits — single point of failure How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window. **Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores. **Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement. **Maturity (30%)** — Project age, version count, PHP version support, and release stability. ### Release Activity Cadence Every ~18 days Total 2 Last Release 136d ago ### Community Maintainers ![](https://www.gravatar.com/avatar/f9891deddc63cb60dd472af17aee913a559f29defbe861135037dbbdf99449a6?d=identicon)[food-tech-devs](/maintainers/food-tech-devs) --- Top Contributors [![oxidmod](https://avatars.githubusercontent.com/u/12136231?v=4)](https://github.com/oxidmod "oxidmod (3 commits)") ### Code Quality TestsPHPUnit Static AnalysisPHPStan Code StylePHP CS Fixer Type Coverage Yes ### Embed Badge ![Health badge](/badges/silpo-tech-orm-bundle/health.svg) ``` [![Health](https://phpackages.com/badges/silpo-tech-orm-bundle/health.svg)](https://phpackages.com/packages/silpo-tech-orm-bundle) ``` ### Alternatives [sylius/sylius E-Commerce platform for PHP, based on Symfony framework. 8.4k5.6M651](/packages/sylius-sylius)[contao/core-bundle Contao Open Source CMS 1231.6M2.4k](/packages/contao-core-bundle)[easycorp/easyadmin-bundle Admin generator for Symfony applications 4.3k16.7M310](/packages/easycorp-easyadmin-bundle)[sulu/sulu Core framework that implements the functionality of the Sulu content management system 1.3k1.3M152](/packages/sulu-sulu)[ec-cube/ec-cube EC-CUBE EC open platform. 78527.0k1](/packages/ec-cube-ec-cube)[open-dxp/opendxp Content & Product Management Framework (CMS/PIM) 7310.3k29](/packages/open-dxp-opendxp) PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)