Merge branch 'develop' into release

Added model, create and required/optional to repository

src/Alias/Model.php

@@ -1,20 +1,20 @@
 <?php
 namespace ProVM\Alias;
 
-use ProVM\Concept\Model\Factory;
+use ProVM\Concept\Model\Repository;
 use ProVM\Concept\Model as ModelInterface;
 
 abstract class Model implements ModelInterface
 {
-    protected Factory $factory;
-    public function setFactory(Factory $factory): ModelInterface
+    protected Repository $repository;
+    public function setRepository(Repository $repository): ModelInterface
     {
-        $this->factory = $factory;
+        $this->repository = $repository;
         return $this;
     }
-    public function getFactory(): Factory
+    public function getRepository(): Repository
     {
-        return $this->factory;
+        return $this->repository;
     }
     protected int $id;
     public function setId(int $id): ModelInterface
@@ -50,7 +50,7 @@ abstract class Model implements ModelInterface
     public function save(): void
     {
         if ($this->isDirty()) {
-            $this->getFactory()->get(get_class($this))->save($this);
+            $this->getRepository()->save($this);
         }
     }
     public function edit(array $data): void
@@ -61,4 +61,29 @@ abstract class Model implements ModelInterface
         }
         $this->isDirty();
     }
+    public function delete(): void
+    {
+        $this->getRepository()->delete($this);
+    }
+
+    public function jsonSerialize(): mixed
+    {
+        $obj = new \ReflectionObject($this);
+        $methods = $obj->getMethods();
+        $output = [];
+        foreach ($methods as $method) {
+            if (!str_contains($method->getName(), 'get')) {
+                continue;
+            }
+            if ($method->getName() === 'getRepository') {
+                continue;
+            }
+            $p = strtolower(preg_replace('/(?<!^)[A-Z]/', '_$0', str_replace('get', '', $method->getName())));
+            if (!isset($this->{$p})) {
+                continue;
+            }
+            $output[$p] = $this->{$method->getName()}();
+        }
+        return $output;
+    }
 }

src/Alias/Model/Mapping.php

@@ -0,0 +1,63 @@
+<?php
+namespace ProVM\Alias\Model;
+
+use ProVM\Concept\Model;
+
+abstract class Mapping implements \ProVM\Concept\Model\Mapping
+{
+    protected string $input;
+    protected string $output;
+    protected \Closure $transformation;
+
+    public function getInputName(): string
+    {
+        return $this->input;
+    }
+    public function getOutputName(): string
+    {
+        return $this->output;
+    }
+    public function getTransformation(): callable
+    {
+        return $this->transformation;
+    }
+
+    public function setInputName(string $input): \ProVM\Concept\Model\Mapping
+    {
+        $this->input = $input;
+        return $this;
+    }
+    public function setOutputName(string $output): \ProVM\Concept\Model\Mapping
+    {
+        $this->output = $output;
+        return $this;
+    }
+    public function setTransformation(callable $transformation): \ProVM\Concept\Model\Mapping
+    {
+        $this->transformation = $transformation;
+        return $this;
+    }
+
+    public function __invoke(mixed $input, mixed &$output, ?array $params = null): void
+    {
+        if (is_array($input)) {
+            $input_value = $input[$this->getInputName()];
+        }
+        if (is_a($input, Model::class)) {
+            $input_value = $input->{$this->getInputName()}();
+        }
+
+        $args = [$input_value];
+        if ($params !== null) {
+            $args = array_merge($args, $params);
+        }
+        $output_value = call_user_func_array($this->getTransformation(), $args);
+
+        if (is_array($output)) {
+            $output[$this->getOutputName()] = $output_value;
+        }
+        if (is_a($output, Model::class)) {
+            $output->{$this->getOutputName()}($output_value);
+        }
+    }
+}

src/Alias/Model/Repository.php

@@ -5,6 +5,7 @@ use ProVM\Concept\Database\Connection;
 use ProVM\Concept\Database\QueryBuilder;
 use ProVM\Concept\Model;
 use ProVM\Concept\Model\Factory;
+use ProVM\Concept\Model\Mapping;
 use ProVM\Concept\Model\Repository as RepositoryInterface;
 
 abstract class Repository implements RepositoryInterface
