refactor(database): support relation-only updates

Author: innocenzi

packages/database/src/Builder/QueryBuilders/UpdateQueryBuilder.php

@@ -63,7 +63,14 @@ public function __construct(
      */
     public function execute(mixed ...$bindings): ?PrimaryKey
     {
-        $result = $this->build()->execute(...$bindings);
+        // For relation-only updates, we need to resolve values to set up
+        // callbacks but we won't actually execute an UPDATE statement.
+        if ($this->hasOnlyRelationUpdates()) {
+            $this->resolveValuesToUpdate();
+            $result = $this->primaryKeyForRelations;
+        } else {
+            $result = $this->build()->execute(...$bindings);
+        }
 
         // Execute after callbacks for relation updates
         if ($this->model->hasPrimaryKey() && $this->after !== [] && $this->primaryKeyForRelations !== null) {
@@ -121,7 +128,7 @@ public function toRawSql(): ImmutableString
 
     public function build(mixed ...$bindings): Query
     {
-        $values = $this->resolveValues();
+        $values = $this->resolveValuesToUpdate();
 
         if ($this->model->hasPrimaryKey()) {
             unset($values[$this->model->getPrimaryKey()]);
@@ -148,7 +155,7 @@ public function build(mixed ...$bindings): Query
         return new Query($this->update, $allBindings)->onDatabase($this->onDatabase);
     }
 
-    private function resolveValues(): ImmutableArray
+    private function resolveValuesToUpdate(): ImmutableArray
     {
         if ($this->hasRelationUpdates()) {
             $this->validateRelationUpdateConstraints();
@@ -527,6 +534,21 @@ public function where(string $field, mixed $value, string|WhereOperator $operato
         return $this;
     }
 
+    private function hasOnlyRelationUpdates(): bool
+    {
+        if (! $this->hasRelationUpdates()) {
+            return false;
+        }
+
+        foreach (array_keys($this->values) as $field) {
+            if (! $this->isRelationField($field)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     private function hasRelationUpdates(): bool
     {
         foreach (array_keys($this->values) as $field) {

packages/database/src/IsDatabaseModel.php

@@ -205,7 +205,7 @@ public function load(string ...$relations): self
     }
 
     /**
-     * Saves the model to the database.
+     * Saves the model to the database. If the model has no primary key, this method always inserts.
      */
     public function save(): self
     {
@@ -250,17 +250,23 @@ public function save(): self
      */
     public function update(mixed ...$params): self
     {
-        inspect(self::class)->validate(...$params);
+        $model = inspect($this);
 
-        foreach ($params as $key => $value) {
-            $this->{$key} = $value;
+        if (! $model->hasPrimaryKey()) {
+            throw Exceptions\ModelDidNotHavePrimaryColumn::neededForMethod($this, 'update');
         }
 
+        $model->validate(...$params);
+
         query($this)
             ->update(...$params)
-            ->build()
+            ->where($model->getPrimaryKey(), $model->getPrimaryKeyValue())
             ->execute();
 
+        foreach ($params as $key => $value) {
+            $this->{$key} = $value;
+        }
+
         return $this;
     }
 

tests/Integration/Database/Builder/IsDatabaseModelTest.php

@@ -658,7 +658,7 @@ public function test_model_create_with_has_many_relations(): void
         $this->assertInstanceOf(PrimaryKey::class, $user->id);
 
         $posts = TestPost::select()
-            ->where('testuser_id', $user->id->value)
+            ->where('test_user_id', $user->id->value)
             ->all();
 
         $this->assertCount(2, $posts);
@@ -667,6 +667,29 @@ public function test_model_create_with_has_many_relations(): void
         $this->assertSame('foo', $posts[1]->title);
         $this->assertSame('bar', $posts[1]->body);
     }
+
+    public function test_model_update_with_only_relations(): void
+    {
+        $this->migrate(
+            CreateMigrationsTable::class,
+            CreateTestUserMigration::class,
+            CreateTestPostMigration::class,
+        );
+
+        $user = TestUser::create(name: 'Frieren');
+        $user->update(posts: [
+            new TestPost('hello', 'world'),
+        ]);
+
+        $posts = TestPost::select()
+            ->where('test_user_id', $user->id->value)
+            ->all();
+
+        $this->assertCount(1, $posts);
+        $this->assertSame('hello', $posts[0]->title);
+        $this->assertSame('world', $posts[0]->body);
+        $this->assertSame('Frieren', $user->name); // Ensure name wasn't changed
+    }
 }
 
 final class Foo
@@ -1048,7 +1071,7 @@ final class CreateTestUserMigration implements DatabaseMigration
 
     public function up(): QueryStatement
     {
-        return CreateTableStatement::forModel(TestUser::class)
+        return new CreateTableStatement('test_users')
             ->primary()
             ->text('name');
     }
@@ -1065,9 +1088,9 @@ final class CreateTestPostMigration implements DatabaseMigration
 
     public function up(): QueryStatement
     {
-        return CreateTableStatement::forModel(TestPost::class)
+        return new CreateTableStatement('test_posts')
             ->primary()
-            ->belongsTo('test_posts.testuser_id', 'test_users.id')
+            ->foreignId('test_user_id', constrainedOn: 'test_users')
             ->string('title')
             ->text('body');
     }