files

src/Core/Record/RecordValidationModule.php

@@ -14,16 +14,23 @@ class RecordValidationModule
      * @param string[] $locales
      * @param Field[] $schemaFields
      * @param RecordField[] $recordFields
+     * @param Edge[] $recordEdges
      * @return RecordError[]
      */
     public static function validate(
         array $locales,
         array $schemaFields,
         array $recordFields,
+        array $recordEdges,
     ): array {
         $errors = [];
         foreach ($schemaFields as $schemaField) {
-            $res = static::validateField("main", $schemaField, $recordFields);
+            $res = static::validateField(
+                "main",
+                $schemaField,
+                $recordFields,
+                $recordEdges,
+            );
             $errors[] = $res;
             if ($schemaField->translatable) {
                 foreach ($locales as $locale) {
@@ -31,6 +38,7 @@ class RecordValidationModule
                         $locale["id"],
                         $schemaField,
                         $recordFields,
+                        $recordEdges,
                     );
                     $errors[] = $res;
                 }
@@ -47,25 +55,39 @@ class RecordValidationModule
      *
      * @param Field $schemaField
      * @param RecordField[] $recordFields
+     * @param Edge[] $recordEdges
      * @return array
      */
     public static function validateField(
         string $locale,
         Field $schemaField,
         array $recordFields,
+        array $recordEdges,
     ): ?RecordError {
         // General Validations
-        $error = static::validateRequired($locale, $schemaField, $recordFields);
+        $error = static::validateRequired(
+            $locale,
+            $schemaField,
+            $recordFields,
+            $recordEdges,
+        );
+
         if (!empty($error)) {
             return $error;
         }
         // Type specific
+
         $error = match ($schemaField->type) {
             "text" => static::validateText(
                 $locale,
                 $schemaField,
                 $recordFields,
             ),
+            "relation" => static::validateRelation(
+                $locale,
+                $schemaField,
+                $recordEdges,
+            ),
             default => static::validateText(
                 $locale,
                 $schemaField,
@@ -80,16 +102,37 @@ class RecordValidationModule
      *
      * @param Field $schemaField
      * @param RecordField[] $recordFields
+     * @param Edge[] $recordEdges
      * @return ?RecordError
      */
     public static function validateRequired(
         string $locale,
         Field $schemaField,
         array $recordFields,
+        array $recordEdges,
     ): ?RecordError {
         if ($schemaField->required === false) {
             return null;
         }
+        return match ($schemaField->type) {
+            "relation" => static::validateRequiredRelation(
+                $locale,
+                $schemaField,
+                $recordEdges,
+            ),
+            default => static::validateRequiredField(
+                $locale,
+                $schemaField,
+                $recordFields,
+            ),
+        };
+    }
+
+    private static function validateRequiredField(
+        string $locale,
+        Field $schemaField,
+        array $recordFields,
+    ): ?RecordError {
         $recordField = static::findField($recordFields, $schemaField, $locale);
 
         if (empty($recordField) || empty($recordField->value)) {
@@ -102,6 +145,27 @@ class RecordValidationModule
 
         return null;
     }
+    private static function validateRequiredRelation(
+        string $locale,
+        Field $schemaField,
+        array $recordEdges,
+    ): ?RecordError {
+        if (
+            collect($recordEdges)
+                ->where("fieldId", $schemaField->id)
+                ->where("locale", $locale)
+                ->where("mode", RecordMode::DRAFT)
+                ->isEmpty()
+        ) {
+            return new RecordError(
+                $schemaField->id,
+                $locale,
+                "This field is required",
+            );
+        }
+
+        return null;
+    }
 
     /**
      *
@@ -151,6 +215,45 @@ class RecordValidationModule
         return null;
     }
 
+    /**
+     *
+     * @param Field $schemaField
+     * @param Edge[] $recordEdges
+     * @return ?RecordError
+     */
+    public static function validateRelation(
+        string $locale,
+        Field $schemaField,
+        array $recordEdges,
+    ): ?RecordError {
+        $count = collect($recordEdges)
+            ->where("fieldId", $schemaField->id)
+            ->where("locale", $locale)
+            ->where("mode", RecordMode::DRAFT)
+            ->count();
+
+        if ($schemaField->props->min > 0) {
+            if ($count < $schemaField->props->min) {
+                return new RecordError(
+                    $schemaField->id,
+                    $locale,
+                    "You have to have at least {$schemaField->props->min} related records",
+                );
+            }
+        }
+        if ($schemaField->props->max > 0) {
+            if ($count > $schemaField->props->max) {
+                return new RecordError(
+                    $schemaField->id,
+                    $locale,
+                    "You have to have at most {$schemaField->props->max} related records",
+                );
+            }
+        }
+
+        return null;
+    }
+
     private static function findField(
         array $recordFields,
         Field $schemaField,