How to get started with annoteted entites and migrations

[Gokujo]

Hey, everybody,
I am trying to create a connection to a database with models. Preferably with automatic creation of migration files. To do this I have approached it in the following way.

Here is my connection configuration

DbHandler::$connection = new DatabaseManager(new Config\DatabaseConfig([
				'databases'   => [
					'default' => [
						'driver' => 'mysql',
						'prefix' => PREFIX . '_'
					],
					'user'    => [
						'driver' => 'mysql',
						'prefix' => USERPREFIX . '_'
					]
				],
				'connections' => [
					'mysql' => new Config\MySQLDriverConfig(
						connection : new Config\MySQL\TcpConnectionConfig(
							database : DBNAME,
							host : $host,
							port : $port,
							user : DBUSER,
							password : DBPASS,
						),
						reconnect : true,
						timezone : $config['date_adjust'],
						queryCache : true
					),
				],
			]));

Migration configuration

DbHandler::$migratorConfig = new MigrationConfig([
				'directory' => __DIR__ . '/_migrations/',
				'table'     => 'mh_migrations',
				'safe'      => true
			]);

Compiler

$classLocator = (new Tokenizer\Tokenizer(new Tokenizer\Config\TokenizerConfig([
			'directories' => [
				DataManager::normalize_path(MH_ROOT . '/_includes/models'),
				// own model paths
			],
		])))->classLocator();


		$migrator = new Migrator(DbHandler::$migratorConfig, DbHandler::$connection, new FileRepository(DbHandler::$migratorConfig));
		$migrator->configure();

		$compiler = (new Compiler())->compile(new Registry(DbHandler::$connection), [
			new Schema\Generator\ResetTables(),
			new Annotated\Embeddings($classLocator),
			new Annotated\Entities($classLocator),
			new Annotated\TableInheritance(),
			new Annotated\MergeColumns(),
			new Schema\Generator\GenerateRelations(),
			new Schema\Generator\GenerateModifiers(),
			new Schema\Generator\ValidateEntities(),
			new Schema\Generator\RenderTables(),
			new Schema\Generator\RenderRelations(),
			new Schema\Generator\RenderModifiers(),
			new Annotated\MergeIndexes(),
			new GenerateMigrations($migrator->getRepository(), $migrator->getConfig()),
			new Schema\Generator\GenerateTypecast(),
		]);

My base model

#[Entity]
#[Behavior\CreatedAt(
	field: 'createdAt',
	column: 'created_at'
)]
#[Behavior\UpdatedAt(
	field: 'updatedAt',
	column: 'updated_at'
)]
class BasisModel {
	#[Column(type: 'bigPrimary', primary: true, autoincrement: true)]
	protected int $id;

	#[Column(type: 'datetime')]
	protected \DateTimeImmutable $createdAt;

	#[Column(type: 'datetime', nullable: true)]
	protected ?\DateTimeImmutable $updatedAt = null;

}

and my model

#[Entity(role : 'mhlogs', repository : MhLogRepository::class, table : 'mh_logs')]
class MhLog extends BasisModel {
	#[Column(type : 'string')]
	private string            $type;
	#[Column(type : 'string')]
	private string            $plugin;
	#[Column(type : 'string')]
	private string            $fn_name;
	#[Column(type : 'datetime')]
	private DateTimeImmutable $time;
}

I hope I've done everything right

And now, how should I get this run? I am a little bit irritated.

For starting the ORM I have this

		$orm = new ORM(new Factory(DbHandler::$connection), $schema);

		return $orm->with(schema : $compiler);

$schema - is my model because compiler gives me some argues with this description:
Expected parameter of type '\Cycle\ORM\SchemaInterface|null', '\mixed[][]' provided

It's a little bit confused described in the docs.

[roxblnfk]

Hello it looks like you want to use JTI hierarchy.
Do you use any framework?

[Gokujo]

if I saw it right the compiler returns role id and scheme, right? but I still get a mixed array

or should I implement to entity class? then how should i initiate the inherited functions?

[roxblnfk]

I still get a mixed array

Could you share?

inherited functions

What do tou mean?

[Gokujo]

Could you share?

public function compile(Registry $registry, array $generators = [], array $defaults = []): array

This is the function of Compiler class

My whole class

<?php


namespace MaHarder\classes;

use Cycle\Annotated;
use Cycle\Database\Config;
use Cycle\Database\DatabaseInterface;
use Cycle\Database\DatabaseManager;
use Cycle\Migrations\Config\MigrationConfig;
use Cycle\Migrations\FileRepository;
use Cycle\Migrations\Migrator;
use Cycle\ORM\Factory;
use Cycle\ORM\ORM;
use Cycle\ORM\ORMInterface;
use Cycle\Schema;
use Cycle\Schema\Compiler;
use Cycle\Schema\Definition\Entity;
use Cycle\Schema\Generator\Migrations\GenerateMigrations;
use Cycle\Schema\Registry;
use db;
use DLEPlugins;
use Exception;
use Spiral\Tokenizer;


require_once(DLEPlugins::Check(ENGINE_DIR . '/inc/maharder/_includes/extras/paths.php'));

abstract class DbHandler {

