install data table

Reviewed-on: #3

backend/Dockerfile

@@ -1,28 +1,36 @@
-FROM docker.arvancloud.ir/dunglas/frankenphp:1.11.2-php8.5-trixie
+FROM php:8.5.3-fpm-alpine3.23
 
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends libpq-dev \
+# Install common PHP extension dependencies
+RUN apk update && apk add --no-cache \
+    bash \
+    curl \
+    libpng \
+    libpng-dev \
+    libjpeg-turbo-dev \
+    freetype-dev \
+    libwebp-dev \
+    libxml2-dev \
     unzip \
-    zip \
-    && install-php-extensions pdo_pgsql pgsql \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
+    libzip-dev \
+    libpq-dev \
+    && docker-php-ext-configure gd --with-freetype --with-jpeg --with-webp \
+    && docker-php-ext-install pdo_pgsql gd zip
 
+# Set the working directory
 WORKDIR /var/www/payment
 
-#ENV SERVER_NAME=your-domain-name.example.com
-
-# Copy Laravel application
 COPY . .
 
-# Give permissions to storage and bootstrap/cache
-RUN chmod -R 777 storage bootstrap/cache
+RUN chmod -R 775 /var/www/payment/storage /var/www/payment/bootstrap/cache
 
 # Install Composer
-COPY --from=docker.arvancloud.ir/composer:latest /usr/bin/composer /usr/bin/composer
+COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
+ENV COMPOSER_ALLOW_SUPERUSER=1
 
-CMD composer install;\
-    php artisan key:generate;\
-    php artisan migrate;\
-    php artisan db:seed;\
-    frankenphp php-server -r public/
+# Default command
+CMD composer install ;\
+    composer dump-autoload --optimize --classmap-authoritative ;\
+    php artisan key:generate ;\
+    php artisan migrate ;\
+    php artisan db:seed ;\
+    php-fpm

backend/Dockerfile.production

@@ -14,19 +14,28 @@ COPY . .
 
 RUN composer dump-autoload --optimize --classmap-authoritative
 
-FROM docker.arvancloud.ir/dunglas/frankenphp:1.11.2-php8.5-trixie AS application
+FROM php:8.5.3-fpm-alpine3.23 AS application
 
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends libpq-dev unzip zip \
-    && install-php-extensions pdo_pgsql pgsql \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
+RUN apk update && apk add --no-cache \
+    bash \
+    curl \
+    libpng \
+    libpng-dev \
+    libjpeg-turbo-dev \
+    freetype-dev \
+    libwebp-dev \
+    libxml2-dev \
+    unzip \
+    libzip-dev \
+    libpq-dev \
+    && docker-php-ext-configure gd --with-freetype --with-jpeg --with-webp \
+    && docker-php-ext-install pdo_pgsql gd zip
 
 WORKDIR /var/www/payment
 
 COPY --from=builder /app /var/www/payment
 
 RUN chown -R www-data:www-data /var/www/payment \
-    && chmod -R 775 storage bootstrap/cache
+    && chmod -R 665 storage bootstrap/cache
 
-CMD ["frankenphp", "php-server", "-r", "public/"]
+CMD ["php-fpm"]

backend/app/Facades/DataTable/DataTable.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Facades\DataTable;
+
+use App\Services\DataTable\DataTableInput;
+use App\Services\DataTable\DataTableService;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Contracts\Database\Query\Builder;
+use Illuminate\Http\Request;
+use App\Services\DataTable\Exceptions\InvalidParameterInterface;
+
+class DataTable
+{
+    /**
+     * Extracts data from request, passes to datatable service and prepares data for response.
+     * @param Model|Builder $mixed
+     * @param Request $request
+     * @param array $allowedFilters
+     * @param array $allowedRelations
+     * @param array $allowedSortings
+     * @param array $allowedSelects
+     * @return array
+     * @throws InvalidParameterInterface if input parameters are invalid.
+     */
+    public function run(
+        Model|Builder $mixed,
+        Request       $request,
+        array         $allowedFilters = [],
+        array         $allowedRelations = [],
+        array         $allowedSortings = [],
+        array         $allowedSelects = [],
+        array         $allowedGroupBy = []
+    ): array
+    {
+
+        $filters = json_decode($request->filters);
+        $sorting = json_decode($request->sorting);
+        $rels = $request->rels ?: array();
+
+        $dataTableInput = new DataTableInput(
+            $request->start,
+            $request->size,
+            $filters,
+            $sorting,
+            $rels,
+            $allowedFilters,
+            $allowedSortings,
+            $allowedGroupBy
+        );
+
+        $query = $this->makeQueryFromModel($mixed);
+
+        $dataTableService = (new DataTableService($query, $dataTableInput))
+            ->setAllowedFilters($allowedFilters)
+            ->setAllowedRelations($allowedRelations)
+            ->setAllowedSortings($allowedSortings)
+            ->setAllowedSelects($allowedSelects)
+            ->setAllowedGroupBy($allowedGroupBy);
+
+        return $dataTableService->getData();
+    }
+
+    protected function makeQueryFromModel(Model|Builder $mixed): Builder
+    {
+        return ($mixed instanceof Model) ? $mixed->query() : $mixed;
+    }
+}

