class Repository extends ActiveRecord
{
    public function save($runValidation = true, $attributeNames = null)
	{
	    throw new \Exception('Низя.');
	}
}

<?php 
 
namespace Core\domain\system\yii2\readers;

use Yii;
use yii\db\Command;

/** 
 * Ридер DAO Yii2 
 * 
 */  
class CommandReader extends Command
{
    
    /**
     * Использование чистых запросов
     *
     * @param string $query
     */
    public function createCommand($query)
    {
        $this->db = Yii::$app->db;
        $this->setSql($query); 
        return $this;    
    }
    
    /**
    * Запрет модификации
    */  
    public function execute()
    { 
        throw new \BadMethodCallException('Modifying the model in the read portion is forbidden.');        
    }
}

<?php 
 
namespace Core\domain\system\yii2\readers;

use yii\db\Query;

/** 
 * Ридер для Query Yii2 
 * 
 */  
class QueryReader extends Query
{

}

<?php 
 
namespace Core\domain\system\yii2\readers;

use Yii;
use yii\db\ActiveQuery;
use Core\domain\system\Reader;

/** 
 * Ридер для ActiveQuery Yii2 
 * 
 */  
class ActiveQueryReader extends ActiveQuery
{
    protected $attributes = [];
    
    /**
    * Связь один-ко-иногим
    *
    * @param string $class
    * @param array $link
    *
    * @return object Query
    */
    public function hasMany($class, $link)
    {    
        return $this->createRelationQuery($class, $link, true);
    }
    
    /**
    * Связь один-к-одному
    *
    * @param string $class
    * @param array $link
    *
    * @return object Query
    */
    public function hasOne($class, $link)
    {    
        return $this->createRelationQuery($class, $link, false);
    }
    
    /**
    * @param string $class
    * @param array $link
    * @param boolean $multiple
    *
    * @return object Query
    */
    protected function createRelationQuery($class, $link, $multiple)
    {
        $query = $class::find();
        $query->primaryModel = $this;
        $query->link = $link;
        $query->multiple = $multiple;
        return $query;
    }
    
    /**
    * Коннект
    */
    public static function getDb()
    {
        return Yii::$app->db;  
    }
   
    /**
    * Получение связи
    */
    public function getRelation($name, $throwException = true)
    {
        $getter = 'get'. $name;
        
        try {
            $model = new Reader::$modelClass;
            $relation = $model->$getter();
        } catch (UnknownMethodException $e) {
            if ($throwException) {
                throw new InvalidArgumentException(get_class($this) .' has no relation named "'. $name .'".', 0, $e);
            }
        }
        
        if (method_exists($model, $getter)) {    
            return $relation;
        }
        
        return null;
    }    
    
    /**
    * Инициализация
    */
    public static function instance()
    {
       return new static(Reader::$modelClass);
    }
    
    /**
    * Инициализация
    */
    public static function instantiate()
    {
       return instance();
    }
    
    /**
    * Заполнение атрибутов модели результатом запроса
    *   
    * @param object $record
    * @param array $row
    *
    * @return void
    */
    public static function populateRecord($record, $row)
    {
        foreach ($row as $name => $value) {
            $record->attributes[$name] = $value;
        }
    }
    
    /**
    * Заглушка на afterFind()
    */
    public function afterFind(){}
}

<?php

namespace Core\domain\system;

use Core\domain\interfaces\ServiceInterface;
use Core\domain\system\yii2\readers\CommandReader;
use Core\domain\system\yii2\readers\QueryReader;
use Core\domain\system\yii2\readers\ActiveQueryReader;

/**
* Базовый ридер
*/
class Reader
{
    const PRIMARY_KEY = 'id';

    public static $modelClass; 
    public static $tableName;
    protected static $readModel;    
    
    /**
    * Эмуляция конструктора для статики
    */    
    public static function init()
    {
        self::$modelClass = get_called_class();        
        self::$readModel  = new ActiveQueryReader(self::$modelClass);
        self::$tableName  = static::tableName();
    }
    
    /**
    * @return string
    */    
    public static function tableName()
    {
        return basename(self::$modelClass);
    }
    
    /**
    * @return string
    */    
    public static function primaryKey()
    {
        return self::PRIMARY_KEY;
    }
    
    /**
    * __call
    */  
    public function __call($method, $params)
    {
        if ($this instanceof ServiceInterface) {
            $reader = new QueryReader;
        } else {
            self::init();        
            $reader = self::$readModel;
        }
        
        return call_user_func_array([$reader, $method], $params);
    }  
    
    /**
    * __callStatic
    */ 
    public static function __callStatic($method, $params)
    {
        self::init();
        return forward_static_call_array([ActiveQueryReader::class, $method], $params);
    }  
 
    /**
     * Использование чистых запросов
     *
     * @param string $query
     */
    public function createCommand($query)
    {
        return (new CommandReader)->createCommand($query);
    }  
 
    /**
     * Эмуляция find()
     */
    public static function find()
    {
        self::init();
        $model = new ActiveQueryReader(get_called_class());
        return $model->select('*')
                     ->from(self::$tableName)
                     ->asArray(); 
    }

    /**
     * Эмуляция findOne() 
     */
    public static function findOne($condition)
    {
        $condition = self::prepareCondition($condition);
        return self::find()->where($condition)
                           ->limit(1)
                           ->one();
    }
    
    /**
     * Эмуляция findAll()
     */
    public static function findAll($condition)
    {
        $condition = self::prepareCondition($condition);
        return self::find()->where($condition)
                           ->all();
    }
    
    /**
     * Запрет чистых запросов через ActiveQuery
     */
    public static function findBySql($sql = NULL)
    {
        throw new \BadMethodCallException('The findBySql() method is not allowed. Use createCommand()');
    }  
    
    /**
     * Подготовка условий
     */
    protected static function prepareCondition($condition)
    {
        if (is_array($condition)) {
         
            if (key($condition) === 0) {
                return [static::primaryKey() => array_values($condition)];
            }
            
            return $condition;
        }
        
        return [static::primaryKey() => $condition];
    }  
}