refactor: Enum converter (#6)

Author: tymondesigns

README.md

@@ -973,15 +973,10 @@ $schema->toJson();
 ```json
 {
     "$schema": "http://json-schema.org/draft-07/schema#",
-    "type": "object",
+    "type": "integer",
+    "title": "PostType",
     "description": "This is the description of the enum",
-    "properties": {
-        "PostType": {
-            "type": "integer",
-            "enum": [1, 2, 3]
-        }
-    },
-    "required": ["PostType"]
+    "enum": [1, 2, 3]
 }
 ```
 

src/Contracts/Converter.php

@@ -4,12 +4,10 @@
 
 namespace Cortex\JsonSchema\Contracts;
 
-use Cortex\JsonSchema\Types\ObjectSchema;
-
 interface Converter
 {
     /**
-     * Convert the value to an object schema.
+     * Convert the value to a schema instance.
      */
-    public function convert(): ObjectSchema;
+    public function convert(): Schema;
 }

src/Converters/EnumConverter.php

@@ -4,10 +4,8 @@
 
 namespace Cortex\JsonSchema\Converters;
 
-use BackedEnum;
 use ReflectionEnum;
 use Cortex\JsonSchema\Support\DocParser;
-use Cortex\JsonSchema\Types\ObjectSchema;
 use Cortex\JsonSchema\Types\StringSchema;
 use Cortex\JsonSchema\Contracts\Converter;
 use Cortex\JsonSchema\Types\IntegerSchema;
@@ -26,17 +24,29 @@ class EnumConverter implements Converter
     public function __construct(
         protected string $enum,
     ) {
-        // @phpstan-ignore function.alreadyNarrowedType
-        if (! is_subclass_of($this->enum, BackedEnum::class)) {
+        $this->reflection = new ReflectionEnum($this->enum);
+
+        if (! $this->reflection->isBacked()) {
             throw new SchemaException('Enum must be a backed enum');
         }
-
-        $this->reflection = new ReflectionEnum($this->enum);
     }
 
-    public function convert(): ObjectSchema
+    public function convert(): StringSchema|IntegerSchema
     {
-        $schema = new ObjectSchema();
+        // Get the basename of the enum namespace
+        $enumName = basename(str_replace('\\', '/', $this->enum));
+
+        // Determine the backing type
+        $schema = match ($this->reflection->getBackingType()?->getName()) {
+            'string' => new StringSchema($enumName),
+            'int' => new IntegerSchema($enumName),
+            default => throw new SchemaException('Unsupported enum backing type. Only "int" or "string" are supported.'),
+        };
+
+        /** @var non-empty-array<int, string|int> $values */
+        $values = array_column($this->enum::cases(), 'value');
+
+        $schema->enum($values);
 
         // Get the description from the doc parser
         $description = $this->getDocParser($this->reflection)?->description() ?? null;
@@ -46,19 +56,7 @@ public function convert(): ObjectSchema
             $schema->description($description);
         }
 
-        // Get the basename of the enum namespace
-        $parts = explode('\\', $this->enum);
-        $enumName = end($parts);
-
-        /** @var non-empty-array<int, string|int> $values */
-        $values = array_column($this->enum::cases(), 'value');
-
-        // Determine the backing type
-        return match ($this->reflection->getBackingType()?->getName()) {
-            'string' => $schema->properties((new StringSchema($enumName))->enum($values)->required()),
-            'int' => $schema->properties((new IntegerSchema($enumName))->enum($values)->required()),
-            default => throw new SchemaException('Unsupported enum backing type. Only "int" or "string" are supported.'),
-        };
+        return $schema;
     }
 
     /**

src/SchemaFactory.php

@@ -5,6 +5,8 @@
 namespace Cortex\JsonSchema;
 
 use Closure;
+use BackedEnum;
+use Cortex\JsonSchema\Contracts\Schema;
 use Cortex\JsonSchema\Enums\SchemaType;
 use Cortex\JsonSchema\Types\NullSchema;
 use Cortex\JsonSchema\Types\ArraySchema;
@@ -16,6 +18,7 @@
 use Cortex\JsonSchema\Types\IntegerSchema;
 use Cortex\JsonSchema\Converters\EnumConverter;
 use Cortex\JsonSchema\Converters\ClassConverter;
+use Cortex\JsonSchema\Exceptions\SchemaException;
 use Cortex\JsonSchema\Converters\ClosureConverter;
 
 class SchemaFactory
@@ -91,8 +94,21 @@ public static function fromClass(object|string $class, bool $publicOnly = true):
      *
      * @param class-string<\BackedEnum> $enum
      */
-    public static function fromEnum(string $enum): ObjectSchema
+    public static function fromEnum(string $enum): StringSchema|IntegerSchema
     {
         return (new EnumConverter($enum))->convert();
     }
+
+    /**
+     * Create a schema from a given value.
+     */
+    public static function from(mixed $value): Schema
+    {
+        return match (true) {
+            $value instanceof Closure => self::fromClosure($value),
+            is_string($value) && enum_exists($value) && is_subclass_of($value, BackedEnum::class) => self::fromEnum($value),
+            is_string($value) && class_exists($value) || is_object($value) => self::fromClass($value),
+            default => throw new SchemaException('Unsupported value type. Only closures, enums, and classes are supported.'),
+        };
+    }
 }

tests/ArchitectureTest.php

@@ -5,10 +5,14 @@
 namespace Cortex\JsonSchema\Tests;
 
 use Throwable;
