feat: Multiple schema versions (#9)

Author: tymondesigns

README.md

@@ -26,6 +26,7 @@
     ])
     ->withRootFiles()
     ->withSpacing(indentation: Option::INDENTATION_SPACES)
+    ->withEditorConfig()
     ->withPreparedSets(
         psr12: true,
         common: true,

ecs.php

@@ -4,6 +4,8 @@
 
 namespace Cortex\JsonSchema\Contracts;
 
+use Cortex\JsonSchema\Enums\SchemaVersion;
+
 interface Schema
 {
     /**
@@ -76,4 +78,14 @@ public function validate(mixed $value): void;
      * Determine if the given value is valid against the schema.
      */
     public function isValid(mixed $value): bool;
+
+    /**
+     * Set the JSON Schema version for this schema.
+     */
+    public function version(SchemaVersion $schemaVersion): static;
+
+    /**
+     * Get the JSON Schema version for this schema.
+     */
+    public function getVersion(): SchemaVersion;
 }

src/Contracts/Schema.php

@@ -13,6 +13,7 @@
 use Cortex\JsonSchema\Support\DocParser;
 use Cortex\JsonSchema\Types\ObjectSchema;
 use Cortex\JsonSchema\Contracts\Converter;
+use Cortex\JsonSchema\Enums\SchemaVersion;
 use Cortex\JsonSchema\Converters\Concerns\InteractsWithTypes;
 
 class ClassConverter implements Converter
@@ -30,13 +31,15 @@ class ClassConverter implements Converter
     public function __construct(
         protected object|string $class,
         protected bool $publicOnly = true,
+        protected ?SchemaVersion $version = null,
     ) {
         $this->reflection = new ReflectionClass($this->class);
+        $this->version = $version ?? SchemaVersion::default();
     }
 
     public function convert(): ObjectSchema
     {
-        $objectSchema = new ObjectSchema();
+        $objectSchema = new ObjectSchema(schemaVersion: $this->version);
 
         // Get the description from the doc parser
         $description = $this->getDocParser($this->reflection)?->description() ?? null;

src/Converters/ClassConverter.php

@@ -14,6 +14,7 @@
 use Cortex\JsonSchema\Support\DocParser;
 use Cortex\JsonSchema\Types\ObjectSchema;
 use Cortex\JsonSchema\Contracts\Converter;
+use Cortex\JsonSchema\Enums\SchemaVersion;
 use Cortex\JsonSchema\Support\NodeCollection;
 use Cortex\JsonSchema\Converters\Concerns\InteractsWithTypes;
 
@@ -25,13 +26,15 @@ class ClosureConverter implements Converter
 
     public function __construct(
         protected Closure $closure,
+        protected ?SchemaVersion $version = null,
     ) {
         $this->reflection = new ReflectionFunction($this->closure);
+        $this->version = $version ?? SchemaVersion::default();
     }
 
     public function convert(): ObjectSchema
     {
-        $objectSchema = new ObjectSchema();
+        $objectSchema = new ObjectSchema(schemaVersion: $this->version);
 
         // Get the description from the doc parser
         $description = $this->getDocParser()?->description() ?? null;

src/Converters/ClosureConverter.php

@@ -18,31 +18,31 @@ trait InteractsWithTypes
     /**
      * Resolve the schema instance from the given reflection type.
      */
-    protected static function getSchemaFromReflectionType(
+    protected function getSchemaFromReflectionType(
         ReflectionNamedType|ReflectionUnionType|ReflectionIntersectionType|null $type,
     ): Schema {
         $schemaTypes = match (true) {
             $type instanceof ReflectionUnionType, $type instanceof ReflectionIntersectionType => array_map(
                 // @phpstan-ignore argument.type
-                fn(ReflectionNamedType $reflectionNamedType): SchemaType => self::resolveSchemaType(
+                fn(ReflectionNamedType $reflectionNamedType): SchemaType => $this->resolveSchemaType(
                     $reflectionNamedType,
                 ),
                 $type->getTypes(),
             ),
             // If the parameter is not typed or explicitly typed as mixed, we use all schema types
             in_array($type?->getName(), ['mixed', null], true) => SchemaType::cases(),
-            default => [self::resolveSchemaType($type)],
+            default => [$this->resolveSchemaType($type)],
         };
 
         return count($schemaTypes) === 1
-            ? $schemaTypes[0]->instance()
-            : new UnionSchema(array_values($schemaTypes));
+            ? $schemaTypes[0]->instance(null, $this->version)
+            : new UnionSchema(array_values($schemaTypes), null, $this->version);
     }
 
     /**
      * Resolve the schema type from the given reflection type.
      */
-    protected static function resolveSchemaType(ReflectionNamedType $reflectionNamedType): SchemaType
+    protected function resolveSchemaType(ReflectionNamedType $reflectionNamedType): SchemaType
     {
         $typeName = $reflectionNamedType->getName();
 

src/Converters/Concerns/InteractsWithTypes.php

@@ -8,6 +8,7 @@
 use Cortex\JsonSchema\Support\DocParser;
 use Cortex\JsonSchema\Types\StringSchema;
 use Cortex\JsonSchema\Contracts\Converter;
+use Cortex\JsonSchema\Enums\SchemaVersion;
 use Cortex\JsonSchema\Types\IntegerSchema;
 use Cortex\JsonSchema\Exceptions\SchemaException;
 
@@ -23,8 +24,10 @@ class EnumConverter implements Converter
      */
     public function __construct(
         protected string $enum,
+        protected ?SchemaVersion $version = null,
     ) {
         $this->reflection = new ReflectionEnum($this->enum);
+        $this->version = $version ?? SchemaVersion::default();
 
         if (! $this->reflection->isBacked()) {
             throw new SchemaException('Enum must be a backed enum');
@@ -38,8 +41,8 @@ public function convert(): StringSchema|IntegerSchema
 
         // Determine the backing type
         $schema = match ($this->reflection->getBackingType()?->getName()) {
-            'string' => new StringSchema($enumName),
-            'int' => new IntegerSchema($enumName),
+            'string' => new StringSchema($enumName, $this->version),
+            'int' => new IntegerSchema($enumName, $this->version),
             default => throw new SchemaException(
                 'Unsupported enum backing type. Only "int" or "string" are supported.',
             ),