backend/app/Facades/DataTable/DataTableFacade.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Facades\DataTable;
+
+use Illuminate\Support\Facades\Facade;
+
+class DataTableFacade extends Facade
+{
+    protected static function getFacadeAccessor(): string
+    {
+        return DataTable::class;
+    }
+}

backend/app/Models/User.php

@@ -9,13 +9,14 @@ use Illuminate\Database\Eloquent\Attributes\Hidden;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Foundation\Auth\User as Authenticatable;
 use Illuminate\Notifications\Notifiable;
+use Laravel\Passport\HasApiTokens;
 
 #[Fillable(['name', 'email', 'password'])]
 #[Hidden(['password', 'remember_token'])]
 class User extends Authenticatable
 {
     /** @use HasFactory<UserFactory> */
-    use HasFactory, Notifiable;
+    use HasFactory, Notifiable, HasApiTokens;
 
     /**
      * Get the attributes that should be cast.

backend/app/Providers/AppServiceProvider.php

@@ -3,6 +3,7 @@
 namespace App\Providers;
 
 use Illuminate\Support\ServiceProvider;
+use Laravel\Passport\Passport;
 
 class AppServiceProvider extends ServiceProvider
 {
@@ -19,6 +20,6 @@ class AppServiceProvider extends ServiceProvider
      */
     public function boot(): void
     {
-        //
+        Passport::enablePasswordGrant();
     }
 }

backend/app/Providers/DataTableServiceProvider.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Providers;
+
+use App\Facades\DataTable\DataTable;
+use Illuminate\Support\ServiceProvider;
+
+class DataTableServiceProvider extends ServiceProvider
+{
+    /**
+     * Register services.
+     */
+    public function register(): void
+    {
+        $this->app->bind('datatable', function () {
+            return new DataTable();
+        });
+    }
+
+    /**
+     * Bootstrap services.
+     */
+    public function boot(): void
+    {
+        //
+    }
+}

backend/app/Services/DataTable/DataTableInput.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace App\Services\DataTable;
+
+use App\Services\DataTable\Filter\Filter;
+use App\Services\DataTable\Sort\Sort;
+
+class DataTableInput
+{
+    /**
+     * @param int $start
+     * @param int $size
+     * @param array $filters
+     * @param array $sorting
+     * @param array $rels
+     */
+    public function __construct(
+        private ?int   $start,
+        private ?int   $size,
+        private array $filters,
+        private ?array $sorting,
+        private array $rels,
+        private array $allowedFilters,
+        private array $allowedSortings,
+        private ?array $GroupBy,
+    )
+    {
+    }
+
+    public function getStart(): ?int
+    {
+        return $this->start;
+    }
+
+    public function getSize(): ?int
+    {
+        return $this->size;
+    }
+
+    /**
+     * @return array returns an array of Filter objects
+     */
+    public function getFilters(): array
+    {
+        $filters = array();
+
+        foreach ($this->filters as $filter) {
+            $filters[] = new Filter(
+                $filter->id,
+                $filter->value,
+                $filter->fn,
+                $filter->datatype,
+                $this->allowedFilters
+            );
+        }
+
+        return $filters;
+    }
+
+    /**
+     * @return array
+     */
+    public function getSorting(): ?array
+    {
+        $sorts = [];
+        if (!empty($this->sorting)){
+            foreach ($this->sorting as $sort) {
+                $sorts[] =  new Sort($sort->id, $sort->desc, $this->allowedSortings);
+            }
+        }
+        return $sorts;
+    }
+
+    public function getRelations(): array
+    {
+        return $this->rels;
+    }
+
+    public function getGroupBy(): ?array
+    {
+        return $this->GroupBy;
+    }
+}

