composer require pollauf/nyoze

my-project/
├── App/
│   ├── Entities/
│   ├── Actions/
│   ├── Repositories/
│   ├── Resources/
│   ├── Rules/
│   └── Support/
├── vendor/
├── composer.json
├── index.php
└── .env

{
    "require": {
        "php": ">=8.2",
        "pollauf/nyoze": "*"
    },
    "autoload": {
        "psr-4": {
            "App\\\\": "App/"
        }
    }
}

<?php
require __DIR__ . '/vendor/autoload.php';

use App\Context;
use Nyoze\Core\Kernel;
use Nyoze\Data\PdoRepository;
use Nyoze\Support\Config;

$config = Config::fromEnv(__DIR__ . '/.env');

$kernel = Kernel::load(function (\Nyoze\Core\App $app) use ($config) {
    $dsn = $config->get('DB_DSN', 'sqlite:database.sqlite');
    $pdo = new PDO($dsn, $config->get('DB_USER'), $config->get('DB_PASS'));
    $app->useRepository(new PdoRepository($pdo));
    (new Context())->register($app);
});

$kernel->app()->run();

<?php
namespace App;

use App\Entities\TaskEntity;
use Nyoze\Core\App;

class Context
{
    public function register(App $app): void
    {
        $app->load([
            TaskEntity::class,
        ]);
    }
}

<?php
namespace App\Entities;

use App\Actions\Tasks\CreateTaskAction;
use App\Actions\Tasks\ListTasksAction;
use Nyoze\Domain\Entity;
use Nyoze\Domain\EntityDefinition;
use Nyoze\Domain\Field;

class TaskEntity extends EntityDefinition
{
    public function name(): string { return 'tasks'; }

    public function define(Entity $entity): void
    {
        $entity
            ->fields(
                Field::string('title')->required(),
                Field::text('description'),
                Field::string('status')->default('pending'),
                Field::datetime('created_at')->defaultNow(),
            )
            ->can('create', CreateTaskAction::class)->post()
            ->can('list', ListTasksAction::class)->get();
    }
}

<?php
namespace App\Actions\Tasks;

use Nyoze\Domain\ActionContext;
use Nyoze\Domain\Result;

class CreateTaskAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        // No need to check if title is empty — Field::string('title')->required()
        // already guarantees presence before the handler runs.

        $task = $ctx->repo()->save('tasks', [
            'title'       => $ctx->input('title'),
            'description' => $ctx->input('description', ''),
            'status'      => $ctx->input('status', 'pending'),
            'created_at'  => $ctx->now(),
        ]);

        return Result::created($task);
    }
}

class ListTasksAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        $tasks = $ctx->repo()->all('tasks');
        return Result::ok($tasks);
    }
}

use Nyoze\Domain\Entity;
use Nyoze\Domain\EntityDefinition;

abstract class EntityDefinition
{
    abstract public function name(): string;
    abstract public function define(Entity $entity): void;
}

use Nyoze\Domain\Entity;
use Nyoze\Domain\EntityDefinition;
use Nyoze\Domain\Field;

class UserEntity extends EntityDefinition
{
    public function name(): string { return 'users'; }

    public function define(Entity $entity): void
    {
        $entity
            ->fields(
                Field::string('name')->required(),
                Field::email('email')->required()->unique(),
                Field::password('password')->hidden(),
            );
    }
}

$entity->auth();

$entity
    ->auth()
    ->ownedBy('id_user');

$entity->virtual();

$entity->fields(
    Field::ref('id_user', 'users')->required(),
    Field::string('title')->required(),
    Field::string('status')->default('draft'),
    Field::text('body'),
    Field::integer('sort_order')->default(0),
);

use Nyoze\Domain\EntityAction;

$entity
    ->can(EntityAction::create())   // POST /api/{entity}
    ->can(EntityAction::list())     // GET  /api/{entity}
    ->can(EntityAction::get())      // GET  /api/{entity}/:id
    ->can(EntityAction::update())   // PUT  /api/{entity}/:id
    ->can(EntityAction::delete());  // DELETE /api/{entity}/:id

