feat: RawValue implementation (#683)

* feat: support raw value

* feat: simplify checks

* feat: move test from harness to extra namespace

* refactor: cleanup test

* fix: correct tests

* style(php-cs-fixer): fix coding standards

* feat: rewrite solution with hard-coded raw value check

* style(php-cs-fixer): fix coding standards

* feat: add types

---------

Co-authored-by: github-actions <github-actions@users.noreply.github.com>

Author: xepozz

src/DataConverter/DataConverter.php

@@ -39,27 +39,33 @@ public static function createDefault(): DataConverterInterface
         );
     }
 
-    public function fromPayload(Payload $payload, $type)
+    /**
+     * @param string|\ReflectionClass|\ReflectionType|Type|null $type
+     */
+    public function fromPayload(Payload $payload, $type): mixed
     {
+        $type = Type::create($type);
+
+        if ($type->isClass() && $type->getName() === RawValue::class) {
+            return new RawValue($payload);
+        }
+
         /** @var \ArrayAccess $meta */
         $meta = $payload->getMetadata();
 
         $encoding = $meta[EncodingKeys::METADATA_ENCODING_KEY];
 
         if (!isset($this->converters[$encoding])) {
-            throw new DataConverterException(\sprintf('Undefined payload encoding %s', $encoding));
+            throw new DataConverterException(\sprintf('Undefined payload encoding "%s"', $encoding));
         }
 
-        $type = Type::create($type);
-        if (\in_array($type->getName(), [Type::TYPE_VOID, Type::TYPE_NULL, Type::TYPE_FALSE, Type::TYPE_TRUE], true)) {
-            return match ($type->getName()) {
-                Type::TYPE_VOID, Type::TYPE_NULL => null,
-                Type::TYPE_TRUE => true,
-                Type::TYPE_FALSE => false,
-            };
-        }
-
-        return $this->converters[$encoding]->fromPayload($payload, $type);
+        return match ($type->getName()) {
+            Type::TYPE_VOID,
+            Type::TYPE_NULL => null,
+            Type::TYPE_TRUE => true,
+            Type::TYPE_FALSE => false,
+            default => $this->converters[$encoding]->fromPayload($payload, $type),
+        };
     }
 
     /**
@@ -69,6 +75,9 @@ public function fromPayload(Payload $payload, $type)
      */
     public function toPayload($value): Payload
     {
+        if ($value instanceof RawValue) {
+            return $value->getPayload();
+        }
         foreach ($this->converters as $converter) {
             $payload = $converter->toPayload($value);
 

src/DataConverter/DataConverterInterface.php

@@ -23,12 +23,10 @@ interface DataConverterInterface
      * @psalm-mutation-free
      * @throws DataConverterException
      */
-    public function fromPayload(Payload $payload, $type);
+    public function fromPayload(Payload $payload, mixed $type);
 
     /**
-     * @param mixed $value
-     *
      * @throws DataConverterException
      */
-    public function toPayload($value): Payload;
+    public function toPayload(mixed $value): Payload;
 }

src/DataConverter/EncodingKeys.php

@@ -17,6 +17,7 @@ final class EncodingKeys
     public const METADATA_MESSAGE_TYPE = 'messageType';
     public const METADATA_ENCODING_NULL = 'binary/null';
     public const METADATA_ENCODING_RAW = 'binary/plain';
+    public const METADATA_ENCODING_RAW_VALUE = 'binary';
     public const METADATA_ENCODING_JSON = 'json/plain';
     public const METADATA_ENCODING_PROTOBUF_JSON = 'json/protobuf';
     public const METADATA_ENCODING_PROTOBUF = 'binary/protobuf';

src/DataConverter/RawValue.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Temporal\DataConverter;
+
+use Temporal\Api\Common\V1\Payload;
+
+final class RawValue
+{
+    private Payload $payload;
+
+    public function __construct(Payload $data)
+    {
+        $this->payload = $data;
+    }
+
+    public function getPayload(): Payload
+    {
+        return $this->payload;
+    }
+}

src/DataConverter/Type.php

@@ -79,25 +79,14 @@ public static function fromReflectionType(\ReflectionType $type): self
      */
     public static function create($type): Type
     {
-        switch (true) {
-            case $type instanceof ReturnType:
-                return new self($type->name, $type->nullable);
-
-            case $type instanceof self:
-                return $type;
-
-            case \is_string($type):
-                return new self($type);
-
-            case $type instanceof \ReflectionClass:
-                return self::fromReflectionClass($type);
-
-            case $type instanceof \ReflectionType:
-                return self::fromReflectionType($type);
-
-            default:
-                return new self();
-        }
+        return match (true) {
+            $type instanceof ReturnType => new self($type->name, $type->nullable),
+            $type instanceof self => $type,
+            \is_string($type) => new self($type),
+            $type instanceof \ReflectionClass => self::fromReflectionClass($type),
+            $type instanceof \ReflectionType => self::fromReflectionType($type),
+            default => new self(),
+        };
     }
 
     public function getName(): string

tests/Acceptance/Extra/DataConverter/RawValueTest.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Temporal\Tests\Acceptance\Extra\DataConverter\RawValue;
+
+use PHPUnit\Framework\Attributes\Test;
+use Temporal\Activity\ActivityInterface;
+use Temporal\Activity\ActivityMethod;
+use Temporal\Activity\ActivityOptions;
+use Temporal\Api\Common\V1\Payload;
+use Temporal\Client\WorkflowStubInterface;
+use Temporal\DataConverter\RawValue;
+use Temporal\Tests\Acceptance\App\Attribute\Stub;
+use Temporal\Tests\Acceptance\App\TestCase;
+use Temporal\Workflow;
+use Temporal\Workflow\WorkflowInterface;
+use Temporal\Workflow\WorkflowMethod;
+
+class RawValueTest extends TestCase
+{
+    #[Test]
+    public function check(
+        #[Stub('Extra_DataConverter_RawValue')]
+        WorkflowStubInterface $stub,
+    ): void {
+        $result = $stub->getResult(RawValue::class);
+
+        self::assertInstanceOf(RawValue::class, $result);
+        self::assertInstanceOf(Payload::class, $result->getPayload());
+        self::assertSame('hello world', $result->getPayload()->getData());
+    }
+}
+
+#[WorkflowInterface]
+class FeatureWorkflow
+{
+    #[WorkflowMethod('Extra_DataConverter_RawValue')]
+    public function run()
+    {
+        $rawValue = new RawValue(new Payload(['data' => 'hello world']));
+
+        $activity = Workflow::newActivityStub(
+            RawValueActivity::class,
+            ActivityOptions::new()
+                ->withScheduleToCloseTimeout('1 minute'),
+        );
+
+        return yield $activity->bypass($rawValue);
+    }
+}
+
+#[ActivityInterface(prefix: 'RawValueActivity.')]
+class RawValueActivity
+{
+    #[ActivityMethod]
+    public function bypass(RawValue $arg): RawValue
+    {
+        return $arg;
+    }
+}

tests/Unit/DataConverter/RawValueConverterTest.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Unit\DataConverter;
+
+use Temporal\Api\Common\V1\Payload;
+use Temporal\DataConverter\DataConverter;
+use Temporal\DataConverter\DataConverterInterface;
+use Temporal\DataConverter\EncodingKeys;
+use Temporal\DataConverter\RawValue;
+use Temporal\Tests\Unit\AbstractUnit;
+
+/**
+ * @group unit
+ * @group data-converter
+ */
+class RawValueConverterTest extends AbstractUnit
+{
+    public function testRawPayloadEncoding(): void
+    {
+        $innerPayload = new Payload(['data' => 1]);
+        $message = new RawValue($innerPayload);
+
+        $payload = DataConverter::createDefault()->toPayload($message);
+
+        self::assertSame($innerPayload, $payload);
+        self::assertSame(EncodingKeys::METADATA_ENCODING_RAW_VALUE, $payload->getMetadata()[EncodingKeys::METADATA_ENCODING_KEY]);
+    }
+
+    public function testRawPayloadDecoding(): void
+    {
+        $innerPayload = new Payload(['data' => 1]);
+        $message = new RawValue($innerPayload);
+
+        $encoded = DataConverter::createDefault()->toPayload($message);
+        $decoded = DataConverter::createDefault()->fromPayload($encoded, RawValue::class);
+
+        self::assertInstanceOf(RawValue::class, $decoded);
+        self::assertSame($decoded->getPayload(), $encoded);
+    }
+
+    protected function create(): DataConverterInterface
+    {
+        return DataConverter::createDefault();
+    }
+}