Update example code to use helpers

Author: rmcdaniel

docs/configuration/microservices.md

@@ -92,7 +92,7 @@ Update your workflow and activity classes to use the shared queue connection. As
 ```php
 // App: workflow microservice
 
-use Workflow\ActivityStub;
+use function Workflow\activity;
 use Workflow\Workflow;
 
 class MyWorkflow extends Workflow
@@ -102,7 +102,7 @@ class MyWorkflow extends Workflow
 
     public function execute($name)
     {
-        $result = yield ActivityStub::make(MyActivity::class, $name);
+        $result = yield activity(MyActivity::class, $name);
         return $result;
     }
 }

docs/defining-workflows/passing-data.md

@@ -18,17 +18,17 @@ $workflow->output();
 
 It will be passed as arguments to the workflow's `execute()` method.
 
-Similarly, you can pass data into an activity via the `ActivityStub::make()` method.
+Similarly, you can pass data into an activity via the `activity()` helper function.
 
 ```php
-use Workflow\ActivityStub;
+use function Workflow\activity;
 use Workflow\Workflow;
 
 class MyWorkflow extends Workflow
 {
     public function execute($name)
     {
-        return yield ActivityStub::make(MyActivity::class, $name);
+        return yield activity(MyActivity::class, $name);
     }
 }
 ```
@@ -55,14 +55,14 @@ Passing in models works similarly to `SerializesModels`.
 
 ```php
 use App\Models\User;
-use Workflow\ActivityStub;
+use function Workflow\activity;
 use Workflow\Workflow;
 
 class MyWorkflow extends Workflow
 {
     public function execute(User $user)
     {
-        return yield ActivityStub::make(MyActivity::class, $user->name);
+        return yield activity(MyActivity::class, $user->name);
     }
 }
 ```

docs/defining-workflows/workflows.md

@@ -15,14 +15,14 @@ php artisan make:workflow MyWorkflow
 It is defined by extending the `Workflow` class and implementing the `execute()` method.
 
 ```php
