Base64 encode serialized jobs when using Postgres

config/venture.php

@@ -1,5 +1,6 @@
 <?php declare(strict_types=1);
 
+use Sassnowski\Venture\Serializer\Base64WorkflowSerializer;
 use Sassnowski\Venture\ClassNameStepIdGenerator;
 use Sassnowski\Venture\UnserializeJobExtractor;
 
@@ -30,4 +31,12 @@
      * Needs to implement `Sassnowski\Venture\JobExtractor`.
      */
     'workflow_job_extractor_class' => UnserializeJobExtractor::class,
+
+    /*
+     * The class that should be used to serialize and unserialize workflow jobs.
+     * In most cases, you won't have to change this.
+     *
+     * Needs to implement `Sassnowski\Venture\Serializer\WorkflowJobSerializer`.
+     */
+    'workflow_job_serializer_class' => Base64WorkflowSerializer::class,
 ];

src/Models/Workflow.php

@@ -22,6 +22,7 @@
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\DB;
 use Opis\Closure\SerializableClosure;
+use Sassnowski\Venture\Serializer\WorkflowJobSerializer;
 use Sassnowski\Venture\Venture;
 use Throwable;
 
@@ -70,7 +71,7 @@ public function jobs(): HasMany
     public function addJobs(array $jobs): void
     {
         collect($jobs)->map(fn (array $job) => [
-            'job' => \serialize(clone $job['job']),
+            'job' => $this->serializer()->serialize(clone $job['job']),
             'name' => $job['name'],
             'uuid' => $job['job']->stepId,
             'edges' => $job['job']->dependantJobs,
@@ -257,7 +258,7 @@ private function runDependantJobs(object $job): void
                 ->whereIn('uuid', $job->dependantJobs)
                 ->get('job')
                 ->pluck('job')
-                ->map(fn (string $job) => \unserialize($job));
+                ->map(fn (string $job) => $this->serializer()->unserialize($job));
         }
 
         $dependantJobs
@@ -266,4 +267,9 @@ private function runDependantJobs(object $job): void
                 $this->dispatchJob($job);
             });
     }
+
+    private function serializer(): WorkflowJobSerializer
+    {
+        return Container::getInstance()->make(WorkflowJobSerializer::class);
+    }
 }

src/Serializer/Base64WorkflowSerializer.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2021 Kai Sassnowski
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ *
+ * @see https://github.com/ksassnowski/venture
+ */
+
+namespace Sassnowski\Venture\Serializer;
+
+use Illuminate\Database\ConnectionInterface;
+use Illuminate\Database\PostgresConnection;
+use Illuminate\Support\Str;
+use Laravel\SerializableClosure\Serializers\UnserializeException;
+
+final class Base64WorkflowSerializer implements WorkflowJobSerializer
+{
+    public function __construct(private ConnectionInterface $connection)
+    {
+    }
+
+    public function serialize(object $job): string
+    {
+        if ($this->isPostgresConnection()) {
+            return \base64_encode(\serialize($job));
+        }
+
+        return \serialize($job);
+    }
+
+    public function unserialize(string $serializedJob): object
+    {
+        if ($this->isPostgresConnection() && !Str::contains($serializedJob, [':', ';'])) {
+            $serializedJob = \base64_decode($serializedJob, true);
+        }
+
+        $result = @\unserialize($serializedJob);
+
+        if (false === $result) {
+            throw new UnserializeException('Unable to unserialize job');
+        }
+
+        return $result;
+    }
+
+    private function isPostgresConnection(): bool
+    {
+        return $this->connection instanceof PostgresConnection;
+    }
+}

