merge rule type customization

Riley19280 · Aug 30, 2024 · 4475691 · 4475691
1 parent 4835b0b
commit 4475691
Show file tree

Hide file tree

Showing 13 changed files with 232 additions and 102 deletions.
diff --git a/config/rules-to-schema.php b/config/rules-to-schema.php
@@ -1,14 +1,13 @@
 <?php
 
-use LaravelRulesToSchema\LaravelRuleType;
 use LaravelRulesToSchema\Parsers\ConfirmedParser;
+use LaravelRulesToSchema\Parsers\CustomRuleSchemaParser;
 use LaravelRulesToSchema\Parsers\EnumParser;
 use LaravelRulesToSchema\Parsers\ExcludedParser;
 use LaravelRulesToSchema\Parsers\FormatParser;
 use LaravelRulesToSchema\Parsers\MiscPropertyParser;
 use LaravelRulesToSchema\Parsers\NestedObjectParser;
 use LaravelRulesToSchema\Parsers\RequiredParser;
-use LaravelRulesToSchema\Parsers\RuleHasJsonSchemaParser;
 use LaravelRulesToSchema\Parsers\TypeParser;
 
 return [
@@ -32,40 +31,15 @@
         EnumParser::class,
         ExcludedParser::class,
         ConfirmedParser::class,
-        RuleHasJsonSchemaParser::class,
-    ],
-
-    /*
-     * For convenience, simple types for custom rules can be added here
-     */
-    'rule_type_map' => [
-        'string' => [
-            ...LaravelRuleType::string(),
-        ],
-        'integer' => [
-            ...LaravelRuleType::integer(),
-        ],
-        'number' => [
-            ...LaravelRuleType::number(),
-        ],
-        'boolean' => [
-            ...LaravelRuleType::boolean(),
-        ],
-        'nullable' => [
-            ...LaravelRuleType::nullable(),
-        ],
-        'array' => [
-            ...LaravelRuleType::array(),
-        ],
-        'exclude' => [
-            ...LaravelRuleType::exclude(),
-        ],
+        CustomRuleSchemaParser::class,
     ],
 
     /*
      * Third party rules that you can provide custom schema definitions for
      */
     'custom_rule_schemas' => [
         // \CustomPackage\CustomRule::class => \Support\CustomRuleSchemaDefinition::class,
+        // \CustomPackage\CustomRule::class => 'string',
+        // \CustomPackage\CustomRule::class => ['null', 'string'],
     ],
 ];
diff --git a/src/Facades/LaravelRulesToSchema.php b/src/Facades/LaravelRulesToSchema.php
@@ -7,6 +7,8 @@
 
 /**
  * @method static FluentSchema parse(array $rules) Parse Rules
+ * @method static void registerParser(string $parser) Register a rule parser
+ * @method static void registerCustomRuleSchema(string $rule, mixed $type) Register a schema for a custom rule
  *
  * @see \LaravelRulesToSchema\LaravelRulesToSchema
  */

diff --git a/src/LaravelRulesToSchema.php b/src/LaravelRulesToSchema.php
@@ -8,6 +8,10 @@ class LaravelRulesToSchema
 {
     use ParsesNormalizedRuleset;
 
+    protected static array $additionalParsers = [];
+
+    protected static array $additionalCustomSchemas = [];
+
     public function parse(array $rules): FluentSchema
     {
         $normalizedRules = (new ValidationRuleNormalizer($rules))->getRules();
@@ -28,4 +32,31 @@ public function parse(array $rules): FluentSchema
 
         return $schema;
     }
+
+    public function getParsers(): array
+    {
+        return array_merge(
+            config('rules-to-schema.parsers'),
+            self::$additionalParsers,
+        );
+    }
+
+    public function registerParser(string $parser): void
+    {
+        self::$additionalParsers[] = $parser;
+    }
+
+    public function getCustomRuleSchemas(): array
+    {
+
+        return array_merge(
+            config('rules-to-schema.custom_rule_schemas'),
+            self::$additionalCustomSchemas,
+        );
+    }
+
+    public function registerCustomRuleSchema(string $rule, mixed $type): void
+    {
+        self::$additionalCustomSchemas[$rule] = $type;
+    }
 }
