Update docs for continue_without_database_transactions

config/scribe.php

@@ -333,10 +333,10 @@ INTRO
     'routeMatcher' => \Knuckles\Scribe\Matching\RouteMatcher::class,
 
     /**
-     * [Advanced usage] If one of your app's database connections does not support transactions,
+     * [Advanced usage] If one of your app's database drivers does not support transactions,
      * docs generation (instantiating Eloquent models and making response calls) will likely fail.
-     * To avoid that, you can add it here, but that means all database changes will persist.
-     * We recommend using a test database when generating.
+     * To avoid that, you can add the driver class name here.
+     * Be warned: that means all database changes will persist.
      */
-    'allow_database_persistence' => [],
+    'continue_without_database_transactions' => [],
 ];

docs/config.md

@@ -205,9 +205,6 @@ When generating example requests, this package uses the fzanninoto/faker package
 .. Tip:: Alternatively, you can set example values for parameters when `documenting them <documenting.html>`_.
 ```
 
-### `routeMatcher`
-The route matcher class provides the algorithm that determines what routes should be documented. The default matcher used is the included `\Knuckles\Scribe\Matching\RouteMatcher::class`, and you can provide your own custom implementation if you wish to programmatically change the algorithm. The provided matcher should be an instance of `\Knuckles\Scribe\Matching\RouteMatcherInterface`.
-
 ### `fractal`
 This section only applies if you're using [transformers](https://fractal.thephpleague.com/transformers/) for your API (via the league/fractal package), and documenting responses with `@transformer` and `@transformerCollection`. Here, you configure how responses are transformed.
 
@@ -217,4 +214,16 @@ This section only applies if you're using [transformers](https://fractal.thephpl
   - `\League\Fractal\Serializer\JsonApiSerializer::class`
 
   Leave this as `null` to use no serializer or return a simple JSON.
-     
+
+
+### `routeMatcher`
+The route matcher class provides the algorithm that determines what routes should be documented. The default matcher used is the included `\Knuckles\Scribe\Matching\RouteMatcher::class`, and you can provide your own custom implementation if you wish to programmatically change the algorithm. The provided matcher should be an instance of `\Knuckles\Scribe\Matching\RouteMatcherInterface`.
+
+### `continue_without_database_transactions`
+By default, Scribe runs response calls and example model creation in a database transaction, and then rolls them back so no changes are persisted. If one of your database drivers does not support database transactions, Scribe will log an error and exit. If you would like Scribe to proceed (and persist the data), add the database driver class name to this array. For example:
+
+```php
+'continue_without_database_transactions' => [
+    Jenssegers\Mongodb\Connection::class,
+],
+```

docs/documenting/documenting-endpoint-responses.md

@@ -122,7 +122,7 @@ This JSON string will be parsed and merged with the response from the file.
 If you don't specify an example response using any of the other means described in this document, Scribe will attempt to get a sample response by making a HTTP request to the local endpoint (known as a "response call").
 
 ```eval_rst
-.. Note:: Response calls are done within a database transaction and changes are rolled back afterwards, so no data is persisted.
+.. Note:: Response calls are done within a database transaction and changes are rolled back afterwards, so no data is persisted. If your database connection does not support transactions, you should add it to `continue_without_database_transactions`, but be warned that data from response calls will be persisted.
 ```
 
 The configuration for response calls is located in the `apply.response_calls` section for each route group in `config/scribe.php`. This means that You can apply different settings for different sets of routes. Here are some important things to note:
@@ -280,7 +280,7 @@ When generating responses from `@apiResource` and `@transformer` tags, Scribe ne
 1. First, it tries the Eloquent model factory: `factory(YourModel::class)->create()`. 
 
 ```eval_rst
