refactor types

Author: tymondesigns

src/Converters/ClosureConverter.php

@@ -54,7 +54,7 @@ public function convert(): ObjectSchema
     /**
      * Create a schema from a given type.
      *
-     * @param array<array-key, array{name: string, type: string|null, description: string|null}> $docParams
+     * @param array<array-key, array{name: string, types: array<array-key, string>, description: string|null}> $docParams
      */
     protected static function getSchemaFromReflectionParameter(
         ReflectionParameter $parameter,

src/Support/DocParser.php

@@ -6,12 +6,15 @@
 
 use PHPStan\PhpDocParser\Lexer\Lexer;
 use PHPStan\PhpDocParser\ParserConfig;
+use PHPStan\PhpDocParser\Ast\Type\TypeNode;
 use PHPStan\PhpDocParser\Parser\TypeParser;
 use PHPStan\PhpDocParser\Parser\PhpDocParser;
 use PHPStan\PhpDocParser\Parser\TokenIterator;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode;
+use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode;
 use PHPStan\PhpDocParser\Parser\ConstExprParser;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTextNode;
+use PHPStan\PhpDocParser\Ast\Type\NullableTypeNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocChildNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\TypelessParamTagValueNode;
@@ -36,14 +39,14 @@ public function description(): ?string
     /**
      * Get the parameters from the docblock.
      *
-     * @return array<array-key, array{name: string, type: string|null, description: string|null}>
+     * @return array<array-key, array{name: string, types: array<array-key, string>, description: string|null}>
      */
     public function params(): array
     {
         return array_map(
             static fn(ParamTagValueNode|TypelessParamTagValueNode $param): array => [
                 'name' => ltrim($param->parameterName, '$'),
-                'type' => $param instanceof TypelessParamTagValueNode ? null : (string) $param->type,
+                'types' => self::mapParamToTypes($param),
                 'description' => empty($param->description) ? null : $param->description,
             ],
             array_merge(
@@ -53,6 +56,30 @@ public function params(): array
         );
     }
 
+    /**
+     * Map the parameter to its types.
+     *
+     * @return array<array-key, string>
+     */
+    protected static function mapParamToTypes(ParamTagValueNode|TypelessParamTagValueNode $param): array
+    {
+        if ($param instanceof TypelessParamTagValueNode) {
+            return [];
+        }
+
+        return match (true) {
+            $param->type instanceof UnionTypeNode => array_map(
+                fn(TypeNode $type): string => (string) $type,
+                $param->type->types,
+            ),
+            $param->type instanceof NullableTypeNode => [
+                (string) $param->type->type,
+                'null',
+            ],
+            default => [(string) $param->type],
+        };
+    }
+
     /**
      * Parse the docblock into a PHPStan PhpDocNode.
      */

tests/Unit/ConditionalSchemaTest.php

@@ -4,6 +4,7 @@
 
 namespace Cortex\JsonSchema\Tests\Unit;
 
+use ArrayObject;
 use Cortex\JsonSchema\Enums\SchemaFormat;
 use Cortex\JsonSchema\Types\ObjectSchema;
 use Cortex\JsonSchema\SchemaFactory as Schema;
@@ -45,7 +46,7 @@
     // Business type requires company_name and tax_id
     expect(fn() => $schema->validate([
         'type' => 'business',
-    ]))->toThrow(SchemaException::class);
+    ]))->toThrow(SchemaException::class, "The data is not valid on 'then' branch");
 
     expect(fn() => $schema->validate([
         'type' => 'business',
@@ -57,7 +58,7 @@
     expect(fn() => $schema->validate([
         'type' => 'personal',
         'company_name' => 'Acme Inc',
-    ]))->toThrow(SchemaException::class);
+    ]))->toThrow(SchemaException::class, "const contains a value that doesn't match the type keyword");
 
     expect(fn() => $schema->validate([
         'type' => 'personal',
@@ -202,9 +203,9 @@
 
     expect(fn() => $schema->validate([
         'credit_card' => 'invalid',
-    ]))->toThrow(SchemaException::class);
+    ]))->toThrow(SchemaException::class, 'The data should match at least one schema');
 
-    expect(fn() => $schema->validate([]))->toThrow(SchemaException::class);
+    expect(fn() => $schema->validate(new ArrayObject()))->toThrow(SchemaException::class, 'The data should match at least one schema');
 });
 
 it('can create a schema with oneOf condition', function (): void {

tests/Unit/Support/DocParserTest.php

@@ -20,34 +20,55 @@
     expect($parser->description())->toBeNull();
 });
 
-it('can parse params', function (): void {
-    $docblock = '/**
-        @param ?string $nickname The nickname of the user
-        @param ?int $age The age of the user
-        @param float|int $price The price of the product
-        @param $status
-    */';
+it('can parse params and description', function (): void {
+    $docblock = <<<'EOD'
+        /**
+         * This is the description
+         * @param ?string $nickname The nickname of the user
+         * @param ?int $age The age of the user
+         * @param float|int $price The price of the product
+         * @param \Cortex\JsonSchema\Tests\Unit\Support\DocParserTest $test The test
+         * @param $any
+         */
+        EOD;
     $parser = new DocParser($docblock);
 
+    expect($parser->description())->toBe('This is the description');
     expect($parser->params())->toBe([
         [
             'name' => 'nickname',
-            'type' => '?string',
+            'types' => [
+                'string',
+                'null',
+            ],
             'description' => 'The nickname of the user',
         ],
         [
             'name' => 'age',
-            'type' => '?int',
+            'types' => [
+                'int',
+                'null',
+            ],
             'description' => 'The age of the user',
         ],
         [
             'name' => 'price',
-            'type' => '(float | int)',
+            'types' => [
+                'float',
+                'int',
+            ],
             'description' => 'The price of the product',
         ],
         [
-            'name' => 'status',
-            'type' => null,
+            'name' => 'test',
+            'types' => [
+                '\Cortex\JsonSchema\Tests\Unit\Support\DocParserTest',
+            ],
+            'description' => 'The test',
+        ],
+        [
+            'name' => 'any',
+            'types' => [],
             'description' => null,
         ],
     ]);