Enhanced Temporal connection configuration for flexibility and SSL su…

…pport

This commit significantly overhauls the Temporal connection configuration system. The previous configuration was limited to specifying a single Temporal address with no support for SSL connections. With the new setup, developers can now define multiple connection options, including SSL-enabled connections.

Changes include:
- Introduction of a 'connections' array to specify multiple connection types (e.g., `default`, `SSL`).
- Addition of the `SslConnection` class to handle SSL connection parameters such as certificates and keys.
- Preservation of backward compatibility by supporting the previous `address` configuration under the `default` connection type.

src/Bootloader/TemporalBridgeBootloader.php

@@ -16,6 +16,8 @@
 use Spiral\RoadRunnerBridge\Bootloader\RoadRunnerBootloader;
 use Spiral\TemporalBridge\Commands;
 use Spiral\TemporalBridge\Config\TemporalConfig;
+use Spiral\TemporalBridge\Connection\SslConnection;
+use Spiral\TemporalBridge\Connection\DsnConnection;
 use Spiral\TemporalBridge\DeclarationLocator;
 use Spiral\TemporalBridge\DeclarationLocatorInterface;
 use Spiral\TemporalBridge\Dispatcher;
@@ -121,8 +123,10 @@ protected function initConfig(EnvironmentInterface $env): void
         $this->config->setDefaults(
             TemporalConfig::CONFIG,
             [
-                'address' => $env->get('TEMPORAL_ADDRESS', '127.0.0.1:7233'),
-                'namespace' => 'App\\Endpoint\\Temporal\\Workflow',
+                'connection' => $env->get('TEMPORAL_CONNECTION', 'default'),
+                'connections' => [
+                    'default' => new DsnConnection(address: $env->get('TEMPORAL_ADDRESS', '127.0.0.1:7233')),
+                ],
                 'defaultWorker' => (string)$env->get(
                     'TEMPORAL_TASK_QUEUE',
                     TemporalWorkerFactoryInterface::DEFAULT_TASK_QUEUE,
@@ -185,7 +189,19 @@ protected function initPipelineProvider(TemporalConfig $config, FactoryInterface
 
     protected function initServiceClient(TemporalConfig $config): ServiceClientInterface
     {
-        return ServiceClient::create($config->getAddress());
+        $connection = $config->getConnection($config->getDefaultConnection());
+
+        if ($connection instanceof SslConnection) {
+            return ServiceClient::createSSL(
+                address: $connection->getAddress(),
+                crt: $connection->crt,
+                clientKey: $connection->clientKey,
+                clientPem: $connection->clientPem,
+                overrideServerName: $connection->overrideServerName,
+            );
+        }
+
+        return ServiceClient::create(address: $connection->getAddress());
     }
 
     protected function initScheduleClient(

src/Config/TemporalConfig.php

@@ -6,6 +6,9 @@
 
 use Spiral\Core\Container\Autowire;
 use Spiral\Core\InjectableConfig;
+use Spiral\TemporalBridge\Connection\Connection;
+use Spiral\TemporalBridge\Connection\DsnConnection;
+use Spiral\TemporalBridge\Connection\SslConnection;
 use Temporal\Client\ClientOptions;
 use Temporal\Exception\ExceptionInterceptorInterface;
 use Temporal\Internal\Interceptor\Interceptor;
@@ -21,8 +24,8 @@
  * }
  *
  * @property array{
- *     address: non-empty-string,
- *     namespace: non-empty-string,
+ *     connection: non-empty-string,
+ *     connections: array<non-empty-string, Connection>,
  *     temporalNamespace: non-empty-string,
  *     defaultWorker: non-empty-string,
  *     workers: array<non-empty-string, WorkerOptions|TWorker>,
@@ -35,8 +38,8 @@ final class TemporalConfig extends InjectableConfig
     public const CONFIG = 'temporal';
 
     protected array $config = [
-        'address' => 'localhost:7233',
-        'namespace' => 'App\\Endpoint\\Temporal\\Workflow',
+        'connection' => 'default',
+        'connections' => [],
         'temporalNamespace' => 'default',
         'defaultWorker' => WorkerFactoryInterface::DEFAULT_TASK_QUEUE,
         'workers' => [],
@@ -47,25 +50,41 @@ final class TemporalConfig extends InjectableConfig
     /**
      * @return non-empty-string
      */
-    public function getDefaultNamespace(): string
+    public function getTemporalNamespace(): string
     {
-        return $this->config['namespace'];
+        return $this->config['temporalNamespace'];
     }
 
-    /**
-     * @return non-empty-string
-     */
-    public function getTemporalNamespace(): string
+    public function getDefaultConnection(): string
     {
-        return $this->config['temporalNamespace'];
+        return $this->config['connection'] ?? 'default';
+    }
+
+    public function getConnection(string $name): Connection
+    {
+        if (isset($this->config['connections'][$name])) {
+            \assert(
+                $this->config['connections'][$name] instanceof Connection,
+                'Connection must be an instance of Connection.',
+            );
+
+            return $this->config['connections'][$name];
+        }
+
+
+        if ($this->config['connections'] === [] && $this->config['address'] !== null) {
+            return new DsnConnection($this->config['address']);
+        }
+
+        throw new \InvalidArgumentException(\sprintf('Connection `%s` is not defined.', $name));
     }
 
     /**
-     * @return non-empty-string
+     * @deprecated
      */
     public function getAddress(): string
     {
-        return $this->config['address'];
+        return $this->getConnection($this->getDefaultConnection())->getAddress();
     }
 
     /**

src/Connection/Connection.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Spiral\TemporalBridge\Connection;
+
+class Connection
+{
+    /**
+     * @param non-empty-string $host
+     * @param int $port
+     */
+    public function __construct(
+        public readonly string $host,
+        public readonly int $port,
+    ) {
+    }
+
+    public function getAddress(): string
+    {
+        return $this->host . ':' . $this->port;
+    }
+}

src/Connection/DsnConnection.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Spiral\TemporalBridge\Connection;
+
+class DsnConnection extends Connection
+{
+    public function __construct(
+        public readonly string $address,
+    ) {
+        [$host, $port] = \explode(':', $address);
+        parent::__construct($host, (int)$port);
+    }
+}

src/Connection/SslConnection.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Spiral\TemporalBridge\Connection;
+
+final class SslConnection extends DsnConnection
+{
+    /**
+     * @param non-empty-string $address
+     * @param string $crt Full path to the certificate file (Default: '')
+     * @param string|null $clientKey Full path to the client key file (Default: null)
+     * @param string|null $clientPem Full path to the client pem file (Default: null)
+     * @param string|null $overrideServerName
+     */
+    public function __construct(
+        string $address,
+        public readonly string $crt = '',
+        public readonly ?string $clientKey = null,
+        public readonly ?string $clientPem = null,
+        public readonly ?string $overrideServerName = null,
+    ) {
+        parent::__construct($address);
+    }
+}

tests/app/config/temporal.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+use Spiral\TemporalBridge\Connection\DsnConnection;
+use Spiral\TemporalBridge\Connection\SslConnection;
+
+return [
+    'connection' => 'default',
+    'connections' => [
+        'default' => new DsnConnection(
+            address: 'localhost:7233',
+        ),
+        'ssl' => new SslConnection(
+            address: 'ssl:7233',
+            crt: '/path/to/crt',
+            clientKey: '/path/to/clientKey',
+            clientPem: '/path/to/clientPem',
+            overrideServerName: 'overrideServerName',
+        ),
+    ],
+];

tests/src/Bootloader/TemporalBridgeBootloaderTest.php

@@ -18,6 +18,8 @@
 use Spiral\TemporalBridge\WorkerFactoryInterface;
 use Spiral\TemporalBridge\WorkersRegistry;
 use Spiral\TemporalBridge\WorkersRegistryInterface;
+use Spiral\Testing\Attribute\Env;
+use Temporal\Api\Workflowservice\V1\WorkflowServiceClient;
 use Temporal\Client\GRPC\ServiceClient;
 use Temporal\Client\GRPC\ServiceClientInterface;
 use Temporal\Client\ScheduleClient;
@@ -63,7 +65,7 @@ public function testWorkerFactory(): void
     {
         $this->assertContainerBoundAsSingleton(
             WorkerFactoryInterface::class,
-            WorkerFactory::class
+            WorkerFactory::class,
         );
     }
 
@@ -107,6 +109,47 @@ public function testPipelineProvider(): void
         );
     }
 
+    #[Env('TEMPORAL_CONNECTION', 'default')]
+    public function testConnection(): void
+    {
+        $client = $this->getContainer()->get(ServiceClientInterface::class);
+
+        $refl = new \ReflectionClass($client);
+        $baseClient = $refl->getParentClass();
+        $property = $baseClient->getProperty('workflowService');
+
+        $property->setAccessible(true);
+        /** @var WorkflowServiceClient $stub */
+        $stub = $property->getValue($client);
+
+        $this->assertSame('localhost:7233', $stub->getTarget());
+    }
+
+    #[Env('TEMPORAL_CONNECTION', 'ssl')]
+    public function testSslConnection(): void
+    {
+        $client = $this->getContainer()->get(ServiceClientInterface::class);
+
+        $refl = new \ReflectionClass($client);
+        $baseClient = $refl->getParentClass();
+        $property = $baseClient->getProperty('workflowService');
+
+        $property->setAccessible(true);
+        /** @var WorkflowServiceClient $stub */
+        $stub = $property->getValue($client);
+
+        $this->assertSame('ssl:7233', $stub->getTarget());
+    }
+
+    #[Env('TEMPORAL_CONNECTION', 'test')]
+    public function testNonExistsConnection(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Connection `test` is not defined.');
+
+        $this->getContainer()->get(ServiceClientInterface::class);
+    }
+
     public function testAddWorkerOptions(): void
     {
         $configs = new ConfigManager($this->createMock(LoaderInterface::class));