Merge branch 'master' into meta-storm-plugin

phpunit.xml.dist

@@ -18,6 +18,7 @@
 >
     <testsuites>
         <testsuite name="Acceptance">
+            <directory suffix="Test.php">tests/Acceptance/Extra</directory>
             <directory suffix="Test.php">tests/Acceptance/Harness</directory>
         </testsuite>
         <testsuite name="Arch">

psalm-baseline.xml

@@ -109,12 +109,23 @@
       <code><![CDATA[$workflowType]]></code>
     </PropertyNotSetInConstructor>
   </file>
+  <file src="src/Client/Schedule/ScheduleOptions.php">
+    <DeprecatedProperty>
+      <code><![CDATA[$this->namespace]]></code>
+    </DeprecatedProperty>
+  </file>
   <file src="src/Client/Schedule/Spec/ScheduleSpec.php">
     <DeprecatedProperty>
       <code><![CDATA[$this->excludeCalendarList]]></code>
       <code><![CDATA[$this->excludeCalendarList]]></code>
     </DeprecatedProperty>
   </file>
+  <file src="src/Client/ScheduleClient.php">
+    <DeprecatedProperty>
+      <code><![CDATA[$options->namespace]]></code>
+      <code><![CDATA[$options->namespace]]></code>
+    </DeprecatedProperty>
+  </file>
   <file src="src/Client/Update/UpdateHandle.php">
     <PossiblyNullArgument>
       <code><![CDATA[$result->getSuccess()]]></code>
@@ -428,7 +439,6 @@
       <code><![CDATA[$attr->getFailure()]]></code>
       <code><![CDATA[$attr->getResult()]]></code>
       <code><![CDATA[$input->workflowType]]></code>
-      <code><![CDATA[$input->workflowType]]></code>
       <code><![CDATA[$result->getQueryResult()]]></code>
       <code><![CDATA[$this->execution]]></code>
       <code><![CDATA[$this->execution]]></code>

src/Client/Schedule/ScheduleOptions.php