use Nyoze\Domain\EntityAction;

$entity->can(EntityAction::all());

$entity
    ->can('profile', UserProfileAction::class)->get()
    ->can('updateProfile', UpdateUserProfileAction::class)->put()
    ->can('changePassword', ChangePasswordAction::class)->post();

use App\Rules\PublishedProjectHasSections;

// Using a Rule class
$entity->invariant(PublishedProjectHasSections::class);

// Using an inline closure
$entity->invariant(
    fn(array $data) => $data['status'] !== 'completed' || ($data['deliverable_count'] ?? 0) > 0,
    'Completed projects must have at least one deliverable'
);

$entity->hasMany('sections', 'id_project');

$entity->hasOne('profile', 'id_user');

$entity->belongsTo('users', 'id_user');

$entity->before('create', function(mixed $data, ActionContext $ctx) {
    $data['created_at'] = $ctx->now();
    return $data;
});

$entity->after('register', function(mixed $data, ActionContext $ctx) {
    // Send welcome email, log event, etc.
});

$entity->when('status', 'published', function(array $data, ActionContext $ctx) {
    // Notify subscribers when status becomes "published"
});

use App\Actions\Projects\DuplicateProjectAction;
use App\Rules\PublishedProjectHasSections;
use Nyoze\Domain\Entity;
use Nyoze\Domain\EntityAction;
use Nyoze\Domain\EntityDefinition;
use Nyoze\Domain\Field;

class ProjectEntity extends EntityDefinition
{
    public function name(): string { return 'projects'; }

    public function define(Entity $entity): void
    {
        $entity
            ->auth()
            ->ownedBy('id_user')
            ->fields(
                Field::ref('id_user', 'users')->required(),
                Field::string('title')->required(),
                Field::string('status')->default('draft'),
                Field::text('body'),
            )
            ->can(EntityAction::all())
            ->can('duplicate', DuplicateProjectAction::class)->post()
            ->invariant(PublishedProjectHasSections::class);
    }
}

use App\Actions\Auth\LoginAction;
use App\Actions\Auth\RegisterAction;
use App\Actions\Auth\LogoutAction;
use Nyoze\Domain\Entity;
use Nyoze\Domain\EntityDefinition;

class SessionEntity extends EntityDefinition
{
    public function name(): string { return 'sessions'; }

    public function define(Entity $entity): void
    {
        $entity
            ->virtual()
            ->can('login', LoginAction::class)->post()
            ->can('register', RegisterAction::class)->post()
            ->can('logout', LogoutAction::class)->post();
    }
}

use Nyoze\Domain\Field;

$entity->fields(
    Field::string('name')->required(),
    Field::email('email')->required()->unique(),
    Field::password('password')->hidden(),
    Field::boolean('active')->default(true),
);

Field::enum('status', OrderStatus::class)

Field::ref('id_user', 'users')->required()
Field::ref('id_project', 'projects')->required()

Field::string('name')->required()

Field::email('email')->required()->unique()

Field::password('password')->hidden()

Field::string('avatar_url')->nullable()

Field::string('status')->default('draft')
Field::boolean('active')->default(true)
Field::integer('sort_order')->default(0)

Field::datetime('created_at')->defaultNow()

Field::string('name')->required()->label('Full Name')

Field::string('title')->required()->max(255)

Field::string('password')->required()->min(8)

Field::string('id_user')->references('users')

Field::string('status')->enumClass(OrderStatus::class)

enum FieldType: string
{
    case Id       = 'id';
    case String   = 'string';
    case Text     = 'text';
    case Integer  = 'integer';
    case BigInt   = 'bigint';
    case Decimal  = 'decimal';
    case Boolean  = 'boolean';
    case DateTime = 'datetime';
    case Date     = 'date';
    case Email    = 'email';
    case Password = 'password';
    case Money    = 'money';
    case Json     = 'json';
    case Enum     = 'enum';
    case Ref      = 'ref';
}

use Nyoze\Domain\Entity;
use Nyoze\Domain\EntityDefinition;
use Nyoze\Domain\Field;

