field-to-schema

Author: dominikzogg

README.md

@@ -35,7 +35,7 @@ Heavily inspired by the well-known TypeScript library [zod](https://github.com/c
 Through [Composer](http://getcomposer.org) as [chubbyphp/chubbyphp-parsing][1].
 
 ```sh
-composer require chubbyphp/chubbyphp-parsing "^1.3"
+composer require chubbyphp/chubbyphp-parsing "^1.4"
 ```
 
 ## Usage
@@ -267,6 +267,9 @@ $p = new Parser();
 
 $schema = $p->object(['name' => $p->string()]);
 
+// create a new schema based on a existing once
+$schema2 = $p->object([...$schema->getFieldToSchema(), 'value' => $p->string()]);
+
 // stdClass object
 $data = $schema->parse(['name' => 'example']);
 

composer.json

@@ -50,7 +50,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "1.3-dev"
+            "dev-master": "1.4-dev"
         }
     },
     "scripts": {

src/Schema/ObjectSchema.php

@@ -18,7 +18,7 @@ final class ObjectSchema extends AbstractSchema implements ObjectSchemaInterface
     /**
      * @var array<string, SchemaInterface>
      */
-    private array $fieldNameToSchema;
+    private array $fieldToSchema;
 
     /**
      * @var null|array<string>
@@ -31,16 +31,16 @@ final class ObjectSchema extends AbstractSchema implements ObjectSchemaInterface
     private ?array $optional = null;
 
     /**
-     * @param array<string, SchemaInterface> $fieldNameToSchema
+     * @param array<string, SchemaInterface> $fieldToSchema
      * @param class-string                   $classname
      */
-    public function __construct(array $fieldNameToSchema, private string $classname = \stdClass::class)
+    public function __construct(array $fieldToSchema, private string $classname = \stdClass::class)
     {
-        foreach ($fieldNameToSchema as $fieldName => $fieldSchema) {
+        foreach ($fieldToSchema as $fieldName => $fieldSchema) {
             if (!\is_string($fieldName)) {
                 throw new \InvalidArgumentException(
                     \sprintf(
-                        'Argument #1 name #%s ($fieldNameToSchema) must be of type string, %s given',
+                        'Argument #1 name #%s ($fieldToSchema) must be of type string, %s given',
                         $fieldName,
                         $this->getDataType($fieldName)
                     )
@@ -50,7 +50,7 @@ public function __construct(array $fieldNameToSchema, private string $classname
             if (!$fieldSchema instanceof SchemaInterface) {
                 throw new \InvalidArgumentException(
                     \sprintf(
-                        'Argument #1 value of #%s ($fieldNameToSchema) must be of type %s, %s given',
+                        'Argument #1 value of #%s ($fieldToSchema) must be of type %s, %s given',
                         $fieldName,
                         SchemaInterface::class,
                         $this->getDataType($fieldSchema)
@@ -59,7 +59,7 @@ public function __construct(array $fieldNameToSchema, private string $classname
             }
         }
 
-        $this->fieldNameToSchema = $fieldNameToSchema;
+        $this->fieldToSchema = $fieldToSchema;
     }
 
     public function parse(mixed $input): mixed
@@ -111,9 +111,17 @@ public function parse(mixed $input): mixed
         }
     }
 
-    public function getFieldSchema(string $fieldName): ?SchemaInterface
+    /**
+     * @return array<string, SchemaInterface>
+     */
+    public function getFieldToSchema(): array
+    {
+        return $this->fieldToSchema;
+    }
+
+    public function getFieldSchema(string $field): ?SchemaInterface
     {
-        return $this->fieldNameToSchema[$fieldName] ?? null;
+        return $this->fieldToSchema[$field] ?? null;
     }
 
     /**
@@ -150,7 +158,7 @@ private function unknownFields(array $input, ParserErrorException $childrenParse
         }
 
         foreach (array_keys($input) as $fieldName) {
-            if (!\in_array($fieldName, $this->strict, true) && !isset($this->fieldNameToSchema[$fieldName])) {
+            if (!\in_array($fieldName, $this->strict, true) && !isset($this->fieldToSchema[$fieldName])) {
                 $childrenParserErrorException->addError(new Error(
                     self::ERROR_UNKNOWN_FIELD_CODE,
                     self::ERROR_UNKNOWN_FIELD_TEMPLATE,
@@ -165,7 +173,7 @@ private function unknownFields(array $input, ParserErrorException $childrenParse
      */
     private function parseFields(array $input, object $object, ParserErrorException $childrenParserErrorException): void
     {
-        foreach ($this->fieldNameToSchema as $fieldName => $fieldSchema) {
+        foreach ($this->fieldToSchema as $fieldName => $fieldSchema) {
             try {
                 if (
                     !\array_key_exists($fieldName, $input)

tests/Unit/Schema/ObjectSchemaTest.php

@@ -5,6 +5,7 @@
 namespace Chubbyphp\Tests\Parsing\Unit\Schema;
 
 use Chubbyphp\Parsing\ParserErrorException;
+use Chubbyphp\Parsing\Schema\BoolSchema;
 use Chubbyphp\Parsing\Schema\FloatSchema;
 use Chubbyphp\Parsing\Schema\IntSchema;
 use Chubbyphp\Parsing\Schema\ObjectSchema;
@@ -56,7 +57,7 @@ public function testConstructWithoutFieldName(): void
             throw new \Exception('code should not be reached');
         } catch (\InvalidArgumentException $invalidArgumentException) {
             self::assertSame(
-                'Argument #1 name #0 ($fieldNameToSchema) must be of type string, integer given',
+                'Argument #1 name #0 ($fieldToSchema) must be of type string, integer given',
                 $invalidArgumentException->getMessage()
             );
         }
@@ -70,7 +71,7 @@ public function testConstructWithoutFieldSchema(): void
             throw new \Exception('code should not be reached');
         } catch (\InvalidArgumentException $invalidArgumentException) {
             self::assertSame(
-                'Argument #1 value of #field2 ($fieldNameToSchema) must be of type Chubbyphp\Parsing\Schema\SchemaInterface, string given',
+                'Argument #1 value of #field2 ($fieldToSchema) must be of type Chubbyphp\Parsing\Schema\SchemaInterface, string given',
                 $invalidArgumentException->getMessage()
             );
         }
@@ -370,6 +371,21 @@ public function testSafeParseFailed(): void
         ], $this->errorsToSimpleArray($schema->safeParse(null)->exception->getErrors()));
     }
 
+    public function testGetFieldToSchema(): void
+    {
+        $fieldToSchema = ['field1' => new StringSchema(), 'field2' => new IntSchema()];
+
+        $schema = new ObjectSchema($fieldToSchema);
+
+        self::assertSame($fieldToSchema, $schema->getFieldToSchema());
+
+        $fieldToSchema2 = [...$schema->getFieldToSchema(), 'field3' => new BoolSchema()];
+
+        $schema2 = new ObjectSchema($fieldToSchema2);
+
+        self::assertSame($fieldToSchema2, $schema2->getFieldToSchema());
+    }
+
     public function testGetFieldSchemaSuccess(): void
     {
         $field2Schema = new IntSchema();