Added await promise chain

Author: rcalicdan

src/Api/Async.php

@@ -3,7 +3,6 @@
 namespace Rcalicdan\FiberAsync\Api;
 
 use Rcalicdan\FiberAsync\Async\AsyncOperations;
-use Rcalicdan\FiberAsync\Loop\LoopOperations;
 use Rcalicdan\FiberAsync\Promise\Interfaces\PromiseInterface;
 
 /**
@@ -22,13 +21,8 @@ final class Async
     /**
      * @var AsyncOperations|null Cached instance of core async operations handler
      */
-    private static ?AsyncOperations $asyncOps = null;
-
-    /**
-     * @var LoopOperations|null Cached instance of loop operations handler
-     */
-    private static ?LoopOperations $loopOps = null;
 
+    private static ?AsyncOperations $asyncOps = null;
     /**
      * Get the singleton instance of AsyncOperations with lazy initialization.
      *
@@ -43,20 +37,6 @@ protected static function getAsyncOperations(): AsyncOperations
         return self::$asyncOps;
     }
 
-    /**
-     * Get the singleton instance of LoopOperations with lazy initialization.
-     *
-     * @return LoopOperations The loop operations handler with automatic lifecycle management
-     */
-    protected static function getLoopOperations(): LoopOperations
-    {
-        if (self::$loopOps === null) {
-            self::$loopOps = new LoopOperations(self::getAsyncOperations());
-        }
-
-        return self::$loopOps;
-    }
-
     /**
      * Reset all cached instances to their initial state.
      *
@@ -67,7 +47,6 @@ protected static function getLoopOperations(): LoopOperations
     public static function reset(): void
     {
         self::$asyncOps = null;
-        self::$loopOps = null;
     }
 
     /**

src/MySQL/MySQLPool.php

@@ -3,9 +3,8 @@
 namespace Rcalicdan\FiberAsync\MySQL;
 
 use Rcalicdan\FiberAsync\Api\Async;
-use Rcalicdan\FiberAsync\Api\Promise;
 use Rcalicdan\FiberAsync\Promise\Interfaces\PromiseInterface;
-use Rcalicdan\FiberAsync\Promise\Promise as AsyncPromise;
+use Rcalicdan\FiberAsync\Promise\Promise;
 use SplQueue;
 
 /**
@@ -33,7 +32,7 @@ public function __construct(array $connectionParams, int $maxSize = 10)
     public function get(): PromiseInterface
     {
         if (! $this->pool->isEmpty()) {
-            return Promise::resolve($this->pool->dequeue());
+            return Promise::resolved($this->pool->dequeue());
         }
 
         // If we haven't reached max connections, create a new one
@@ -55,7 +54,7 @@ public function get(): PromiseInterface
         }
 
         // Pool is full, wait for a connection to be released
-        $promise = new AsyncPromise;
+        $promise = new Promise;
         $this->waiters->enqueue($promise);
 
         return $promise;

src/Promise/Handlers/AwaitHandler.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace Rcalicdan\FiberAsync\Promise\Handlers;
+
+use Exception;
+use Rcalicdan\FiberAsync\EventLoop\EventLoop;
+use Rcalicdan\FiberAsync\Promise\Interfaces\PromiseInterface;
+use Throwable;
+
+final class AwaitHandler
+{
+    /**
+     * Block execution until the promise resolves and return the value.
+     *
+     * @template TValue
+     * @param PromiseInterface<TValue> $promise
+     * @param bool $resetEventLoop Whether to reset the event loop after completion (default: true)
+     * @return TValue
+     * @throws Throwable
+     */
+    public function await(PromiseInterface $promise, bool $resetEventLoop = true): mixed
+    {
+        try {
+            if ($promise->isResolved()) {
+                return $promise->getValue();
+            }
+
+            if ($promise->isRejected()) {
+                $reason = $promise->getReason();
+                throw $reason instanceof Throwable ? $reason : new Exception($this->safeStringCast($reason));
+            }
+
+            $result = null;
+            $error = null;
+            $completed = false;
+
+            $promise
+                ->then(function ($value) use (&$result, &$completed) {
+                    $result = $value;
+                    $completed = true;
+                    return $value;
+                })
+                ->catch(function ($reason) use (&$error, &$completed) {
+                    $error = $reason;
+                    $completed = true;
+                    return $reason;
+                });
+
+            while (!$completed) {
+                EventLoop::getInstance()->run();
+            }
+
+            if ($error !== null) {
+                throw $error instanceof Throwable ? $error : new Exception($this->safeStringCast($error));
+            }
+
+            return $result;
+        } finally {
+            if ($resetEventLoop) {
+                EventLoop::reset();
+            }
+        }
+    }
+
+    /**
+     * Safely convert mixed value to string for error messages
+     */
+    private function safeStringCast(mixed $value): string
+    {
+        return match (true) {
+            is_string($value) => $value,
+            is_null($value) => 'null',
+            is_scalar($value) => (string) $value,
+            is_object($value) && method_exists($value, '__toString') => (string) $value,
+            is_array($value) => 'Array: ' . json_encode($value),
+            is_object($value) => 'Object: ' . get_class($value),
+            default => 'Unknown error type: ' . gettype($value)
+        };
+    }
+}