class UserEntity extends EntityDefinition
{
    public function name(): string { return 'users'; }

    public function define(Entity $entity): void
    {
        $entity
            ->auth()
            ->fields(
                Field::string('name')->required(),
                Field::email('email')->required()->unique(),
                Field::password('password')->hidden(),
                Field::string('language')->default('pt-BR'),
                Field::string('avatar_url'),
                Field::boolean('onboarding_done')->default(false),
                Field::boolean('active')->default(true),
            );
    }
}

public function __invoke(ActionContext $ctx): Result

use Nyoze\Domain\ActionContext;
use Nyoze\Domain\Result;

class UserProfileAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        $user = $ctx->repo()->find('users', $ctx->userId());

        if (!$user) {
            return Result::notFound('User not found');
        }

        return Result::ok($user);
    }
}

use Nyoze\Domain\EntityAction;

$entity
    ->can(EntityAction::all())
    ->can('profile', UserProfileAction::class)->get()
    ->can('changePassword', ChangePasswordAction::class)->post();

$entity->can('ping', fn(ActionContext $ctx) => Result::ok(['pong' => true]))->get();

$project = $ctx->entity();
// ['id' => 1, 'title' => 'My Project', 'status' => 'draft', ...]

$allInput = $ctx->data();
// ['name' => 'John', 'email' => 'john@example.com', ...]

$email = $ctx->input('email');
$language = $ctx->input('language', 'en');

$id = $ctx->param('id');

$userId = $ctx->userId();

$user = $ctx->repo()->find('users', $ctx->userId());
$allProjects = $ctx->repo()->all('projects', ['id_user' => $ctx->userId()]);

$repo = $ctx->repository();

$hashedPassword = $ctx->hash($ctx->input('password'));

if (!$ctx->verifyHash($password, $user['password'])) {
    return Result::fail('Invalid credentials');
}

$timestamp = $ctx->now();
// "2024-01-15 14:30:00"

// Dispatch to another entity
$result = $ctx->dispatch('credits', 'initialize', [
    'id_user' => $user['id'],
    'plan_credits' => 30,
]);

if (!$result->success) {
    return $result; // Propagate failure — triggers rollback
}

$exec = $ctx->execution();
$exec->correlationId();  // Unique ID for this request
$exec->depth();          // Current nesting depth (0 = root)
$exec->callStack();      // Array of entity/action pairs
$exec->rootEntity();     // Root entity name
$exec->rootAction();     // Root action name
$exec->parentEntity();   // Parent entity (null if root)
$exec->parentAction();   // Parent action (null if root)

use App\Repositories\UserRepository;
use App\Resources\UserResource;
use App\Support\TokenHelper;
use Nyoze\Domain\ActionContext;
use Nyoze\Domain\Result;

class LoginAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        $email    = $ctx->input('email');
        $password = $ctx->input('password');

        if (!$email || !$password) {
            return Result::fail('Email and password are required');
        }

        $users = new UserRepository($ctx->repo());
        $user  = $users->findByEmail($email);

        if (!$user || !$ctx->verifyHash($password, $user['password'])) {
            return Result::fail('Invalid credentials');
        }

        return Result::ok([
            'token' => TokenHelper::generate($user['id']),
            'user'  => UserResource::make($user),
        ]);
    }
}

use App\Repositories\UserRepository;
use App\Resources\UserResource;
use App\Support\TokenHelper;
use Nyoze\Domain\ActionContext;
use Nyoze\Domain\Result;

class RegisterAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        $name     = $ctx->input('name');
        $email    = $ctx->input('email');
        $password = $ctx->input('password');

        if (!$name || !$email || !$password) {
            return Result::fail('Name, email and password are required');
        }

        $users = new UserRepository($ctx->repo());

        if ($users->emailExists($email)) {
            return Result::fail('Email already registered');
        }

        $user = $users->save([
            'name'     => $name,
            'email'    => $email,
            'password' => $ctx->hash($password),
        ]);

        // Initialize credits through the pipeline
        $creditResult = $ctx->dispatch('credits', 'initialize', [
            'id_user' => $user['id'],
        ]);

        if (!$creditResult->success) {
            return $creditResult;
        }

        return Result::created([
            'token' => TokenHelper::generate($user['id']),
            'user'  => UserResource::make($user),
        ]);
    }
}

