Merge pull request #4 from soap/develop

Add Laravel 12 support

Author: soap

composer.json

@@ -21,11 +21,11 @@
         }
     ],
     "require": {
-        "php": "^8.2|^8.3",
-        "illuminate/contracts": "^10.0||^11.0",
+        "php": "^8.2|^8.3|^8.4",
+        "illuminate/contracts": "^10.0||^11.0||^12.0",
         "spatie/laravel-package-tools": "^1.16",
         "symfony/expression-language": "^7.1",
-        "zerodahero/laravel-workflow": "^6.0.0"
+        "zerodahero/laravel-workflow": "^6.1"
     },
     "require-dev": {
         "larastan/larastan": "^2.9",

config/workflow-process.php

@@ -2,5 +2,22 @@
 
 // config for Soap/LaravelWorkflowProcess
 return [
+    'custom_functions' => [
+        // 'function_name' => [
+        //     'compiler'  => function () { return 'true'; },
+        //     'evaluator' => function (array $variables) { return true; },
+        // ],
+        // 'function_name' => 'App\CustomGuardFunction',
+        // 'authenicated' => \Soap\LaravelWorkflowProcess\GuardFunctions\Authenticated::class,
 
+        'authenticated' => [
+            'compiler' => function ($guard = 'web') {
+                return sprintf('authenticated("%s")', $guard);
+            },
+            'evaluator' => function (array $variables, $guard = 'web') {
+                // This allows checking a specific guard (e.g., 'web', 'api', etc.)
+                return auth()->guard($guard)->check();
+            },
+        ],
+    ],
 ];

it

@@ -0,0 +1,23 @@
+<?php
+
+namespace Soap\LaravelWorkflowProcess\Contracts;
+
+interface GuardFunctionInterface
+{
+    /**
+     * Compile the function. Used by the ExpressionLanguage compiler.
+     * This is the function that will be called when the expression is compiled.
+     * It is used for caching the compiled expression.
+     *
+     * @param  mixed  ...$args
+     */
+    public function compile(...$args): string;
+
+    /**
+     * Evaluate the function. Executed during the evaluation.
+     *
+     * @param  mixed  ...$args
+     * @return mixed
+     */
+    public function evaluate(array $variables, ...$args);
+}

src/Contracts/GuardFunctionInterface.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Soap\LaravelWorkflowProcess;
+
+use Soap\LaravelWorkflowProcess\Contracts\GuardFunctionInterface;
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+
+class GuardEvaluator
+{
+    protected $expressionLanguage;
+
+    public function __construct(ExpressionLanguage $expressionLanguage)
+    {
+        $this->expressionLanguage = $expressionLanguage;
+        $this->registerCustomFunctions();
+    }
+
+    protected function registerCustomFunctions()
+    {
+        $customFunctions = config('workflow.custom_functions', []);
+
+        foreach ($customFunctions as $name => $definition) {
+            if (is_string($definition) && class_exists($definition)) {
+                // Instantiate the class via Laravel's container.
+                $instance = app($definition);
+                if ($instance instanceof GuardFunctionInterface) {
+                    $compiler = [$instance, 'compile'];
+                    $evaluator = [$instance, 'evaluate'];
+                } else {
+                    throw new \Exception("Class {$definition} must implement GuardFunctionInterface.");
+                }
+            } elseif (is_array($definition)) {
+                $compiler = $definition['compiler'] ?? function () {
+                    return 'true';
+                };
+                $evaluator = $definition['evaluator'] ?? function (array $variables) {
+                    return true;
+                };
+            } else {
+                continue; // Skip invalid definitions.
+            }
+
+            $this->expressionLanguage->register($name, $compiler, $evaluator);
+        }
+    }
+
+    public function evaluate(string $expression, array $variables = [])
+    {
+        return $this->expressionLanguage->evaluate($expression, $variables);
+    }
+}

src/GuardEvaluator.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Soap\LaravelWorkflowProcess\GuardFunctions;
+
+use Soap\LaravelWorkflowProcess\Contracts\GuardFunctionInterface;
+
+class Authenticated implements GuardFunctionInterface
+{
+    public function compile(...$args): string
+    {
+        // Compiler returns a placeholder.
+        $guard = $args[0] ?? 'web';
+
+        return sprintf('authenticated("%s")', $guard);
+    }
+
+    public function evaluate(array $variables, ...$args)
+    {
+        // Get the guard name, defaulting to 'web'
+        $guard = $args[0] ?? 'web';
+
+        return auth()->guard($guard)->check();
+    }
+}

src/GuardFunctions/Authenticated.php

@@ -24,6 +24,13 @@ public function configurePackage(Package $package): void
             ->hasCommand(LaravelWorkflowProcessCommand::class);
     }
 
