optimize schema

Author: dominikzogg

src/Parser.php

@@ -101,9 +101,9 @@ public function literal(bool|float|int|string $literal): LiteralSchema
      * @param array<string, SchemaInterface> $fieldNameToSchema
      * @param class-string                   $classname
      */
-    public function object(array $fieldNameToSchema, string $classname = \stdClass::class): ObjectSchema
+    public function object(array $fieldNameToSchema, string $classname = \stdClass::class, bool $construct = false): ObjectSchema
     {
-        return new ObjectSchema($fieldNameToSchema, $classname);
+        return new ObjectSchema($fieldNameToSchema, $classname, $construct);
     }
 
     public function record(SchemaInterface $fieldSchema): RecordSchema

src/Schema/ObjectConstructorSchema.php

@@ -16,7 +16,7 @@ final class ObjectSchema extends AbstractObjectSchema implements ObjectSchemaInt
      * @param array<mixed, mixed> $fieldToSchema
      * @param class-string        $classname
      */
-    public function __construct(array $fieldToSchema, private string $classname = \stdClass::class)
+    public function __construct(array $fieldToSchema, private string $classname = \stdClass::class, private bool $construct = false)
     {
         parent::__construct($fieldToSchema);
     }
@@ -26,20 +26,29 @@ public function __construct(array $fieldToSchema, private string $classname = \s
      */
     protected function parseFields(array $input, Errors $childrenErrors): object
     {
-        $object = new ($this->classname);
-
+        $fields = [];
         foreach ($this->getFieldToSchema() as $fieldName => $fieldSchema) {
             try {
                 if ($this->skip($input, $fieldName)) {
                     continue;
                 }
 
-                $object->{$fieldName} = $fieldSchema->parse($input[$fieldName] ?? null);
+                $fields[$fieldName] = $fieldSchema->parse($input[$fieldName] ?? null);
             } catch (ErrorsException $e) {
                 $childrenErrors->add($e->errors, $fieldName);
             }
         }
 
-        return $object;
+        if (!$this->construct) {
+            $object = new ($this->classname);
+
+            foreach ($fields as $fieldName => $fieldValue) {
+                $object->{$fieldName} = $fieldValue;
+            }
+
+            return $object;
+        }
+
+        return new ($this->classname)(...$fields);
     }
 }

src/Schema/ObjectSchema.php

@@ -33,6 +33,30 @@ enum BackedSuit: string
     case Spades = 'S';
 }
 
+final class ObjectDemo implements \JsonSerializable
+{
+    public string $field1;
+
+    public function jsonSerialize(): array
+    {
+        return [
+            'field1' => $this->field1,
+        ];
+    }
+}
+
+final class ObjectConstructDemo implements \JsonSerializable
+{
+    public function __construct(public string $field1) {}
+
+    public function jsonSerialize(): array
+    {
+        return [
+            'field1' => $this->field1,
+        ];
+    }
+}
+
 /**
  * @covers \Chubbyphp\Parsing\Parser
  *
@@ -159,7 +183,7 @@ public function testLiteral(): void
         self::assertInstanceOf(LiteralSchema::class, $literalSchema);
     }
 
-    public function testObject(): void
+    public function testObjectStdClass(): void
     {
         $p = new Parser();
 
@@ -170,6 +194,44 @@ public function testObject(): void
         self::assertInstanceOf(ObjectSchema::class, $objectSchema);
     }
 
+    public function testObjectWithObject(): void
+    {
+        $p = new Parser();
+
+        $objectSchema = $p->object([
+            'field' => $p->string(),
+        ], ObjectDemo::class, );
+
+        $classnameReflection = new \ReflectionProperty(ObjectSchema::class, 'classname');
+
+        self::assertSame(ObjectDemo::class, $classnameReflection->getValue($objectSchema));
+
+        $constructReflection = new \ReflectionProperty(ObjectSchema::class, 'construct');
+
+        self::assertFalse($constructReflection->getValue($objectSchema));
+
+        self::assertInstanceOf(ObjectSchema::class, $objectSchema);
+    }
+
+    public function testObjectWithObjectConstruct(): void
+    {
+        $p = new Parser();
+
+        $objectSchema = $p->object([
+            'field' => $p->string(),
+        ], ObjectConstructDemo::class, true);
+
+        $classnameReflection = new \ReflectionProperty(ObjectSchema::class, 'classname');
+
+        self::assertSame(ObjectConstructDemo::class, $classnameReflection->getValue($objectSchema));
+
+        $constructReflection = new \ReflectionProperty(ObjectSchema::class, 'construct');
+
+        self::assertTrue($constructReflection->getValue($objectSchema));
+
+        self::assertInstanceOf(ObjectSchema::class, $objectSchema);
+    }
+
     public function testRecord(): void
     {
         $p = new Parser();