	static ?DatabaseManager $connection     = null;
	static ?db              $dle_db         = null;
	static ?MigrationConfig $migratorConfig = null;

	public static function init() : void {
		global $config;

		require_once(DLEPlugins::Check(DataManager::normalize_path(ENGINE_DIR . '/data/dbconfig.php')));

		if (is_null(DbHandler::$dle_db)) DbHandler::$dle_db = $db;

		if (is_null(DbHandler::$connection)) {
			$db_name_port = explode(':', DBHOST);
			$port         = count($db_name_port) > 1 ? (int) $db_name_port[1] : 3306;
			$host         = $db_name_port[0];

			DbHandler::$connection = new DatabaseManager(new Config\DatabaseConfig([
				'databases'   => [
					'default' => [
						'driver' => 'mysql',
						'prefix' => PREFIX . '_'
					],
					'user'    => [
						'driver' => 'mysql',
						'prefix' => USERPREFIX . '_'
					]
				],
				'connections' => [
					'mysql' => new Config\MySQLDriverConfig(
						connection : new Config\MySQL\TcpConnectionConfig(
							database : DBNAME,
							host : $host,
							port : $port,
							user : DBUSER,
							password : DBPASS,
						),
						reconnect : true,
						timezone : $config['date_adjust'],
						queryCache : true
					),
				],
			]));

		}

		if (is_null(DbHandler::$migratorConfig)) {
			DbHandler::$migratorConfig = new MigrationConfig([
				'directory' => MH_ROOT . '/_migrations/',
				'table'     => 'mh_migrations',
				'safe'      => true
			]);
		}
	}

	static function run(Entity $model, bool $userDb = false) : ORMInterface {
		DbHandler::init();

		$classLocator = (new Tokenizer\Tokenizer(new Tokenizer\Config\TokenizerConfig([
			'directories' => [
				DataManager::normalize_path(MH_ROOT . '/_includes/models'),
				// own model paths
			],
		])))->classLocator();


		$migrator = new Migrator(DbHandler::$migratorConfig, DbHandler::$connection, new FileRepository(DbHandler::$migratorConfig));
		$migrator->configure();

		$compiler = new Compiler();
		$compiler->compile(new Registry(DbHandler::$connection), [
			new Schema\Generator\ResetTables(),
			new Annotated\Embeddings($classLocator),
			new Annotated\Entities($classLocator),
			new Annotated\TableInheritance(),
			new Annotated\MergeColumns(),
			new Schema\Generator\GenerateRelations(),
			new Schema\Generator\GenerateModifiers(),
			new Schema\Generator\ValidateEntities(),
			new Schema\Generator\RenderTables(),
			new Schema\Generator\RenderRelations(),
			new Schema\Generator\RenderModifiers(),
			new Annotated\MergeIndexes(),
			new GenerateMigrations($migrator->getRepository(), $migrator->getConfig()),
			new Schema\Generator\GenerateTypecast(),
		]);

		$orm = new ORM(new Factory(DbHandler::$connection), $model->getSchema());

		return $orm->with(schema : $compiler->getSchema()[$model->getRole()]);

	}

	static function getDleDb() : db {
		DbHandler::init();
		return DbHandler::$dle_db;
	}

	static function getDb() : DatabaseInterface {
		DbHandler::init();
		return DbHandler::$connection->database('default');
	}

	static function getUserDb() : DatabaseInterface {
		DbHandler::init();
		return DbHandler::$connection->database('user');
	}

	static function runMigrations() : void {
		DbHandler::init();
		try {
			DbHandler::$migrator->run();
		} catch (Exception|\Throwable $e) {
			DbHandler::$migrator->rollback();
		}
	}

}

And those line get my head aroused

$orm = new ORM(new Factory(DbHandler::$connection), $model->getSchema());

		return $orm->with(schema : $compiler->getSchema()[$model->getRole()]);

What do tou mean?

PHPStorm means I should implement SchemaInterface to Entity. But that's bullshit. I don't get how to get SchemaInterface from Entity. I have no problem with working without migrations but I would like to have them

[roxblnfk]

// ... 
		$compiler = new Compiler();
                // Compiler returns Schema array that can be cached
		$schemaArray = $compiler->compile(new Registry(DbHandler::$connection), [
			new Schema\Generator\ResetTables(),
			new Annotated\Embeddings($classLocator),
			new Annotated\Entities($classLocator),
			new Annotated\TableInheritance(),
			new Annotated\MergeColumns(),
			new Schema\Generator\GenerateRelations(),
			new Schema\Generator\GenerateModifiers(),
			new Schema\Generator\ValidateEntities(),
			new Schema\Generator\RenderTables(),
			new Schema\Generator\RenderRelations(),
			new Schema\Generator\RenderModifiers(),
			new Annotated\MergeIndexes(),
			new GenerateMigrations($migrator->getRepository(), $migrator->getConfig()),
			new Schema\Generator\GenerateTypecast(),
		]);

                // You can modify Schema array if you need.
                // For example: add entities that weren't described using attributes
                // Using Schema array you can create Schema object:
                $schema = new \Cycle\ORM\Schema($schemaArray);

                // Schema object is used in ORM
		$orm = new ORM(new Factory(DbHandler::$connection), $schema);

		return $orm;
// ...