src/Promise/Interfaces/PromiseInterface.php

@@ -115,4 +115,13 @@ public function getValue(): mixed;
      * @throws LogicException If called on a non-rejected promise.
      */
     public function getReason(): mixed;
+
+    /**
+     * Block execution until the promise resolves and return the value.
+     *
+     * @param bool $resetEventLoop Whether to reset the event loop after completion (default: true)
+     * @return TValue The resolved value
+     * @throws \Throwable The rejection reason if promise was rejected
+     */
+    public function await(bool $resetEventLoop = true): mixed;
 }

src/Promise/Promise.php

@@ -3,6 +3,7 @@
 namespace Rcalicdan\FiberAsync\Promise;
 
 use Rcalicdan\FiberAsync\Async\AsyncOperations;
+use Rcalicdan\FiberAsync\Promise\Handlers\AwaitHandler;
 use Rcalicdan\FiberAsync\Promise\Handlers\CallbackHandler;
 use Rcalicdan\FiberAsync\Promise\Handlers\ChainHandler;
 use Rcalicdan\FiberAsync\Promise\Handlers\ExecutorHandler;
@@ -50,6 +51,11 @@ class Promise implements PromiseCollectionInterface, PromiseInterface
      */
     private ResolutionHandler $resolutionHandler;
 
+    /**
+     * @var AwaitHandler
+     */
+    private AwaitHandler $awaitHandler;
+
     /**
      * @var CancellablePromiseInterface<mixed>|null
      */
@@ -75,18 +81,27 @@ public function __construct(?callable $executor = null)
         $this->callbackHandler = new CallbackHandler;
         $this->executorHandler = new ExecutorHandler;
         $this->chainHandler = new ChainHandler;
+        $this->awaitHandler = new AwaitHandler;
         $this->resolutionHandler = new ResolutionHandler(
             $this->stateHandler,
             $this->callbackHandler
         );
 
         $this->executorHandler->executeExecutor(
             $executor,
-            fn ($value) => $this->resolve($value),
-            fn ($reason) => $this->reject($reason)
+            fn($value) => $this->resolve($value),
+            fn($reason) => $this->reject($reason)
         );
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function await(bool $resetEventLoop = true): mixed
+    {
+        return $this->awaitHandler->await($this, $resetEventLoop);
+    }
+
     /**
      * {@inheritdoc}
      */
@@ -187,9 +202,9 @@ function (callable $resolve, callable $reject) use ($onFulfilled, $onRejected) {
                 };
 
                 if ($this->stateHandler->isResolved()) {
-                    $this->chainHandler->scheduleHandler(fn () => $handleResolve($this->stateHandler->getValue()));
+                    $this->chainHandler->scheduleHandler(fn() => $handleResolve($this->stateHandler->getValue()));
                 } elseif ($this->stateHandler->isRejected()) {
-                    $this->chainHandler->scheduleHandler(fn () => $handleReject($this->stateHandler->getReason()));
+                    $this->chainHandler->scheduleHandler(fn() => $handleReject($this->stateHandler->getReason()));
                 } else {
                     $this->callbackHandler->addThenCallback($handleResolve);
                     $this->callbackHandler->addCatchCallback($handleReject);