RESTstop

// src/api/modules/orders/Module.php
namespace api\modules\orders;

class Module extends \yii\base\Module
{
    public $controllerNamespace = 'api\modules\orders\controllers';

    // Maps this module to the 'my_module' database schema
    public $dbSchema = 'my_module';
}

namespace api\modules\public\models;

use common\models\BaseActiveRecord;
use common\behaviors\LinkBehavior;

class Post extends BaseActiveRecord
{
    public function behaviors()
    {
        return [
            'link' => [
                'class' => LinkBehavior::class,
                'rollbackOnError' => true, // All-or-nothing (default)
            ],
        ];
    }

    public function extraFields()
    {
        return ['tags']; // Relations that can be linked via API
    }

    public function getTags()
    {
        return $this->hasMany(Tag::class, ['id' => 'tag_id'])
            ->viaTable('post_tag', ['post_id' => 'id']);
    }

    // Junction relation for LinkBehavior (convention: get{OwnerClass}{RelationPlural})
    public function getPostTags()
    {
        return $this->hasMany(PostTag::class, ['post_id' => 'id']);
    }
}

namespace api\modules\public\models;

use common\models\BaseActiveRecord;
use common\behaviors\RelationsBehavior;
use common\behaviors\LinkBehavior;

class User extends BaseActiveRecord
{
    public function behaviors()
    {
        return [
            'relations' => [
                'class' => RelationsBehavior::class,
                'relations' => ['roles'], // Optional: specific relations only
                'deferUpdatesToLinkBehavior' => true, // Let LinkBehavior handle UPDATE
            ],
            'link' => [
                'class' => LinkBehavior::class,
            ],
        ];
    }

    public function extraFields()
    {
        return ['roles'];
    }

    public function getRoles()
    {
        return $this->hasMany(Role::class, ['id' => 'role_id'])
            ->viaTable('user_role', ['user_id' => 'id']);
    }

    public function getUserRoles()
    {
        return $this->hasMany(UserRole::class, ['user_id' => 'id']);
    }
}

namespace api\modules\public\controllers;

use common\controllers\BaseController;
use common\traits\SearchableTrait;

class PostController extends BaseController
{
    use SearchableTrait;

    public $modelClass = 'api\modules\public\models\Post';

    // Whitelist filterable attributes (security)
    public $filterableAttributes = ['title', 'status', 'user_id', 'published_at'];

    public function actions()
    {
        $actions = parent::actions();
        $actions['index']['prepareDataProvider'] = [$this, 'prepareSearchDataProvider'];
        return $actions;
    }

    // Optional: customize pagination
    protected function getPaginationConfig(): array
    {
        return [
            'params' => \Yii::$app->request->getQueryParams(),
            'defaultPageSize' => 25,
            'pageSizeLimit' => [1, 100],
        ];
    }

    // Optional: customize sorting
    protected function getSortConfig(): array
    {
        return [
            'params' => \Yii::$app->request->getQueryParams(),
            'defaultOrder' => ['published_at' => SORT_DESC],
        ];
    }
}

namespace api\modules\public\models;

use common\models\BaseActiveRecord;
use common\traits\VirtualAttributesTrait;

class User extends BaseActiveRecord
{
    use VirtualAttributesTrait;

    public function afterFind()
    {
        parent::afterFind();

        // Computed attribute
        $this->fullName = trim($this->first_name . ' ' . $this->last_name);

        // Aggregated data
        $this->postCount = $this->getPosts()->count();
    }

    public function fields()
    {
        $fields = parent::fields();

        // Include virtual attributes in API response
        $fields['fullName'] = function ($model) {
            return $model->fullName ?? null;
        };
        $fields['postCount'] = function ($model) {
            return $model->postCount ?? 0;
        };

        return $fields;
    }
}

$user = User::findOne(1);

// Set virtual attributes
$user->fullName = 'John Doe';
$user->permissions = ['read', 'write'];

// Get virtual attributes
echo $user->fullName; // 'John Doe'

// Check existence
if ($user->hasVirtualAttribute('fullName')) {
    // ...
}

// Bulk operations
$user->setVirtualAttributes([
    'fullName' => 'John Doe',
    'isAdmin' => true,
]);

$virtuals = $user->getVirtualAttributes();
// ['fullName' => 'John Doe', 'isAdmin' => true]

// Real attributes still work normally
$user->email = 'john@example.com';
$user->save(); // Only saves email, not virtual attributes

namespace api\modules\public\controllers;

use common\controllers\BaseController;

