Merge pull request #88 from innocenzi/feat/null-to-optional

rubenvanassche · web-flow · commit 2a81539b80bd · 2024-10-04T15:12:52.000+02:00
feat: support `nullToOptional` config
diff --git a/src/Actions/TranspileTypeToTypeScriptAction.php b/src/Actions/TranspileTypeToTypeScriptAction.php
@@ -32,11 +32,15 @@ class TranspileTypeToTypeScriptAction
 
     private ?string $currentClass;
 
+    private bool $nullablesAreOptional;
+
     public function __construct(
         MissingSymbolsCollection $missingSymbolsCollection,
+        bool $nullablesAreOptional = false,
         ?string $currentClass = null
     ) {
         $this->missingSymbolsCollection = $missingSymbolsCollection;
+        $this->nullablesAreOptional = $nullablesAreOptional;
         $this->currentClass = $currentClass;
     }
 
@@ -84,6 +88,10 @@ private function resolveListType(AbstractList $list): string
 
     private function resolveNullableType(Nullable $nullable): string
     {
+        if ($this->nullablesAreOptional) {
+            return $this->execute($nullable->getActualType());
+        }
+
         return "{$this->execute($nullable->getActualType())} | null";
     }
 
diff --git a/src/Collectors/DefaultCollector.php b/src/Collectors/DefaultCollector.php
@@ -37,9 +37,11 @@ protected function resolveAlreadyTransformedType(ClassTypeReflector $reflector):
     {
         $missingSymbols = new MissingSymbolsCollection();
         $name = $reflector->getName();
+        $nullablesAreOptional = $this->config->shouldConsiderNullAsOptional();
 
         $transpiler = new TranspileTypeToTypeScriptAction(
             $missingSymbols,
+            $nullablesAreOptional,
             $name
         );
 
diff --git a/src/Transformers/DtoTransformer.php b/src/Transformers/DtoTransformer.php
@@ -54,22 +54,26 @@ protected function transformProperties(
         ReflectionClass $class,
         MissingSymbolsCollection $missingSymbols
     ): string {
-        $isOptional = ! empty($class->getAttributes(Optional::class));
+        $isClassOptional = ! empty($class->getAttributes(Optional::class));
+        $nullablesAreOptional = $this->config->shouldConsiderNullAsOptional();
 
         return array_reduce(
             $this->resolveProperties($class),
-            function (string $carry, ReflectionProperty $property) use ($isOptional, $missingSymbols) {
+            function (string $carry, ReflectionProperty $property) use ($isClassOptional, $missingSymbols, $nullablesAreOptional) {
                 $isHidden = ! empty($property->getAttributes(Hidden::class));
 
                 if ($isHidden) {
                     return $carry;
                 }
 
-                $isOptional = $isOptional || ! empty($property->getAttributes(Optional::class));
+                $isOptional = $isClassOptional
+                    || ! empty($property->getAttributes(Optional::class))
+                    || ($property->getType()?->allowsNull() && $nullablesAreOptional);
 
                 $transformed = $this->reflectionToTypeScript(
                     $property,
                     $missingSymbols,
+                    $isOptional,
                     ...$this->typeProcessors()
                 );
 
diff --git a/src/Transformers/InterfaceTransformer.php b/src/Transformers/InterfaceTransformer.php
@@ -35,6 +35,7 @@ function (string $parameterCarry, \ReflectionParameter $parameter) use ($missing
                         $type = $this->reflectionToTypeScript(
                             $parameter,
                             $missingSymbols,
+                            false,
                             ...$this->typeProcessors()
                         );
 
@@ -53,6 +54,7 @@ function (string $parameterCarry, \ReflectionParameter $parameter) use ($missing
                     $returnType = $this->reflectionToTypeScript(
                         $method,
                         $missingSymbols,
+                        false,
                         ...$this->typeProcessors()
                     );
                 }
diff --git a/src/Transformers/TransformsTypes.php b/src/Transformers/TransformsTypes.php
@@ -16,6 +16,7 @@ trait TransformsTypes
     protected function reflectionToTypeScript(
         ReflectionMethod | ReflectionProperty | ReflectionParameter $reflection,
         MissingSymbolsCollection $missingSymbolsCollection,
+        bool $nullablesAreOptional = false,
         TypeProcessor ...$typeProcessors
     ): ?string {
         $type = $this->reflectionToType(
@@ -31,6 +32,7 @@ protected function reflectionToTypeScript(
         return $this->typeToTypeScript(
             $type,
             $missingSymbolsCollection,
+            $nullablesAreOptional,
             $reflection->getDeclaringClass()?->getName()
         );
     }
@@ -60,10 +62,12 @@ protected function reflectionToType(
     protected function typeToTypeScript(
         Type $type,
         MissingSymbolsCollection $missingSymbolsCollection,
+        bool $nullablesAreOptional = false,
         ?string $currentClass = null,
     ): string {
         $transpiler = new TranspileTypeToTypeScriptAction(
             $missingSymbolsCollection,
+            $nullablesAreOptional,
             $currentClass,
         );
 
diff --git a/src/TypeScriptTransformerConfig.php b/src/TypeScriptTransformerConfig.php
@@ -29,6 +29,8 @@ class TypeScriptTransformerConfig
 
     private bool $transformToNativeEnums = false;
 
+    private bool $nullToOptional = false;
+
     public static function create(): self
     {
         return new self();
@@ -90,6 +92,13 @@ public function transformToNativeEnums(bool $transformToNativeEnums = true): sel
         return $this;
     }
 
+    public function nullToOptional(bool $nullToOptional = false): self
+    {
+        $this->nullToOptional = $nullToOptional;
+
+        return $this;
+    }
+
     public function getAutoDiscoverTypesPaths(): array
     {
         return $this->autoDiscoverTypesPaths;
@@ -162,4 +171,9 @@ public function shouldTransformToNativeEnums(): bool
     {
         return $this->transformToNativeEnums;
     }
+
+    public function shouldConsiderNullAsOptional(): bool
+    {
+        return $this->nullToOptional;
+    }
 }
diff --git a/tests/Actions/TranspileTypeToTypeScriptActionTest.php b/tests/Actions/TranspileTypeToTypeScriptActionTest.php
@@ -4,21 +4,23 @@
 use phpDocumentor\Reflection\Types\Self_;
 use phpDocumentor\Reflection\Types\Static_;
 use phpDocumentor\Reflection\Types\This;
-use function PHPUnit\Framework\assertContains;
-use function PHPUnit\Framework\assertEquals;
-use function Spatie\Snapshots\assertMatchesSnapshot;
 use Spatie\TypeScriptTransformer\Actions\TranspileTypeToTypeScriptAction;
 use Spatie\TypeScriptTransformer\Structures\MissingSymbolsCollection;
 use Spatie\TypeScriptTransformer\Tests\FakeClasses\Enum\RegularEnum;
 use Spatie\TypeScriptTransformer\Types\StructType;
 
+use function PHPUnit\Framework\assertContains;
+use function PHPUnit\Framework\assertEquals;
+use function Spatie\Snapshots\assertMatchesSnapshot;
+
 beforeEach(function () {
     $this->missingSymbols = new MissingSymbolsCollection();
 
     $this->typeResolver = new TypeResolver();
 
     $this->action = new TranspileTypeToTypeScriptAction(
         $this->missingSymbols,
+        false,
         'fake_class'
     );
 });
@@ -62,3 +64,17 @@
 
     expect($transformed)->toBe('string | number');
 });
+
+it('does not add nullable unions to optional properties', function () {
+    $action = new TranspileTypeToTypeScriptAction(
+        $this->missingSymbols,
+        true
+    );
+
+    $transformed = $action->execute(StructType::fromArray([
+        'a_string' => 'string',
+        'a_nullable_string' => '?string',
+    ]));
+
+    assertEquals('{a_string:string;a_nullable_string:string;}', $transformed);
+});
diff --git a/tests/Transformers/DtoTransformerTest.php b/tests/Transformers/DtoTransformerTest.php
@@ -2,9 +2,6 @@
 
 use phpDocumentor\Reflection\Type;
 use phpDocumentor\Reflection\Types\String_;
-use function PHPUnit\Framework\assertEquals;
-use function Spatie\Snapshots\assertMatchesSnapshot;
-use function Spatie\Snapshots\assertMatchesTextSnapshot;
 use Spatie\TypeScriptTransformer\Attributes\Hidden;
 use Spatie\TypeScriptTransformer\Attributes\LiteralTypeScriptType;
 use Spatie\TypeScriptTransformer\Attributes\Optional;
@@ -20,6 +17,10 @@
 use Spatie\TypeScriptTransformer\TypeProcessors\TypeProcessor;
 use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
 
+use function PHPUnit\Framework\assertEquals;
+use function Spatie\Snapshots\assertMatchesSnapshot;
+use function Spatie\Snapshots\assertMatchesTextSnapshot;
+
 beforeEach(function () {
     $config = TypeScriptTransformerConfig::create()
         ->defaultTypeReplacements([
@@ -48,10 +49,10 @@
 it('a type processor can remove properties', function () {
     $config = TypeScriptTransformerConfig::create();
 
-    $transformer = new class($config) extends DtoTransformer {
+    $transformer = new class ($config) extends DtoTransformer {
         protected function typeProcessors(): array
         {
-            $onlyStringPropertiesProcessor = new class implements TypeProcessor {
+            $onlyStringPropertiesProcessor = new class () implements TypeProcessor {
                 public function process(
                     Type $type,
                     ReflectionProperty | ReflectionParameter | ReflectionMethod $reflection,
@@ -74,7 +75,7 @@ public function process(
 });
 
 it('will take transform as typescript attributes into account', function () {
-    $class = new class {
+    $class = new class () {
         #[TypeScriptType('int')]
         public $int;
 
@@ -102,7 +103,7 @@ public function process(
 });
 
 it('transforms properties to optional ones when using optional attribute', function () {
-    $class = new class {
+    $class = new class () {
         #[Optional]
         public string $string;
     };
@@ -133,7 +134,7 @@ class DummyOptionalDto
 
 
 it('transforms properties to hidden ones when using hidden attribute', function () {
-    $class = new class() {
+    $class = new class () {
         public string $visible;
         #[Hidden]
         public string $hidden;
@@ -146,3 +147,17 @@ class DummyOptionalDto
 
     assertMatchesSnapshot($type->transformed);
 });
+
+it('transforms nullable properties to optional ones according to config', function () {
+    $class = new class () {
+        public ?string $string;
+    };
+
+    $config = TypeScriptTransformerConfig::create()->nullToOptional(true);
+    $type = (new DtoTransformer($config))->transform(
+        new ReflectionClass($class),
+        'Typed'
+    );
+
+    $this->assertMatchesSnapshot($type->transformed);
+});
diff --git a/tests/Transformers/InterfaceTransformerTest.php b/tests/Transformers/InterfaceTransformerTest.php
@@ -1,12 +1,13 @@
 <?php
 
-use function PHPUnit\Framework\assertNotNull;
-use function PHPUnit\Framework\assertNull;
-use function Spatie\Snapshots\assertMatchesTextSnapshot;
 use Spatie\TypeScriptTransformer\Tests\Fakes\FakeInterface;
 use Spatie\TypeScriptTransformer\Transformers\InterfaceTransformer;
 use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
 
+use function PHPUnit\Framework\assertNotNull;
+use function PHPUnit\Framework\assertNull;
+use function Spatie\Snapshots\assertMatchesTextSnapshot;
+
 it('will only convert interfaces', function () {
     $transformer = new InterfaceTransformer(
         TypeScriptTransformerConfig::create()
diff --git a/tests/__snapshots__/DtoTransformerTest__it_transforms_nullable_properties_to_optional_ones_according_to_config__1.txt b/tests/__snapshots__/DtoTransformerTest__it_transforms_nullable_properties_to_optional_ones_according_to_config__1.txt
@@ -0,0 +1,3 @@
+{
+string?: string;
+}

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,8 @@ class TypeScriptTransformerConfig`
`29`	`29`
`30`	`30`	`private bool $transformToNativeEnums = false;`
`31`	`31`
	`32`	`+ private bool $nullToOptional = false;`
	`33`	`+`
`32`	`34`	`public static function create(): self`
`33`	`35`	`{`
`34`	`36`	`return new self();`
`@@ -90,6 +92,13 @@ public function transformToNativeEnums(bool $transformToNativeEnums = true): sel`
`90`	`92`	`return $this;`
`91`	`93`	`}`
`92`	`94`
	`95`	`+ public function nullToOptional(bool $nullToOptional = false): self`
	`96`	`+ {`
	`97`	`+ $this->nullToOptional = $nullToOptional;`
	`98`	`+`
	`99`	`+ return $this;`
	`100`	`+ }`
	`101`	`+`
`93`	`102`	`public function getAutoDiscoverTypesPaths(): array`
`94`	`103`	`{`
`95`	`104`	`return $this->autoDiscoverTypesPaths;`
`@@ -162,4 +171,9 @@ public function shouldTransformToNativeEnums(): bool`
`162`	`171`	`{`
`163`	`172`	`return $this->transformToNativeEnums;`
`164`	`173`	`}`
	`174`	`+`
	`175`	`+ public function shouldConsiderNullAsOptional(): bool`
	`176`	`+ {`
	`177`	`+ return $this->nullToOptional;`
	`178`	`+ }`
`165`	`179`	`}`