feat(core): support frankenphp worker mode

packages/core/src/GenericResetHandler.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Core;
+
+use Tempest\Container\Container;
+
+final readonly class GenericResetHandler implements ResetHandler
+{
+    public function __construct(
+        private ResetableContainer $resetableContainer,
+    ) {}
+
+    public function reset(Container $container): void
+    {
+        foreach ($this->resetableContainer->resetableClasses as $class) {
+            if (! $container->has($class)) {
+                continue;
+            }
+
+            $container->get($class)->reset();
+        }
+
+        foreach ($this->resetableContainer->resetableStaticClasses as $class) {
+            $class::resetStatic();
+        }
+    }
+}

packages/core/src/ResetHandler.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Core;
+
+use Tempest\Container\Container;
+
+interface ResetHandler
+{
+    public function reset(Container $container): void;
+}

packages/core/src/ResetHandlerInitializer.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Core;
+
+use Tempest\Container\Container;
+use Tempest\Container\Initializer;
+
+final readonly class ResetHandlerInitializer implements Initializer
+{
+    public function initialize(Container $container): ResetHandler
+    {
+        return $container->get(GenericResetHandler::class);
+    }
+}

packages/core/src/Resetable.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Core;
+
+interface Resetable
+{
+    public function reset(): void;
+}

packages/core/src/ResetableContainer.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Core;
+
+use Tempest\Container\Singleton;
+
+#[Singleton]
+class ResetableContainer
+{
+    /**
+     * @param class-string<Resetable>[] $resetableClasses
+     * @param class-string<ResetableStatic>[] $resetableStaticClasses
+     */
+    public function __construct(
+        private(set) array $resetableClasses = [],
+        private(set) array $resetableStaticClasses = [],
+    ) {}
+
+    /** @param class-string<Resetable> $class */
+    public function add(string $class): void
+    {
+        $this->resetableClasses[] = $class;
+    }
+
+    /** @param class-string<ResetableStatic> $class */
+    public function addStatic(string $class): void
+    {
+        $this->resetableStaticClasses[] = $class;
+    }
+}

packages/core/src/ResetableDiscovery.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Core;
+
+use Tempest\Discovery\Discovery;
+use Tempest\Discovery\DiscoveryLocation;
+use Tempest\Discovery\IsDiscovery;
+use Tempest\Reflection\ClassReflector;
+
+final class ResetableDiscovery implements Discovery
+{
+    use IsDiscovery;
+
+    private const int IS_RESETABLE = 1;
+    private const int IS_RESETABLE_STATIC = 2;
+
+    public function __construct(
+        private readonly ResetableContainer $resetableContainer,
+    ) {}
+
+    public function discover(DiscoveryLocation $location, ClassReflector $class): void
+    {
+        if ($class->implements(Resetable::class)) {
+            $this->discoveryItems->add($location, [self::IS_RESETABLE, $class->getName()]);
+        }
+
+        if ($class->implements(ResetableStatic::class)) {
+            $this->discoveryItems->add($location, [self::IS_RESETABLE_STATIC, $class->getName()]);
+        }
+    }
+
+    public function apply(): void
+    {
+        foreach ($this->discoveryItems as [$type, $className]) {
+            if ($type === self::IS_RESETABLE) {
+                $this->resetableContainer->add($className);
+            } else {
+                $this->resetableContainer->addStatic($className);
+            }
+        }
+    }
+}

packages/core/src/ResetableStatic.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Core;
+
+interface ResetableStatic
+{
+    public static function resetStatic(): void;
+}

packages/database/src/Builder/ModelInspector.php

@@ -3,6 +3,8 @@
 namespace Tempest\Database\Builder;
 
 use ReflectionException;
+use Tempest\Core\Resetable;
+use Tempest\Core\ResetableStatic;
 use Tempest\Database\BelongsTo;
 use Tempest\Database\Config\DatabaseConfig;
 use Tempest\Database\Eager;