diff --git a/src/Parsers/CustomRuleSchemaParser.php b/src/Parsers/CustomRuleSchemaParser.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace LaravelRulesToSchema\Parsers;
+
+use FluentJsonSchema\Enums\JsonSchemaType;
+use FluentJsonSchema\FluentSchema;
+use LaravelRulesToSchema\Contracts\HasJsonSchema;
+use LaravelRulesToSchema\Contracts\RuleParser;
+use LaravelRulesToSchema\Facades\LaravelRulesToSchema;
+use PHPUnit\Logging\Exception;
+
+class CustomRuleSchemaParser implements RuleParser
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function __invoke(string $attribute, FluentSchema $schema, array $validationRules, array $nestedRuleset): array|FluentSchema|null
+    {
+        foreach ($validationRules as $ruleArgs) {
+            [$rule, $args] = $ruleArgs;
+
+            $ruleName = is_object($rule) ? get_class($rule) : $rule;
+
+            if ($rule instanceof HasJsonSchema) {
+                return $rule->toJsonSchema($attribute);
+            } elseif (array_key_exists($ruleName, LaravelRulesToSchema::getCustomRuleSchemas())) {
+                $typehint = LaravelRulesToSchema::getCustomRuleSchemas()[$ruleName];
+
+                if (is_string($typehint)) {
+                    if (class_exists($typehint)) {
+                        $instance = app($typehint);
+
+                        if (! $instance instanceof HasJsonSchema) {
+                            throw new Exception('Custom rule schemas must implement '.HasJsonSchema::class);
+                        }
+
+                        return $instance->toJsonSchema($attribute);
+                    } else {
+                        $schema->type()->fromString($typehint);
+                    }
+                } elseif ($typehint instanceof JsonSchemaType) {
+                    $schema->type()->fromString($typehint->value);
+                } elseif (is_array($typehint)) {
+                    foreach ($typehint as $type) {
+                        if ($type instanceof JsonSchemaType) {
+                            $schema->type()->fromString($type->value);
+                        } else {
+                            $schema->type()->fromString($type);
+                        }
+                    }
+                }
+            }
+        }
+
+        return $schema;
+    }
+}
diff --git a/src/Parsers/ExcludedParser.php b/src/Parsers/ExcludedParser.php
@@ -4,14 +4,15 @@
 
 use FluentJsonSchema\FluentSchema;
 use LaravelRulesToSchema\Contracts\RuleParser;
