Merge pull request #45 from ianhoffman/ih-uniqueItems-2

Skip unsupported uniqueItems constraints

Author: Michael Hahn

src/Codegen/Constraints/ArrayBuilder.php

@@ -17,14 +17,20 @@
 type TArraySchemaItemsSingleSchema = TSchema;
 type TArraySchemaItemsMultiSchema = vec<TSchema>;
 
+enum HackArrayType: string {
+  VEC = 'vec';
+  KEYSET = 'keyset';
+}
+
 class ArrayBuilder extends BaseBuilder<TArraySchema> {
   private ?IBuilder $singleItemSchemaBuilder = null;
   protected static string $schema_name = 'Slack\Hack\JsonSchema\Codegen\TArraySchema';
+  private HackArrayType $hackArrayType = HackArrayType::VEC;
 
   <<__Override>>
   public function build(): this {
     $this->setupSingleItemSchemaBuilder();
-    $this->validateSchema();
+    $this->determineHackArrayType();
 
     $class = $this->codegenClass()
       ->addMethod($this->getCheckMethod());
@@ -65,12 +71,7 @@ public function getType(): string {
     // Items is a single type, get the type from the items builder.
     $items_builder = $this->singleItemSchemaBuilder;
     invariant($items_builder is nonnull, 'must call `build` method before accessing type');
-    if ($this->schema['uniqueItems'] ?? false) {
-      $container = 'keyset';
-    } else {
-      $container = 'vec';
-    }
-    return "{$container}<{$items_builder->getType()}>";
+    return "{$this->hackArrayType}<{$items_builder->getType()}>";
   }
 
   protected function getCheckMethod(): CodegenMethod {
@@ -166,7 +167,7 @@ private function buildItemsSingleSchema(HackBuilder $hb): void {
       ->endIfBlock()
       ->ensureEmptyLine();
 
-    if ($this->typed_schema['uniqueItems'] ?? false) {
+    if ($this->hackArrayType === HackArrayType::KEYSET) {
       $hb
         ->addMultilineCall(
           '$output = Constraints\ArrayUniqueItemsConstraint::check',
@@ -263,13 +264,13 @@ private function setupSingleItemSchemaBuilder(): void {
   }
 
   /**
-   * Validate that the schema is supported.
+   * Determine the type of hack array we will generate.
    */
-  private function validateSchema(): void {
+  private function determineHackArrayType(): void {
     if ($this->schema['uniqueItems'] ?? false) {
       $item_type = $this->singleItemSchemaBuilder?->getType();
-      if ($item_type !== 'string' && $item_type !== 'int') {
-        throw new \Exception('uniqueItems is only implemented for arrays of strings and integers');
+      if ($item_type === 'string' || $item_type === 'int') {
+        $this->hackArrayType = HackArrayType::KEYSET;
       }
     }
   }

tests/ArraySchemaValidatorTest.php

@@ -206,10 +206,16 @@ public function testUniqueItemsWithCoercion(): void {
     expect($validated)->toEqual(shape('unique_numbers_coerce' => keyset($input)));
   }
 
-  public function testInvalidUniqueItemsConstraint(): void {
-    $ret = self::getBuilder('array-schema-invalid.json', 'ArraySchemaInvalidValidator');
-    expect(() ==> $ret['codegen']->build())
-      ->toThrow(\Exception::class, 'uniqueItems is only implemented for arrays of strings and integers');
+  public function testUnsupportedUniqueItemsConstraint(): void {
+    $input = vec[dict['foo' => 'a'], dict['foo' => 'a']];
+
+    $validator = new ArraySchemaValidator(dict['unsupported_unique_items' => $input]);
+    $validator->validate();
+
+    expect($validator->isValid())->toBeTrue();
+    $validated = $validator->getValidatedInput();
+
+    expect($validated)->toEqual(shape('unsupported_unique_items' => vec[shape('foo' => 'a'), shape('foo' => 'a')]));
   }
 
 }

tests/examples/array-schema-invalid.json

@@ -39,6 +39,18 @@
       "items": {
         "type": "integer"
       }
+    },
+    "unsupported_unique_items": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+          "type": "object",
+          "properties": {
+              "foo": {
+                  "type": "string"
+              }
+          }
+      }
     }
   }
 }

tests/examples/array-schema.json

@@ -5,19 +5,25 @@
  * To re-generate this file run `make test`
  *
  *
- * @generated SignedSource<<731edaf71398ea5fb65cfa1e09cab571>>
+ * @generated SignedSource<<458640baae767319d7594d9b4fcce940>>
  */
 namespace Slack\Hack\JsonSchema\Tests\Generated;
 use namespace Slack\Hack\JsonSchema;
 use namespace Slack\Hack\JsonSchema\Constraints;
 
+type TArraySchemaValidatorPropertiesUnsupportedUniqueItemsItems = shape(
+  ?'foo' => string,
+  ...
+);
+
 type TArraySchemaValidator = shape(
   ?'array_of_strings' => vec<string>,
   ?'untyped_array' => vec<mixed>,
   ?'coerce_array' => vec<num>,
   ?'unique_strings' => keyset<string>,
   ?'unique_numbers' => keyset<int>,
   ?'unique_numbers_coerce' => keyset<int>,
+  ?'unsupported_unique_items' => vec<TArraySchemaValidatorPropertiesUnsupportedUniqueItemsItems>,
   ...
 );
 
@@ -252,6 +258,88 @@ public static function check(mixed $input, string $pointer): keyset<int> {
   }
 }
 
+final class ArraySchemaValidatorPropertiesUnsupportedUniqueItemsItemsPropertiesFoo {
+
+  private static bool $coerce = false;
+
+  public static function check(mixed $input, string $pointer): string {
+    $typed = Constraints\StringConstraint::check($input, $pointer, self::$coerce);
+
+    return $typed;
+  }
+}
+
+final class ArraySchemaValidatorPropertiesUnsupportedUniqueItemsItems {
+
+  private static bool $coerce = false;
+
+  public static function check(
+    mixed $input,
+    string $pointer,
+  ): TArraySchemaValidatorPropertiesUnsupportedUniqueItemsItems {
+    $typed = Constraints\ObjectConstraint::check($input, $pointer, self::$coerce);
+
+    $errors = vec[];
+    $output = shape();
+
+    /*HHAST_IGNORE_ERROR[UnusedVariable] Some loops generated with this statement do not use their $value*/
+    foreach ($typed as $key => $value) {
+      /* HH_IGNORE_ERROR[4051] allow dynamic access to preserve input. See comment in the codegen lib for reasoning and alternatives if needed. */
+      $output[$key] = $value;
+    }
+
+    if (\HH\Lib\C\contains_key($typed, 'foo')) {
+      try {
+        $output['foo'] = ArraySchemaValidatorPropertiesUnsupportedUniqueItemsItemsPropertiesFoo::check(
+          $typed['foo'],
+          JsonSchema\get_pointer($pointer, 'foo'),
+        );
+      } catch (JsonSchema\InvalidFieldException $e) {
+        $errors = \HH\Lib\Vec\concat($errors, $e->errors);
+      }
+    }
+
+    if (\HH\Lib\C\count($errors)) {
+      throw new JsonSchema\InvalidFieldException($pointer, $errors);
+    }
+
+    /* HH_IGNORE_ERROR[4163] */
+    return $output;
+  }
+}
+
+final class ArraySchemaValidatorPropertiesUnsupportedUniqueItems {
+
+  private static bool $coerce = false;
+
+  public static function check(
+    mixed $input,
+    string $pointer,
+  ): vec<TArraySchemaValidatorPropertiesUnsupportedUniqueItemsItems> {
+    $typed = Constraints\ArrayConstraint::check($input, $pointer, self::$coerce);
+
+    $output = vec[];
+    $errors = vec[];
+
+    foreach ($typed as $index => $value) {
+      try {
+        $output[] = ArraySchemaValidatorPropertiesUnsupportedUniqueItemsItems::check(
+          $value,
+          JsonSchema\get_pointer($pointer, (string) $index),
+        );
+      } catch (JsonSchema\InvalidFieldException $e) {
+        $errors = \HH\Lib\Vec\concat($errors, $e->errors);
+      }
+    }
+
+    if (\HH\Lib\C\count($errors)) {
+      throw new JsonSchema\InvalidFieldException($pointer, $errors);
+    }
+
+    return $output;
+  }
+}
+
 final class ArraySchemaValidator
   extends JsonSchema\BaseValidator<TArraySchemaValidator> {
 
@@ -338,6 +426,17 @@ public static function check(
       }
     }
 
+    if (\HH\Lib\C\contains_key($typed, 'unsupported_unique_items')) {
+      try {
+        $output['unsupported_unique_items'] = ArraySchemaValidatorPropertiesUnsupportedUniqueItems::check(
+          $typed['unsupported_unique_items'],
+          JsonSchema\get_pointer($pointer, 'unsupported_unique_items'),
+        );
+      } catch (JsonSchema\InvalidFieldException $e) {
+        $errors = \HH\Lib\Vec\concat($errors, $e->errors);
+      }
+    }
+
     if (\HH\Lib\C\count($errors)) {
       throw new JsonSchema\InvalidFieldException($pointer, $errors);
     }