- Added support for mysql, sqlite connections

- Added EntityManager
- Fixed Database Connector for Laravel
- Added facades for DatabaseManager and EntityManager
- Updated readme

Author: butschster

README.md

@@ -1,7 +1,10 @@
 # Cycle ORM integration for the Laravel Framework
+Cycle is a PHP DataMapper ORM and Data Modelling engine designed to safely work in classic and daemonized PHP 
+applications (like RoadRunner). The ORM provides flexible configuration options to model datasets, a powerful query
+builder, and supports dynamic mapping schemas. The engine can work with plain PHP objects, support annotation
+declarations, and proxies via extensions.
 
-**!!! Important note!!!**
-At this moment this package work only with postgres database driver.
+Full information - https://cycle-orm.dev/docs
 
 ### Requirements
 - Laravel 7.x
@@ -14,6 +17,14 @@ From the command line run
 composer require butschster/cycle-orm
 ```
 
+Optionally you can register the EntityManager, Transaction and/or ORM facade:
+```
+'DatabaseManager' => Butschster\Cycle\Facades\DatabaseManager::class,
+'Transaction' => Butschster\Cycle\Facades\Transaction::class,
+'ORM' => Butschster\Cycle\Facades\ORM::class,
+'EntityManager' => Butschster\Cycle\Facades\EntityManager::class,
+```
+
 ### Env variables
 
 ```
@@ -38,12 +49,26 @@ Publish the config file.
 php artisan vendor:publish --provider="Butschster\Cycle\Providers\LaravelServiceProvider" --tag=config
 ```
 
+#### Configure Databases
+The list of available connections and databases can be listed in the `config/cycle.php` - `database` section. 
+For more information see https://cycle-orm.dev/docs/basic-connect#configure-databases
+
+#### Getting Database Manager ($dbal)
+`DatabaseManager` registered as a singleton container 
+
+```
+$dbal = $this->app->get(\Spiral\Database\DatabaseManager::class);
+// Or
+$dbal = $this->app->get(\Spiral\Database\DatabaseProviderInterface::class);
+```
+
+
 **That's it!**
 
 ### Console commands
 
 #### php artisan cycle:migrate
-Run cycle orm migrations from directory.
+Run cycle orm migrations from the directory.
 
 #### php artisan cycle:refresh
 Refresh database schema.
@@ -59,6 +84,65 @@ By default, class locator looks for entities in app folder. You can specify loca
 ...
 ```
 
+### Entity Manager
+The EntityManager is the central access point to ORM functionality. It can be used to find, persist and remove entities.
+
+#### Using the EntityManager
+You can use the facade,  container or Dependency injection to access the EntityManager methods
+```php
+EntityManager::persist($entity);
+
+// Or
+
+app(\Butschster\Cycle\Contracts\EntityManager::class)->persist($entity);
+
+// Or
+
+use Butschster\Cycle\Contracts\EntityManager;
+
+class ExampleController extends Controller
+{
+    protected $em;
+
+    public function __construct(EntityManager $em)
+    {
+        $this->em = $em;
+    }
+}
+```
+
+#### Finding entities
+Entities are objects with identity. Their identity has a conceptual meaning inside your domain. In a CMS application 
+each article has a unique id. You can uniquely identify each article by that id.
+
+```php
+$article = EntityManager::findByPK('App\Article', 1);
+$article->setTitle('Different title');
+
+$article2 = EntityManager::findByPK('App\Article', 1);
+
+if ($article === $article2) {
+    echo "Yes we are the same!";
+}
+```
+
+#### Persisting
+By passing the entity through the persist method of the EntityManager, that entity becomes MANAGED, which means that
+its persistence is from now on managed by an EntityManager. 
+
+```php
+$article = new Article;
+$article->setTitle('Let\'s learn about persisting');
+
+EntityManager::persist($article);
+```
+
+#### Deleting
+An entity can be deleted from persistent storage by passing it to the delete($entity) method.
+```php
+EntityManager::delete($article);
+```
+
 ### Example
 
 #### User