@@ -16,20 +16,23 @@ final class ScheduleOptions
 {
     use CloneWith;
 
-    public readonly string $namespace;
-    public readonly bool $triggerImmediately;
+    /**
+     * @deprecated will be removed in the next major version.
+     */
+    public readonly ?string $namespace;
 
     /**
      * @var list<BackfillPeriod>
      */
     public readonly array $backfills;
 
+    public readonly bool $triggerImmediately;
     public readonly EncodedCollection $memo;
     public readonly EncodedCollection $searchAttributes;
 
     private function __construct()
     {
-        $this->namespace = 'default';
+        $this->namespace = null;
         $this->triggerImmediately = false;
         $this->backfills = [];
         $this->memo = EncodedCollection::empty();
@@ -41,6 +44,10 @@ public static function new(): self
         return new self();
     }
 
+    /**
+     * @deprecated Configure the namespace on the {@see \Temporal\Client\ClientOptions} instead
+     *             when creating the {@see \Temporal\Client\ScheduleClient}.
+     */
     public function withNamespace(string $namespace): self
     {
         /** @see self::$namespace */

src/Client/ScheduleClient.php

@@ -81,7 +81,7 @@ public function createSchedule(
         $request = new CreateScheduleRequest();
         $request
             ->setRequestId(Uuid::v4())
-            ->setNamespace($options->namespace)
+            ->setNamespace($options->namespace ?? $this->clientOptions->namespace)
             ->setScheduleId($scheduleId)
             ->setIdentity($this->clientOptions->identity);
 
@@ -123,7 +123,7 @@ public function createSchedule(
             $this->converter,
             $this->marshaller,
             $this->protoConverter,
-            $options->namespace,
+            $options->namespace ?? $this->clientOptions->namespace,
             $scheduleId,
         );
     }

src/Internal/Client/ResponseToResultMapper.php

@@ -25,7 +25,7 @@ public function __construct(
     public function mapUpdateWorkflowResponse(
         UpdateWorkflowExecutionResponse $result,
         string $updateName,
-        string $workflowType,
+        ?string $workflowType,
         WorkflowExecution $workflowExecution,
     ): StartUpdateOutput {
         $outcome = $result->getOutcome();

src/Internal/Declaration/Dispatcher/Dispatcher.php

@@ -120,7 +120,10 @@ private function createExecutorFromFunction(\ReflectionFunction $fun): \Closure
                     throw new \BadMethodCallException($message, $type, $error);
                 });
 
-                return $closure->call($ctx, ...$arguments);
+
+                return $fun->isStatic()
+                    ? $closure->bindTo(null, $ctx::class)?->__invoke(...$arguments) ?? $closure(...$arguments)
+                    : $closure->call($ctx, ...$arguments);
             } finally {
                 \restore_error_handler();
             }

src/Internal/Workflow/Process/DeferredGenerator.php

@@ -89,7 +89,7 @@ public function send(mixed $value): mixed
      */
     public function getReturn(): mixed
     {
-        // $this->start();
+        $this->finished or throw new \LogicException('Cannot get return value of a generator that was not finished.');
         try {
             return $this->generator->getReturn();
         } catch (\Throwable $e) {
@@ -149,7 +149,8 @@ public function valid(): bool
     {
         $this->start();
         try {
-            return $this->generator->valid();
+            $result = $this->generator->valid() or $this->finished = true;
+            return $result;
         } catch (\Throwable $e) {
             $this->handleException($e);
         }
@@ -218,9 +219,9 @@ private function handleException(\Throwable $e): never
     {
         $this->finished and throw $e;
         $this->finished = true;
-        foreach ($this->catchers as $catch) {
+        foreach ($this->catchers as $catcher) {
             try {
-                $catch($e);
+                $catcher($e);
             } catch (\Throwable) {
                 // Do nothing.
             }

src/Internal/Workflow/Process/Scope.php

@@ -186,7 +186,8 @@ public function startSignal(callable $handler, ValuesInterface $values, string $
      */
     public function attach(\Generator $generator): self
     {
-        $this->coroutine = DeferredGenerator::fromGenerator($generator);
+        $this->coroutine = DeferredGenerator::fromGenerator($generator)
+            ->catch($this->onException(...));
 
         $this->next();
         return $this;
@@ -386,13 +387,13 @@ protected function next(): void
         begin:
         $this->context->resolveConditions();
 
-        if (!$this->coroutine->valid()) {
-            try {
+        try {
+            if (!$this->coroutine->valid()) {
                 $this->onResult($this->coroutine->getReturn());
-            } catch (\Throwable) {
-                $this->onResult(null);
+                return;
             }
-
+        } catch (\Throwable) {
+            $this->onResult(null);
             return;
         }
 
@@ -418,11 +419,7 @@ protected function next(): void
                 break;
 
             case $current instanceof \Generator:
-                try {
-                    $this->nextPromise($this->createScope(false)->attach($current));
-                } catch (\Throwable $e) {
-                    $this->coroutine->throw($e);
-                }
+                $this->nextPromise($this->createScope(false)->attach($current));
                 break;
 
             default:

src/Workflow.php

@@ -18,6 +18,7 @@
 use Temporal\Client\WorkflowStubInterface;
 use Temporal\DataConverter\Type;
 use Temporal\DataConverter\ValuesInterface;
+use Temporal\Exception\Failure\CanceledFailure;
 use Temporal\Exception\OutOfContextException;
 use Temporal\Internal\Support\Facade;
 use Temporal\Internal\Workflow\ScopeContext;
@@ -958,6 +959,9 @@ public static function uuid7(?\DateTimeInterface $dateTime = null): PromiseInter
      * Run a function when the mutex is released.
      * The mutex is locked for the duration of the function.
      *
+     * Note that calling the method creates a non-detached asynchronous context {@see Workflow::async()}.
+     * Closing the context using the `cancel()` method will reject the returned promise with a {@see CanceledFailure}.
+     *
      * @template T
      * @param Mutex $mutex Mutex name or instance.
      * @param callable(): T $callable Function to run.

tests/Acceptance/Extra/Schedule/ScheduleClientTest.php

@@ -40,6 +40,17 @@ public function listSchedulesWithQuery(
             );
         }
 
+        // Wait for schedules to be created
+        $deadline = \microtime(true) + 5;
+        check:
+        $paginator = $client->listSchedules(
+            pageSize: 10,
+            query: 'bar = 4242'
+        );
+        if (\count($paginator->getPageItems()) < 6 && \microtime(true) < $deadline) {
+            goto check;
+        }
+
         try {
             $paginator = $client->listSchedules(
                 pageSize: 5,

tests/Acceptance/Extra/Update/UntypedStubTest.php

@@ -9,7 +9,7 @@
 use Temporal\Client\WorkflowClientInterface;
 use Temporal\Client\WorkflowStubInterface;
 use Temporal\Exception\Client\TimeoutException;
-use Temporal\Exception\Client\UntypedStubException;
+use Temporal\Exception\Client\WorkflowUpdateException;
 use Temporal\Internal\Support\DateInterval;
 use Temporal\Tests\Acceptance\App\Attribute\Stub;
 use Temporal\Tests\Acceptance\App\TestCase;
@@ -37,7 +37,11 @@ public function fetchResolvedResultAfterWorkflowCompleted(
 
         $this->assertSame(['key' => 'resolved'], (array)$result, 'Workflow result contains resolved value');
         $this->assertFalse($handle->hasResult());
-        $this->assertFalse($resolver->hasResult(), 'Resolver should not have result because of wait policy');
+
+        // Since Temporal CLI 1.2.0, the result is available immediately after the operation
+        $this->assertTrue($resolver->hasResult());
+        $this->assertSame('resolved', $resolver->getResult());
+
         // Fetch result
         $this->assertSame('resolved', $handle->getResult());
         $this->assertTrue($handle->hasResult());
@@ -68,14 +72,27 @@ public function fetchResultWithTimeout(
         $this->assertSame(['key' => null], (array)$result, 'Workflow result contains resolved value');
     }
 
+    #[Test]
+    public function useClientRunningWorkflowStub(
+        #[Stub('Extra_Update_UntypedStub')] WorkflowStubInterface $stub,
+        WorkflowClientInterface $client,
+    ): void {
+        $untyped = $client->newUntypedRunningWorkflowStub(
+            $stub->getExecution()->getID(),
+            $stub->getExecution()->getRunID(),
+        );
+
+        $this->fetchResolvedResultAfterWorkflowCompleted($untyped);
+    }
+
     #[Test]
     public function handleUnknownUpdate(
         #[Stub('Extra_Update_UntypedStub')] WorkflowStubInterface $stub,
     ): void {
         try {
             $stub->startUpdate('unknownUpdateMethod', '42');
             $this->fail('Should throw exception');
-        } catch (UntypedStubException $e) {
+        } catch (WorkflowUpdateException $e) {
             $this->assertStringContainsString(
                 'unknown update method unknownUpdateMethod',
                 $e->getPrevious()->getMessage(),

tests/Acceptance/Extra/Update/UpdateWithStartTest.php

@@ -60,7 +60,7 @@ public function failWithBadUpdateName(
             try {
                 $stub->getResult(timeout: 1);
                 $this->fail('Workflow must fail');
-            } catch (WorkflowFailedException $e) {
+            } catch (WorkflowFailedException) {
                 $this->assertTrue(true);
             }
         }

tests/Acceptance/Extra/Workflow/AllHandlersFinishedTest.php

@@ -33,7 +33,11 @@ public function updateHandlersWithOneCall(
 
         $this->assertSame(['key' => 'resolved'], (array) $result, 'Workflow result contains resolved value');
         $this->assertFalse($handle->hasResult());
-        $this->assertFalse($resolver->hasResult(), 'Resolver should not have result because of wait policy');
+
+        // Since Temporal CLI 1.2.0, the result is available immediately after the operation
+        $this->assertTrue($resolver->hasResult());
+        $this->assertSame('resolved', $resolver->getResult());
+
         // Fetch signal's result
         $this->assertSame('resolved', $handle->getResult());
         $this->assertTrue($handle->hasResult());

tests/Acceptance/Extra/Workflow/MutexRunLockedTest.php

@@ -8,6 +8,7 @@
 use React\Promise\PromiseInterface;
 use Temporal\Client\WorkflowStubInterface;
 use Temporal\DataConverter\Type;
+use Temporal\Exception\Failure\CanceledFailure;
 use Temporal\Tests\Acceptance\App\Attribute\Stub;
 use Temporal\Tests\Acceptance\App\TestCase;
 use Temporal\Workflow;
@@ -28,6 +29,7 @@ public function runLockedWithGeneratorAndAwait(
         $this->assertTrue($result[0], 'Mutex must be unlocked after runLocked is finished');
         $this->assertTrue($result[1], 'The function inside runLocked mist wait for signal');
         $this->assertTrue($result[2], 'Mutex must be locked during runLocked');
+        $this->assertNull($result[3], 'No exception must be thrown');
     }
 
     #[Test]
@@ -41,6 +43,7 @@ public function runLockedAndCancel(
 
         $this->assertTrue($result[0], 'Mutex must be unlocked after runLocked is cancelled');
         $this->assertNull($result[2], 'Mutex must be locked during runLocked');
+        $this->assertSame(CanceledFailure::class, $result[3], 'CanceledFailure must be thrown');
     }
 }
 
@@ -64,7 +67,12 @@ public function __construct()
     #[Workflow\ReturnType(Type::TYPE_ARRAY)]
     public function handle(): \Generator
     {
-        $result = yield $this->promise = Workflow::runLocked($this->mutex, $this->runLocked(...));
+        $exception = null;
+        try {
+            $result = yield $this->promise = Workflow::runLocked($this->mutex, $this->runLocked(...));
+        } catch (\Throwable $e) {
+            $exception = $e::class;
+        }
 
         $trailed = false;
         yield Workflow::await(
@@ -78,7 +86,7 @@ public function handle(): \Generator
         // that was created inside the first runLocked
         $trailed and throw new \Exception('The trailed runLocked must not be executed.');
 
-        return [$this->unlocked, $this->unblock, $result];
+        return [$this->unlocked, $this->unblock, $result, $exception];
     }
 
     #[Workflow\SignalMethod]