namespace Nyoze\Data;

interface Repository
{
    // Data access
    public function find(string $table, int|string $id): ?array;
    public function findBy(string $table, array $conditions): ?array;
    public function all(string $table, array $conditions = [], ?string $orderBy = null,
        ?string $direction = 'ASC', ?int $limit = null, ?int $offset = null): array;
    public function save(string $table, array $data): array;
    public function update(string $table, array $data, array $conditions): int;
    public function delete(string $table, int|string $id): bool;
    public function query(): Query;

    // Transaction control
    public function beginTransaction(): void;
    public function commit(): void;
    public function rollBack(): void;
    public function inTransaction(): bool;
    public function transaction(callable $callback): mixed;
}

$user = $repo->find('users', 42);
// ['id' => 42, 'name' => 'John', 'email' => 'john@example.com', ...]

$user = $repo->findBy('users', ['email' => 'john@example.com']);

// All active users
$users = $repo->all('users', ['active' => true]);

// Ordered by name, limited to 10
$users = $repo->all('users', [], 'name', 'ASC', 10);

// With offset for pagination
$users = $repo->all('users', [], 'created_at', 'DESC', 20, 40);

// Insert (no id)
$user = $repo->save('users', [
    'name'  => 'John',
    'email' => 'john@example.com',
]);
// ['id' => 1, 'name' => 'John', 'email' => 'john@example.com']

// Update (id present)
$user = $repo->save('users', [
    'id'   => 1,
    'name' => 'John Doe',
]);

$affected = $repo->update('users', ['active' => false], ['id' => 42]);

$deleted = $repo->delete('users', 42);

$results = $repo->query()
    ->select('id', 'name', 'email')
    ->from('users')
    ->where('active', true)
    ->orderBy('name')
    ->limit(10)
    ->get();

$repo->beginTransaction();

$repo->commit();

$repo->rollBack();

if ($repo->inTransaction()) {
    // inside a transaction
}

// Preferred: automatic commit/rollback
$result = $ctx->repo()->transaction(function($repo) {
    $repo->save('orders', $orderData);
    $repo->save('order_items', $itemData);
    return Result::created($order);
});

// Manual control (when needed)
$repo->beginTransaction();
try {
    $repo->save('users', $userData);
    $repo->save('profiles', $profileData);
    $repo->commit();
} catch (\Throwable $e) {
    $repo->rollBack();
    throw $e;
}

use Nyoze\Data\PdoRepository;

$pdo  = new PDO('mysql:host=localhost;dbname=myapp', 'user', 'pass');
$repo = new PdoRepository($pdo);

$pdo = $repo->pdo();

$repo->query()->select('id', 'name', 'email')

$repo->query()->from('users')

$repo->query()->from('users')->where('active', true)
$repo->query()->from('users')->where('age', 18, '>=')

$repo->query()->from('users')->whereIn('id', [1, 2, 3])

$repo->query()->from('users')->orderBy('created_at', 'DESC')

$repo->query()->from('users')->limit(10)

$repo->query()->from('users')->limit(10)->offset(20)

$repo->query()
    ->select('projects.title', 'users.name')
    ->from('projects')
    ->join('users', 'users.id = projects.id_user', 'LEFT')

$users = $repo->query()
    ->from('users')
    ->where('active', true)
    ->orderBy('name')
    ->get();

$user = $repo->query()
    ->from('users')
    ->where('email', 'john@example.com')
    ->first();

$total = $repo->query()
    ->from('users')
    ->where('active', true)
    ->count();

$hasAdmin = $repo->query()
    ->from('users')
    ->where('role', 'admin')
    ->exists();

use Nyoze\Data\Repository;

class UserRepository
{
    public function __construct(
        private readonly Repository $repo,
    ) {}

    public function findById(int $id): ?array
    {
        return $this->repo->find('users', $id);
    }

