Doctrine ORM Service Provider ============================= Provides Doctrine ORM Entity Managers as services to Pimple applications. Features -------- * Leverages the core [Doctrine Service Provider][1] for either Silex or Cilex. * Default Entity Manager can be bound to any database connection * Multiple Entity Managers can be defined * Mechanism for allowing Service Providers to register their own mappings Requirements ------------ * PHP 5.3+ * Doctrine ~2.3 Currently requires both **dbs** and **dbs.event_manager** services in order to work. These can be provided by a Doctrine Service Provider like the [Silex][1] or [Cilex][8] service providers. If you can or want to fake it, go for it. :) Optional Dependencies --------------------- ### PSR-0 Resource Locator Service Provider An implementation of [dflydev/psr0-resource-locator-service-provider][6] is required if using namespaceish resource mapping. See documentation for **orm.generate_psr0_mapping** for more information. Installation ------------ Through [Composer](http://getcomposer.org) as [dflydev/doctrine-orm-service-provider][7]. Usage ----- To get up and running, register `DoctrineOrmServiceProvider` and manually specify the directory that will contain the proxies along with at least one mapping. In each of these examples an Entity Manager that is bound to the default database connection will be provided. It will be accessible via **orm.em**. ```php "pdo_sqlite", "path" => "/path/to/sqlite.db", ); // ensure that $container['dbs'] and $container['dbs.event_manager'] // are available, most likely by way of a core service provider. $container["orm.proxies_dir"] = "/path/to/proxies"; $container["orm.em.options"] = array( "mappings" => array( // Using actual filesystem paths array( "type" => "annotation", "namespace" => "Foo\Entities", "path" => __DIR__."/src/Foo/Entities", ), array( "type" => "xml", "namespace" => "Bat\Entities", "path" => __DIR__."/src/Bat/Resources/mappings", ), // Using PSR-0 namespaceish embedded resources // (requires registering a PSR-0 Resource Locator // Service Provider) array( "type" => "annotation", "namespace" => "Baz\Entities", "resources_namespace" => "Baz\Entities", ), array( "type" => "xml", "namespace" => "Bar\Entities", "resources_namespace" => "Bar\Resources\mappings", ), ), ); $doctrineOrmServiceProvider = new DoctrineOrmServiceProvider; $doctrineormServiceProvider->register($container); ``` ### Silex ```php register(new DoctrineServiceProvider, array( "db.options" => array( "driver" => "pdo_sqlite", "path" => "/path/to/sqlite.db", ), )); $app->register(new DoctrineOrmServiceProvider, array( "orm.proxies_dir" => "/path/to/proxies", "orm.em.options" => array( "mappings" => array( // Using actual filesystem paths array( "type" => "annotation", "namespace" => "Foo\Entities", "path" => __DIR__."/src/Foo/Entities", ), array( "type" => "xml", "namespace" => "Bat\Entities", "path" => __DIR__."/src/Bat/Resources/mappings", ), // Using PSR-0 namespaceish embedded resources // (requires registering a PSR-0 Resource Locator // Service Provider) array( "type" => "annotation", "namespace" => "Baz\Entities", "resources_namespace" => "Baz\Entities", ), array( "type" => "xml", "namespace" => "Bar\Entities", "resources_namespace" => "Bar\Resources\mappings", ), ), ), )); ``` ### Cilex ```php register(new DoctrineServiceProvider, array( /** same as the Silex example **/ )); $app->register(new DoctrineOrmServiceProvider, array( /** same as the Silex example **/ )); ``` Configuration ------------- ### Parameters * **orm.em.options**: Array of Entity Manager options. These options are available: * **connection** (Default: default): String defining which database connection to use. Used when using named databases via **dbs**. * **mappings**: Array of mapping definitions. Each mapping definition should be an array with the following options: * **type**: Mapping driver type, one of `annotation`, `xml`, `yml` or `php`. * **namespace**: Namespace in which the entities reside. Additionally, each mapping definition should contain one of the following options: * **path**: Path to where the mapping files are located. This should be an actual filesystem path. For the php driver it can be an array of paths * **resources_namespace**: A namespaceish path to where the mapping files are located. Example: `Path\To\Foo\Resources\mappings` Each **annotation** mapping may also specify the following options: * **use_simple_annotation_reader** (Default: true): If `true`, only simple notations like `@Entity` will work. If `false`, more advanced notations and aliasing via `use` will work. (Example: `use Doctrine\ORM\Mapping AS ORM`, `@ORM\Entity`) Note that if set to `false`, the `AnnotationRegistry` will probably need to be configured correctly so that it can load your Annotations classes. See this FAQ: [Why aren't my Annotations classes being found?](#why-arent-my-annotations-classes-being-found) * **query_cache** (Default: setting specified by orm.default_cache): String or array describing query cache implementation. * **metadata_cache** (Default: setting specified by orm.default_cache): String or array describing metadata cache implementation. * **result_cache** (Default: setting specified by orm.default_cache): String or array describing result cache implementation. * **orm.ems.options**: Array of Entity Manager configuration sets indexed by each Entity Manager's name. Each value should look like **orm.em.options**. Example configuration: ```php array( 'connection' => 'mysql', 'mappings' => array(), ), 'sqlite' => array( 'connection' => 'sqlite', 'mappings' => array(), ), ); ``` Example usage: ```php share($app->extend('orm.ems.config', function ($config, $app) { $mapping = $app['orm.generate_psr0_mapping'](array( 'Foo\Resources\mappings' => 'Foo\Entities', 'Bar\Resources\mappings' => 'Bar\Entities', )); $chain = $app['orm.mapping_driver_chain.locator'](); foreach ($mapping as $directory => $namespace) { $driver = new XmlDriver($directory); $chain->addDriver($driver, $namespace); } return $config; })); ``` ### Services * **orm.em**: Entity Manager, instance `Doctrine\ORM\EntityManager`. * **orm.ems**: Entity Managers, array of `Doctrine\ORM\EntityManager` indexed by name. Frequently Asked Questions -------------------------- ### Why aren't my Annotations classes being found? When **use_simple_annotation_reader** is set to `False` for an entity, the `AnnotationRegistry` needs to have the project's autoloader added to it. Example: ```php