-.. Note:: Scribe uses :code:`create()` instead of :code:`make()` when calling the factory, but runs it in a database transaction which is rolled back afterwards, so no data is persisted.
+.. Note:: Scribe uses :code:`create()` instead of :code:`make()` when calling the factory, but runs it in a database transaction which is rolled back afterwards, so no data is persisted. If your database connection does not support transactions, you should add it to `continue_without_database_transactions`, but be warned that created models will be persisted.
 ```
 
 2. If that fails, Scribe calls `YourModel::first()` to retrieve the first model from the database. 

src/Exceptions/DatabaseTransactionsNotSupported.php

@@ -7,12 +7,12 @@ use RuntimeException;
 
 class DatabaseTransactionsNotSupported extends RuntimeException implements ScribeException
 {
-    public static function create(string $connection, string $driver)
+    public static function create(string $connectionName, string $driverName)
     {
         return new self(
-            "Database Driver [{$driver}] for connection [{$connection}] does not support transactions. " .
+            "Database Driver [{$driverName}] for connection [{$connectionName}] does not support transactions. " .
             "Changes to your database will be persistent. " .
-            "To allow this, add \"{$connection}\" to the \"allow_database_persistence\" config."
+            "To allow this, add \"{$driverName}\" to the \"continue_without_database_transactions\" config."
         );
     }
 }

src/Extracting/DatabaseTransactionHelpers.php

@@ -10,9 +10,6 @@ use Knuckles\Scribe\Tools\DocumentationConfig;
 
 trait DatabaseTransactionHelpers
 {
-    /**
-     * @return void
-     */
     private function startDbTransaction()
     {
         $connections = array_keys(config('database.connections', []));
@@ -27,11 +24,13 @@ trait DatabaseTransactionHelpers
                     return;
                 }
 
-                if ($this->canAllowDatabasePersistence($connection)) {
-                    throw DatabaseTransactionsNotSupported::create($connection, get_class($driver));
+                $driverClassName = get_class($driver);
+
+                if ($this->shouldAllowDatabasePersistence($driverClassName)) {
+                    throw DatabaseTransactionsNotSupported::create($connection, $driverClassName);
                 }
 
-                c::warn("Database driver for the connection [{$connection}] does not support transactions. Any changes made to your database will persist.");
+                c::warn("Database driver [$driverClassName] for the connection [{$connection}] does not support transactions. Any changes made to your database will persist.");
             } catch (ScribeException $e) {
                 throw $e;
             } catch (Exception $e) {
@@ -56,20 +55,14 @@ trait DatabaseTransactionHelpers
                     return;
                 }
 
-                c::warn("Database driver for the connection [{$connection}] does not support transactions. Any changes made to your database have been persisted.");
+                $driverClassName = get_class($driver);
+                c::warn("Database driver [$driverClassName] for the connection [{$connection}] does not support transactions. Any changes made to your database have been persisted.");
             } catch (Exception $e) {
             }
         }
     }
 
-    /**
-     * Assesses whether or not the "PDO" driver provided supports transactions
-     *
-     * @param mixed $driver Driver prodicted for particular connection
-     *
-     * @return boolean
-     */
-    private static function driverSupportsTransactions($driver)
+    private static function driverSupportsTransactions($driver): bool
     {
         $methods = ['beginTransaction', 'rollback'];
 
@@ -85,16 +78,16 @@ trait DatabaseTransactionHelpers
     /**
      * Assesses whether drivers without transaction support can proceed
      *
-     * @param string $connection Name of the connection
+     * @param string $driverClassName
      *
-     * @return boolean
+     * @return bool
      */
-    private function canAllowDatabasePersistence(string $connection)
+    private function shouldAllowDatabasePersistence(string $driverClassName): bool
     {
         $config = $this->getConfig();
 
-        $whitelistedConnections = $config->get('allow_database_persistence', []);
-        return in_array($connection, $whitelistedConnections);
+        $whitelistedDrivers = $config->get('continue_without_database_transactions', []);
+        return in_array($driverClassName, $whitelistedDrivers);
     }
 
     /**