    public function findByEmail(string $email): ?array
    {
        return $this->repo->findBy('users', ['email' => $email]);
    }

    public function emailExists(string $email): bool
    {
        return $this->repo->query()
            ->from('users')
            ->where('email', $email)
            ->exists();
    }

    public function save(array $data): array
    {
        return $this->repo->save('users', $data);
    }
}

class UserProfileAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        $users = new UserRepository($ctx->repo());
        $user  = $users->findById($ctx->userId());

        if (!$user) {
            return Result::notFound('User not found');
        }

        return Result::ok(UserResource::make($user));
    }
}

namespace Nyoze\Domain;

abstract class Resource
{
    abstract protected function transform(array $data): array;

    public static function make(array $data): array;
    public static function collection(array $items): array;
}

use Nyoze\Domain\Resource;

class UserResource extends Resource
{
    protected function transform(array $data): array
    {
        unset($data['password']);
        return $data;
    }
}

use Nyoze\Domain\Resource;

class CreditResource extends Resource
{
    protected function transform(array $data): array
    {
        $plan      = $data['plan_credits'] ?? 0;
        $purchased = $data['purchased_credits'] ?? 0;

        return [
            'total_credits'     => $plan + $purchased,
            'plan_credits'      => $plan,
            'purchased_credits' => $purchased,
        ];
    }
}

$user = $repo->find('users', $userId);
$output = UserResource::make($user);
// Password field is removed from the output

$users = $repo->all('users', ['active' => true]);
$output = UserResource::collection($users);
// Each user in the array has the password field removed

use Nyoze\Domain\ActionContext;
use Nyoze\Domain\Result;

class UserProfileAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        $user = $ctx->repo()->find('users', $ctx->userId());

        if (!$user) {
            return Result::notFound('User not found');
        }

        return Result::ok(UserResource::make($user));
    }
}

class LoginAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        // ... authentication logic ...

        return Result::ok([
            'token' => TokenHelper::generate($user['id']),
            'user'  => UserResource::make($user),
        ]);
    }
}

namespace Nyoze\Domain;

abstract class Rule
{
    abstract public function check(array $data): bool;
    abstract public function message(): string;
}

use Nyoze\Domain\Rule;

class PublishedProjectHasSections extends Rule
{
    public function check(array $data): bool
    {
        if ($data['status'] !== 'published') return true;
        return ($data['section_count'] ?? 0) > 0;
    }

    public function message(): string
    {
        return 'Published projects must have at least one section';
    }
}

use Nyoze\Domain\Rule;

class ActiveProjectMustHaveOwner extends Rule
{
    public function check(array $data): bool
    {
        if (($data['status'] ?? '') !== 'active') return true;
        return !empty($data['id_user']);
    }

    public function message(): string
    {
        return 'Active projects must have an owner';
    }
}

use App\Rules\PublishedProjectHasSections;
use Nyoze\Domain\Entity;
use Nyoze\Domain\EntityAction;
use Nyoze\Domain\EntityDefinition;
use Nyoze\Domain\Field;

class ProjectEntity extends EntityDefinition
{
    public function name(): string { return 'projects'; }

    public function define(Entity $entity): void
    {
        $entity
            ->auth()
            ->ownedBy('id_user')
            ->fields(
                Field::ref('id_user', 'users')->required(),
                Field::string('title')->required(),
                Field::string('status')->default('draft'),
            )
            ->can(EntityAction::all())
            ->invariant(PublishedProjectHasSections::class);
    }
}

// Good: protects domain coherence (end date must be after start date)
$entity->invariant(
    fn(array $data) => !$data['start_date'] || !$data['end_date'] || $data['end_date'] >= $data['start_date'],
    'End date cannot be before start date'
);

// When PublishedProjectHasSections fails:
{
    "success": false,
    "error": "Published projects must have at least one section"
}
// HTTP 422 Unprocessable Entity

$entity->before('create', function(mixed $data, ActionContext $ctx) {
    // Add a timestamp before the record is created
    $data['created_at'] = $ctx->now();
    return $data;
});