-use Workflow\ActivityStub;
+use function Workflow\activity;
 use Workflow\Workflow;
 
 class MyWorkflow extends Workflow
 {
     public function execute()
     {
-        $result = yield ActivityStub::make(MyActivity::class);
+        $result = yield activity(MyActivity::class);
 
         return $result;
     }

docs/failures-and-recovery.md

@@ -25,15 +25,15 @@ class MyActivity extends Activity
 
 ```php
 use Exception;
-use Workflow\ActivityStub;
+use function Workflow\activity;
 use Workflow\Workflow;
 
 class MyWorkflow extends Workflow
 {
     public function execute()
     {
         try {
-            $result = yield ActivityStub::make(MyActivity::class);
+            $result = yield activity(MyActivity::class);
         } catch (Exception) {
             // handle the exception here
         }

docs/features/child-workflows.md

@@ -6,17 +6,17 @@ sidebar_position: 7
 
 It's often necessary to break down complex processes into smaller, more manageable units. Child workflows provide a way to encapsulate a sub-process within a parent workflow. This allows you to create hierarchical and modular structures for your workflows, making them more organized and maintainable.
 
-A child workflow is just like any other workflow. The only difference is how it's invoked within the parent workflow, using `ChildWorkflowStub::make()`.
+A child workflow is just like any other workflow. The only difference is how it's invoked within the parent workflow, using `child()`.
 
 ```php
-use Workflow\ChildWorkflowStub;
+use function Workflow\child;
 use Workflow\Workflow;
 
 class ParentWorkflow extends Workflow
 {
     public function execute()
     {
-        $result = yield ChildWorkflowStub::make(ChildWorkflow::class);
+        $result = yield child(ChildWorkflow::class);
     }
 }
 ```
@@ -30,14 +30,14 @@ Parent workflows can signal their child workflows to coordinate behavior or pass
 The `child()` method returns a `ChildWorkflowHandle` for the most recently created child workflow:
 
 ```php
-use Workflow\ChildWorkflowStub;
+use function Workflow\child;
 use Workflow\Workflow;
 
 class ParentWorkflow extends Workflow
 {
     public function execute()
     {
-        $child = ChildWorkflowStub::make(ChildWorkflow::class);
+        $child = child(ChildWorkflow::class);
 
         $childHandle = $this->child();
 
@@ -55,24 +55,24 @@ class ParentWorkflow extends Workflow
 Use the `children()` method to get handles for all child workflows created by the parent:
 
 ```php
-use Workflow\ChildWorkflowStub;
+use function Workflow\{all, child};
 use Workflow\Workflow;
 
 class ParentWorkflow extends Workflow
 {
     public function execute()
     {
-        $child1 = ChildWorkflowStub::make(ChildWorkflow::class, 'first');
-        $child2 = ChildWorkflowStub::make(ChildWorkflow::class, 'second');
-        $child3 = ChildWorkflowStub::make(ChildWorkflow::class, 'third');
+        $child1 = child(ChildWorkflow::class, 'first');
+        $child2 = child(ChildWorkflow::class, 'second');
+        $child3 = child(ChildWorkflow::class, 'third');
 
         $childHandles = $this->children();
 
         foreach ($childHandles as $childHandle) {
             $childHandle->process('approved');
         }
 
-        $results = yield ChildWorkflowStub::all([$child1, $child2, $child3]);
+        $results = yield all([$child1, $child2, $child3]);
 
         return $results;
     }
@@ -86,10 +86,9 @@ The `children()` method returns children in reverse chronological order (most re
 You can forward external signals to child workflows by combining signal methods with child handles:
 
 ```php
-use Workflow\ChildWorkflowStub;
+use function Workflow\{await, child};
 use Workflow\SignalMethod;
 use Workflow\Workflow;
-use Workflow\WorkflowStub;
 
 class ParentWorkflow extends Workflow
 {
@@ -105,11 +104,11 @@ class ParentWorkflow extends Workflow
 
     public function execute()
     {
-        $child = ChildWorkflowStub::make(ChildWorkflow::class);
+        $child = child(ChildWorkflow::class);
 
         $childHandle = $this->child();
 
-        yield WorkflowStub::await(fn () => $this->processed);
+        yield await(fn () => $this->processed);
 
         $childHandle->process($this->status);
 
@@ -127,16 +126,15 @@ class ParentWorkflow extends Workflow
 You can access the underlying stored workflow ID using the `id()` method. This allows you to store the ID for external systems to signal the child directly.
 
 ```php
-use Workflow\ActivityStub;
-use Workflow\ChildWorkflowStub;
+use function Workflow\{activity, child};
 use Workflow\Workflow;
 
 class ParentWorkflow extends Workflow
 {    
     public function execute()
     {
-        $child = ChildWorkflowStub::make(ChildWorkflow::class);
-        yield ActivityStub::make(StoreWorkflowIdActivity::class, $this->child()->id());
+        $child = child(ChildWorkflow::class);
+        yield activity(StoreWorkflowIdActivity::class, $this->child()->id());
         yield $child;
     }
 }
@@ -145,7 +143,7 @@ class ParentWorkflow extends Workflow
 or
 
 ```php
-use Workflow\ChildWorkflowStub;
+use function Workflow\{await, child};
 use Workflow\QueryMethod;
 use Workflow\Workflow;
 
@@ -161,9 +159,9 @@ class ParentWorkflow extends Workflow
 
     public function execute()
     {
-        $child = ChildWorkflowStub::make(ChildWorkflow::class);
+        $child = child(ChildWorkflow::class);
         $childHandle = $this->child();
-        yield WorkflowStub::await(fn () => !is_null($childHandle));
+        yield await(fn () => !is_null($childHandle));
         $this->childId = $childHandle->id();
         yield $child;
     }
@@ -183,19 +181,19 @@ if ($childId = $workflow->childId()) {
 
 ## Async Activities
 
-Rather than creating a child workflow, you can pass a callback to `ActivityStub::async()` and it will be executed in the context of a separate workflow.
+Rather than creating a child workflow, you can pass a callback to `async()` and it will be executed in the context of a separate workflow.
 
 ```php
-use Workflow\ActivityStub;
 use Workflow\Workflow;
+use function Workflow\{activity, async};
 
 class AsyncWorkflow extends Workflow
 {
     public function execute()
     {
-        [$result, $otherResult] = yield ActivityStub::async(function () {
-            $result = yield ActivityStub::make(Activity::class);
-            $otherResult = yield ActivityStub::make(OtherActivity::class, 'other');
+        [$result, $otherResult] = yield async(function () {
+            $result = yield activity(Activity::class);
+            $otherResult = yield activity(OtherActivity::class, 'other');
             return [$result, $otherResult];
         });
     }

docs/features/concurrency.md

@@ -4,24 +4,24 @@ sidebar_position: 8
 
 # Concurrency
 
-Activities can be executed in series or in parallel. In either case, you start by using `ActivityStub::make()` to create a new instance of an activity and return a promise that represents the execution of that activity. The activity will immediately begin executing in the background. You can then `yield` this promise to pause the execution of the workflow and wait for the result of the activity, or pass the promise into the `ActivityStub::all()` method to wait for a group of activities to complete in parallel.
+Activities can be executed in series or in parallel. In either case, you start by using `activity()` to create a new instance of an activity and return a promise that represents the execution of that activity. The activity will immediately begin executing in the background. You can then `yield` this promise to pause the execution of the workflow and wait for the result of the activity, or pass the promise into the `all()` method to wait for a group of activities to complete in parallel.
 
 ## Series
 
 This example will execute 3 activities in series, waiting for the completion of each activity before continuing to the next one.
 
 ```php
-use Workflow\ActivityStub;
+use function Workflow\activity;
 use Workflow\Workflow;
 
 class MyWorkflow extends Workflow
 {
     public function execute()
     {
         return [
-            yield ActivityStub::make(MyActivity1::class),
-            yield ActivityStub::make(MyActivity1::class),
-            yield ActivityStub::make(MyActivity1::class),
+            yield activity(MyActivity1::class),
+            yield activity(MyActivity1::class),
+            yield activity(MyActivity1::class),
         ];
     }
 }
@@ -32,47 +32,47 @@ class MyWorkflow extends Workflow
 This example will execute 3 activities in parallel, waiting for the completion of all activities and collecting the results.
 
 ```php
-use Workflow\ActivityStub;
+use function Workflow\{activity, all};
 use Workflow\Workflow;
 
 class MyWorkflow extends Workflow
 {
     public function execute()
     {
-        return yield ActivityStub::all([
-            ActivityStub::make(MyActivity1::class),
-            ActivityStub::make(MyActivity2::class),
-            ActivityStub::make(MyActivity3::class),
+        return yield all([
+            activity(MyActivity1::class),
+            activity(MyActivity2::class),
+            activity(MyActivity3::class),
         ]);
     }
 }
 ```
 
-The main difference between the serial example and the parallel execution example is the number of `yield` statements. In the serial example, there are 3 `yield` statements, one for each activity. This means that the workflow will pause and wait for each activity to complete before continuing to the next one. In the parallel example, there is only 1 `yield` statement, which wraps all of the activities in a call to `ActivityStub::all()`. This means that all of the activities will be executed in parallel, and the workflow will pause and wait for all of them to complete as a group before continuing.
+The main difference between the serial example and the parallel execution example is the number of `yield` statements. In the serial example, there are 3 `yield` statements, one for each activity. This means that the workflow will pause and wait for each activity to complete before continuing to the next one. In the parallel example, there is only 1 `yield` statement, which wraps all of the activities in a call to `all()`. This means that all of the activities will be executed in parallel, and the workflow will pause and wait for all of them to complete as a group before continuing.
 
 ## Mix and Match
 
 You can also mix serial and parallel executions as desired.
 
 ```php
-use Workflow\ActivityStub;
+use function Workflow\{activity, all, async};
 use Workflow\Workflow;
 
 class MyWorkflow extends Workflow
 {
     public function execute()
     {
         return [
-            yield ActivityStub::make(MyActivity1::class),
-            yield ActivityStub::all([
-                ActivityStub::async(fn () => [
-                    yield ActivityStub::make(MyActivity2::class),
-                    yield ActivityStub::make(MyActivity3::class),
+            yield activity(MyActivity1::class),
+            yield all([
+                async(fn () => [
+                    yield activity(MyActivity2::class),
+                    yield activity(MyActivity3::class),
                 ]),
-                ActivityStub::make(MyActivity4::class),
-                ActivityStub::make(MyActivity5::class),
+                activity(MyActivity4::class),
+                activity(MyActivity5::class),
             ]),
-            yield ActivityStub::make(MyActivity6::class),
+            yield activity(MyActivity6::class),
         ];
     }
 }
@@ -84,15 +84,15 @@ Activity 1 will execute and complete before any other activities start. Activiti
 
 ## Child Workflows in Parallel
 
-You can pass child workflows to `ActivityStub::all()` along with with other activities (but we also provide `ChildWorkflowStub::all()` if you prefer). Both of these are just thin wrappers for React Promise's `all()`. It works the same way as parallel activity execution, but for child workflows. It allows you to fan out multiple child workflows and wait for all of them to complete together.
+You can pass child workflows to `all()` along with with other activities. Both of these are just thin wrappers for React Promise's `all()`. It works the same way as parallel activity execution, but for child workflows. It allows you to fan out multiple child workflows and wait for all of them to complete together.
 
 ```php
-use Workflow\ChildWorkflowStub;
+use function Workflow\{all, child};
 
-$results = yield ChildWorkflowStub::all([
-    ChildWorkflowStub::make(ChildA::class),
-    ChildWorkflowStub::make(ChildB::class),
-    ChildWorkflowStub::make(ChildC::class),
+$results = yield all([
+    child(ChildA::class),
+    child(ChildB::class),
+    child(ChildC::class),
 ]);
 ```
 

docs/features/continue-as-new.md

@@ -13,24 +13,23 @@ This is useful when you need to:
 
 ## Using `continueAsNew`
 
-To restart a workflow as new, call the static method `WorkflowStub::continueAsNew(...)` from within the workflow’s `execute()` method.
+To restart a workflow as new, call the helper function `continueAsNew(...)` from within the workflow’s `execute()` method.
 
 ```php
-use Workflow\ActivityStub;
+use function Workflow\{activity, continueAsNew};
 use Workflow\Workflow;
-use Workflow\WorkflowStub;
 
 class CounterWorkflow extends Workflow
 {
     public function execute(int $count = 0, int $max = 3)
     {
-        $result = yield ActivityStub::make(CountActivity::class, $count);
+        $result = yield activity(CountActivity::class, $count);
 
         if ($count >= $max) {
             return 'workflow_' . $result;
         }
 
-        return yield WorkflowStub::continueAsNew($count + 1, $max);
+        return yield continueAsNew($count + 1, $max);
     }
 }
 ```