+use LaravelRulesToSchema\LaravelRuleType;
 
 class ExcludedParser implements RuleParser
 {
     public function __invoke(string $attribute, FluentSchema $schema, array $validationRules, array $nestedRuleset): array|FluentSchema|null
     {
         foreach ($validationRules as $ruleArgs) {
             [$rule, $args] = $ruleArgs;
-            if (is_string($rule) && in_array($rule, config('rules-to-schema.rule_type_map.exclude'))) {
+            if (is_string($rule) && in_array($rule, LaravelRuleType::exclude())) {
                 return null;
             }
         }

diff --git a/src/Parsers/RuleHasJsonSchemaParser.php b/src/Parsers/RuleHasJsonSchemaParser.php
diff --git a/src/Parsers/TypeParser.php b/src/Parsers/TypeParser.php
@@ -6,6 +6,7 @@
 use Illuminate\Validation\Rules\Enum as EnumRule;
 use Illuminate\Validation\Rules\In as InRule;
 use LaravelRulesToSchema\Contracts\RuleParser;
+use LaravelRulesToSchema\LaravelRuleType;
 use ReflectionClass;
 
 class TypeParser implements RuleParser
@@ -17,25 +18,25 @@ public function __invoke(string $attribute, FluentSchema $schema, array $validat
 
             $ruleName = is_object($rule) ? get_class($rule) : $rule;
 
-            if (in_array($ruleName, config('rules-to-schema.rule_type_map.string'))) {
+            if (in_array($ruleName, LaravelRuleType::string())) {
                 $schema->type()->string();
             }
-            if (in_array($ruleName, config('rules-to-schema.rule_type_map.integer'))) {
+            if (in_array($ruleName, LaravelRuleType::integer())) {
                 $schema->type()->integer();
             }
-            if (in_array($ruleName, config('rules-to-schema.rule_type_map.number'))) {
+            if (in_array($ruleName, LaravelRuleType::number())) {
                 $schema->type()->number();
             }
-            if (in_array($ruleName, config('rules-to-schema.rule_type_map.boolean'))) {
+            if (in_array($ruleName, LaravelRuleType::boolean())) {
                 $schema->type()->boolean();
             }
-            if (in_array($ruleName, config('rules-to-schema.rule_type_map.array'))) {
+            if (in_array($ruleName, LaravelRuleType::array())) {
                 // Check if what we are dealing with is not an object type with properties
                 if (count(array_diff_key($nestedRuleset, array_flip([config('rules-to-schema.validation_rule_token')]))) == 0) {
                     $schema->type()->array();
                 }
             }
-            if (in_array($ruleName, config('rules-to-schema.rule_type_map.nullable'))) {
+            if (in_array($ruleName, LaravelRuleType::nullable())) {
                 $schema->type()->null();
             }
 

diff --git a/src/ParsesNormalizedRuleset.php b/src/ParsesNormalizedRuleset.php
@@ -3,6 +3,7 @@
 namespace LaravelRulesToSchema;
 
 use FluentJsonSchema\FluentSchema;
+use LaravelRulesToSchema\Contracts\RuleParser;
 use Mockery\Exception;
 
 trait ParsesNormalizedRuleset
@@ -13,11 +14,11 @@ public function parseRuleset(string $name, array $nestedRuleset): null|FluentSch
 
         $schemas = [$name => FluentSchema::make()];
 
-        foreach (config('rules-to-schema.parsers') as $parserClass) {
+        foreach (\LaravelRulesToSchema\Facades\LaravelRulesToSchema::getParsers() as $parserClass) {
             $instance = app($parserClass);
 
-            if (! $instance instanceof \LaravelRulesToSchema\Contracts\RuleParser) {
-                throw new Exception('Rule parsers must implement '.\LaravelRulesToSchema\Contracts\RuleParser::class);
+            if (! $instance instanceof RuleParser) {
+                throw new Exception('Rule parsers must implement '.RuleParser::class);
             }
 
             $newSchemas = [];

diff --git a/tests/.pest/snapshots/ConfigurationTest/can_register_custom_parsers.snap b/tests/.pest/snapshots/ConfigurationTest/can_register_custom_parsers.snap
@@ -0,0 +1,11 @@
+{
+    "type": "object",
+    "properties": {
+        "custom": {
+            "type": "array",
+            "items": {
+                "type": "integer"
+            }
+        }
+    }
+}
diff --git a/tests/.pest/snapshots/ConfigurationTest/can_register_custom_rule_schemas.snap b/tests/.pest/snapshots/ConfigurationTest/can_register_custom_rule_schemas.snap
@@ -0,0 +1,11 @@
+{
+    "type": "object",
+    "properties": {
+        "custom": {
+            "type": [
+                "null",
+                "string"
+            ]
+        }
+    }
+}
diff --git a/tests/.pest/snapshots/ConfigurationTest/custom_rule_can_have_custom_schema.snap b/tests/.pest/snapshots/ConfigurationTest/custom_rule_can_have_custom_schema.snap
@@ -22,6 +22,36 @@
                     }
                 }
             }
+        },
+        "integer": {
+            "type": "integer"
+        },
+        "number": {
+            "type": "number"
+        },
+        "boolean": {
+            "type": "boolean"
+        },
+        "array": {
+            "type": "array"
+        },
+        "nullable": {
+            "type": "null"
+        },
+        "custom_rule_as_enum": {
+            "type": "string"
+        },
+        "custom_rule_as_enum_array": {
+            "type": [
+                "null",
+                "number"
+            ]
+        },
+        "custom_multiple_types": {
+            "type": [
+                "null",
+                "string"
+            ]
         }
     }
 }