@@ -168,34 +252,50 @@ class UserRepository extends Repository
 ```php
 use Cycle\ORM\ORMInterface;
 use Butschster\Cycle\Facades\ORM;
+use Butschster\Cycle\Facades\EntityManager;
 
 $user = new User();
+
 $repository = app(ORMInterface::class)->getRepository($user);
 // or
 $repository = ORM::getRepository($user);
 // or
 $repository = ORM::getRepository(User::class);
 
 $repository->persist($user);
+
+// or
+
+EntityManager::persist($user);
 ```
 
 #### Update user
 ```php
 use Butschster\Cycle\Facades\ORM;
+use Butschster\Cycle\Facades\EntityManager;
 
 $repository = ORM::getRepository(User::class);
 $user = $repository->findByPK('5c9e177b0a975a6eeccf5960');
 $user->setAuthPassword('secret');
 
 $repository->persist($user);
+
+// or
+
+EntityManager::persist($user);
 ```
 
 #### Delete user
 ```php
 use Butschster\Cycle\Facades\ORM;
+use Butschster\Cycle\Facades\EntityManager;
 
 $repository = ORM::getRepository(User::class);
 $user = $repository->findByPK('5c9e177b0a975a6eeccf5960');
 
 $repository->delete($user);
+
+// or
+
+EntityManager::delete($user);
 ```

config/cycle.php

