Split DatabaseInterface and ProcessIoDatabase implementation

This is done to achieve better separation of concerns in preparation for
creating different database communication implementations for Windows
support in the future.

Author: clue

README.md

@@ -9,7 +9,7 @@ built on top of [ReactPHP](https://reactphp.org/).
 * [Usage](#usage)
   * [Factory](#factory)
     * [open()](#open)
-  * [Database](#database)
+  * [DatabaseInterface](#databaseinterface)
     * [exec()](#exec)
     * [query()](#query)
     * [quit()](#quit)
@@ -33,7 +33,7 @@ $factory = new Clue\React\SQLite\Factory($loop);
 
 $name = 'Alice';
 $factory->open('users.db')->then(
-    function (Clue\React\SQLite\Database $db) use ($name) {
+    function (Clue\React\SQLite\DatabaseInterface $db) use ($name) {
         $db->exec('CREATE TABLE IF NOT EXISTS foo (id INTEGER PRIMARY KEY AUTOINCREMENT, bar STRING)');
 
         $db->query('INSERT INTO foo (bar) VALUES (?)', array($name))->then(
@@ -58,7 +58,7 @@ See also the [examples](examples).
 
 ### Factory
 
-The `Factory` is responsible for opening your [`Database`](#database) instance.
+The `Factory` is responsible for opening your [`DatabaseInterface`](#databaseinterface) instance.
 It also registers everything with the main [`EventLoop`](https://github.com/reactphp/event-loop#usage).
 
 ```php
@@ -71,14 +71,14 @@ $factory = new Clue\React\SQLite\Factory($loop);
 The `open(string $filename, int $flags = null): PromiseInterface<Database>` method can be used to
 open a new database connection for the given SQLite database file.
 
-This method returns a promise that will resolve with a `Database` on
+This method returns a promise that will resolve with a `DatabaseInterface` on
 success or will reject with an `Exception` on error. The SQLite extension
 is inherently blocking, so this method will spawn an SQLite worker process
 to run all SQLite commands and queries in a separate process without
 blocking the main process.
 
 ```php
-$factory->open('users.db')->then(function (Database $db) {
+$factory->open('users.db')->then(function (DatabaseInterface $db) {
     // database ready
     // $db->query('INSERT INTO users (name) VALUES ("test")');
     // $db->quit();
@@ -91,17 +91,17 @@ The optional `$flags` parameter is used to determine how to open the
 SQLite database. By default, open uses `SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE`.
 
 ```php
-$factory->open('users.db', SQLITE3_OPEN_READONLY)->then(function (Database $db) {
+$factory->open('users.db', SQLITE3_OPEN_READONLY)->then(function (DatabaseInterface $db) {
     // database ready (read-only)
     // $db->quit();
 }, function (Exception $e) {
     echo 'Error: ' . $e->getMessage() . PHP_EOL;
 });
 ```
 
-### Database
+### DatabaseInterface
 
-The `Database` class represents a connection that is responsible for
+The `DatabaseInterface` represents a connection that is responsible for
 comunicating with your SQLite database wrapper, managing the connection state
 and sending your database queries.
 

examples/insert.php

@@ -1,6 +1,6 @@
 <?php
 
-use Clue\React\SQLite\Database;
+use Clue\React\SQLite\DatabaseInterface;
 use Clue\React\SQLite\Factory;
 use Clue\React\SQLite\Result;
 
@@ -10,7 +10,7 @@
 $factory = new Factory($loop);
 
 $n = isset($argv[1]) ? $argv[1] : 1;
-$factory->open('test.db')->then(function (Database $db) use ($n) {
+$factory->open('test.db')->then(function (DatabaseInterface $db) use ($n) {
     $db->exec('CREATE TABLE IF NOT EXISTS foo (id INTEGER PRIMARY KEY AUTOINCREMENT, bar STRING)');
 
     for ($i = 0; $i < $n; ++$i) {

examples/search.php

@@ -1,6 +1,6 @@
 <?php
 
-use Clue\React\SQLite\Database;
+use Clue\React\SQLite\DatabaseInterface;
 use Clue\React\SQLite\Factory;
 use Clue\React\SQLite\Result;
 
@@ -10,7 +10,7 @@
 $factory = new Factory($loop);
 
 $search = isset($argv[1]) ? $argv[1] : 'foo';
-$factory->open('test.db')->then(function (Database $db) use ($search){
+$factory->open('test.db')->then(function (DatabaseInterface $db) use ($search){
     $db->query('SELECT * FROM foo WHERE bar LIKE ?', ['%' . $search . '%'])->then(function (Result $result) {
         echo 'Found ' . count($result->rows) . ' rows: ' . PHP_EOL;
         echo implode("\t", $result->columns) . PHP_EOL;

src/Database.php renamed to src/DatabaseInterface.php

@@ -2,14 +2,11 @@
 
 namespace Clue\React\SQLite;
 
-use Clue\React\NDJson\Decoder;
-use Evenement\EventEmitter;
-use React\ChildProcess\Process;
-use React\Promise\Deferred;
+use Evenement\EventEmitterInterface;
 use React\Promise\PromiseInterface;
 
 /**
- * The `Database` class represents a connection that is responsible for
+ * The `DatabaseInterface` represents a connection that is responsible for
  * communicating with your SQLite database wrapper, managing the connection state
  * and sending your database queries.
  *
@@ -42,52 +39,8 @@
  *
  *     See also the [`close()`](#close) method.
  */
-class Database extends EventEmitter
+interface DatabaseInterface extends EventEmitterInterface
 {
-    private $process;
-    private $pending = array();
-    private $id = 0;
-    private $closed = false;
-
-    /**
-     * @internal see Factory instead
-     * @see Factory
-     * @param Process $process
-     */
-    public function __construct(Process $process)
-    {
-        $this->process = $process;
-
-        $in = new Decoder($process->stdout, true, 512, 0, 16 * 1024 * 1024);
-        $in->on('data', function ($data) use ($in) {
-            if (!isset($data['id']) || !isset($this->pending[$data['id']])) {
-                $this->emit('error', array(new \RuntimeException('Invalid message received')));
-                $in->close();
-                return;
-            }
-
-            /* @var Deferred $deferred */
-            $deferred = $this->pending[$data['id']];
-            unset($this->pending[$data['id']]);
-
-            if (isset($data['error'])) {
-                $deferred->reject(new \RuntimeException(
-                    isset($data['error']['message']) ? $data['error']['message'] : 'Unknown error',
-                    isset($data['error']['code']) ? $data['error']['code'] : 0
-                ));
-            } else {
-                $deferred->resolve($data['result']);
-            }
-        });
-        $in->on('error', function (\Exception $e) {
-            $this->emit('error', array($e));
-            $this->close();
-        });
-        $in->on('close', function () {
-            $this->close();
-        });
-    }
-
     /**
      * Executes an async query.
      *
@@ -129,16 +82,7 @@ public function __construct(Process $process)
      * @param string $sql SQL statement
      * @return PromiseInterface<Result> Resolves with Result instance or rejects with Exception
      */
-    public function exec($sql)
-    {
-        return $this->send('exec', array($sql))->then(function ($data) {
-            $result = new Result();
-            $result->changed = $data['changed'];
-            $result->insertId = $data['insertId'];
-
-            return $result;
-        });
-    }
+    public function exec($sql);
 
     /**
      * Performs an async query.
@@ -196,18 +140,7 @@ public function exec($sql)
      * @param array  $params Parameters which should be bound to query
      * @return PromiseInterface<Result> Resolves with Result instance or rejects with Exception
      */
-    public function query($sql, array $params = array())
-    {
-        return $this->send('query', array($sql, $params))->then(function ($data) {
-            $result = new Result();
-            $result->changed = $data['changed'];
-            $result->insertId = $data['insertId'];
-            $result->columns = $data['columns'];
-            $result->rows = $data['rows'];
-
-            return $result;
-        });
-    }
+    public function query($sql, array $params = array());
 
     /**
      * Quits (soft-close) the connection.
@@ -225,14 +158,7 @@ public function query($sql, array $params = array())
      *
      * @return PromiseInterface<void> Resolves (with void) or rejects with Exception
      */
-    public function quit()
-    {
-        $promise = $this->send('close', array());
-
-        $this->process->stdin->end();
-
-        return $promise;
-    }
+    public function quit();
 
     /**
      * Force-close the connection.
@@ -249,44 +175,5 @@ public function quit()
      *
      * @return void
      */
-    public function close()
-    {
-        if ($this->closed) {
-            return;
-        }
-
-        $this->closed = true;
-        foreach ($this->process->pipes as $pipe) {
-            $pipe->close();
-        }
-        $this->process->terminate();
-
-        foreach ($this->pending as $one) {
-            $one->reject(new \RuntimeException('Database closed'));
-        }
-        $this->pending = array();
-
-        $this->emit('close');
-        $this->removeAllListeners();
-    }
-
-    /** @internal */
-    public function send($method, array $params)
-    {
-        if (!$this->process->stdin->isWritable()) {
-            return \React\Promise\reject(new \RuntimeException('Database closed'));
-        }
-
-        $id = ++$this->id;
-        $this->process->stdin->write(\json_encode(array(
-            'id' => $id,
-            'method' => $method,
-            'params' => $params
-        ), \JSON_UNESCAPED_SLASHES) . "\n");
-
-        $deferred = new Deferred();
-        $this->pending[$id] = $deferred;
-
-        return $deferred->promise();
-    }
+    public function close();
 }

src/Factory.php

@@ -4,13 +4,14 @@
 
 use React\ChildProcess\Process;
 use React\EventLoop\LoopInterface;
+use Clue\React\SQLite\Io\ProcessIoDatabase;
 
 class Factory
 {
     private $loop;
 
     /**
-     * The `Factory` is responsible for opening your [`Database`](#database) instance.
+     * The `Factory` is responsible for opening your [`DatabaseInterface`](#databaseinterface) instance.
      * It also registers everything with the main [`EventLoop`](https://github.com/reactphp/event-loop#usage).
      *
      * ```php
@@ -28,14 +29,14 @@ public function __construct(LoopInterface $loop)
     /**
      * Opens a new database connection for the given SQLite database file.
      *
-     * This method returns a promise that will resolve with a `Database` on
+     * This method returns a promise that will resolve with a `DatabaseInterface` on
      * success or will reject with an `Exception` on error. The SQLite extension
      * is inherently blocking, so this method will spawn an SQLite worker process
      * to run all SQLite commands and queries in a separate process without
      * blocking the main process.
      *
      * ```php
-     * $factory->open('users.db')->then(function (Database $db) {
+     * $factory->open('users.db')->then(function (DatabaseInterface $db) {
      *     // database ready
      *     // $db->query('INSERT INTO users (name) VALUES ("test")');
      *     // $db->quit();
@@ -48,7 +49,7 @@ public function __construct(LoopInterface $loop)
      * SQLite database. By default, open uses `SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE`.
      *
      * ```php
-     * $factory->open('users.db', SQLITE3_OPEN_READONLY)->then(function (Database $db) {
+     * $factory->open('users.db', SQLITE3_OPEN_READONLY)->then(function (DatabaseInterface $db) {
      *     // database ready (read-only)
      *     // $db->quit();
      * }, function (Exception $e) {
@@ -58,7 +59,7 @@ public function __construct(LoopInterface $loop)
      *
      * @param string $filename
      * @param ?int   $flags
-     * @return PromiseInterface<Database> Resolves with Database instance or rejects with Exception
+     * @return PromiseInterface<DatabaseInterface> Resolves with DatabaseInterface instance or rejects with Exception
      */
     public function open($filename, $flags = null)
     {
@@ -107,7 +108,7 @@ public function open($filename, $flags = null)
         $process = new Process($command, null, null, $pipes);
         $process->start($this->loop);
 
-        $db = new Database($process);
+        $db = new ProcessIoDatabase($process);
         $args = array($filename);
         if ($flags !== null) {
             $args[] = $flags;