Use Model for Join write operations

composer.json

@@ -73,6 +73,10 @@
         }
     },
     "config": {
+        "allow-plugins": {
+            "ergebnis/composer-normalize": true,
+            "phpstan/extension-installer": true
+        },
         "sort-packages": true
     }
 }

docs/persistence/sql/queries.rst

@@ -473,11 +473,11 @@ and overwrite this simple method to support expressions like this, for example:
 Joining with other tables
 -------------------------
 
-.. php:method:: join($foreign_table, $master_field, $join_kind)
+.. php:method:: join($foreignTable, $master_field, $join_kind)
 
     Join results with additional table using "JOIN" statement in your query.
 
-    :param string|array $foreign_table: table to join (may include field and alias)
+    :param string|array $foreignTable: table to join (may include field and alias)
     :param mixed  $master_field:  main field (and table) to join on or Expression
     :param string $join_kind:     'left' (default), 'inner', 'right' etc - which join type to use
     :returns: $this

phpstan.neon.dist

@@ -53,9 +53,6 @@ parameters:
         # for src/Persistence/Sql.php
         - '~^Call to an undefined method Atk4\\Data\\Persistence::expr\(\)\.$~'
         - '~^Call to an undefined method Atk4\\Data\\Persistence::exprNow\(\)\.$~'
-        # for src/Persistence/Sql/Join.php
-        - '~^Call to an undefined method Atk4\\Data\\Persistence::initQuery\(\)\.$~'
-        - '~^Call to an undefined method Atk4\\Data\\Persistence::lastInsertId\(\)\.$~'
         # for src/Reference/HasMany.php
         - '~^Call to an undefined method Atk4\\Data\\Model::dsql\(\)\.$~'
         # for tests/FieldTest.php

src/Model.php

@@ -147,7 +147,7 @@ class Model implements \IteratorAggregate
     /** @var array Array of set order by. */
     public $order = [];
 