backend/app/Services/DataTable/DataTableService.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace App\Services\DataTable;
+
+use App\Services\DataTable\Filter\ApplyFilter;
+use App\Services\DataTable\Sort\ApplySort;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class DataTableService
+{
+
+    protected array $allowedFilters;
+    protected array $allowedRelations;
+    protected array $allowedSortings;
+    protected array $allowedSelects;
+    protected array $allowedGroupBy;
+    private int $totalRowCount;
+
+    public function __construct(
+        protected Builder      $query,
+        private DataTableInput $dataTableInput
+    )
+    {
+    }
+
+    public function setAllowedFilters(array $allowedFilters): DataTableService
+    {
+        $this->allowedFilters = $allowedFilters;
+        return $this;
+    }
+
+    public function setAllowedRelations(array $allowedRelations): DataTableService
+    {
+        $this->allowedRelations = $allowedRelations;
+        return $this;
+    }
+
+    public function setAllowedSortings(array $allowedSortings): DataTableService
+    {
+        $this->allowedSortings = $allowedSortings;
+        return $this;
+    }
+
+    public function setAllowedSelects(array $allowedSelects): DataTableService
+    {
+        $this->allowedSelects = $allowedSelects;
+        return $this;
+    }
+
+    public function setAllowedGroupBy(array $allowedGroupBy): DataTableService
+    {
+        $this->allowedGroupBy = $allowedGroupBy;
+        return $this;
+    }
+
+    /**
+     * Handle 'getData' operations
+     * @return array
+     */
+    public function getData(): array
+    {
+        $query = $this->buildQuery();
+        $data = $query->get();
+
+        return array(
+            'data' => $data,
+            'meta' => [
+                'totalRowCount' => $this->totalRowCount
+            ]
+        );
+    }
+
+    protected function buildQuery(): Builder
+    {
+        $query = $this->query;
+
+        foreach ($this->dataTableInput->getFilters() as $filter) {
+            $query = (new ApplyFilter($query, $filter))->apply();
+        }
+
+        $query = $this->applySelect($query, $this->allowedSelects);
+        $query = $this->includeRelationsInQuery($query, $this->allowedRelations);
+        $query = $this->applyGroupBy($query, $this->allowedGroupBy);
+
+        $this->totalRowCount = $query->count();
+
+        if (!is_null($this->dataTableInput->getStart())) {
+            $query->offset($this->dataTableInput->getStart());
+        }
+
+        if(!is_null($this->dataTableInput->getSize())){
+            $query->limit($this->dataTableInput->getSize());
+        }
+
+        $sorting = $this->dataTableInput->getSorting();
+        foreach ($sorting as $sort){
+            $query = (new ApplySort($query, $sort))->apply();
+        }
+
+        return $query;
+    }
+
+    protected function applySelect(Builder $query, array $selectedFields): Builder
+    {
+        if (!empty($selectedFields)) {
+            $query->select($selectedFields);
+        }
+
+        return $query;
+    }
+
+    protected function applyGroupBy(Builder $query, array $groupBy): Builder
+    {
+        return empty($groupBy) ? $query : $query->groupBy($groupBy);
+    }
+
+    protected function includeRelationsInQuery(Builder $query, array $rels): Builder
+    {
+        if (!empty($rels)) {
+            $query->with($rels);
+        }
+
+        return $query;
+    }
+
+    // (later) define mapping of relation names to prevent relation name expose.
+    // (later) define mapping of column names to prevent column name expose.
+}

backend/app/Services/DataTable/Enums/DataType.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Services\DataTable\Enums;
+
+enum DataType: string
+{
+    case NUMERIC = 'numeric';
+    case TEXT = 'text';
+    case DATE = 'date';
+
+    public static function values(): array
+    {
+       return array_column(self::cases(), 'value');
+    }
+}

backend/app/Services/DataTable/Enums/SearchType.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Services\DataTable\Enums;
+
+enum SearchType: string
+{
+    case CONTAINS = 'contains';
+    case EQUALS = 'equals';
+    case NOT_EQUALS = 'notEquals';
+    case BETWEEN = 'between';
+    case GREATER_THAN = 'greaterThan';
+    case LESS_THAN = 'lessThan';
+    case FUZZY = 'fuzzy';
+
+    public static function values(): array
+    {
+       return array_column(self::cases(), 'value');
+    }
+}