@@ -47,6 +48,22 @@ abstract class Repository implements RepositoryInterface
     {
         return $this->factory;
     }
+    protected string $model;
+    public function setModel(string $model_class): RepositoryInterface
+    {
+        $this->model = $model_class;
+        return $this;
+    }
+    public function getModel(): string
+    {
+        return $this->model;
+    }
+    public function getNewModel(): Model
+    {
+        $class = $this->getModel();
+        return (new $class())
+            ->setRepository($this);
+    }
     protected string $table;
     public function setTable(string $table): RepositoryInterface
     {
@@ -57,6 +74,40 @@ abstract class Repository implements RepositoryInterface
     {
         return $this->table;
     }
+    protected array $column_mappings;
+    protected array $property_mappings;
+    public function getColumnMappings(): array
+    {
+        return $this->column_mappings;
+    }
+    public function addColumnMapping(Mapping $mapping): RepositoryInterface
+    {
+        $this->column_mappings []= $mapping;
+        return $this;
+    }
+    public function setColumnMappings(array $mappings): RepositoryInterface
+    {
+        foreach ($mappings as $mapping) {
+            $this->addColumnMapping($mapping);
+        }
+        return $this;
+    }
+    public function getPropertyMappings(): array
+    {
+        return $this->property_mappings;
+    }
+    public function addPropertyMapping(Mapping $mapping): Repository
+    {
+        $this->property_mappings []= $mapping;
+        return $this;
+    }
+    public function setPropertyMappings(array $mappings): Repository
+    {
+        foreach ($mappings as $mapping) {
+            $this->addPropertyMapping($mapping);
+        }
+        return $this;
+    }
     protected array $columns;
     public function setColumns(array $columns): RepositoryInterface
     {
@@ -74,40 +125,159 @@ abstract class Repository implements RepositoryInterface
     {
         return $this->columns;
     }
+    protected array $properties;
+    public function getProperties(): array
+    {
+        return $this->properties;
+    }
+    public function addProperty(string $property): RepositoryInterface
+    {
+        $this->properties []= $property;
+        return $this;
+    }
+    public function setProperties(array $properties): RepositoryInterface
+    {
+        foreach ($properties as $property) {
+            $this->addProperty($property);
+        }
+        return $this;
+    }
+    protected array $required;
+    public function setRequired(array $columns): RepositoryInterface
+    {
+        foreach ($columns as $item) {
+            $this->addRequired($item);
+        }
+        return $this;
+    }
+    public function addRequired(string $column): RepositoryInterface
+    {
+        $this->required []= $column;
+        return $this;
+    }
+    public function getRequired(): array
+    {
+        if (isset($this->optional) and !isset($this->required)) {
+            return array_diff($this->getColumns(), $this->getOptional());
+        }
+        return $this->required ?? $this->getColumns();
+    }
+    protected array $optional;
+    public function setOptional(array $columns): RepositoryInterface
+    {
+        foreach ($columns as $item) {
+            $this->addColumn($item);
+        }
+        return $this;
+    }
+    public function addOptional(string $column): RepositoryInterface
+    {
+        $this->optional []= $column;
+        return $this;
+    }
+    public function getOptional(): array
+    {
+        if (isset($this->required) and !isset($this->optional)) {
+            return array_diff($this->getColumns(), $this->getRequired());
+        }
+        return $this->optional ?? [];
+    }
 
+    public function getMethod(string $property, bool $get = true): string
+    {
+        $m = str_replace(' ', '', ucwords(str_replace('_', ' ', $property)));
+        if ($get) {
+            return "get{$m}";
+        }
+        return "set{$m}";
+    }
+    public function getProperty(string $method): string
+    {
+        $parts = preg_split('/(?=[A-Z])/', $method);
+        if (in_array(strtolower($parts[0]), ['get', 'set'])) {
+            array_shift($parts);
+        }
+        return strtolower(implode('_', $parts));
+    }
+    public function fillData(Model $model, array $data): Model
+    {
+        foreach ($this->getPropertyMappings() as $mapping) {
+            $mapping($data, $model);
+        }
+        return $model;
+    }
+    public function mapArray(Model $model, array $data): array
+    {
+        foreach ($this->getColumnMappings() as $mapping) {
+            $mapping($model, $data);
+        }
+        return $data;
+    }
+    public function load(array $data): Model
+    {
+        return $this->fillData($this->getNewModel()
+            ->setId($data['id']), $data);
+    }
     public function save(Model $model): void
     {
         if (!$model->isDirty() and !$model->isNew()) {
             return;
         }
-        $cols = [];
-        $values = [];
-        foreach ($this->getColumns() as $column) {
-            $m = 'get' . ucwords($column);
-            $cols []= '?';
-            $values []= $model->{$m}();
+        if (!$model->isNew()) {
+            $this->update($model);
+            return;
         }
+        $values = array_replace(array_flip($this->getColumns()), $this->mapArray($model, []));
+        $cols = array_fill(0, count($values), '?');
         $query = $this->getQueryBuilder()->insert($this->getTable())->columns($this->getColumns())->values($cols);
+        $this->getConnection()->execute($query, array_values($values));
+    }
+    public function update(Model $model): void
+    {
+        if (!$model->isDirty() and !$model->isNew()) {
+            return;
+        }
+        $values = $this->mapArray($model, []);
+        $cols = array_map(function($column) {
+            return "{$column} = ?";
+        }, $values);
+        $values = array_values($values);
+        $values []= $model->getId();
+        $query = $this->getQueryBuilder()->update($this->getTable())->set($cols)->where(['id = ?']);
         $this->getConnection()->execute($query, $values);
     }
+    public function create(array $data): Model
+    {
+        return $this->fillData($this->getNewModel()
+            ->setNew(), $data);
+    }
     public function edit(Model $model, array $data): Model
     {
         foreach ($this->getColumns() as $col) {
             if (isset($data[$col])) {
-                $m = 'set' . ucwords($col);
+                $m = $this->getMethod($col, false);
+                if (!method_exists($model, $m)) {
+                    continue;
+                }
                 $model->{$m}($data[$col]);
             }
         }
         return $model;
     }
+    public function delete(Model $model): void
+    {
+        $query = $this->getQueryBuilder()->delete($this->getTable())->where(['id = ?']);
+        $this->getConnection()->execute($query, [$model->getId()]);
+    }
+
     public function fetchById(int $id): Model
     {
         $query = $this->getQueryBuilder()
             ->select()
             ->from($this->getTable())
-            ->where([['id', '?']])
+            ->where(['id = ?'])
             ->limit(1);
-        return $this->load($this->getConnection()->execute($query, [$id])->getAsArray()[0]);
+        return $this->load($this->getConnection()->execute($query, [$id])->getFirstAsArray());
     }
     public function fetchAll(): array
     {

src/Concept/Model.php

@@ -1,12 +1,13 @@
 <?php
 namespace ProVM\Concept;
 
-use ProVM\Concept\Model\Factory;
+use JsonSerializable;
+use ProVM\Concept\Model\Repository;
 
-interface Model
+interface Model extends JsonSerializable
 {
-    public function setFactory(Factory $factory): Model;
-    public function getFactory(): Factory;
+    public function setRepository(Repository $factory): Model;
+    public function getRepository(): Repository;
     public function setId(int $id): Model;
     public function getId(): int;
     public function setNew(): Model;
@@ -15,4 +16,5 @@ interface Model
     public function isDirty(): bool;
     public function save(): void;
     public function edit(array $data): void;
+    public function delete(): void;
 }

src/Concept/Model/Factory.php

@@ -1,13 +1,48 @@
 <?php
 namespace ProVM\Concept\Model;
 
+use ProVM\Concept\Model;
 use Psr\Container\ContainerInterface;
 
 interface Factory
 {
+    /**
+     * @param ContainerInterface $container
+     * @return Factory
+     */
     public function setContainer(ContainerInterface $container): Factory;
+
+    /**
+     * @return ContainerInterface
+     */
     public function getContainer(): ContainerInterface;
-    public function setNamespace(string $namespace): Factory;
-    public function getNamespace(): string;
-    public function get(string $repository_name): Repository;
+
+    /**
+     * Get Repository by class
+     * @param string $repository_class
+     * @return Repository
+     */
+    public function get(string $repository_class): Repository;
+
+    /**
+     * Get Repository by Model class
+     * @param string $model_class
+     * @return Repository
+     */
+    public function getByModel(string $model_class): Repository;
+
+    /**
+     * Fetch Model by Id
+     * @param string $model_class
+     * @param int $id
+     * @return Model
+     */
+    public function fetchById(string $model_class, int $id): Model;
+
+    /**
+     * Fetch all Models
+     * @param string $model_class
+     * @return array
+     */
+    public function fetchAll(string $model_class): array;
 }

src/Concept/Model/Mapping.php

@@ -0,0 +1,13 @@
+<?php
+namespace ProVM\Concept\Model;
+
+interface Mapping
+{
+    public function getInputName(): string;
+    public function getOutputName(): string;
+    public function getTransformation(): callable;
+    public function setInputName(string $input): Mapping;
+    public function setOutputName(string $output): Mapping;
+    public function setTransformation(callable $transformation): Mapping;
+    public function __invoke(mixed $input, mixed &$output, ?array $params = null): mixed;
+}

src/Concept/Model/Repository.php

@@ -7,22 +7,274 @@ use ProVM\Concept\Model;
 
 interface Repository
 {
+    /**
+     * @param Connection $connection
+     * @return Repository
+     */
     public function setConnection(Connection $connection): Repository;
+
+    /**
+     * @return Connection
+     */
     public function getConnection(): Connection;
+
+    /**
+     * @param QueryBuilder $builder
+     * @return Repository
+     */
     public function setQueryBuilder(QueryBuilder $builder): Repository;
+
+    /**
+     * @return QueryBuilder
+     */
     public function getQueryBuilder(): QueryBuilder;
+
+    /**
+     * @param Factory $factory
+     * @return Repository
+     */
     public function setFactory(Factory $factory): Repository;
+
+    /**
+     * @return Factory
+     */
     public function getFactory(): Factory;
+
+    /**
+     * @param string $model_class
+     * @return Repository
+     */
+    public function setModel(string $model_class): Repository;
+
+    /**
+     * @return string
+     */
+    public function getModel(): string;
+
+    /**
+     * Get clean empty Model
+     * @return Model
+     */
+    public function getNewModel(): Model;
+
+    /**
+     * Set up the Repository
+     * SHOULD CALL
+     *      setTable
+     *      setColumns [setRequired, setOptional]
+     *      setProperties
+     *      setMapping
+     *      setModel
+     * @return Repository
+     */
     public function setup(): Repository;
-    public function setTable(string $table): Repository;
+
+    /**
+     * @return string
+     */
     public function getTable(): string;
+
+    /**
+     * @param string $table
+     * @return Repository
+     */
+    public function setTable(string $table): Repository;
+
+    /**
+     * @return array
+     */
+    public function getColumnMappings(): array;
+
+    /**
+     * @param Mapping $mapping
+     * @return Repository
+     */
+    public function addColumnMapping(Mapping $mapping): Repository;
+
+    /**
+     * @param array $mappings
+     * @return Repository
+     */
+    public function setColumnMappings(array $mappings): Repository;
+
+    /**
+     * @return array
+     */
+    public function getPropertyMappings(): array;
+
+    /**
+     * @param Mapping $mapping
+     * @return Repository
+     */
+    public function addPropertyMapping(Mapping $mapping): Repository;
+
+    /**
+     * @param array $mappings
+     * @return Repository
+     */
+    public function setPropertyMappings(array $mappings): Repository;
+
+    /**
+     * Set columns in table
+     * @param array $columns
+     * @return Repository
+     */
     public function setColumns(array $columns): Repository;
+
+    /**
+     * @param string $column
+     * @return Repository
+     */
     public function addColumn(string $column): Repository;
+
+    /**
+     * Get table columns
+     * @return array
+     */
     public function getColumns(): array;
+
+    /**
+     * Get Model properties
+     * @return array
+     */
+    public function getProperties(): array;
+
+    /**
+     * @param string $property
+     * @param $value
+     * @return Repository
+     */
+    public function addProperty(string $property): Repository;
+
+    /**
+     * Set Model properties
+     * @param array $properties
+     * @return Repository
+     */
+    public function setProperties(array $properties): Repository;
+
+    /**
+     * Set required columns
+     * Optional
+     * @param array $columns
+     * @return Repository
+     */
+    public function setRequired(array $columns): Repository;
+
+    /**
+     * @param string $column
+     * @return Repository
+     */
+    public function addRequired(string $column): Repository;
+
+    /**
+     * Get required columns
+     * @return array
+     */
+    public function getRequired(): array;
+
+    /**
+     * Set optional columns
+     * @param array $columns
+     * @return Repository
+     */
+    public function setOptional(array $columns): Repository;
+
+    /**
+     * @param string $column
+     * @return Repository
+     */
+    public function addOptional(string $column): Repository;
+
+    /**
+     * Get optional columns
+     * @return array
+     */
+    public function getOptional(): array;
+
+    /**
+     * Get Model method
+     * @param string $property
+     * @param bool $get
+     * @return string
+     */
+    public function getMethod(string $property, bool $get = true): string;
+
+    /**
+     * @param string $method
+     * @return string
+     */
+    public function getProperty(string $method): string;
+
+    /**
+     * Fill empty Model with data
+     * @param Model $model
+     * @param array $data
+     * @return Model
+     */
+    public function fillData(Model $model, array $data): Model;
+
+    /**
+     * Fill data array with Model values. Accepts a preset data array
+     * @param Model $model
+     * @param array $data
+     * @return array
+     */
+    public function mapArray(Model $model, array $data): array;
+
+    /**
+     * Transform result array to Model
+     * @param array $data
+     * @return Model
+     */
     public function load(array $data): Model;
+
+    /**
+     * Save Model to table
+     * @param Model $model
+     * @return void
+     */
     public function save(Model $model): void;
-    public function edit(Model $model, array $data): Model;
+
+    /**
+     * Update table value with Model
+     * @param Model $model
+     * @return void
+     */
+    public function update(Model $model): void;
+
+    /**
+     * Create new Model with data
+     * @param array $data
+     * @return Model
+     */
     public function create(array $data): Model;
+
+    /**
+     * Edit Model with data
+     * @param Model $model
+     * @param array $data
+     * @return Model
+     */
+    public function edit(Model $model, array $data): Model;
+
+    /**
+     * Delete Model from table
+     * @param Model $model
+     * @return void
+     */
+    public function delete(Model $model): void;
+
+    /**
+     * Fetch Model by Id
+     * @param int $id
+     * @return Model
+     */
     public function fetchById(int $id): Model;
+
+    /**
+     * Fetch all Models
+     * @return array
+     */
     public function fetchAll(): array;
 }

src/Implement/Model/Factory.php

@@ -1,6 +1,7 @@
 <?php
 namespace ProVM\Implement\Model;
 
+use ProVM\Concept\Model;
 use Psr\Container\ContainerInterface;
 use ProVM\Concept\Model\Factory as FactoryInterface;
 use ProVM\Concept\Model\Repository;
@@ -22,25 +23,22 @@ class Factory implements FactoryInterface
     {
         return $this->container;
     }
-    protected string $namespace;
-    public function setNamespace(string $namespace): FactoryInterface
+    public function get(string $repository_class): Repository
     {
-        $this->namespace = $namespace;
-        return $this;
+        return $this->getContainer()->get($repository_class);
     }
-    public function getNamespace(): string
+    public function getByModel(string $model_class): Repository
     {
-        return $this->namespace;
+        $class = str_replace('Model', 'Repository', $model_class);
+        return $this->get($class);
     }
-    protected function buildRepository(string $repository_name): string
+
+    public function fetchById(string $model_class, int $id): Model
     {
-        return implode("\\", [
-            $this->getNamespace(),
-            $repository_name
-        ]);
+        return $this->getByModel($model_class)->fetchById($id);
     }
-    public function get(string $repository_name): Repository
+    public function fetchAll(string $model_class): array
     {
-        return $this->getContainer()->get($this->buildRepository($repository_name));
+        return $this->getByModel($model_class)->fetchAll();
     }
 }

src/Implement/Model/Mapping/Basic.php

@@ -0,0 +1,16 @@
+<?php
+namespace ProVM\Implement\Model\Mapping;
+
+use ProVM\Alias\Model\Mapping;
+
+class Basic extends Mapping
+{
+    public function __construct(string $input, string $output)
+    {
+        $this->setInputName($input)
+            ->setOutputName($output)
+            ->setTransformation(function($item) {
+                return $item;
+            });
+    }
+}