class UserController extends BaseController
{
    public $modelClass = 'api\modules\public\models\User';

    public function actions()
    {
        $actions = parent::actions();

        // Customize rules action
        $actions['rules']['checkAccess'] = [$this, 'checkAccess'];

        return $actions;
    }
}

class User extends BaseActiveRecord
{
    public function rules()
    {
        return [
            [['email', 'password_hash'], 'required'],
            [['email'], 'email'],
            [['email'], 'string', 'max' => 255],
            [['password_hash'], 'string', 'min' => 8, 'max' => 60],
            [['status'], 'integer', 'min' => 0, 'max' => 10],
            [['email'], 'unique'],
        ];
    }
}

namespace api\modules\public\models;

use common\models\BaseActiveRecord;
use common\models\BaseActiveQuery;

class Tag extends BaseActiveRecord
{
    // Define junction fields to include when this model is expanded
    public static function junctionFields()
    {
        return [
            'posts' => ['weight'], // Include 'weight' from post_tag junction
        ];
    }

    public function getTags()
    {
        return $this->hasMany(Tag::class, ['id' => 'tag_id'])
            ->viaTable('post_tag', ['post_id' => 'id']);
    }

    // Use BaseActiveQuery for junction data support
    public static function find()
    {
        return new BaseActiveQuery(get_called_class());
    }
}

// In model relation definition
public function getTags()
{
    return $this->hasMany(Tag::class, ['id' => 'tag_id'])
        ->viaTable('post_tag', ['post_id' => 'id']); // Automatically includes junction data
}

// Manual junction data inclusion
$tags = $post->getTags()->withJunctionData()->all();

// config/params.php
return [
    'cors' => [
        'allowedOrigins' => ['http://localhost:3000', 'https://app.example.com'],
        'allowedHeaders' => ['Content-Type', 'Authorization', 'X-Requested-With'],
        'exposedHeaders' => ['X-Pagination-Total-Count', 'X-Pagination-Page-Count'],
        'allowCredentials' => true,
        'maxAge' => 86400,
    ],
];

namespace api\modules\public\controllers;

use common\controllers\BaseController;

class ProductController extends BaseController
{
    public $modelClass = 'api\modules\public\models\Product';

    // RulesAction is automatically available at /api/products/rules

    // Access Bearer token if needed
    public function actionCustom()
    {
        $token = $this->getAccessTokenFromRequest();
        // ...
    }
}

use common\models\SearchableModel;

// Create search model with attributes
$searchModel = new SearchableModel();
$searchModel->defineAttributes(['name', 'status', 'price']);
$searchModel->defineTypesFromModel(Product::class);

// Set search values
$searchModel->name = 'shirt';
$searchModel->price = 50;

// Apply to query with operators
$query = Product::find();
$searchModel->search($query, [
    'name' => 'like',   // WHERE name LIKE '%shirt%'
    'price' => 'lt',    // AND price < 50
]);

$products = $query->all();

class ProductController extends BaseController
{
    use SearchableTrait;

    public $modelClass = Product::class;
    public $filterableAttributes = ['name', 'status', 'price', 'category_id'];
    // SearchableModel is created automatically with these attributes
}

$searchModel = (new SearchableModel())
    ->defineAttribute('name', 'John')
    ->defineAttribute('status', 'active')
    ->setAttributeType('price', 'number');

// config/web.php
return [
    'components' => [
        'errorHandler' => [
            'class' => 'common\errorHandler\CustomErrorHandler',
        ],
    ],
];

use common\exceptions\LinkException;

// Throw with errors
throw new LinkException(
    422,
    'Link operation failed',
    [
        'tags' => [
            '999' => 'Record not found',
            '888' => 'Already linked'
        ]
    ]
);

namespace api\modules\public\models;

use common\models\BaseActiveRecord;
use common\behaviors\LinkBehavior;
use common\behaviors\RelationsBehavior;
use common\traits\VirtualAttributesTrait;

class Post extends BaseActiveRecord
{
    use VirtualAttributesTrait;

    public static function tableName()
    {
        return 'post';
    }

    public function behaviors()
    {
        return [
            'relations' => [
                'class' => RelationsBehavior::class,
                'deferUpdatesToLinkBehavior' => true,
            ],
            'link' => [
                'class' => LinkBehavior::class,
                'rollbackOnError' => true,
            ],
        ];
    }

    public function rules()
    {
        return [
            [['title', 'user_id'], 'required'],
            [['title'], 'string', 'max' => 255],
            [['content'], 'string'],
            [['status'], 'in', 'range' => ['draft', 'published', 'archived']],
            [['user_id'], 'integer'],
        ];
    }