backend/app/Services/DataTable/Exceptions/InvalidFilterException.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services\DataTable\Exceptions;
+
+use Exception;
+
+class InvalidFilterException extends Exception implements InvalidParameterInterface
+{
+    protected $fieldName;
+
+    public function __construct($fieldName, $message = "", $code = 400, \Throwable $previous = null)
+    {
+        $this->fieldName = $fieldName;
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function getFieldName()
+    {
+        return $this->fieldName;
+    }
+}

backend/app/Services/DataTable/Exceptions/InvalidParameterInterface.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace App\Services\DataTable\Exceptions;
+
+interface InvalidParameterInterface
+{
+}

backend/app/Services/DataTable/Exceptions/InvalidRelationException.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services\DataTable\Exceptions;
+
+use Exception;
+
+class InvalidRelationException extends Exception implements InvalidParameterInterface
+{
+    protected $fieldName;
+
+    public function __construct($fieldName, $message = "", $code = 400, \Throwable $previous = null)
+    {
+        $this->fieldName = $fieldName;
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function getFieldName()
+    {
+        return $this->fieldName;
+    }
+}

backend/app/Services/DataTable/Exceptions/InvalidSortingException.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services\DataTable\Exceptions;
+
+use Exception;
+
+class InvalidSortingException extends Exception implements InvalidParameterInterface
+{
+    protected $fieldName;
+
+    public function __construct($fieldName, $message = "", $code = 400, \Throwable $previous = null)
+    {
+        $this->fieldName = $fieldName;
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function getFieldName()
+    {
+        return $this->fieldName;
+    }
+}

backend/app/Services/DataTable/Filter/ApplyFilter.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace App\Services\DataTable\Filter;
+
+use App\Services\DataTable\Enums\SearchType;
+use App\Services\DataTable\Exceptions\InvalidFilterException;
+use App\Services\DataTable\Filter\SearchFunctions\FilterBetween;
+use App\Services\DataTable\Filter\SearchFunctions\FilterContains;
+use App\Services\DataTable\Filter\SearchFunctions\FilterEquals;
+use App\Services\DataTable\Filter\SearchFunctions\FilterGreaterThan;
+use App\Services\DataTable\Filter\SearchFunctions\FilterLessThan;
+use App\Services\DataTable\Filter\SearchFunctions\FilterNotEquals;
+use App\Services\DataTable\Filter\SearchFunctions\SearchFilter;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class ApplyFilter
+{
+    private SearchFilter $searchFilter;
+
+    /**
+     * @param Builder $query
+     * @param Filter $filter
+     */
+    public function __construct(
+        private Builder $query,
+        private Filter  $filter,
+    )
+    {
+    }
+
+    public function apply(): Builder
+    {
+        $filter = $this->filter;
+        $query = $this->query;
+
+        $searchType = SearchType::from($filter->getFn());
+        switch ($searchType) {
+            case SearchType::CONTAINS:
+                $this->searchFilter = new FilterContains($query, $filter);
+                break;
+
+            case SearchType::EQUALS:
+                $this->searchFilter = new FilterEquals($query, $filter);
+                break;
+
+            case SearchType::NOT_EQUALS:
+                $this->searchFilter = new FilterNotEquals($query, $filter);
+                break;
+
+            case SearchType::BETWEEN:
+                $this->searchFilter = new FilterBetween($query, $filter);
+                break;
+
+            case SearchType::GREATER_THAN:
+                $this->searchFilter = new FilterGreaterThan($query, $filter);
+                break;
+
+            case SearchType::LESS_THAN:
+                $this->searchFilter = new FilterLessThan($query, $filter);
+                break;
+
+            default:
+                $searchFunction = $filter->getFn();
+                throw new InvalidFilterException($searchFunction, "search function `$searchFunction` is invalid.");
+
+        }
+
+        $relation = $this->filter->getRelation();
+        return method_exists($this->query->getModel(), $relation) ? $this->applyFilterToRelation($relation) : $this->searchFilter->apply();
+    }
+
+    protected function applyFilterToRelation(string $relation): Builder
+    {
+        return $this->query->whereHas($relation, function (Builder $query) {
+            $this->filter->removeRelationFromId();
+            $this->applyFilter($query, $this->filter);
+        });
+    }
+
+    private function applyFilter(Builder $query, Filter $filter): Builder
+    {
+        return (new ApplyFilter($query, $filter))->apply();
+    }
+}

backend/app/Services/DataTable/Filter/Filter.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\Services\DataTable\Filter;
+
+use App\Services\DataTable\Validators\FilterValidator;
+
+class Filter
+{
+    private static FilterValidator $filterValidator;
+
+    /**
+     * @param string $id
+     * @param string|int|array $value
+     * @param string $fn
+     * @param string $datatype
+     * @param array $allowedFilters
+     * @throws \App\Services\DataTable\Exceptions\InvalidFilterException
+     */
+    public function __construct(
+        private string           $id,
+        private string|int|array $value,
+        private string           $fn,
+        private string           $datatype,
+        private array $allowedFilters
+    )
+    {
+        self::$filterValidator = FilterValidator::getInstance();
+        self::$filterValidator->isValid($this, $this->allowedFilters);
+    }
+
+    public function getId(): string
+    {
+        return $this->id;
+    }
+
+    public function getValue(): array|int|string
+    {
+        return $this->value;
+    }
+
+    public function getFn(): string
+    {
+        return $this->fn;
+    }
+
+    public function getDatatype(): string
+    {
+        return $this->datatype;
+    }
+
+    public function getRelation(): string
+    {
+        $fieldArray = explode('.', $this->id);
+        return count($fieldArray) > 1 ? $fieldArray[0] : '';
+    }
+
+    public function getColumn(): string
+    {
+        $fieldArray = explode('.', $this->id);
+        return array_pop($fieldArray);
+    }
+
+    public function removeRelationFromId(): void
+    {
+        $this->id = $this->getColumn();
+    }
+
+    public function setValue(int|array|string $value): void
+    {
+        $this->value = $value;
+    }
+
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterBetween.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterBetween extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $query = $this->query;
+        [$minVal, $maxVal] = $this->filter->getValue();
+
+        if ($minVal) {
+            if ($this->filter->getDatatype() == "date") {
+                $minVal = $minVal . " 00:00:00";
+            }
+            $this->filter->setValue($minVal);
+            $query = (new FilterGreaterThanOrEqual($this->query, $this->filter))->apply();
+        }
+
+        if ($maxVal) {
+            if ($this->filter->getDatatype() == "date") {
+                $maxVal = $maxVal . " 23:59:59";
+            }
+            $this->filter->setValue($maxVal);
+            $query = (new FilterLessThanOrEqual($this->query, $this->filter))->apply();
+        }
+
+        return $query;
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterContains.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterContains extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $column = $this->filter->getId();
+        $value = '%' . $this->filter->getValue() . '%';
+
+        if ($this->filter->getDatatype() == DataType::TEXT->value) {
+            $query = $this->searchIgnoreCase($column, $value);
+
+        } else {
+            $query = $this->query->where($column, 'LIKE', $value);
+        }
+
+        return $query;
+    }
+
+    private function searchIgnoreCase(string $column, string $value): Builder
+    {
+        $value = strtolower($value);
+        return $this->query->whereRaw("LOWER($column) LIKE ?", [$value]);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterEquals.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterEquals extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $column = $this->filter->getId();
+        $value = $this->filter->getValue();
+
+        if ($this->filter->getDatatype() == DataType::TEXT->value) {
+            $query = $this->searchIgnoreCase($column, $value);
+        } else {
+            $query = $this->query->where($column, $value);
+        }
+
+        return $query;
+    }
+
+    private function searchIgnoreCase(string $column, string $value): Builder
+    {
+        $value = strtolower($value);
+        return $this->query->whereRaw("LOWER($column) = ?", [$value]);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterGreaterThan.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterGreaterThan extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $value = ($this->filter->getDatatype() == DataType::NUMERIC) ?
+            (float)$this->filter->getValue() : $this->filter->getValue();
+
+        return $this->query->where($this->filter->getId(), '>', $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterGreaterThanOrEqual.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterGreaterThanOrEqual extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $value = ($this->filter->getDatatype() == DataType::NUMERIC) ?
+            (float)$this->filter->getValue() : $this->filter->getValue();
+
+        return $this->query->where($this->filter->getId(), '>=', $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterLessThan.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterLessThan extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $value = ($this->filter->getDatatype() == DataType::NUMERIC) ?
+            (float)$this->filter->getValue() : $this->filter->getValue();
+
+        return $this->query->where($this->filter->getId(), '<', $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterLessThanOrEqual.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterLessThanOrEqual extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $value = ($this->filter->getDatatype() == DataType::NUMERIC) ?
+            (float)$this->filter->getValue() : $this->filter->getValue();
+
+        return $this->query->where($this->filter->getId(), '<=', $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterNotEquals.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterNotEquals extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $column = $this->filter->getId();
+        $value = $this->filter->getValue();
+
+        return $this->query->whereNot($column, $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/SearchFilter.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Filter\Filter;
+use Illuminate\Contracts\Database\Query\Builder;
+
+abstract class SearchFilter
+{
+    /**
+     * @param Builder $query
+     * @param Filter $filter
+     */
+    public function __construct(
+        protected Builder $query,
+        protected Filter  $filter,
+    )
+    {
+    }
+
+    abstract public function apply(): Builder;
+}

backend/app/Services/DataTable/Sort/ApplySort.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Services\DataTable\Sort;
+
+use Illuminate\Contracts\Database\Query\Builder;
+
+class ApplySort
+{
+
+    /**
+     * @param Builder $query
+     * @param ?Sort $sort
+     */
+    public function __construct(
+        private Builder $query,
+        private ?Sort    $sort,
+    )
+    {
+    }
+
+    public function apply(): Builder
+    {
+        $query = $this->query;
+
+        if (!is_null($this->sort)) {
+            $query->orderBy($this->sort->getId(), $this->sort->getDirection());
+        }
+
+        return $query;
+    }
+}

backend/app/Services/DataTable/Sort/Sort.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Services\DataTable\Sort;
+
+use App\Services\DataTable\Validators\SortingValidator;
+
+class Sort
+{
+    private static SortingValidator $sortingValidator;
+
+    /**
+     * @param string $id
+     * @param bool $desc
+     * @param array $allowedSortings
+     * @throws \App\Services\DataTable\Exceptions\InvalidSortingException
+     */
+    public function __construct(
+        private string $id,
+        private bool   $desc,
+        private array $allowedSortings,
+    )
+    {
+        self::$sortingValidator = SortingValidator::getInstance();
+        self::$sortingValidator->isValid($this, $this->allowedSortings);
+    }
+
+    /**
+     * @return string
+     */
+    public function getId(): string
+    {
+        return $this->id;
+    }
+
+    public function getDirection(): string
+    {
+        return $this->desc === true ? 'desc' : 'asc';
+    }
+}

backend/app/Services/DataTable/Validators/FilterValidator.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Services\DataTable\Validators;
+
+use App\Services\DataTable\Enums\SearchType;
+use App\Services\DataTable\Enums\DataType;
+use App\Services\DataTable\Exceptions\InvalidFilterException;
+use App\Services\DataTable\Filter\Filter;
+
+class FilterValidator
+{
+    private static $instance;
+
+    private function __construct()
+    {
+    }
+
+    public static function getInstance(): FilterValidator
+    {
+        if (!isset(self::$instance)) {
+            self::$instance = new static();
+        }
+
+        return self::$instance;
+    }
+
+    public function isValid(Filter $filter, array $allowedFilters): bool
+    {
+        if (!$this->isAllowed($filter, $allowedFilters)) {
+            $filterId = $filter->getId();
+            throw new InvalidFilterException($filter->getId(), "filtering field `$filterId` is not allowed.");
+        }
+
+        if (!$this->isValidSearchFunction($filter)) {
+            $searchFunction = $filter->getFn();
+            throw new InvalidFilterException($searchFunction, "search function `$searchFunction` is invalid.");
+        }
+
+        if ($this->isValidDataType($filter) == -1) {
+            throw new InvalidFilterException(null, "datatype property is not set in `filters` array.");
+        }
+
+        if (!$this->isValidDataType($filter)) {
+            $datatype = $filter->getDatatype();
+            throw new InvalidFilterException($datatype, "datatype `$datatype` is invalid.");
+        }
+
+        return true;
+    }
+
+    protected function isAllowed(Filter $filter, array $allowedFilters): bool
+    {
+        return $allowedFilters == ['*'] || in_array($filter->getId(), $allowedFilters);
+    }
+
+    protected function isValidSearchFunction(Filter $filter): bool
+    {
+        $searchFunction = $filter->getFn();
+        return isset($searchFunction) && in_array($searchFunction, SearchType::values());
+    }
+
+    protected function isValidDataType(Filter $filter): int
+    {
+        if (!property_exists($filter, 'datatype'))
+            return -1;
+
+        return $filter->getDatatype() && in_array($filter->getDatatype(), DataType::values()) ? 1 : 0;
+    }
+}

backend/app/Services/DataTable/Validators/RelationValidator.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Services\DataTable\Validators;
+
+use App\Services\DataTable\Exceptions\InvalidRelationException;
+
+class RelationValidator
+{
+    public static function validate(?array $rels, array $allowedRelations): bool
+    {
+        foreach ($rels as $relation) {
+
+            if (!self::isAllowed($relation, $allowedRelations)) {
+                throw new InvalidRelationException($relation, "relation `$relation` is not allowed.");
+            }
+        }
+
+        return true;
+    }
+
+    public static function isAllowed(string $relation, array $allowedRelations): bool
+    {
+        return !$relation || in_array($relation, $allowedRelations);
+    }
+}

backend/app/Services/DataTable/Validators/SortingValidator.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Services\DataTable\Validators;
+
+use App\Services\DataTable\Exceptions\InvalidSortingException;
+use App\Services\DataTable\Sort\Sort;
+
+class SortingValidator
+{
+    private static $instance;
+
+    private function __construct()
+    {
+    }
+
+    public static function getInstance(): SortingValidator
+    {
+        if (!isset(self::$instance)) {
+            self::$instance = new static();
+        }
+
+        return self::$instance;
+    }
+
+    public function isValid(Sort $sorting, array $allowedSortings): bool
+    {
+        if (!$this->isAllowed($sorting, $allowedSortings)) {
+            $sortId = $sorting->getId();
+            throw new InvalidSortingException($sortId, "sorting field `$sortId` is not allowed.");
+        }
+
+        return true;
+    }
+
+    protected function isAllowed(Sort $sorting, array $allowedSortings): bool
+    {
+        return $allowedSortings == ['*'] || in_array($sorting->getId(), $allowedSortings);
+    }
+}

backend/app/User/Services/FIB/AuthorizationService.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace App\User\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class AuthorizationService
+{
+    protected string $url;
+    protected string $channelName;
+    protected array $inputParameters;
+
+    public function __construct()
+    {
+        $this->url = config('fib.authorization.url');
+        $this->channelName = '';
+    }
+
+    public function setInputParameters(): void
+    {
+        $this->inputParameters = [
+            'client_id' => config('fib.authorization.client_id'),
+            'client_secret' => config('fib.authorization.client_secret'),
+            'grant_type' => 'client_credentials',
+        ];
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders(['Content-Type' => 'application/json'])
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url, $this->inputParameters)
+            ->json();
+    }
+}

backend/app/User/Services/FIB/CancelPaymentService.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace App\User\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class CancelPaymentService
+{
+    protected string $url;
+    protected string $channelName;
+    protected string $accessToken;
+    protected array $headers;
+
+    public function __construct()
+    {
+        $this->url = config('fib.cancelPayment.url');
+        $this->channelName = '';
+    }
+
+    public function setHeaders(): void
+    {
+        $this->headers = [
+            'Authorization' => 'Bearer ' . $this->accessToken,
+            'Content-Type' => 'application/json',
+        ];
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders($this->headers)
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+}

backend/app/User/Services/FIB/CheckPaymentStatusService.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\User\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class CheckPaymentStatusService
+{
+    protected string $url;
+    protected string $channelName;
+
+    public function __construct()
+    {
+        $this->url = config('fib.checkPaymentStatus.url');
+        $this->channelName = '';
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function sendRequest(): array
+    {
+        return Http::throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+}

backend/app/User/Services/FIB/CreatePaymentService.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\User\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class CreatePaymentService
+{
+    protected string $url;
+    protected string $channelName;
+    protected string $accessToken;
+    protected array $headers;
+    protected array $inputParameters;
+
+    public function __construct()
+    {
+        $this->url = config('fib.createPayment.url');
+        $this->channelName = '';
+    }
+
+    public function setAccessToken(string $accessToken): void
+    {
+        $this->accessToken = $accessToken;
+    }
+
+    public function setHeaders(): void
+    {
+        $this->headers = [
+            'Authorization' => 'Bearer ' . $this->accessToken,
+            'Content-Type' => 'application/json',
+        ];
+    }
+
+    public function setInputParameters(array $inputParameters): void
+    {
+        $this->inputParameters = $inputParameters;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders($this->headers)
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url, $this->inputParameters)
+            ->json();
+    }
+}

backend/app/User/Services/FIB/RefundService.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace App\User\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class RefundService
+{
+    protected string $url;
+    protected string $channelName;
+    protected string $accessToken;
+    protected array $headers;
+
+    public function __construct()
+    {
+        $this->url = config('fib.refund.url');
+        $this->channelName = '';
+    }
+
+    public function setHeaders(): void
+    {
+        $this->headers = [
+            'Authorization' => 'Bearer ' . $this->accessToken,
+            'Content-Type' => 'application/json',
+        ];
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders($this->headers)
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+}

backend/bootstrap/app.php

@@ -7,6 +7,7 @@ use Illuminate\Foundation\Configuration\Middleware;
 return Application::configure(basePath: dirname(__DIR__))
     ->withRouting(
         web: __DIR__.'/../routes/web.php',
+        api: __DIR__.'/../routes/api.php',
         commands: __DIR__.'/../routes/console.php',
         health: '/up',
     )

backend/bootstrap/providers.php

@@ -1,7 +1,6 @@
 <?php
 
-use App\Providers\AppServiceProvider;
-
 return [
-    AppServiceProvider::class,
+    App\Providers\AppServiceProvider::class,
+    App\Providers\DataTableServiceProvider::class,
 ];

backend/composer.json

@@ -11,6 +11,7 @@
     "require": {
         "php": "^8.3",
         "laravel/framework": "^13.0",
+        "laravel/passport": "^13.0",
         "laravel/tinker": "^3.0"
     },
     "require-dev": {
@@ -86,4 +87,4 @@
     },
     "minimum-stability": "stable",
     "prefer-stable": true
-}
+}

backend/config/auth.php

@@ -42,6 +42,10 @@ return [
             'driver' => 'session',
             'provider' => 'users',
         ],
+        'api' => [
+            'driver' => 'passport',
+            'provider' => 'users',
+        ],
     ],
 
     /*

backend/config/fib.php

@@ -0,0 +1,25 @@
+<?php
+
+return [
+    'authorization' => [
+        'url' => env('FIB_AUTHORIZATION_URL'),
+        'client_id' => env('FIB_CLIENT_ID'),
+        'client_secret' => env('FIB_CLIENT_SECRET'),
+    ],
+
+    'createPayment' => [
+        'url' => env('FIB_CREATE_PAYMENT_URL'),
+    ],
+
+    'checkPaymentStatus' => [
+        'url' => env('FIB_CHECK_PAYMENT_STATUS_URL'),
+    ],
+
+    'cancelPayment' => [
+        'url' => env('FIB_CANCEL_PAYMENT_URL'),
+    ],
+
+    'refund' => [
+        'url' => env('FIB_REFUND_URL'),
+    ],
+];

backend/config/passport.php

@@ -0,0 +1,48 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Passport Guard
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify which authentication guard Passport will use when
+    | authenticating users. This value should correspond with one of your
+    | guards that is already present in your "auth" configuration file.
+    |
+    */
+
+    'guard' => 'web',
+
+    'middleware' => [],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Encryption Keys
+    |--------------------------------------------------------------------------
+    |
+    | Passport uses encryption keys while generating secure access tokens for
+    | your application. By default, the keys are stored as local files but
+    | can be set via environment variables when that is more convenient.
+    |
+    */
+
+    'private_key' => env('PASSPORT_PRIVATE_KEY'),
+
+    'public_key' => env('PASSPORT_PUBLIC_KEY'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Passport Database Connection
+    |--------------------------------------------------------------------------
+    |
+    | By default, Passport's models will utilize your application's default
+    | database connection. If you wish to use a different connection you
+    | may specify the configured name of the database connection here.
+    |
+    */
+
+    'connection' => env('PASSPORT_CONNECTION'),
+
+];

backend/database/migrations/2026_04_27_122415_create_oauth_auth_codes_table.php

@@ -0,0 +1,39 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('oauth_auth_codes', function (Blueprint $table) {
+            $table->char('id', 80)->primary();
+            $table->foreignId('user_id')->index();
+            $table->foreignUuid('client_id');
+            $table->text('scopes')->nullable();
+            $table->boolean('revoked');
+            $table->dateTime('expires_at')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('oauth_auth_codes');
+    }
+
+    /**
+     * Get the migration connection name.
+     */
+    public function getConnection(): ?string
+    {
+        return $this->connection ?? config('passport.connection');
+    }
+};

backend/database/migrations/2026_04_27_122416_create_oauth_access_tokens_table.php

@@ -0,0 +1,41 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('oauth_access_tokens', function (Blueprint $table) {
+            $table->char('id', 80)->primary();
+            $table->foreignId('user_id')->nullable()->index();
+            $table->foreignUuid('client_id');
+            $table->string('name')->nullable();
+            $table->text('scopes')->nullable();
+            $table->boolean('revoked');
+            $table->timestamps();
+            $table->dateTime('expires_at')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('oauth_access_tokens');
+    }
+
+    /**
+     * Get the migration connection name.
+     */
+    public function getConnection(): ?string
+    {
+        return $this->connection ?? config('passport.connection');
+    }
+};

backend/database/migrations/2026_04_27_122417_create_oauth_refresh_tokens_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('oauth_refresh_tokens', function (Blueprint $table) {
+            $table->char('id', 80)->primary();
+            $table->char('access_token_id', 80)->index();
+            $table->boolean('revoked');
+            $table->dateTime('expires_at')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('oauth_refresh_tokens');
+    }
+
+    /**
+     * Get the migration connection name.
+     */
+    public function getConnection(): ?string
+    {
+        return $this->connection ?? config('passport.connection');
+    }
+};

backend/database/migrations/2026_04_27_122418_create_oauth_clients_table.php

@@ -0,0 +1,42 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('oauth_clients', function (Blueprint $table) {
+            $table->uuid('id')->primary();
+            $table->nullableMorphs('owner');
+            $table->string('name');
+            $table->string('secret')->nullable();
+            $table->string('provider')->nullable();
+            $table->text('redirect_uris');
+            $table->text('grant_types');
+            $table->boolean('revoked');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('oauth_clients');
+    }
+
+    /**
+     * Get the migration connection name.
+     */
+    public function getConnection(): ?string
+    {
+        return $this->connection ?? config('passport.connection');
+    }
+};

backend/database/migrations/2026_04_27_122419_create_oauth_device_codes_table.php

@@ -0,0 +1,42 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('oauth_device_codes', function (Blueprint $table) {
+            $table->char('id', 80)->primary();
+            $table->foreignId('user_id')->nullable()->index();
+            $table->foreignUuid('client_id')->index();
+            $table->char('user_code', 8)->unique();
+            $table->text('scopes');
+            $table->boolean('revoked');
+            $table->dateTime('user_approved_at')->nullable();
+            $table->dateTime('last_polled_at')->nullable();
+            $table->dateTime('expires_at')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('oauth_device_codes');
+    }
+
+    /**
+     * Get the migration connection name.
+     */
+    public function getConnection(): ?string
+    {
+        return $this->connection ?? config('passport.connection');
+    }
+};

backend/routes/api.php

@@ -0,0 +1,8 @@
+<?php
+
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Route;
+
+Route::get('/user', function (Request $request) {
+    return $request->user();
+})->middleware('auth:api');

docker-compose.production.yml

@@ -1,60 +0,0 @@
-services:
-  postgres:
-    image: docker.arvancloud.ir/postgres:17.8-alpine3.23
-    container_name: pgsql
-    restart: unless-stopped
-    ports:
-      - "8091:5432"
-    environment:
-      POSTGRES_DB: ${POSTGRES_DB}
-      POSTGRES_USER: ${POSTGRES_USER}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
-    volumes:
-      - payment-db:/var/lib/postgresql/data
-    networks:
-      - payment
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-
-  backend:
-    build:
-      context: ${BACKEND_PATH}
-      dockerfile: Dockerfile.production
-    container_name: laravel
-    tty: true
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:80"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    ports:
-      - "8003:80"
-      - "443:443"
-      - "443:443/udp"
-    volumes:
-      - ${BACKEND_PATH}:/var/www/${PROJECT_NAME}
-    depends_on:
-      - postgres
-    networks:
-      - payment
-    logging:
-      driver: "syslog"
-      options:
-        syslog-address: "tcp://host.docker.internal:514"
-        tag: "laravel-backend"
-        syslog-facility: "daemon"
-        max-size: "10m"
-    mem_limit: 512M
-    cpus: 1
-
-volumes:
-  payment-db:
-    driver: local
-
-networks:
-  payment:
-    driver: bridge

docker-compose.yml

@@ -1,14 +1,39 @@
 services:
-  postgres:
-    image: docker.arvancloud.ir/postgres:17.8-alpine3.23
-    container_name: pgsql
+  nginx:
+    image: nginx:stable-alpine3.23-perl
+    container_name: nginx
     restart: unless-stopped
     ports:
-      - "8091:5432"
+      - "8000:80"
+    volumes:
+      - ./nginx/payment.conf:/etc/nginx/conf.d/default.conf
+      - ${BACKEND_PATH}:/var/www/${PROJECT_NAME}
+    networks:
+      - payment
+
+  redis:
+    image: redis:8.6.0-alpine3.23
+    container_name: redis
+    restart: unless-stopped
+    tty: true
+    networks:
+      - payment
+
+  postgres:
+    image: postgres:18.2-alpine3.23
+    container_name: payment-db
+    restart: unless-stopped
+    ports:
+      - "8092:5432"
     environment:
       POSTGRES_DB: ${POSTGRES_DB}
       POSTGRES_USER: ${POSTGRES_USER}
       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+    healthcheck:
+      test: [ "CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}" ]
+      interval: 30s
+      timeout: 10s
+      retries: 3
     volumes:
       - payment-db:/var/lib/postgresql/data
     networks:
@@ -22,17 +47,22 @@ services:
     tty: true
     restart: unless-stopped
     ports:
-      - "8003:80"
-      - "443:443"
-      - "443:443/udp"
+      - "9000:9000"
     volumes:
       - ${BACKEND_PATH}:/var/www/${PROJECT_NAME}
-#      - caddy_data:/data
-#      - caddy_config:/config
     depends_on:
       - postgres
     networks:
       - payment
+#    logging:
+#      driver: "syslog"
+#      options:
+#        syslog-address: "tcp://host.docker.internal:514"
+#        tag: "laravel-backend"
+#        syslog-facility: "daemon"
+#        max-size: "10m"
+#    mem_limit: 512M
+#    cpus: 1
 
 volumes:
   payment-db:

nginx/payment.conf

@@ -0,0 +1,21 @@
+server {
+    listen 80;
+    listen [::]:80;
+    charset utf-8;
+
+    location / {
+            try_files $uri $uri/ /index.php?$query_string;
+        }
+
+    location ~ ^/index\.php(/|$) {
+        include fastcgi_params;
+        fastcgi_pass laravel:9000;
+        fastcgi_index index.php;
+        fastcgi_hide_header X-Powered-By;
+        fastcgi_param SCRIPT_FILENAME /var/www/payment/public/index.php;
+    }
+
+    location ~ /\.(?!well-known).* {
+            deny all;
+        }
+}