Skip to content

Commit 54b2aa8

Browse files
fix(database): honour injected connections during initialization (#2326)
Co-authored-by: Brent Roose <brent.roose@gmail.com>
1 parent 8509ea0 commit 54b2aa8

6 files changed

Lines changed: 191 additions & 56 deletions

File tree

‎packages/database/src/Connection/ConnectionInitializer.php‎

Lines changed: 11 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5,19 +5,26 @@
55
namespace Tempest\Database\Connection;
66

77
use Tempest\Container\Container;
8-
use Tempest\Container\Initializer;
8+
use Tempest\Container\DynamicInitializer;
99
use Tempest\Container\Singleton;
1010
use Tempest\Database\Config\DatabaseConfig;
11+
use Tempest\Reflection\ClassReflector;
12+
use UnitEnum;
1113

12-
final class ConnectionInitializer implements Initializer
14+
final class ConnectionInitializer implements DynamicInitializer
1315
{
1416
/** @var Connection[] */
1517
private static array $connections = [];
1618

19+
public function canInitialize(ClassReflector $class, string|UnitEnum|null $tag): bool
20+
{
21+
return $class->getName() === Connection::class;
22+
}
23+
1724
#[Singleton]
18-
public function initialize(Container $container): Connection
25+
public function initialize(ClassReflector $class, string|UnitEnum|null $tag, Container $container): Connection
1926
{
20-
$config = $container->get(DatabaseConfig::class);
27+
$config = $container->get(DatabaseConfig::class, $tag);
2128
$connectionKey = $this->getConnectionKey($config);
2229

2330
$connection = $config->usePersistentConnection

‎packages/database/src/DatabaseInitializer.php‎

Lines changed: 2 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,6 @@
99
use Tempest\Container\Singleton;
1010
use Tempest\Database\Config\DatabaseConfig;
1111
use Tempest\Database\Connection\Connection;
12-
use Tempest\Database\Connection\PDOConnection;
1312
use Tempest\Database\Transactions\GenericTransactionManager;
1413
use Tempest\EventBus\EventBus;
1514
use Tempest\Mapper\SerializerFactory;
@@ -18,9 +17,6 @@
1817

1918
final class DatabaseInitializer implements DynamicInitializer
2019
{
21-
/** @var Connection[] */
22-
private static array $connections = [];
23-
2420
public function canInitialize(ClassReflector $class, string|UnitEnum|null $tag): bool
2521
{
2622
return $class->getType()->matches(Database::class);
@@ -30,42 +26,14 @@ public function canInitialize(ClassReflector $class, string|UnitEnum|null $tag):
3026
public function initialize(ClassReflector $class, string|UnitEnum|null $tag, Container $container): Database
3127
{
3228
$config = $container->get(DatabaseConfig::class, $tag);
33-
$connectionKey = $this->getConnectionKey($config);
34-
35-
$connection = $config->usePersistentConnection
36-
? self::$connections[$connectionKey] ?? null
37-
: null;
38-
39-
if (! $connection) {
40-
$connection = new PDOConnection($config);
41-
$connection->connect();
42-
self::$connections[$connectionKey] = $connection;
43-
} elseif ($connection->ping() === false) {
44-
$connection->reconnect();
45-
}
46-
47-
$container->singleton(
48-
className: Connection::class,
49-
definition: $connection,
50-
tag: $tag,
51-
);
29+
$connection = $container->get(Connection::class, $tag);
5230

5331
return new GenericDatabase(
5432
connection: $connection,
5533
transactionManager: new GenericTransactionManager($connection),
5634
serializerFactory: $container->get(SerializerFactory::class),
5735
eventBus: $container->get(EventBus::class),
36+
config: $config,
5837
);
5938
}
60-
61-
private function getConnectionKey(DatabaseConfig $config): string
62-
{
63-
return hash('xxh128', serialize([
64-
$config->dsn,
65-
$config->username,
66-
$config->options,
67-
$config->password,
68-
$config->tag,
69-
]));
70-
}
7139
}

‎packages/database/src/GenericDatabase.php‎

Lines changed: 11 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,12 @@
44

55
namespace Tempest\Database;
66

7+
use LogicException;
78
use PDO;
89
use PDOException;
910
use PDOStatement;
1011
use Tempest\Database\Builder\QueryBuilders\BuildsQuery;
12+
use Tempest\Database\Config\DatabaseConfig;
1113
use Tempest\Database\Config\DatabaseDialect;
1214
use Tempest\Database\Connection\Connection;
1315
use Tempest\Database\Connection\PDOConnection;
@@ -20,20 +22,20 @@
2022
use Throwable;
2123
use UnitEnum;
2224

23-
// TODO: add DatabaseConnection to the Connection interface instead (4.x)
24-
/** @property PDOConnection $connection */
2525
final class GenericDatabase implements Database
2626
{
27+
private readonly ?DatabaseConfig $config;
28+
2729
private ?PDOStatement $lastStatement = null;
2830

2931
private ?Query $lastQuery = null;
3032

3133
public DatabaseDialect $dialect {
32-
get => $this->connection->config->dialect;
34+
get => $this->config->dialect ?? throw new LogicException('A database configuration is required to determine the dialect.');
3335
}
3436

3537
public string|UnitEnum|null $tag {
36-
get => $this->connection->config->tag;
38+
get => $this->config->tag ?? null;
3739
}
3840

3941
private DatabaseContext $context {
@@ -45,7 +47,11 @@ public function __construct(
4547
private(set) readonly TransactionManager $transactionManager,
4648
private(set) readonly SerializerFactory $serializerFactory,
4749
private readonly EventBus $eventBus,
48-
) {}
50+
?DatabaseConfig $config = null,
51+
) {
52+
// Preserve the v3 constructor for callers that pass a PDOConnection directly.
53+
$this->config = $config ?? ($connection instanceof PDOConnection ? $connection->config : null);
54+
}
4955

5056
public function execute(BuildsQuery|Query $query): void
5157
{

‎src/Tempest/Framework/Testing/TestingDatabaseInitializer.php‎

Lines changed: 17 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -35,29 +35,34 @@ public function canInitialize(ClassReflector $class, string|UnitEnum|null $tag):
3535
public function initialize(ClassReflector $class, string|UnitEnum|null $tag, Container $container): Database
3636
{
3737
$tag = Str\parse($tag);
38+
$config = $container->get(DatabaseConfig::class, $tag);
3839

39-
/** @var PDOConnection|null $connection */
40-
$connection = self::$connections[$tag] ?? null;
40+
if ($container->has(Connection::class, $tag)) {
41+
$connection = $container->get(Connection::class, $tag);
42+
} else {
43+
/** @var PDOConnection|null $connection */
44+
$connection = self::$connections[$tag] ?? null;
4145

42-
if ($connection === null) {
43-
$config = $container->get(DatabaseConfig::class, $tag);
44-
$connection = new PDOConnection($config);
45-
$connection->connect();
46+
if ($connection === null) {
47+
$connection = new PDOConnection($config);
48+
$connection->connect();
4649

47-
self::$connections[$tag] = $connection;
48-
}
50+
self::$connections[$tag] = $connection;
51+
}
4952

50-
if ($connection->ping() === false) {
51-
$connection->reconnect();
52-
}
53+
if ($connection->ping() === false) {
54+
$connection->reconnect();
55+
}
5356

54-
$container->singleton(Connection::class, $connection, $tag);
57+
$container->singleton(Connection::class, $connection, $tag);
58+
}
5559

5660
return new GenericDatabase(
5761
$connection,
5862
new GenericTransactionManager($connection),
5963
$container->get(SerializerFactory::class),
6064
$container->get(EventBus::class),
65+
config: $config,
6166
);
6267
}
6368
}

‎tests/Integration/Container/TaggedDynamicInitializerTest.php‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
use PHPUnit\Framework\TestCase;
77
use Tempest\Container\GenericContainer;
88
use Tempest\Database\Config\SQLiteConfig;
9+
use Tempest\Database\Connection\ConnectionInitializer;
910
use Tempest\Database\Database;
1011
use Tempest\Database\DatabaseInitializer;
1112
use Tempest\EventBus\EventBus;
@@ -21,6 +22,7 @@ public function resolve(): void
2122
$container = new GenericContainer();
2223
$container->singleton(SerializerFactory::class, new SerializerFactory($container));
2324
$container->singleton(EventBus::class, new GenericEventBus($container, new EventBusConfig()));
25+
$container->addInitializer(ConnectionInitializer::class);
2426
$container->addInitializer(DatabaseInitializer::class);
2527

2628
$container->config(new SQLiteConfig(

‎tests/Integration/Database/DatabaseInitializerTest.php‎

Lines changed: 148 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,15 +2,22 @@
22

33
namespace Tests\Tempest\Integration\Database;
44

5+
use PDO;
6+
use PDOStatement;
57
use PHPUnit\Framework\Attributes\Test;
68
use ReflectionMethod;
9+
use RuntimeException;
10+
use Tempest\Database\Config\DatabaseConfig;
11+
use Tempest\Database\Config\DatabaseDialect;
712
use Tempest\Database\Config\MysqlConfig;
813
use Tempest\Database\Config\SQLiteConfig;
914
use Tempest\Database\Connection\Connection;
15+
use Tempest\Database\Connection\ConnectionInitializer;
1016
use Tempest\Database\Connection\PDOConnection;
1117
use Tempest\Database\Database;
1218
use Tempest\Database\DatabaseInitializer;
1319
use Tempest\Database\GenericDatabase;
20+
use Tempest\Database\Query;
1421
use Tempest\Framework\Testing\TestingDatabaseInitializer;
1522
use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
1623

@@ -47,6 +54,146 @@ public function it_resolves_multiple_persistent_connections_by_tag(): void
4754
$this->assertSame($backup->connection, $this->container->get(Connection::class, 'backup'));
4855
}
4956

57+
#[Test]
58+
public function it_resolves_tagged_connections_before_databases_without_sharing_them(): void
59+
{
60+
$this->configureSqliteDatabase('main', 'connection-first-main.sqlite');
61+
$this->configureSqliteDatabase('backup', 'connection-first-backup.sqlite');
62+
63+
$mainConnection = $this->container->get(Connection::class, 'main');
64+
$backupConnection = $this->container->get(Connection::class, 'backup');
65+
66+
$this->assertInstanceOf(PDOConnection::class, $mainConnection);
67+
$this->assertInstanceOf(PDOConnection::class, $backupConnection);
68+
$this->assertNotSame($mainConnection, $backupConnection);
69+
$main = $this->container->get(Database::class, 'main');
70+
$backup = $this->container->get(Database::class, 'backup');
71+
$this->assertInstanceOf(GenericDatabase::class, $main);
72+
$this->assertInstanceOf(GenericDatabase::class, $backup);
73+
$this->assertSame($mainConnection, $main->connection);
74+
$this->assertSame($backupConnection, $backup->connection);
75+
$this->assertSame('main', $main->tag);
76+
$this->assertSame('backup', $backup->tag);
77+
}
78+
79+
#[Test]
80+
public function it_honours_an_injected_connection_when_resolving_database_first(): void
81+
{
82+
$this->configureSqliteDatabase('main', 'injected-database-first.sqlite');
83+
$connection = $this->createMock(Connection::class);
84+
$this->container->singleton(Connection::class, $connection, 'main');
85+
86+
$database = $this->container->get(Database::class, 'main');
87+
88+
$this->assertInstanceOf(GenericDatabase::class, $database);
89+
$this->assertSame($connection, $database->connection);
90+
$this->assertSame($connection, $this->container->get(Connection::class, 'main'));
91+
$this->assertSame(DatabaseDialect::SQLITE, $database->dialect);
92+
$this->assertSame('main', $database->tag);
93+
}
94+
95+
#[Test]
96+
public function it_honours_an_untagged_injected_connection(): void
97+
{
98+
$connection = $this->createMock(Connection::class);
99+
$this->container->unregister(Database::class);
100+
$this->container->singleton(Connection::class, $connection);
101+
102+
$database = $this->container->get(Database::class);
103+
104+
$this->assertInstanceOf(GenericDatabase::class, $database);
105+
$this->assertSame($connection, $database->connection);
106+
$this->assertSame($connection, $this->container->get(Connection::class));
107+
$this->assertSame($this->container->get(DatabaseConfig::class)->dialect, $database->dialect);
108+
$this->assertSame($this->container->get(DatabaseConfig::class)->tag, $database->tag);
109+
}
110+
111+
#[Test]
112+
public function it_keeps_injected_tagged_connections_separate(): void
113+
{
114+
$this->configureSqliteDatabase('main', 'injected-main.sqlite');
115+
$this->configureSqliteDatabase('backup', 'injected-backup.sqlite');
116+
117+
$mainConnection = $this->createMock(Connection::class);
118+
$backupConnection = $this->createMock(Connection::class);
119+
$this->container->singleton(Connection::class, $mainConnection, 'main');
120+
$this->container->singleton(Connection::class, $backupConnection, 'backup');
121+
122+
$main = $this->container->get(Database::class, 'main');
123+
$backup = $this->container->get(Database::class, 'backup');
124+
$this->assertInstanceOf(GenericDatabase::class, $main);
125+
$this->assertInstanceOf(GenericDatabase::class, $backup);
126+
$this->assertSame($mainConnection, $main->connection);
127+
$this->assertSame($backupConnection, $backup->connection);
128+
$this->assertSame('main', $main->tag);
129+
$this->assertSame('backup', $backup->tag);
130+
}
131+
132+
#[Test]
133+
public function it_honours_an_injected_connection_when_resolving_connection_first(): void
134+
{
135+
$this->configureSqliteDatabase('main', 'injected-connection-first.sqlite');
136+
$connection = $this->createMock(Connection::class);
137+
$this->container->singleton(Connection::class, $connection, 'main');
138+
139+
$this->assertSame($connection, $this->container->get(Connection::class, 'main'));
140+
141+
$database = $this->container->get(Database::class, 'main');
142+
143+
$this->assertInstanceOf(GenericDatabase::class, $database);
144+
$this->assertSame($connection, $database->connection);
145+
}
146+
147+
#[Test]
148+
public function it_uses_the_injected_connection_in_an_externally_managed_transaction(): void
149+
{
150+
$this->configureSqliteDatabase('main', 'external-transaction.sqlite');
151+
152+
$pdo = new PDO('sqlite::memory:');
153+
$pdo->exec('CREATE TABLE outbox (message TEXT)');
154+
155+
$connection = $this->createMock(Connection::class);
156+
$connection
157+
->method('prepare')
158+
->willReturnCallback(
159+
fn (string $sql): PDOStatement => $pdo->prepare($sql) ?: throw new RuntimeException('Could not prepare SQL statement.'),
160+
);
161+
$connection->expects($this->never())->method('connect');
162+
$connection->expects($this->never())->method('reconnect');
163+
$connection->expects($this->never())->method('ping');
164+
165+
$this->container->singleton(Connection::class, $connection, 'main');
166+
$database = $this->container->get(Database::class, 'main');
167+
168+
$pdo->beginTransaction();
169+
$database->execute(new Query("INSERT INTO outbox (message) VALUES ('application')"));
170+
$pdo->exec("INSERT INTO outbox (message) VALUES ('messenger')");
171+
172+
$this->assertCount(2, $database->fetch(new Query('SELECT * FROM outbox')));
173+
174+
$pdo->rollBack();
175+
176+
$this->assertSame([], $database->fetch(new Query('SELECT * FROM outbox')));
177+
}
178+
179+
#[Test]
180+
public function the_testing_initializer_also_honours_an_injected_connection(): void
181+
{
182+
$this->container
183+
->removeInitializer(DatabaseInitializer::class)
184+
->addInitializer(TestingDatabaseInitializer::class);
185+
186+
$this->configureSqliteDatabase('main', 'injected-testing.sqlite');
187+
$connection = $this->createMock(Connection::class);
188+
$this->container->singleton(Connection::class, $connection, 'main');
189+
190+
$database = $this->container->get(Database::class, 'main');
191+
192+
$this->assertInstanceOf(GenericDatabase::class, $database);
193+
$this->assertSame($connection, $database->connection);
194+
$this->assertSame('main', $database->tag);
195+
}
196+
50197
#[Test]
51198
public function it_reuses_a_persistent_connection_for_the_same_connection_config(): void
52199
{
@@ -117,7 +264,7 @@ public function it_does_not_reuse_a_persistent_connection_for_the_same_tag_with_
117264
#[Test]
118265
public function it_does_not_reuse_a_persistent_connection_when_only_the_password_differs(): void
119266
{
120-
$initializer = new DatabaseInitializer();
267+
$initializer = new ConnectionInitializer();
121268
$method = new ReflectionMethod($initializer, 'getConnectionKey');
122269

123270
$first = new MysqlConfig(

0 commit comments

Comments
 (0)