+    public function registeringPackage()
+    {
+        $this->app->singleton(GuardEvaluator::class, function ($app) {
+            return new GuardEvaluator(new \Symfony\Component\ExpressionLanguage\ExpressionLanguage);
+        });
+    }
+
     public function packageBooted()
     {
         Event::subscribe(WorkflowGuardSubscriber::class);

src/LaravelWorkflowProcessServiceProvider.php

@@ -2,11 +2,26 @@
 
 namespace Soap\LaravelWorkflowProcess\Listeners;
 
-use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+use Soap\LaravelWorkflowProcess\GuardEvaluator;
 use ZeroDaHero\LaravelWorkflow\Events\GuardEvent;
 
 class WorkflowGuardSubscriber
 {
+    /**
+     * The guard evaluator instance.
+     *
+     * @var GuardEvaluator
+     */
+    protected $guardEvaluator;
+
+    /**
+     * Create a new subscriber instance.
+     */
+    public function __construct(GuardEvaluator $guardEvaluator)
+    {
+        $this->guardEvaluator = $guardEvaluator;
+    }
+
     /**
      * Handle the event.
      */
@@ -15,16 +30,27 @@ public function handleOnGuard(GuardEvent $event): void
         // This is a call by using event proxy to Symfony GuardEvent
         $subject = $event->getSubject();
         $transition = $event->getTransition();
+
         $workflow = $event->getWorkflow();
         $metaData = $workflow->getMetadataStore()->getTransitionMetadata($transition);
+
         if (isset($metaData['guard'])) {
-            $guard = $metaData['guard'];
-            $expressionLanguage = new ExpressionLanguage;
-            $result = $expressionLanguage->evaluate($guard, [
-                'authenticated' => auth()->check(),
-                'subject' => $subject,
-                'user' => auth()->user(),
-            ]);
+            $guardExpression = $metaData['guard'];
+            // Prepare variables to pass to the evaluator.
+            // You can pass the workflow subject, user, or any other required objects.
+            $variables = [
+                'subject' => $event->getSubject(),
+            ];
+
+            // Optionally include the authenticated user.
+            if (auth()->check()) {
+                $variables['user'] = auth()->user();
+            }
+
+            // Evaluate the guard expression using the GuardEvaluator.
+            $result = $this->guardEvaluator->evaluate($guardExpression, $variables);
+
+            // If the expression evaluates to false, block the transition.
             if (! $result) {
                 $event->setBlocked(true, 'Guard blocked');
             }

src/Listeners/WorkflowGuardSubscriber.php

@@ -0,0 +1,53 @@
+<?php
+
+use Soap\LaravelWorkflowProcess\GuardEvaluator;
+use Soap\LaravelWorkflowProcess\Tests\Stubs\CheckFlagGuardFunction;
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+
+it('evaluates a custom closure guard function correctly', function () {
+    // Set a test configuration for custom guard functions.
+    // Here we define a function named "checkFlag" that returns the value of a 'flag' variable.
+    config()->set('workflow.custom_functions', [
+        'checkFlag' => [
+            'compiler' => function () {
+                // The compiler returns a placeholder expression.
+                return 'true';
+            },
+            'evaluator' => function (array $variables) {
+                // Evaluate by returning the 'flag' variable or false if not set.
+                return $variables['flag'] ?? false;
+            },
+        ],
+    ]);
+
+    // Instantiate the ExpressionLanguage and GuardEvaluator.
+    $expressionLanguage = new ExpressionLanguage;
+    $guardEvaluator = new GuardEvaluator($expressionLanguage);
+
+    // Evaluate the expression with 'flag' set to true.
+    $resultTrue = $guardEvaluator->evaluate('checkFlag()', ['flag' => true]);
+    expect($resultTrue)->toBeTrue();
+
+    // Evaluate the expression with 'flag' set to false.
+    $resultFalse = $guardEvaluator->evaluate('checkFlag()', ['flag' => false]);
+    expect($resultFalse)->toBeFalse();
+});
+
+it('evaluates a custom guard function defined as a class correctly', function () {
+    // Set the configuration so that the custom function points to our evaluator class.
+    config()->set('workflow.custom_functions', [
+        'checkFlag' => CheckFlagGuardFunction::class,
+    ]);
+
+    // Instantiate the ExpressionLanguage and GuardEvaluator.
+    $expressionLanguage = new ExpressionLanguage;
+    $guardEvaluator = new GuardEvaluator($expressionLanguage);
+
+    // Evaluate the expression with 'flag' set to true.
+    $resultTrue = $guardEvaluator->evaluate('checkFlag()', ['flag' => true]);
+    expect($resultTrue)->toBeTrue();
+
+    // Evaluate the expression with 'flag' set to false.
+    $resultFalse = $guardEvaluator->evaluate('checkFlag()', ['flag' => false]);
+    expect($resultFalse)->toBeFalse();
+});