refactor: update facade structure and add service providers for logging and Redis (#4)

Reviewed-on: #4
Co-authored-by: Ron Rise <ron@siteworxpro.com>
Co-committed-by: Ron Rise <ron@siteworxpro.com>

src/Facades/Config.php

@@ -1,57 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Siteworxpro\App\Facades;
-
-use Illuminate\Contracts\Container\BindingResolutionException;
-use Illuminate\Support\Facades\Facade;
-use Siteworx\Config\Exception\EmptyDirectoryException;
-use Siteworx\Config\Exception\FileNotFoundException;
-use Siteworx\Config\Exception\UnsupportedFormatException;
-
-/**
- * Class Config
- *
- * This class serves as a facade for the configuration settings of the application.
- * It extends the Facade class from the Illuminate\Support\Facades namespace.
- *
- * @method static bool | string | int  get(string $key) Retrieve the configuration value for the given key.
- *
- * @package Siteworx\App\Facades
- */
-class Config extends Facade
-{
-    protected static $cached = false;
-
-
-    /**
-     * @throws UnsupportedFormatException
-     * @throws FileNotFoundException
-     * @throws EmptyDirectoryException
-     */
-    public static function getFacadeRoot(): \Siteworx\Config\Config
-    {
-        if (self::$resolvedInstance !== null) {
-            try {
-                $config = self::resolveFacadeInstance(self::getFacadeAccessor());
-                if ($config instanceof \Siteworx\Config\Config) {
-                    return $config;
-                }
-            } catch (BindingResolutionException) {
-            }
-        }
-
-        return \Siteworx\Config\Config::load(__DIR__ . '/../../config.php');
-    }
-
-    /**
-     * Get the registered name of the component.
-     *
-     * @return string The name of the component.
-     */
-    protected static function getFacadeAccessor(): string
-    {
-        return \Siteworx\Config\Config::class;
-    }
-}

src/Http/Middleware/CorsMiddleware.php

@@ -9,7 +9,7 @@ use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
-use Siteworxpro\App\Facades\Config;
+use Siteworxpro\App\Services\Facades\Config;
 
 /**
  * Class CorsMiddleware

src/Server.php

@@ -5,16 +5,20 @@ declare(strict_types=1);
 namespace Siteworxpro\App;
 
 use Illuminate\Container\Container;
-use Illuminate\Support\Facades\Facade;
+use Illuminate\Support\ServiceProvider;
 use League\Route\Http\Exception\MethodNotAllowedException;
 use League\Route\Http\Exception\NotFoundException;
 use League\Route\Router;
 use Nyholm\Psr7\Factory\Psr17Factory;
+use Siteworx\Config\Config as SWConfig;
 use Siteworxpro\App\Controllers\IndexController;
-use Siteworxpro\App\Facades\Config;
-use Siteworxpro\App\Facades\Logger;
 use Siteworxpro\App\Http\JsonResponseFactory;
 use Siteworxpro\App\Http\Middleware\CorsMiddleware;
+use Siteworxpro\App\Services\Facade;
+use Siteworxpro\App\Services\Facades\Config;
+use Siteworxpro\App\Services\Facades\Logger;
+use Siteworxpro\App\Services\ServiceProviders\LoggerServiceProvider;
+use Siteworxpro\App\Services\ServiceProviders\RedisServiceProvider;
 use Spiral\RoadRunner\Http\PSR7Worker;
 use Spiral\RoadRunner\Worker;
 
@@ -39,11 +43,17 @@ class Server
      */
     protected PSR7Worker $worker;
 
+    public static array $serviceProviders = [
+        LoggerServiceProvider::class,
+        RedisServiceProvider::class
+    ];
+
 
     /**
      * Server constructor.
      *
      * Initializes the server by booting the PSR-7 worker and router.
+     * @throws \ReflectionException
      */
     public function __construct()
     {
@@ -58,11 +68,33 @@ class Server
      * subclasses to ensure proper initialization.
      *
      * @return void
+     * @throws \ReflectionException
      */
     private function boot(): void
     {
         $container = new Container();
-        Facade::setFacadeApplication($container);
+        Facade::setFacadeContainer($container);
+
+        // Bind the container to the Config facade first so that it can be used by service providers
+        $container->bind(SWConfig::class, function () {
+            return SWConfig::load(__DIR__ . '/../config.php');
+        });
+
+        foreach (self::$serviceProviders as $serviceProvider) {
+            if (class_exists($serviceProvider)) {
+                $provider = new $serviceProvider($container);
+                if ($provider instanceof ServiceProvider) {
+                    $provider->register();
+                } else {
+                    throw new \RuntimeException(sprintf(
+                        'Service provider %s is not an instance of ServiceProvider.',
+                        $serviceProvider
+                    ));
+                }
+            } else {
+                throw new \RuntimeException(sprintf('Service provider %s not found.', $serviceProvider));
+            }
+        }
 
         $this->worker = new PSR7Worker(
             Worker::create(),

src/Services/Facade.php

@@ -0,0 +1,308 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\App\Services;
+
+use Illuminate\Contracts\Container\Container;
+use Illuminate\Support\Testing\Fakes\Fake;
+use Mockery;
+use Mockery\Expectation;
+use Mockery\ExpectationInterface;
+use Mockery\LegacyMockInterface;
+use Mockery\MockInterface;
+
+class Facade
+{
+    /**
+     * The application instance being facaded.
+     *
+     * @var Container | null
+     */
+    protected static ?Container $container = null;
+
+    /**
+     * The resolved object instances.
+     *
+     * @var array
+     */
+    protected static array $resolvedInstance;
+
+    /**
+     * Indicates if the resolved instance should be cached.
+     *
+     * @var bool
+     */
+    protected static bool $cached = true;
+
+    /**
+     * Run a Closure when the facade has been resolved.
+     *
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public static function resolved(\Closure $callback): void
+    {
+        $accessor = static::getFacadeAccessor();
+
+        if (static::$container->resolved($accessor) === true) {
+            $callback(static::getFacadeRoot(), static::$container);
+        }
+
+        static::$container->afterResolving($accessor, function ($service, $app) use ($callback) {
+            $callback($service, $app);
+        });
+    }
+
+    /**
+     * Convert the facade into a Mockery spy.
+     *
+     * @return MockInterface
+     */
+    public static function spy(): MockInterface
+    {
+        if (! static::isMock()) {
+            $class = static::getMockableClass();
+
+            return tap($class ? Mockery::spy($class) : Mockery::spy(), function ($spy) {
+                static::swap($spy);
+            });
+        }
+
+        throw new \RuntimeException('Cannot spy on an existing mock instance.');
+    }
+
+    /**
+     * Initiate a partial mock on the facade.
+     *
+     * @return MockInterface
+     */
+    public static function partialMock(): MockInterface
+    {
+        $name = static::getFacadeAccessor();
+
+        $mock = static::isMock()
+            ? static::$resolvedInstance[$name]
+            : static::createFreshMockInstance();
+
+        return $mock->makePartial();
+    }
+
+    /**
+     * Initiate a mock expectation on the facade.
+     *
+     * @return Expectation|ExpectationInterface
+     */
+    public static function shouldReceive(): Mockery\Expectation | Mockery\ExpectationInterface
+    {
+        $name = static::getFacadeAccessor();
+
+        $mock = static::isMock()
+            ? static::$resolvedInstance[$name]
+            : static::createFreshMockInstance();
+
+        return $mock->shouldReceive(...func_get_args());
+    }
+
+    /**
+     * Initiate a mock expectation on the facade.
+     *
+     * @return Expectation|ExpectationInterface
+     */
+    public static function expects(): Mockery\Expectation | Mockery\ExpectationInterface
+    {
+        $name = static::getFacadeAccessor();
+
+        $mock = static::isMock()
+            ? static::$resolvedInstance[$name]
+            : static::createFreshMockInstance();
+
+        return $mock->expects(...func_get_args());
+    }
+
+    /**
+     * Create a fresh mock instance for the given class.
+     *
+     * @return MockInterface|LegacyMockInterface
+     */
+    protected static function createFreshMockInstance(): MockInterface | LegacyMockInterface
+    {
+        return tap(static::createMock(), function ($mock) {
+            static::swap($mock);
+
+            $mock->shouldAllowMockingProtectedMethods();
+        });
+    }
+
+    /**
+     * Create a fresh mock instance for the given class.
+     *
+     * @return MockInterface
+     */
+    protected static function createMock(): MockInterface
+    {
+        $class = static::getMockableClass();
+
+        return $class ? Mockery::mock($class) : Mockery::mock();
+    }
+
+    /**
+     * Determines whether a mock is set as the instance of the facade.
+     *
+     * @return bool
+     */
+    protected static function isMock(): bool
+    {
+        $name = static::getFacadeAccessor();
+
+        return isset(static::$resolvedInstance[$name]) &&
+            static::$resolvedInstance[$name] instanceof LegacyMockInterface;
+    }
+
+    /**
+     * Get the mockable class for the bound instance.
+     *
+     * @return string|null
+     */
+    protected static function getMockableClass(): ?string
+    {
+        if ($root = static::getFacadeRoot()) {
+            return get_class($root);
+        }
+
+        return null;
+    }
+
+    /**
+     * Hotswap the underlying instance behind the facade.
+     *
+     * @param  mixed  $instance
+     * @return void
+     */
+    public static function swap(mixed $instance): void
+    {
+        static::$resolvedInstance[static::getFacadeAccessor()] = $instance;
+
+        if (isset(static::$container)) {
+            static::$container->instance(static::getFacadeAccessor(), $instance);
+        }
+    }
+
+    /**
+     * Determines whether a "fake" has been set as the facade instance.
+     *
+     * @return bool
+     */
+    public static function isFake(): bool
+    {
+        $name = static::getFacadeAccessor();
+
+        return isset(static::$resolvedInstance[$name]) &&
+            static::$resolvedInstance[$name] instanceof Fake;
+    }
+
+    /**
+     * Get the root object behind the facade.
+     *
+     * @return mixed
+     */
+    public static function getFacadeRoot(): mixed
+    {
+        return static::resolveFacadeInstance(static::getFacadeAccessor());
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     *
+     * @throws \RuntimeException
+     */
+    protected static function getFacadeAccessor(): string
+    {
+        throw new \RuntimeException('Facade does not implement getFacadeAccessor method.');
+    }
+
+    /**
+     * Resolve the facade root instance from the container.
+     *
+     * @param string $name
+     * @return mixed
+     */
+    protected static function resolveFacadeInstance(string $name): mixed
+    {
+        if (isset(static::$resolvedInstance[$name])) {
+            return static::$resolvedInstance[$name];
+        }
+
+        if (static::$container) {
+            if (static::$cached) {
+                return static::$resolvedInstance[$name] = static::$container[$name];
+            }
+
+            return static::$container[$name];
+        }
+
+        return null;
+    }
+
+    /**
+     * Clear a resolved facade instance.
+     *
+     * @param string $name
+     * @return void
+     */
+    public static function clearResolvedInstance(string $name): void
+    {
+        unset(static::$resolvedInstance[$name]);
+    }
+
+    /**
+     * Clear all of the resolved instances.
+     *
+     * @return void
+     */
+    public static function clearResolvedInstances(): void
+    {
+        static::$resolvedInstance = [];
+    }
+
+    /**
+     * Get the application instance behind the facade.
+     */
+    public static function getFacadeContainer(): ?Container
+    {
+        return static::$container;
+    }
+
+    /**
+     * Set the application instance.
+     *
+     * @param Container $container
+     * @return void
+     */
+    public static function setFacadeContainer(Container $container): void
+    {
+        static::$container = $container;
+    }
+
+    /**
+     * Handle dynamic, static calls to the object.
+     *
+     * @param string $method
+     * @param array $args
+     * @return mixed
+     *
+     * @throws \RuntimeException
+     */
+    public static function __callStatic(string $method, array $args)
+    {
+        $instance = static::getFacadeRoot();
+
+        if (! $instance) {
+            throw new \RuntimeException('A facade root has not been set.');
+        }
+
+        return $instance->$method(...$args);
+    }
+}

src/Services/Facades/Config.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\App\Services\Facades;
+
+use Siteworx\Config\Config as SwConfig;
+use Siteworxpro\App\Services\Facade;
+
+/**
+ * Class Config
+ *
+ * This class serves as a facade for the configuration settings of the application.
+ * It extends the Facade class from the Illuminate\Support\Facades namespace.
+ *
+ * @method static array | bool | string | int | null  get(string $key) Retrieve the configuration value for the given key. // @codingStandardsIgnoreStart
+ *
+ * @package Siteworx\App\Facades
+ */
+class Config extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string The name of the component.
+     */
+    protected static function getFacadeAccessor(): string
+    {
+        return SwConfig::class;
+    }
+}

src/Services/Facades/Logger.php

@@ -2,11 +2,10 @@
 
 declare(strict_types=1);
 
-namespace Siteworxpro\App\Facades;
+namespace Siteworxpro\App\Services\Facades;
 
-use Illuminate\Support\Facades\Facade;
 use RoadRunner\Logger\Logger as RRLogger;
-use Spiral\Goridge\RPC\RPC;
+use Siteworxpro\App\Services\Facade;
 
 /**
  * Class Logger
@@ -14,6 +13,7 @@ use Spiral\Goridge\RPC\RPC;
  * This class serves as a facade for the Monolog logger.
  * It extends the Facade class from the Illuminate\Support\Facades namespace.
  *
+ * @method static debug(string $message, array $context = []) Log an informational message.
  * @method static info(string $message, array $context = []) Log an informational message.
  * @method static error(string $message, array $context = []) Log an error message.
  * @method static warning(string $message, array $context = []) Log a warning message.
@@ -22,22 +22,6 @@ use Spiral\Goridge\RPC\RPC;
  */
 class Logger extends Facade
 {
-    public static function getFacadeRoot(): RRLogger
-    {
-        if (self::$resolvedInstance !== null) {
-            $logger = self::resolveFacadeInstance(self::getFacadeAccessor());
-
-            if ($logger instanceof RRLogger) {
-                return $logger;
-            }
-        }
-
-
-        $rpc = RPC::create('tcp://127.0.0.1:6001');
-
-        return new RRLogger($rpc);
-    }
-
     /**
      * Get the registered name of the component.
      *

src/Services/Facades/Redis.php

@@ -2,11 +2,11 @@
 
 declare(strict_types=1);
 
-namespace Siteworxpro\App\Facades;
+namespace Siteworxpro\App\Services\Facades;
 
-use Illuminate\Support\Facades\Facade;
 use Predis\Client;
 use Predis\Response\Status;
+use Siteworxpro\App\Services\Facade;
 
 /**
  * Facade for the Redis client.
@@ -21,25 +21,6 @@ use Predis\Response\Status;
  */
 class Redis extends Facade
 {
-    public static function getFacadeRoot(): Client
-    {
-        if (self::$resolvedInstance !== null) {
-            $redis = self::resolveFacadeInstance(self::getFacadeAccessor());
-
-            if ($redis instanceof Client) {
-                return $redis;
-            }
-        }
-
-        // Create a new Redis client instance if not already resolved
-        return new Client([
-            'scheme' => 'tcp',
-            'host' => Config::get('redis.host'),
-            'port' => Config::get('redis.port'),
-            'database' => Config::get('redis.database'),
-        ]);
-    }
-
     /**
      * Get the registered name of the component.
      *

src/Services/ServiceProviders/LoggerServiceProvider.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\App\Services\ServiceProviders;
+
+use Illuminate\Support\ServiceProvider;
+use RoadRunner\Logger\Logger as RRLogger;
+use Spiral\Goridge\RPC\RPC;
+
+class LoggerServiceProvider extends ServiceProvider
+{
+    public function register(): void
+    {
+        $this->app->singleton(RRLogger::class, function () {
+            $rpc = RPC::create('tcp://127.0.0.1:6001');
+            return new RRLogger($rpc);
+        });
+    }
+}

src/Services/ServiceProviders/RedisServiceProvider.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\App\Services\ServiceProviders;
+
+use Illuminate\Support\ServiceProvider;
+use Predis\Client;
+use Siteworxpro\App\Services\Facades\Config;
+
+class RedisServiceProvider extends ServiceProvider
+{
+    public function register(): void
+    {
+        $this->app->singleton(Client::class, function () {
+            return new Client([
+                'scheme' => 'tcp',
+                'host' => Config::get('redis.host'),
+                'port' => Config::get('redis.port'),
+                'database' => Config::get('redis.database'),
+            ]);
+        });
+    }
+}