    public function fields()
    {
        $fields = parent::fields();
        $fields['authorName'] = fn($model) => $model->authorName ?? null;
        return $fields;
    }

    public function extraFields()
    {
        return ['tags', 'author'];
    }

    public static function junctionFields()
    {
        return [
            'tags' => ['weight'],
        ];
    }

    public function afterFind()
    {
        parent::afterFind();
        $this->authorName = $this->author->fullName ?? null;
    }

    public function getTags()
    {
        return $this->hasMany(Tag::class, ['id' => 'tag_id'])
            ->viaTable('post_tag', ['post_id' => 'id']);
    }

    public function getPostTags()
    {
        return $this->hasMany(PostTag::class, ['post_id' => 'id']);
    }

    public function getAuthor()
    {
        return $this->hasOne(User::class, ['id' => 'user_id']);
    }
}

namespace api\modules\public\controllers;

use common\controllers\BaseController;
use common\traits\SearchableTrait;

class PostController extends BaseController
{
    use SearchableTrait;

    public $modelClass = 'api\modules\public\models\Post';
    public $filterableAttributes = ['title', 'status', 'user_id', 'published_at'];

    public function actions()
    {
        $actions = parent::actions();
        $actions['index']['prepareDataProvider'] = [$this, 'prepareSearchDataProvider'];
        return $actions;
    }

    protected function getSortConfig(): array
    {
        return [
            'params' => \Yii::$app->request->getQueryParams(),
            'defaultOrder' => ['published_at' => SORT_DESC],
            'attributes' => ['title', 'status', 'published_at', 'created_at'],
        ];
    }
}

namespace api\modules\public\models;

use Yii;
use yii\web\IdentityInterface;
use common\models\BaseActiveRecord;
use common\behaviors\RelationsBehavior;
use common\traits\VirtualAttributesTrait;

class User extends BaseActiveRecord implements IdentityInterface
{
    use VirtualAttributesTrait;

    public static function tableName()
    {
        return '{{%user}}';
    }

    public function behaviors()
    {
        return [
            'relations' => [
                'class' => RelationsBehavior::class,
            ],
        ];
    }

    public function rules()
    {
        return [
            [['email', 'password_hash'], 'required'],
            [['email'], 'email'],
            [['email'], 'string', 'max' => 255],
            [['email'], 'unique'],
        ];
    }

    public function fields()
    {
        $fields = parent::fields();
        // Exclude sensitive fields
        unset($fields['password_hash'], $fields['auth_key'], $fields['access_token']);

        // Add computed fields
        $fields['fullName'] = fn($model) => $model->fullName ?? null;
        $fields['roleNames'] = fn($model) => $model->roleNames ?? [];

        return $fields;
    }

    public function extraFields()
    {
        return ['roles', 'posts'];
    }

    public function afterFind()
    {
        parent::afterFind();
        $this->fullName = trim(($this->first_name ?? '') . ' ' . ($this->last_name ?? ''));
        $this->roleNames = array_map(fn($r) => $r->name, $this->roles);
    }

    public function getRoles()
    {
        return $this->hasMany(Role::class, ['id' => 'role_id'])
            ->viaTable('user_role', ['user_id' => 'id']);
    }

    public function getUserRoles()
    {
        return $this->hasMany(UserRole::class, ['user_id' => 'id']);
    }

    public function getPosts()
    {
        return $this->hasMany(Post::class, ['user_id' => 'id']);
    }

    // IdentityInterface implementation...
    public static function findIdentity($id)
    {
        return static::findOne(['id' => $id, 'status' => self::STATUS_ACTIVE]);
    }

    public static function findIdentityByAccessToken($token, $type = null)
    {
        return static::findOne(['access_token' => $token]);
    }

    public function getId() { return $this->id; }
    public function getAuthKey() { return $this->auth_key; }
    public function validateAuthKey($authKey) { return $this->auth_key === $authKey; }

    public function validatePassword($password)
    {
        return Yii::$app->security->validatePassword($password, $this->password_hash);
    }

    public function setPassword($password)
    {
        $this->password_hash = Yii::$app->security->generatePasswordHash($password);
    }
}

// src/api/config/swagger-local.php
return [
    'info' => [
        'title' => 'My API',
        'description' => 'API description',
        'version' => '1.0.0',
    ],
    'servers' => [
        ['url' => 'http://localhost:8080', 'description' => 'Development'],
        ['url' => 'https://api.example.com', 'description' => 'Production'],
    ],
];