@@ -29,7 +31,7 @@
 use function Tempest\Support\arr;
 use function Tempest\Support\str;
 
-final class ModelInspector
+final class ModelInspector implements Resetable, ResetableStatic
 {
     use HasMemoization;
 
@@ -43,11 +45,16 @@ final class ModelInspector
         get => get(Validator::class);
     }
 
-    public static function reset(): void
+    public static function resetStatic(): void
     {
         self::$inspectors = [];
     }
 
+    public function reset(): void
+    {
+        $this->resetMemoization();
+    }
+
     public static function forModel(object|string $model): self
     {
         $key = match (true) {

packages/http/src/Cookie/CookieManager.php

@@ -6,13 +6,14 @@
 
 use Tempest\Clock\Clock;
 use Tempest\Core\AppConfig;
+use Tempest\Core\Resetable;
 use Tempest\DateTime\DateTimeInterface;
 use Tempest\Support\Str;
 
 /**
  * Manages cookies that will be sent to the client.
  */
-final class CookieManager
+final class CookieManager implements Resetable
 {
     /** @var \Tempest\Http\Cookie\Cookie[] */
     private array $cookies = [];
@@ -74,4 +75,9 @@ public function remove(string $key): void
 
         $this->add($cookie);
     }
+
+    public function reset(): void
+    {
+        $this->cookies = [];
+    }
 }

packages/http/src/OpaqueRequest.php

@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Http;
+
+use Tempest\Container\Singleton;
+use Tempest\Http\Cookie\Cookie;
+
+#[Singleton]
+final class OpaqueRequest implements Request
+{
+    public function __construct(
+        private RequestHolder $requestHolder,
+    ) {}
+
+    public array $cookies {
+        get {
+            return $this->requestHolder->request->cookies;
+        }
+    }
+
+    public array $files {
+        get {
+            return $this->requestHolder->request->files;
+        }
+    }
+
+    public array $query {
+        get {
+            return $this->requestHolder->request->query;
+        }
+    }
+
+    public string $path {
+        get {
+            return $this->requestHolder->request->path;
+        }
+    }
+    public RequestHeaders $headers {
+        get {
+            return $this->requestHolder->request->headers;
+        }
+    }
+
+    public array $body {
+        get {
+            return $this->requestHolder->request->body;
+        }
+    }
+
+    public ?string $raw {
+        get {
+            return $this->requestHolder->request->raw;
+        }
+    }
+
+    public string $uri {
+        get {
+            return $this->requestHolder->request->uri;
+        }
+    }
+
+    public Method $method {
+        get {
+            return $this->requestHolder->request->method;
+        }
+    }
+
+    public function has(string $key): bool
+    {
+        return $this->requestHolder->request->has($key);
+    }
+
+    public function hasBody(?string $key = null): bool
+    {
+        return $this->requestHolder->request->hasBody($key);
+    }
+
+    public function hasQuery(string $key): bool
+    {
+        return $this->requestHolder->request->hasQuery($key);
+    }
+
+    public function get(string $key, mixed $default = null): mixed
+    {
+        return $this->requestHolder->request->get($key, $default);
+    }
+
+    public function getSessionValue(string $name): mixed
+    {
+        return $this->requestHolder->request->getSessionValue($name);
+    }
+
+    public function getCookie(string $name): ?Cookie
+    {
+        return $this->requestHolder->request->getCookie($name);
+    }
+
+    public function accepts(ContentType ...$contentType): bool
+    {
+        return $this->requestHolder->request->accepts(...$contentType);
+    }
+}

packages/http/src/RequestHolder.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Http;
+
+use Tempest\Container\Singleton;
+use Tempest\Core\Resetable;
+
+#[Singleton]
+final class RequestHolder implements Resetable
+{
+    private(set) Request $request;
+
+    public function setRequest(Request $request): void
+    {
+        $this->request = $request;
+    }
+
+    public function reset(): void
+    {
+        unset($this->request);
+    }
+}