@@ -17,13 +17,39 @@
         ],
 
         'connections' => [
+            'sqlite' => [
+                'driver' => Spiral\Database\Driver\SQLite\SQLiteDriver::class,
+                'options' => [
+                    'connection' => sprintf(
+                        'sqlite:%s',
+                        env('DB_DATABASE', database_path('database.sqlite'))
+                    ),
+                    'username' => env('DB_USERNAME', 'root'),
+                    'password' => env('DB_PASSWORD'),
+                ]
+            ],
+
+            'mysql' => [
+                'driver' => Spiral\Database\Driver\MySQL\MySQLDriver::class,
+                'options' => [
+                    'connection' => sprintf(
+                        'mysql:host=%s;port=%d;dbname=%s',
+                        env('DB_HOST', '127.0.0.1'),
+                        env('DB_PORT', 3304),
+                        env('DB_DATABASE', 'homestead')
+                    ),
+                    'username' => env('DB_USERNAME', 'root'),
+                    'password' => env('DB_PASSWORD'),
+                ]
+            ],
+
             'postgres' => [
                 'driver' => Spiral\Database\Driver\Postgres\PostgresDriver::class,
                 'options' => [
                     'connection' => sprintf(
                         'pgsql:host=%s;port=%d;dbname=%s;',
                         env('DB_HOST', '127.0.0.1'),
-                        env('DB_PORT', '5432'),
+                        env('DB_PORT', 5432),
                         env('DB_DATABASE', 'homestead')
                     ),
                     'username' => env('DB_USERNAME', 'root'),

src/Contracts/EntityManager.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Butschster\Cycle\Contracts;
+
+use Illuminate\Support\Collection;
+
+interface EntityManager
+{
+    /**
+     * Find entity by PK
+     *
+     * @param string $entity
+     * @param string|int $id
+     * @return object|null
+     */
+    public function findByPK(string $entity, $id);
+
+    /**
+     * Find entity using given scope (where).
+     *
+     * @param array $scope
+     * @return null|object
+     */
+    public function findOne(string $entity, array $scope = []);
+
+    /**
+     * Find multiple entities using given scope and sort options.
+     *
+     * @param string $entity
+     * @param array $scope
+     * @param array $orderBy
+     *
+     * @return Collection
+     */
+    public function findAll(string $entity, array $scope = [], array $orderBy = []): Collection;
+
+    /**
+     * @param object $entity
+     * @param bool $cascade
+     * @param bool $run
+     */
+    public function persist(object $entity, bool $cascade = true, bool $run = true): void;
+
+    /**
+     * @param object $entity
+     * @param bool $cascade
+     * @param bool $run
+     */
+    public function delete(object $entity, bool $cascade = true, bool $run = true): void;
+}

src/Database/Connection.php

@@ -4,30 +4,30 @@
 
 use Closure;
 use Cycle\ORM\ORMInterface;
-use Exception;
+use Illuminate\Database\ConnectionInterface;
 use Illuminate\Database\DetectsConcurrencyErrors;
-use Illuminate\Database\PostgresConnection;
 use Spiral\Database\Driver\DriverInterface;
+use Spiral\Database\Injection\Fragment;
 use Spiral\Database\Query\BuilderInterface;
 use Throwable;
 
-class Connection extends PostgresConnection
+class Connection implements ConnectionInterface
 {
     use DetectsConcurrencyErrors;
 
-    protected ORMInterface $ORM;
-
-    protected DriverInterface $driver;
+    private ORMInterface $ORM;
+    private DriverInterface $driver;
+    private ConnectionInterface $connection;
 
     /**
+     * @param ConnectionInterface $connection
      * @param ORMInterface $ORM
-     * @param array $config
      */
-    public function __construct(ORMInterface $ORM, array $config)
+    public function __construct(ConnectionInterface $connection, ORMInterface $ORM)
     {
         $this->ORM = $ORM;
         $this->driver = $ORM->getFactory()->database()->getDriver();
-        $this->config = $config;
+        $this->connection = $connection;
     }
 
     /** @inheritDoc */
@@ -99,19 +99,19 @@ public function affectingStatement($query, $bindings = [])
     /** @inheritDoc */
     public function unprepared($query)
     {
-        throw new Exception('Not implemented');
+        return $this->driver->execute($query);
     }
 
     /** @inheritDoc */
     public function prepareBindings(array $bindings)
     {
-        throw new Exception('Not implemented');
+        return $this->connection->prepareBindings($bindings);
     }
 
     /** @inheritDoc */
     public function pretend(Closure $callback)
     {
-        throw new Exception('Not implemented');
+        return $this->connection->pretend($callback);
     }
 
     /** @inheritDoc */
@@ -127,9 +127,9 @@ public function transaction(Closure $callback, $attempts = 1)
                 $callbackResult = $callback($this);
             }
 
-            // If we catch an exception we'll rollback this transaction and try again if we
-            // are not out of attempts. If we are out of attempts we will just throw the
-            // exception back out and let the developer handle an uncaught exceptions.
+                // If we catch an exception we'll rollback this transaction and try again if we
+                // are not out of attempts. If we are out of attempts we will just throw the
+                // exception back out and let the developer handle an uncaught exceptions.
             catch (Throwable $e) {
                 $this->handleTransactionException(
                     $e,
@@ -229,4 +229,9 @@ protected function handleCommitTransactionException(Throwable $e, $currentAttemp
 
         throw $e;
     }
+
+    public function raw($value)
+    {
+        return new Fragment($value);
+    }
 }

src/Entity/Manager.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Butschster\Cycle\Entity;
+
+use Butschster\Cycle\Contracts\EntityManager;
+use Cycle\ORM\ORMInterface;
+use Illuminate\Support\Collection;
+
+class Manager implements EntityManager
+{
+    private ORMInterface $orm;
+
+    public function __construct(ORMInterface $orm)
+    {
+        $this->orm = $orm;
+    }
+
+    public function findByPK(string $entity, $id)
+    {
+        return $this->orm->getRepository($entity)
+            ->findByPK($id);
+    }
+
+    public function findOne(string $entity, array $scope = [])
+    {
+        return $this->orm->getRepository($entity)
+            ->findOne($scope);
+    }
+
+    public function findAll(string $entity, array $scope = [], array $orderBy = []): Collection
+    {
+        return $this->orm->getRepository($entity)
+            ->findAll($scope, $orderBy);
+    }
+
+    public function persist(object $entity, bool $cascade = true, bool $run = true): void
+    {
+        $this->orm->getRepository($entity)
+            ->persist($entity, $cascade, $run);
+    }
+
+    public function delete(object $entity, bool $cascade = true, bool $run = true): void
+    {
+        $this->orm->getRepository($entity)
+            ->delete($entity, $cascade, $run);
+    }
+}