$entity->before('delete', function(mixed $data, ActionContext $ctx) {
    // Prevent deletion of admin users
    if (($data['role'] ?? '') === 'admin') {
        return Result::forbidden('Cannot delete admin users');
    }
});

$entity->after('register', function(mixed $data, ActionContext $ctx) {
    // Send a welcome email after registration
    // $data contains the result from the action
});

$entity->after('delete', function(mixed $data, ActionContext $ctx) {
    // Clean up related resources after deletion
});

$entity->when('status', 'published', function(array $data, ActionContext $ctx) {
    // Notify subscribers when a project is published
});

$entity->when('status', 'archived', function(array $data, ActionContext $ctx) {
    // Clean up resources when a project is archived
});

class AddTimestamp
{
    public function __invoke(mixed $data, ActionContext $ctx): array
    {
        $data['updated_at'] = $ctx->now();
        return $data;
    }
}

$entity->before('update', AddTimestamp::class);

1. Before hooks      → Run in registration order
2. BEGIN TRANSACTION
3. Action handler    → The __invoke method of the action class
4. Invariants        → All registered Rule checks
5. COMMIT
6. When hooks        → Triggered by field values in the result
7. After hooks       → Run in registration order

1. Before hooks      → Run in registration order
2. Invariants        → All registered Rule checks
3. BEGIN TRANSACTION
4. Write operation   → The actual database write
5. After hooks       → Run in registration order
6. COMMIT

before hooks → handler → invariants → [queue when/after hooks] → return Result

use Nyoze\Domain\Entity;
use Nyoze\Domain\EntityDefinition;
use Nyoze\Domain\Field;
use Nyoze\Domain\ActionContext;
use Nyoze\Domain\Result;

class OrdersEntity extends EntityDefinition
{
    public function name(): string { return 'orders'; }

    public function define(Entity $entity): void
    {
        $entity
            ->auth()
            ->ownedBy('id_user')
            ->fields(
                Field::ref('id_user', 'users')->required(),
                Field::string('status')->default('pending'),
                Field::money('total')->required(),
                Field::datetime('created_at')->defaultNow(),
            )
            ->can('place', PlaceOrderAction::class)->post()
            ->can('cancel', CancelOrderAction::class)->post()
            ->before('place', function(mixed $data, ActionContext $ctx) {
                $data['created_at'] = $ctx->now();
                return $data;
            })
            ->after('place', function(mixed $data, ActionContext $ctx) {
                // Send order confirmation
            })
            ->when('status', 'shipped', function(array $data, ActionContext $ctx) {
                // Notify customer of shipment
            })
            ->when('status', 'cancelled', function(array $data, ActionContext $ctx) {
                // Process refund
            })
            ->invariant(fn(array $d) => ($d['total'] ?? 0) > 0, 'Order total must be positive');
    }
}

class RegisterAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        $user = $ctx->repo()->save('users', [...]);

        // Dispatch through the pipeline — not a direct repo call
        $result = $ctx->dispatch('credits', 'initialize', [
            'id_user' => $user['id'],
        ]);

        if (!$result->success) {
            return $result;
        }

        return Result::created([...]);
    }
}

subscriptions.manage (depth=0)
├─ BEGIN TRANSACTION
├─ handler
│   ├─ dispatch subscriptions.create (depth=1)
│   │   ├─ before hooks
│   │   ├─ handler (writes to user_subscriptions)
│   │   ├─ invariants checked
│   │   └─ when/after hooks → QUEUED
│   ├─ dispatch credits.updatePlanCredits (depth=1)
│   │   ├─ before hooks
│   │   ├─ handler (writes to credits)
│   │   ├─ invariants checked
│   │   └─ when/after hooks → QUEUED
│   └─ returns Result::ok
├─ invariants checked
├─ COMMIT
├─ FLUSH queued when hooks
└─ FLUSH queued after hooks

$ctx->execution()->callStack();
// [
//   ['entity' => 'subscriptions', 'action' => 'manage',           'depth' => 0],
//   ['entity' => 'subscriptions', 'action' => 'create',           'depth' => 1],
//   ['entity' => 'credits',       'action' => 'updatePlanCredits', 'depth' => 2],
// ]