+use Cortex\JsonSchema\Contracts\Schema;
+use Cortex\JsonSchema\Contracts\Converter;
 
 arch()->preset()->php();
 arch()->preset()->security();
 
 arch()->expect('Cortex\JsonSchema\Contracts')->toBeInterfaces();
 arch()->expect('Cortex\JsonSchema\Enums')->toBeEnums();
-arch()->expect('Cortex\JsonSchema\Exceptions')->toExtend(Throwable::class);
+arch()->expect('Cortex\JsonSchema\Exceptions')->toImplement(Throwable::class);
+arch()->expect('Cortex\JsonSchema\Converters')->classes()->toImplement(Converter::class);
+arch()->expect('Cortex\JsonSchema\Types')->classes()->toImplement(Schema::class);

tests/Unit/Converters/EnumConverterTest.php

@@ -4,7 +4,8 @@
 
 namespace Cortex\JsonSchema\Tests\Unit\Converters;
 
-use Cortex\JsonSchema\Types\ObjectSchema;
+use Cortex\JsonSchema\Types\StringSchema;
+use Cortex\JsonSchema\Types\IntegerSchema;
 use Cortex\JsonSchema\Converters\EnumConverter;
 use Cortex\JsonSchema\Exceptions\SchemaException;
 
@@ -21,20 +22,13 @@ enum PostStatus: string
 
     $schema = (new EnumConverter(PostStatus::class))->convert();
 
-    expect($schema)->toBeInstanceOf(ObjectSchema::class);
+    expect($schema)->toBeInstanceOf(StringSchema::class);
     expect($schema->toArray())->toBe([
-        'type' => 'object',
+        'type' => 'string',
         '$schema' => 'http://json-schema.org/draft-07/schema#',
+        'title' => 'PostStatus',
         'description' => 'This is the description of the string backed enum',
-        'properties' => [
-            'PostStatus' => [
-                'type' => 'string',
-                'enum' => ['draft', 'published', 'archived'],
-            ],
-        ],
-        'required' => [
-            'PostStatus',
-        ],
+        'enum' => ['draft', 'published', 'archived'],
     ]);
 });
 
@@ -49,20 +43,13 @@ enum PostType: int
 
     $schema = (new EnumConverter(PostType::class))->convert();
 
-    expect($schema)->toBeInstanceOf(ObjectSchema::class);
+    expect($schema)->toBeInstanceOf(IntegerSchema::class);
     expect($schema->toArray())->toBe([
-        'type' => 'object',
+        'type' => 'integer',
         '$schema' => 'http://json-schema.org/draft-07/schema#',
+        'title' => 'PostType',
         'description' => 'This is the description of the integer backed enum',
-        'properties' => [
-            'PostType' => [
-                'type' => 'integer',
-                'enum' => [1, 2, 3],
-            ],
-        ],
-        'required' => [
-            'PostType',
-        ],
+        'enum' => [1, 2, 3],
     ]);
 });
 

tests/Unit/SchemaFactoryTest.php

@@ -91,6 +91,9 @@
     ]);
 
     expect($schema->toJson())->toBe(json_encode($schema->toArray()));
+
+    // Assert that the from method behaves in the same way as the fromClosure method
+    expect(Schema::from($closure))->toEqual($schema);
 });
 
 it('can create a schema from a class', function (): void {
@@ -123,4 +126,32 @@ public function __construct(
             'age',
         ],
     ]);
+
+    // Assert that the from method behaves in the same way as the fromClass method
+    expect(Schema::from($class))->toEqual($schema);
+});
+
+it('can create a schema from an enum', function (): void {
+    /** This is a custom enum for testing */
+    enum UserRole: string
+    {
+        case Admin = 'admin';
+        case Editor = 'editor';
+        case Viewer = 'viewer';
+        case Guest = 'guest';
+    }
+
+    $schema = Schema::fromEnum(UserRole::class);
+
+    expect($schema)->toBeInstanceOf(StringSchema::class);
+    expect($schema->toArray())->toBe([
+        'type' => 'string',
+        '$schema' => 'http://json-schema.org/draft-07/schema#',
+        'title' => 'UserRole',
+        'description' => 'This is a custom enum for testing',
+        'enum' => ['admin', 'editor', 'viewer', 'guest'],
+    ]);
+
+    // Assert that the from method behaves in the same way as the fromEnum method
+    expect(Schema::from(UserRole::class))->toEqual($schema);
 });

tests/Unit/Targets/IntegerSchemaTest.php

@@ -4,9 +4,9 @@
 
 namespace Cortex\JsonSchema\Tests\Unit;
 
+use Cortex\JsonSchema\Types\IntegerSchema;
 use Cortex\JsonSchema\SchemaFactory as Schema;
 use Cortex\JsonSchema\Exceptions\SchemaException;
-use Cortex\JsonSchema\Types\IntegerSchema;
 
 covers(IntegerSchema::class);
 

tests/Unit/Targets/StringSchemaTest.php

@@ -5,9 +5,9 @@
 namespace Cortex\JsonSchema\Tests\Unit;
 
 use Cortex\JsonSchema\Enums\SchemaFormat;
+use Cortex\JsonSchema\Types\StringSchema;
 use Cortex\JsonSchema\SchemaFactory as Schema;
 use Cortex\JsonSchema\Exceptions\SchemaException;
-use Cortex\JsonSchema\Types\StringSchema;
 
 covers(StringSchema::class);