src/Serializer/DefaultSerializer.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2021 Kai Sassnowski
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ *
+ * @see https://github.com/ksassnowski/venture
+ */
+
+namespace Sassnowski\Venture\Serializer;
+
+use Laravel\SerializableClosure\Serializers\UnserializeException;
+
+final class DefaultSerializer implements WorkflowJobSerializer
+{
+    public function serialize(object $job): string
+    {
+        return \serialize($job);
+    }
+
+    public function unserialize(string $serializedJob): object
+    {
+        $result = @\unserialize($serializedJob);
+
+        if (false === $result) {
+            throw new UnserializeException('Unable to unserialize job');
+        }
+
+        return $result;
+    }
+}

src/Serializer/WorkflowJobSerializer.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2021 Kai Sassnowski
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ *
+ * @see https://github.com/ksassnowski/venture
+ */
+
+namespace Sassnowski\Venture\Serializer;
+
+use Laravel\SerializableClosure\Serializers\UnserializeException;
+
+interface WorkflowJobSerializer
+{
+    public function serialize(object $job): string;
+
+    /**
+     * @throws UnserializeException thrown if the string could not be unserialized for any reason
+     */
+    public function unserialize(string $serializedJob): object;
+}

src/UnserializeJobExtractor.php

@@ -14,13 +14,20 @@
 namespace Sassnowski\Venture;
 
 use Illuminate\Contracts\Queue\Job;
+use Sassnowski\Venture\Serializer\WorkflowJobSerializer;
 use function class_uses_recursive;
 
 final class UnserializeJobExtractor implements JobExtractor
 {
+    public function __construct(private WorkflowJobSerializer $serializer)
+    {
+    }
+
     public function extractWorkflowJob(Job $queueJob): ?object
     {
-        $instance = \unserialize($queueJob->payload()['data']['command']);
+        $instance = $this->serializer->unserialize(
+            $queueJob->payload()['data']['command'],
+        );
 
         $uses = class_uses_recursive($instance);
 

src/VentureServiceProvider.php

@@ -15,6 +15,8 @@
 
 use Illuminate\Support\ServiceProvider;
 use Sassnowski\Venture\Manager\WorkflowManager;
+use Sassnowski\Venture\Serializer\Base64WorkflowSerializer;
+use Sassnowski\Venture\Serializer\WorkflowJobSerializer;
 use function config;
 
 class VentureServiceProvider extends ServiceProvider
@@ -45,6 +47,7 @@ public function register(): void
         $this->registerManager();
         $this->registerJobExtractor();
         $this->registerStepIdGenerator();
+        $this->registerJobSerializer();
     }
 
     private function registerManager(): void
@@ -73,4 +76,15 @@ private function registerStepIdGenerator(): void
             ),
         );
     }
+
+    private function registerJobSerializer(): void
+    {
+        $this->app->bind(
+            WorkflowJobSerializer::class,
+            config(
+                'venture.workflow_job_serializer_class',
+                Base64WorkflowSerializer::class,
+            ),
+        );
+    }
 }

tests/BackwardsCompatabilityTest.php → tests/BackwardsCompatibilityTest.php

@@ -13,8 +13,12 @@
 
 use Illuminate\Support\Facades\Bus;
 use Illuminate\Support\Str;
+use Sassnowski\Venture\ClassNameStepIdGenerator;
 use Sassnowski\Venture\JobExtractor;
 use Sassnowski\Venture\Manager\WorkflowManager;
+use Sassnowski\Venture\Serializer\Base64WorkflowSerializer;
+use Sassnowski\Venture\Serializer\WorkflowJobSerializer;
+use Sassnowski\Venture\StepIdGenerator;
 use Sassnowski\Venture\UnserializeJobExtractor;
 use Stubs\TestJob1;
 use Stubs\TestJob2;
@@ -39,24 +43,30 @@
     Bus::assertDispatched(TestJob2::class);
 });
 
