Basic models using data mapper

CHANGELOG.md

@@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [v0.4.0 (2024-09-27)](https://github.com/phenixphp/framework/compare/0.3.8...0.4.0)
 
 ### Added
+- Integrate CORS middleware. ([#30](https://github.com/phenixphp/framework/pull/30))
+- Add basic form request. ([#31](https://github.com/phenixphp/framework/pull/31))
 - Basic validation layer using form request. ([#32](https://github.com/phenixphp/framework/pull/32))
 - Stream form parser. ([#33](https://github.com/phenixphp/framework/pull/33))
 - Move validation layer to framework. ([#34](https://github.com/phenixphp/framework/pull/34))

src/Configurations/Cors.php

@@ -8,12 +8,12 @@
 
 class Cors extends Configuration
 {
-    public readonly array|string $origins;
-    public readonly array $allowedMethods;
-    public readonly int $maxAge;
-    public readonly array $allowedHeaders;
-    public readonly array $exposableHeaders;
-    public readonly bool $allowCredentials;
+    protected array|string $origins;
+    protected array $allowedMethods;
+    protected int $maxAge;
+    protected array $allowedHeaders;
+    protected array $exposableHeaders;
+    protected bool $allowCredentials;
 
     public function __construct(array $config)
     {

src/Contracts/Database/ModelAttribute.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Contracts\Database;
+
+interface ModelAttribute
+{
+    public function getColumnName(): string|null;
+}

src/Data/Collection.php

@@ -8,6 +8,8 @@
 use Ramsey\Collection\Collection as GenericCollection;
 use SplFixedArray;
 
+use function array_key_first;
+
 class Collection extends GenericCollection implements Arrayable
 {
     public static function fromArray(array $data): self
@@ -21,4 +23,15 @@ public static function fromArray(array $data): self
 
         return $collection;
     }
+
+    public function first(): mixed
+    {
+        $firstIndex = array_key_first($this->data);
+
+        if ($firstIndex === null) {
+            return null;
+        }
+
+        return $this->data[$firstIndex];
+    }
 }

src/Database/Concerns/Query/HasSentences.php

@@ -0,0 +1,114 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Concerns\Query;
+
+use Amp\Sql\SqlQueryError;
+use Amp\Sql\SqlTransactionError;
+use League\Uri\Components\Query;
+use League\Uri\Http;
+use Phenix\Database\Constants\Actions;
+use Phenix\Database\Paginator;
+
+trait HasSentences
+{
+    public function paginate(Http $uri,  int $defaultPage = 1, int $defaultPerPage = 15): Paginator
+    {
+        $this->action = Actions::SELECT;
+
+        $query = Query::fromUri($uri);
+
+        $currentPage = filter_var($query->get('page') ?? $defaultPage, FILTER_SANITIZE_NUMBER_INT);
+        $currentPage = $currentPage === false ? $defaultPage : $currentPage;
+
+        $perPage = filter_var($query->get('per_page') ?? $defaultPerPage, FILTER_SANITIZE_NUMBER_INT);
+        $perPage = $perPage === false ? $defaultPerPage : $perPage;
+
+        $countQuery = clone $this;
+
+        $total = $countQuery->count();
+
+        $data = $this->page((int) $currentPage, (int) $perPage)->get();
+
+        return new Paginator($uri, $data, (int) $total, (int) $currentPage, (int) $perPage);
+    }
+
+    public function count(string $column = '*'): int
+    {
+        $this->action = Actions::SELECT;
+
+        $this->countRows($column);
+
+        [$dml, $params] = $this->toSql();
+
+        /** @var array<string, int> $count */
+        $count = $this->connection
+            ->prepare($dml)
+            ->execute($params)
+            ->fetchRow();
+
+        return array_values($count)[0];
+    }
+
+    public function insert(array $data): bool
+    {
+        [$dml, $params] = $this->insertRows($data)->toSql();
+
+        try {
+            $this->connection->prepare($dml)->execute($params);
+
+            return true;
+        } catch (SqlQueryError|SqlTransactionError) {
+            return false;
+        }
+    }
+
+    public function exists(): bool
+    {
+        $this->action = Actions::EXISTS;
+
+        $this->existsRows();
+
+        [$dml, $params] = $this->toSql();
+
+        $results = $this->connection->prepare($dml)->execute($params)->fetchRow();
+
+        return (bool) array_values($results)[0];
+    }
+
+    public function doesntExist(): bool
+    {
+        return ! $this->exists();
+    }
+
+    public function update(array $values): bool
+    {
+        $this->updateRow($values);
+
+        [$dml, $params] = $this->toSql();
+
+        try {
+            $this->connection->prepare($dml)->execute($params);
+
+            return true;
+        } catch (SqlQueryError|SqlTransactionError) {
+            return false;
+        }
+    }
+
+    public function delete(): bool
+    {
+        $this->deleteRows();
+
+        [$dml, $params] = $this->toSql();
+
+        try {
+            $this->connection->prepare($dml)->execute($params);
+
+            return true;
+        } catch (SqlQueryError|SqlTransactionError) {
+            return false;
+        }
+    }
+}

src/Database/Concerns/Query/PrepareColumns.php

@@ -4,24 +4,28 @@
 
 namespace Phenix\Database\Concerns\Query;
 
+use Phenix\Database\Alias;
 use Phenix\Database\Functions;
 use Phenix\Database\SelectCase;
 use Phenix\Database\Subquery;
 use Phenix\Exceptions\QueryError;
 use Phenix\Util\Arr;
 
+use function is_string;
+
 trait PrepareColumns
 {
     protected function prepareColumns(array $columns): string
     {
-        $columns = array_map(function ($column) {
+        $columns = Arr::map($columns, function (string|Functions|SelectCase|Subquery $value, int|string $key): string {
             return match (true) {
-                $column instanceof Functions => (string) $column,
-                $column instanceof SelectCase => (string) $column,
-                $column instanceof Subquery => $this->resolveSubquery($column),
-                default => $column,
+                is_string($key) => (string) Alias::of($key)->as($value),
+                $value instanceof Functions => (string) $value,
+                $value instanceof SelectCase => (string) $value,
+                $value instanceof Subquery => $this->resolveSubquery($value),
+                default => $value,
             };
-        }, $columns);
+        });
 
         return Arr::implodeDeeply($columns, ', ');
     }

src/Database/Constants/IdType.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Constants;
+
+enum IdType
+{
+    case NUMERIC;
+    case STR;
+}

src/Database/Models/Attributes/BelongsTo.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Models\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+readonly class BelongsTo extends Column
+{
+    public function __construct(
+        public string $foreignProperty,
+        public string|null $name = null,
+    ) {
+    }
+}

src/Database/Models/Attributes/BelongsToMany.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Models\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+readonly class BelongsToMany extends Column
+{
+    public function __construct(
+        public string $table,
+        public string $foreignKey,
+        public string $relatedModel,
+        public string $relatedForeignKey,
+    ) {
+    }
+
+    public function getColumnName(): string|null
+    {
+        return null;
+    }
+}

src/Database/Models/Attributes/Column.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Models\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+readonly class Column extends ModelAttribute
+{
+    public function __construct(
+        public string|null $name = null
+    ) {
+    }
+
+    public function getColumnName(): string|null
+    {
+        return $this->name;
+    }
+}

src/Database/Models/Attributes/ForeignKey.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Models\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+readonly class ForeignKey extends Column
+{
+}

src/Database/Models/Attributes/HasMany.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Models\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+readonly class HasMany extends Column
+{
+    public function __construct(
+        public string $model,
+        public string $foreignKey,
+        public bool $chaperone = false,
+    ) {
+    }
+
+    public function getColumnName(): string|null
+    {
+        return null;
+    }
+}

src/Database/Models/Attributes/Id.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Models\Attributes;
+
+use Attribute;
+use Phenix\Database\Constants\IdType;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+readonly class Id extends Column
+{
+    public function __construct(
+        public string|null $name = null,
+        public IdType $idType = IdType::NUMERIC
+    ) {
+    }
+}

src/Database/Models/Attributes/ModelAttribute.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Models\Attributes;
+
+use Phenix\Contracts\Database\ModelAttribute as ModelAttributeContract;
+
+abstract readonly class ModelAttribute implements ModelAttributeContract
+{
+}

src/Database/Models/Collection.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Models;
+
+use Phenix\Data\Collection as DataCollection;
+
+class Collection extends DataCollection
+{
+    public function __construct(array $data = [])
+    {
+        parent::__construct(DatabaseModel::class, $data);
+    }
+
+    public function modelKeys(): array
+    {
+        return $this->reduce(function (array $carry, DatabaseModel $model): array {
+            $carry[] = $model->getKey();
+
+            return $carry;
+        }, []);
+    }
+
+    public function map(callable $callback): self
+    {
+        return new self(array_map($callback, $this->data));
+    }
+
+    public function toArray(): array
+    {
+        return $this->reduce(function (array $carry, DatabaseModel $model): array {
+            $carry[] = $model->toArray();
+
+            return $carry;
+        }, []);
+    }
+}