added basic support

Author: Blazik

composer.json

@@ -9,7 +9,10 @@
             "email": "jakub.blaha@involve.cz"
         }
     ],
-    "require": {},
+    "require": {
+        "php": "^8.0",
+        "laravel/framework": "^10.0"
+    },
     "autoload": {
         "psr-4": {
             "BoredProgrammers\\LaravelEloquentMappable\\": "src/"

src/Models/Scopes/MappedColumnsScope.php

@@ -0,0 +1,99 @@
+<?php declare(strict_types=1);
+
+namespace BoredProgrammers\LaravelEloquentMappable\Models\Scopes;
+
+use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Scope;
+use Illuminate\Database\Query\Builder as QueryBuilder;
+use Illuminate\Database\Query\JoinClause;
+
+class MappedColumnsScope implements Scope
+{
+
+    public function apply(EloquentBuilder $builder, Model $model): void
+    {
+        $builder->beforeQuery(function (QueryBuilder $builder) use ($model) {
+            if (!$mappedColToDbCol = $model->columns ?? null) {
+                return;
+            }
+
+            $modelTable = $model->getTable();
+            $mappedColToDbColWithTable = collect($mappedColToDbCol)
+                ->mapWithKeys(fn($value, $key) => [$modelTable . '.' . $key => $modelTable . '.' . $value])
+                ->merge($mappedColToDbCol);
+
+            $dbColToMappedCol = $mappedColToDbColWithTable->flip();
+
+            $builder->columns = $this->mapColumns(
+                $builder->columns,
+                $mappedColToDbColWithTable,
+                $dbColToMappedCol,
+                $model
+            );
+
+            $builder->wheres = $this->mapColumns(
+                $builder->wheres,
+                $mappedColToDbColWithTable,
+                $dbColToMappedCol,
+                $model
+            );
+
+            $builder->joins = $this->mapJoins($builder->joins, $mappedColToDbColWithTable);
+        });
+    }
+
+    private function mapColumns($array, $mappedColToDbColWithTable, $dbColToMappedCol, $model)
+    {
+        if (!$array) {
+            return $array;
+        }
+
+        foreach ($array as $key => $column) {
+            $columnName = is_array($column) ? $column['column'] : $column;
+
+            if ($columnName === '*' || str_contains($columnName, ' as ')) { // todo: add support for column aliases
+                continue;
+            }
+
+            if ($newColumnName = $mappedColToDbColWithTable[$columnName] ?? null) {
+                if (is_array($column)) {
+                    $array[$key]['column'] = $newColumnName;
+                } else {
+                    $array[$key] = $newColumnName;
+                }
+            }
+        }
+
+        return $array;
+    }
+
+    private function mapJoins($joins, $mappedColToDbColWithTable)
+    {
+        if (!$joins) {
+            return $joins;
+        }
+
+        /** @var JoinClause $joinClause */
+        foreach ($joins as $joinClause) {
+            foreach ($joinClause->wheres as $whereKey => $whereData) {
+                if ($whereData['type'] === 'Column') {
+                    if ($dbCol = $mappedColToDbColWithTable[$whereData['first']] ?? null) {
+                        $joinClause->wheres[$whereKey]['first'] = $dbCol;
+                    }
+
+                    if ($dbCol = $mappedColToDbColWithTable[$whereData['second']] ?? null) {
+                        $joinClause->wheres[$whereKey]['second'] = $dbCol;
+                    }
+                }
+            }
+
+            if ($joinClause->joins) {
+                $joinClause->joins = $this->mapJoins($joinClause->joins, $mappedColToDbColWithTable);
+            }
+        }
+
+        return $joins;
+    }
+
+}

src/Models/Traits/HasMappableColumns.php

@@ -0,0 +1,84 @@
+<?php declare(strict_types=1);
+
+namespace BoredProgrammers\LaravelEloquentMappable\Models\Traits;
+
+use BoredProgrammers\LaravelEloquentMappable\Models\Scopes\MappedColumnsScope;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Str;
+use Illuminate\Support\Traits\Macroable;
+
+/**
+ * @property array $columns
+ */
+trait HasMappableColumns
+{
+
+    use Macroable {
+        __call as macroCall;
+    }
+
+    protected static function bootHasMappableColumns(): void
+    {
+        static::addGlobalScope(new MappedColumnsScope());
+
+        foreach ((new static)->columns ?? [] as $mappedCol => $dbCol) {
+            static::macro('get' . Str::studly($mappedCol) . 'Attribute', function () use ($dbCol) {
+                return $this->$dbCol;
+            });
+
+            static::macro('set' . Str::studly($mappedCol) . 'Attribute', function ($value) use ($dbCol) {
+                $this->$dbCol = $value;
+            });
+        }
+    }
+
+    public function newInstance($attributes = [], $exists = false): Model
+    {
+        /** @var Model $instance */
+        $instance = parent::newInstance($attributes, $exists);
+
+        foreach ($instance->columns ?? [] as $mappedCol => $dbCol) {
+            $instance->hidden[] = $dbCol;
+            $instance->appends[] = $mappedCol;
+
+            if (in_array($mappedCol, $instance->guarded)) {
+                $instance->guarded[] = $dbCol;
+            }
+
+            if (in_array($mappedCol, $instance->fillable)) {
+                $instance->fillable[] = $dbCol;
+            }
+        }
+
+        return $instance;
+    }
+
+    public function hasGetMutator($key): bool
+    {
+        return parent::hasGetMutator($key) || static::hasMacro('get' . Str::studly($key) . 'Attribute');
+    }
+
+    public function hasSetMutator($key): bool
+    {
+        return parent::hasSetMutator($key) || static::hasMacro('set' . Str::studly($key) . 'Attribute');
+    }
+
+    public function __call($method, $parameters)
+    {
+        if (Str::startsWith($method, ['set', 'get']) && self::hasMacro($method)) {
+            return self::macroCall($method, $parameters);
+        }
+
+        return parent::__call($method, $parameters);
+    }
+
+    public static function __callStatic($method, $parameters)
+    {
+        if (Str::startsWith($method, ['set', 'get']) && self::hasMacro($method)) {
+            return self::macroCall($method, $parameters);
+        }
+
+        return parent::__callStatic($method, $parameters);
+    }
+
+}