-it('can handle missing workflow step id generator class in config', function (): void {
+it('can handle missing class keys in config', function (string $abstract, string $defaultClass): void {
     config([
         'venture' => [
             'workflow_table' => 'workflows',
             'jobs_table' => 'workflow_jobs',
         ],
     ]);
 
-    expect(app('venture.manager'))->toBeInstanceOf(WorkflowManager::class);
-});
-
-it('can handle missing job extractor class in config', function (): void {
-    config([
-        'venture' => [
-            'workflow_table' => 'workflows',
-            'jobs_table' => 'workflow_jobs',
-        ],
-    ]);
-
-    expect(app(JobExtractor::class))->toBeInstanceOf(UnserializeJobExtractor::class);
-});
+    expect(app($abstract))->toBeInstanceOf($defaultClass);
+})->with([
+    'workflow manager' => [
+        'venture.manager',
+        WorkflowManager::class,
+    ],
+    'job extractor' => [
+        JobExtractor::class,
+        UnserializeJobExtractor::class,
+    ],
+    'workflow step id generator' => [
+        StepIdGenerator::class,
+        ClassNameStepIdGenerator::class,
+    ],
+    'workflow serializer' => [
+        WorkflowJobSerializer::class,
+        Base64WorkflowSerializer::class,
+    ],
+]);

tests/Base64SerializerTest.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2021 Kai Sassnowski
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ *
+ * @see https://github.com/ksassnowski/venture
+ */
+
+use Illuminate\Database\ConnectionInterface;
+use Illuminate\Database\MySqlConnection;
+use Illuminate\Database\PostgresConnection;
+use Laravel\SerializableClosure\Serializers\UnserializeException;
+use Mockery as m;
+use Sassnowski\Venture\Serializer\Base64WorkflowSerializer;
+use Stubs\TestJob1;
+
+it('simply serializes workflow jobs if a non-postgres connection is used', function (): void {
+    $connection = m::mock(MySqlConnection::class);
+    $serializer = new Base64WorkflowSerializer($connection);
+    $workflowJob = new TestJob1();
+
+    $result = $serializer->serialize($workflowJob);
+
+    expect($result)->toBe(\serialize($workflowJob));
+});
+
+it('base64 encodes workflow jobs if a postgres connection is used', function (): void {
+    $connection = m::mock(PostgresConnection::class);
+    $serializer = new Base64WorkflowSerializer($connection);
+    $workflowJob = new TestJob1();
+
+    $result = $serializer->serialize($workflowJob);
+
+    expect($result)->toBe(\base64_encode(\serialize($workflowJob)));
+});
+
+it('simply unserializes workflow jobs if a non-postgres connection is used', function (): void {
+    $connection = m::mock(MySqlConnection::class);
+    $serializer = new Base64WorkflowSerializer($connection);
+    $workflowJob = new TestJob1();
+    $serializedJob = \serialize($workflowJob);
+
+    $result = $serializer->unserialize($serializedJob);
+
+    expect($result)->toEqual($workflowJob);
+});
+
+it('unserializes and base64 decodes the job if a postgres connection is used', function (): void {
+    $connection = m::mock(PostgresConnection::class);
+    $serializer = new Base64WorkflowSerializer($connection);
+    $workflowJob = new TestJob1();
+    $serializedJob = \base64_encode(\serialize($workflowJob));
+
+    $result = $serializer->unserialize($serializedJob);
+
+    expect($result)->toEqual($workflowJob);
+});
+
+it('does not base64 decode a job if it has not been encoded before even if using a postgres connection', function (): void {
+    $connection = m::mock(PostgresConnection::class);
+    $serializer = new Base64WorkflowSerializer($connection);
+    $workflowJob = new TestJob1();
+    $serializedJob = \serialize($workflowJob);
+
+    $result = $serializer->unserialize($serializedJob);
+
+    expect($result)->toEqual($workflowJob);
+});
+
+it('throws an exception if the job could not be unserialized', function (): void {
+    $serializer = new Base64WorkflowSerializer(m::mock(ConnectionInterface::class));
+    $serializer->unserialize('::not-a-valid-serialized-string::');
+})->throws(UnserializeException::class);