validate supported write relations

Author: michalsn

src/Exceptions/NestedModelException.php

@@ -32,4 +32,9 @@ public static function forIncorrectReturnType(string $name): static
     {
         return new self(lang('NestedModel.incorrectReturnType', [$name]));
     }
+
+    public static function forRelationDoesNotSupportWrite(): static
+    {
+        return new self(lang('NestedModel.relationDoesNotSupportWrite'));
+    }
 }

src/Language/en/NestedModel.php

@@ -1,9 +1,10 @@
 <?php
 
 return [
-    'methodNotSupported'        => 'This method is not supported for the "{0}" relation.',
-    'parentRelationNotDeclared' => 'Parent relation "{0}" has not been declared yet.',
-    'relationNotDefined'        => 'Relation "{0}" is not defined.',
-    'missingReturnType'         => 'Method "{0}()" is missing a required return type declaration.',
-    'incorrectReturnType'       => 'Method "{0}()" returned an incorrect type.',
+    'methodNotSupported'          => 'This method is not supported for the "{0}" relation.',
+    'parentRelationNotDeclared'   => 'Parent relation "{0}" has not been declared yet.',
+    'relationNotDefined'          => 'Relation "{0}" is not defined.',
+    'missingReturnType'           => 'Method "{0}()" is missing a required return type declaration.',
+    'incorrectReturnType'         => 'Method "{0}()" returned an incorrect type.',
+    'relationDoesNotSupportWrite' => 'This type of relation does not support write.',
 ];

src/Traits/HasRelations.php

@@ -39,6 +39,9 @@ protected function initRelations(): void
         helper('inflector');
     }
 
+    /**
+     * Set the relation to use.
+     */
     public function with(string $relation, ?Closure $closure = null): static
     {
         if (str_contains($relation, '.')) {
@@ -64,6 +67,9 @@ public function with(string $relation, ?Closure $closure = null): static
         return $this;
     }
 
+    /**
+     * Validate relation definition.
+     */
     private function checkReturnType(string $methodName): bool
     {
         if (! method_exists($this, $methodName)) {
@@ -183,12 +189,18 @@ public function belongsToMany(Model|string $model, ?string $pivotTable = null, ?
             ->setMany($pivotTable, $pivotForeignKey, $pivotRelatedKey);
     }
 
+    /**
+     * Return model instance.
+     */
     private function getModelInstance(Model|string $model): Model
     {
         return $model instanceof Model ? $model : model($model);
     }
 
-    private function createPivotTableName($table1, $table2): string
+    /**
+     * Create pivot table name.
+     */
+    private function createPivotTableName(mixed $table1, mixed $table2): string
     {
         $tables = [$table1, $table2];
         sort($tables);
@@ -199,6 +211,8 @@ private function createPivotTableName($table1, $table2): string
     }
 
     /**
+     * Get the caller method name.
+     *
      * @throws ReflectionException
      */
     private function getInitialMethodName(): string
@@ -378,6 +392,9 @@ protected function relationsAfterFind(array $eventData): array
         return $eventData;
     }
 
+    /**
+     * Get relation data for a single item.
+     */
     protected function getDataForRelationById(int|string $id, Relation $relation)
     {
         $relation->applyWith()->applyRelation([$id], $this->primaryKey)->applyConditions();
@@ -389,6 +406,9 @@ protected function getDataForRelationById(int|string $id, Relation $relation)
         return $relation->filterResults($results, $this->tempReturnType);
     }
 
+    /**
+     * Get relation data for many items.
+     */
     protected function getDataForRelationByIds(array $id, Relation $relation): array
     {
         $relation->applyWith()->applyRelation($id, $this->primaryKey)->applyConditions();
@@ -439,6 +459,28 @@ protected function getDataForRelationByIds(array $id, Relation $relation): array
         return $relationData;
     }
 
+    /**
+     * Validate if given relation can be handled during write operation.
+     */
+    protected function validateWriteRelations(): void
+    {
+        if ($this->relations === []) {
+            return;
+        }
+
+        foreach ($this->relations as $relation) {
+            if (
+                ! in_array($relation->type, [RelationTypes::hasOne, RelationTypes::hasMany], true)
+                || (
+                    in_array($relation->type, [RelationTypes::hasOne, RelationTypes::hasMany], true)
+                    && ($relation->hasMany() || $relation->hasThrough())
+                )
+            ) {
+                throw NestedModelException::forRelationDoesNotSupportWrite();
+            }
+        }
+    }
+
     /**
      * Whether to use transaction during insert/update.
      */
@@ -451,6 +493,8 @@ public function useTransactions(bool $value = true): static
 
     public function insert($row = null, bool $returnID = true): bool|int|string
     {
+        $this->validateWriteRelations();
+
         if ($this->useTransactions) {
             try {
                 $this->db->transException(true)->transStart();
@@ -480,6 +524,8 @@ public function insert($row = null, bool $returnID = true): bool|int|string
 
     public function update($id = null, $row = null): bool
     {
+        $this->validateWriteRelations();
+
         if ($this->useTransactions) {
             try {
                 $this->db->transException(true)->transStart();

tests/ExceptionTest.php

@@ -60,4 +60,12 @@ public function testMethodNotSupported(): void
 
         model(UserModel::class)->posts()->latestOfMany();
     }
+
+    public function testNotValidWriteRelation(): void
+    {
+        $this->expectException(NestedModelException::class);
+        $this->expectExceptionMessage('This type of relation does not support write.');
+
+        model(UserModel::class)->with('address')->insert(['what' => 'ever']);
+    }
 }