-    /** @var array Array of WITH cursors set. */
+    /** @var array<string, array{'model': Model, 'mapping': array<int|string, string>, 'recursive': bool}> */
     public $with = [];
 
     /**
@@ -1074,8 +1074,8 @@ public function withId($id)
      */
     public function addWith(self $model, string $alias, array $mapping = [], bool $recursive = false)
     {
-        if (isset($this->with[$alias])) {
-            throw (new Exception('With cursor already set with this alias'))
+        if ($alias === $this->table || $alias === $this->table_alias || isset($this->with[$alias])) {
+            throw (new Exception('With cursor already set with given alias'))
                 ->addMoreInfo('alias', $alias);
         }
 

src/Model/Join.php

@@ -19,7 +19,7 @@
  *
  * @method Model getOwner()
  */
-class Join
+abstract class Join
 {
     use DiContainerTrait;
     use InitializerTrait {
@@ -31,8 +31,7 @@ class Join
     }
 
     /**
-     * Name of the table (or collection) that can be used to retrieve data from.
-     * For SQL, This can also be an expression or sub-select.
+     * Foreign model or WITH/CTE alias when used with SQL persistence.
      *
      * @var string
      */
@@ -120,9 +119,9 @@ class Join
     /** @var array<int, array<string, mixed>> Data indexed by spl_object_id(entity) which is populated here as the save/insert progresses. */
     private $saveBufferByOid = [];
 
-    public function __construct(string $foreign_table = null)
+    public function __construct(string $foreignTable = null)
     {
-        $this->foreign_table = $foreign_table;
+        $this->foreign_table = $foreignTable;
 
         // handle foreign table containing a dot - that will be reverse join
         if (strpos($this->foreign_table, '.') !== false) {
@@ -132,6 +131,42 @@ public function __construct(string $foreign_table = null)
         }
     }
 
+    /**
+     * Create fake foreign model, in the future, this method should be removed
+     * in favor of always requiring an object model.
+     */
+    protected function createFakeForeignModel(): Model
+    {
+        $fakeModel = new Model($this->getOwner()->persistence, [
+            'table' => $this->foreign_table,
+        ]);
+        foreach ($this->getOwner()->getFields() as $ownerField) {
+            if ($ownerField->hasJoin() && $ownerField->getJoin()->short_name === $this->short_name
+                && $ownerField->short_name !== $fakeModel->id_field
+                && $ownerField->short_name !== $this->foreign_field) {
+                $fakeModel->addField($ownerField->short_name, [
+                    'actual' => $ownerField->actual,
+                    'type' => $ownerField->type,
+                ]);
+            }
+        }
+        if ($fakeModel->id_field !== $this->foreign_field && $this->foreign_field !== null) {
+            $fakeModel->addField($this->foreign_field, ['type' => 'integer']);
+        }
+
+        return $fakeModel;
+    }
+
+    public function getForeignModel(): Model
+    {
+        // TODO this should be removed in the future
+        if (!isset($this->getOwner()->with[$this->foreign_table])) {
+            return $this->createFakeForeignModel();
+        }
+
+        return $this->getOwner()->with[$this->foreign_table]['model'];
+    }
+
     /**
      * @param Model $owner
      *
@@ -203,6 +238,8 @@ protected function init(): void
     {
         $this->_init();
 
+        $this->getForeignModel(); // assert valid foreign_table
+
         // owner model should have id_field set
         $id_field = $this->getOwner()->id_field;
         if (!$id_field) {
@@ -236,12 +273,29 @@ protected function init(): void
             }
         }
 
-        $this->onHookToOwnerEntity(Model::HOOK_AFTER_UNLOAD, \Closure::fromCallable([$this, 'afterUnload']));
-
         // if kind is not specified, figure out join type
         if (!$this->kind) {
             $this->kind = $this->weak ? 'left' : 'inner';
         }
+
+        $this->initJoinHooks();
+    }
+
+    protected function initJoinHooks(): void
+    {
+        $this->onHookToOwnerEntity(Model::HOOK_AFTER_UNLOAD, \Closure::fromCallable([$this, 'afterUnload']));
+
+        if ($this->reverse) {
+            $this->onHookToOwnerEntity(Model::HOOK_AFTER_INSERT, \Closure::fromCallable([$this, 'afterInsert']), [], -5);
+            $this->onHookToOwnerEntity(Model::HOOK_BEFORE_UPDATE, \Closure::fromCallable([$this, 'beforeUpdate']), [], -5);
+            $this->onHookToOwnerEntity(Model::HOOK_BEFORE_DELETE, \Closure::fromCallable([$this, 'doDelete']), [], -5);
+        } else {
+            $this->onHookToOwnerEntity(Model::HOOK_BEFORE_INSERT, \Closure::fromCallable([$this, 'beforeInsert']), [], -5);
+            $this->onHookToOwnerEntity(Model::HOOK_BEFORE_UPDATE, \Closure::fromCallable([$this, 'beforeUpdate']), [], -5);
+            $this->onHookToOwnerEntity(Model::HOOK_AFTER_DELETE, \Closure::fromCallable([$this, 'doDelete']));
+
+            $this->onHookToOwnerEntity(Model::HOOK_AFTER_LOAD, \Closure::fromCallable([$this, 'afterLoad']));
+        }
     }
 
     /**
@@ -280,23 +334,23 @@ public function addFields(array $fields = [], array $defaults = [])
      *
      * @param array<string, mixed> $defaults
      */
-    public function join(string $foreign_table, array $defaults = []): self
+    public function join(string $foreignTable, array $defaults = []): self
     {
         $defaults['joinName'] = $this->short_name;
 
-        return $this->getOwner()->join($foreign_table, $defaults);
+        return $this->getOwner()->join($foreignTable, $defaults);
     }
 
     /**
      * Another leftJoin will be attached to a current join.
      *
      * @param array<string, mixed> $defaults
      */
-    public function leftJoin(string $foreign_table, array $defaults = []): self
+    public function leftJoin(string $foreignTable, array $defaults = []): self
     {
         $defaults['joinName'] = $this->short_name;
 
-        return $this->getOwner()->leftJoin($foreign_table, $defaults);
+        return $this->getOwner()->leftJoin($foreignTable, $defaults);
     }
 
     /**
@@ -452,12 +506,100 @@ public function setSaveBufferValue(Model $entity, string $fieldName, $value): vo
         $this->saveBufferByOid[spl_object_id($entity)][$fieldName] = $value;
     }
 
-    /**
-     * Clears id and save buffer.
-     */
     protected function afterUnload(Model $entity): void
     {
         $this->unsetId($entity);
         $this->unsetSaveBuffer($entity);
     }
+
+    abstract public function afterLoad(Model $entity): void;
+
+    public function beforeInsert(Model $entity, array &$data): void
+    {
+        if ($this->weak) {
+            return;
+        }
+
+        $model = $this->getOwner();
+
+        // the value for the master_field is set, so we are going to use existing record anyway
+        if ($model->hasField($this->master_field) && $entity->get($this->master_field) !== null) {
+            return;
+        }
+
+        $foreignModel = $this->getForeignModel();
+        $foreignEntity = $foreignModel->createEntity()
+            ->setMulti($this->getAndUnsetSaveBuffer($entity))
+            /*->set($this->foreign_field, null)*/;
+        $foreignEntity->save();
+
+        $this->setId($entity, $foreignEntity->getId());
+
+        if ($this->hasJoin()) {
+            $this->getJoin()->setSaveBufferValue($entity, $this->master_field, $this->getId($entity));
+        } else {
+            $data[$this->master_field] = $this->getId($entity);
+        }
+
+        // $entity->set($this->master_field, $this->getId($entity));
+    }
+
+    public function afterInsert(Model $entity): void
+    {
+        if ($this->weak) {
+            return;
+        }
+
+        $this->setSaveBufferValue($entity, $this->foreign_field, $this->hasJoin() ? $this->getJoin()->getId($entity) : $entity->getId()); // from array persistence...
+
+        $foreignModel = $this->getForeignModel();
+        $foreignEntity = $foreignModel->createEntity()
+            ->setMulti($this->getAndUnsetSaveBuffer($entity))
+            ->set($this->foreign_field, $this->hasJoin() ? $this->getJoin()->getId($entity) : $entity->getId());
+        $foreignEntity->save();
+
+        $this->setId($entity, $entity->getId()); // TODO why is this here? it seems to be not needed
+    }
+
+    public function beforeUpdate(Model $entity, array &$data): void
+    {
+        if ($this->weak) {
+            return;
+        }
+
+        if (!$this->issetSaveBuffer($entity)) {
+            return;
+        }
+
+        $foreignModel = $this->getForeignModel();
+        $foreignId = $this->reverse ? $entity->getId() : $entity->get($this->master_field);
+        $saveBuffer = $this->getAndUnsetSaveBuffer($entity);
+        $foreignModel->atomic(function () use ($foreignModel, $foreignId, $saveBuffer) {
+            $foreignModel = (clone $foreignModel)->addCondition($this->foreign_field, $foreignId);
+            foreach ($foreignModel as $foreignEntity) {
+                $foreignEntity->setMulti($saveBuffer);
+                $foreignEntity->save();
+            }
+        });
+
+        // $this->setId($entity, ??); // TODO needed? from array persistence
+    }
+
+    public function doDelete(Model $entity): void
+    {
+        if ($this->weak) {
+            return;
+        }
+
+        $foreignModel = $this->getForeignModel();
+        $foreignId = $this->reverse ? $entity->getId() : $entity->get($this->master_field);
+        $foreignModel->atomic(function () use ($foreignModel, $foreignId) {
+            $foreignModel = (clone $foreignModel)->addCondition($this->foreign_field, $foreignId);
+            foreach ($foreignModel as $foreignEntity) {
+                $foreignEntity->delete();
+            }
+        });
+
+        $this->unsetId($entity); // TODO needed? from array persistence
+    }
 }

src/Persistence/Array_.php

@@ -214,20 +214,21 @@ public function tryLoad(Model $model, $id): ?array
     {
         if ($id === self::ID_LOAD_ONE || $id === self::ID_LOAD_ANY) {
             $action = $this->action($model, 'select');
-            $action->generator->rewind(); // TODO needed for some reasons!
 
-            $selectRow = $action->getRow();
-            if ($selectRow === null) {
+            $action->limit($id === self::ID_LOAD_ANY ? 1 : 2);
+
+            $rowsRaw = $action->getRows();
+            if (count($rowsRaw) === 0) {
                 return null;
-            } elseif ($id === self::ID_LOAD_ONE && $action->getRow() !== null) {
+            } elseif (count($rowsRaw) !== 1) {
                 throw (new Exception('Ambiguous conditions, more than one record can be loaded.'))
                     ->addMoreInfo('model', $model)
                     ->addMoreInfo('id', null);
             }
 
-            $id = $selectRow[$model->id_field];
+            $idRaw = reset($rowsRaw)[$model->id_field];
 
-            $row = $this->tryLoad($model, $id);
+            $row = $this->tryLoad($model, $idRaw);
 
             return $row;
         }
@@ -238,7 +239,6 @@ public function tryLoad(Model $model, $id): ?array
             $condition->key = $model->getField($model->id_field);
             $condition->setOwner($model->createEntity()); // TODO needed for typecasting to apply
             $action->filter($condition);
-            $action->generator->rewind(); // TODO needed for some reasons!
 
             $rowData = $action->getRow();
             if ($rowData === null) {