[
    'correlation_id' => 'a1b2c3d4',
    'root'           => 'subscriptions.manage',
    'failed'         => 'credits.initialize',
    'stage'          => 'invariants',
    'rolled_back'    => true,
    'call_chain'     => '└── subscriptions.manage\n  └── credits.initialize ❌',
]

$kernel = Kernel::load(function (App $app) {
    $app->database()->mysql([
        'host'     => '127.0.0.1',
        'database' => 'minha_app',
        'user'     => 'root',
        'pass'     => 'secret',
    ]);

    (new Context())->register($app);
});

use Nyoze\Data\Database\MySqlProvider;
use Nyoze\Data\Database\IdStrategy;

$app->database()
    ->provider(new MySqlProvider())
    ->connection([
        'dsn'  => 'mysql:host=127.0.0.1;dbname=app;charset=utf8mb4',
        'user' => 'root',
        'pass' => 'secret',
    ])
    ->idStrategy(IdStrategy::Snowflake)
    ->nodeId(1);

use Nyoze\Data\Database\DatabaseProviderInterface;
use Nyoze\Data\Database\TableDefinition;
use Nyoze\Data\Database\ColumnDefinition;
use Nyoze\Data\Database\IdStrategy;

class PostgresProvider implements DatabaseProviderInterface
{
    public function name(): string { return 'postgres'; }
    public function createTable(TableDefinition $table): string { /* ... */ }
    public function createAll(array $tables): string { /* ... */ }
    public function columnSql(ColumnDefinition $column): string { /* ... */ }
    public function idColumnSql(IdStrategy $strategy): string { /* ... */ }
}

class CreateOrderAction
{
    public function __invoke(ActionContext $ctx): Result
    {
        $orderId = $ctx->ids()->next();

        $order = $ctx->repo()->save('orders', [
            'id'      => $orderId,
            'id_user' => $ctx->userId(),
            'status'  => 'pending',
        ]);

        return Result::created($order);
    }
}

$app->database()->mysql([...])->nodeId((int) getenv('SNOWFLAKE_NODE_ID') ?: 0);

use Nyoze\Data\Database\SnowflakeGenerator;

$parts = SnowflakeGenerator::parse($id);
// ['timestamp' => 1700000123456, 'nodeId' => 1, 'sequence' => 42]

php Nyoze make:migration

Created: 2025_01_15_143022_users.sql
Created: 2025_01_15_143022_projects.sql
Created: 2025_01_15_143022_sections.sql

database/migrations/
├── 2025_01_15_143022_users.sql
├── 2025_01_15_143022_users_rollback.sql      (optional)
├── 2025_01_15_143022_projects.sql
└── 2025_01_15_143022_sections.sql

CREATE TABLE IF NOT EXISTS users (
    id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    password VARCHAR(255),
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

php Nyoze migrate

✓ 2025_01_15_143022_users.sql
✓ 2025_01_15_143022_projects.sql
✓ 2025_01_15_143022_sections.sql

php Nyoze migrate:rollback

DROP TABLE IF EXISTS users;

# Print to terminal
php Nyoze schema:dump

# Save to file
php Nyoze schema:dump --file

php vendor/bin/Nyoze

# List entities
php Nyoze entities

# Generate migrations from entities
php Nyoze make:migration

# Run pending migrations
php Nyoze migrate

# Rollback last migration
php Nyoze migrate:rollback

# Dump schema to terminal
php Nyoze schema:dump

# Dump schema to file
php Nyoze schema:dump --file

<?php
use App\Context;
use Nyoze\Core\App;

return function (App $app) {
    $app->database()->mysql([
        'host'     => getenv('DB_HOST') ?: '127.0.0.1',
        'database' => getenv('DB_DATABASE') ?: 'minha_app',
        'user'     => getenv('DB_USER') ?: 'root',
        'pass'     => getenv('DB_PASS') ?: '',
    ]);

    (new Context())->register($app);
};