NyozeSimplicidade e Consistência
Um framework centrado em entidades. Declare a estrutura do domínio uma vez e o Nyoze resolve rotas, validação e persistência.
Consistência do início ao fim.
class UserEntity extends EntityDefinition
{
public function define(Entity $entity): void
{
$entity
->fields(
Field::string('name')->required(),
Field::email('email')->unique(),
Field::password('password')->hidden(),
)
->can('profile', ProfileAction::class)
->invariant(EmailRequired::class);
}
}Consistência
Modelo centrado em entidades. Um padrão. Todo projeto.
Entidade como núcleo
Campos, relações e restrições declarados em um lugar. O sistema se organiza a partir dessa definição.
Padronização estrutural
Entidades definem estrutura, actions definem comportamento, repositories cuidam dos dados. Sem variação.
Previsibilidade
Qualquer desenvolvedor localiza qualquer parte do código sem orientação. O padrão comunica por si.
Simplicidade
Menos conceitos, menos arquivos, menos decisões.
Complexidade reduzida
Sem rotas manuais, sem service providers, sem configs dispersos. A entidade declara, o framework resolve.
Leitura clara
Uma entidade se lê como uma especificação. Campos, actions e regras visíveis em um único arquivo.
Custo cognitivo menor
O desenvolvedor foca no domínio, não na infraestrutura do framework.
Como funciona
A entidade é o núcleo. Tudo parte dela.
Defina a entidade
Campos, tipos e restrições com API fluente.
$entity->fields(
Field::ref('id_user', 'users'),
Field::string('title')->required(),
Field::string('status')->default('draft'),
);Conecte o comportamento
Cada ->can() vira um endpoint HTTP.
$entity
->can('create', CreateAction::class)->post()
->can('list', ListAction::class)->get();Isole a lógica
Uma action, um ActionContext, um Result.
class CreateAction
{
public function __invoke(ActionContext $ctx): Result
{
$project = $ctx->repo()->save('projects', [
'title' => $ctx->input('title'),
'id_user' => $ctx->userId(),
]);
return Result::created($project);
}
}Execute
Kernel, repositório, entidades. Pronto.
$kernel = Kernel::load(function (App $app) {
$app->useRepository(
new PdoRepository(new PDO('sqlite:app.db'))
);
$app->load([UserEntity::class]);
});
$kernel->app()->run();Database & Migrations
Providers plugáveis, schema automático e CLI integrada.
Providers plugáveis
MySQL, SQLite ou seu próprio provider. A geração de SQL é desacoplada — troque de banco sem alterar entidades.
Schema automático
O Nyoze lê suas entidades e gera migrations SQL automaticamente. Sem escrever DDL manual.
IDs configuráveis
Snowflake, AutoIncrement, UUID ou ULID. Escolha a estratégia global ou por entidade.
CLI integrada
Gere migrations, execute, reverta e inspecione o schema direto do terminal.
Configuração fluente
Configure o banco com uma única chamada. O provider, a conexão e a estratégia de ID ficam centralizados.
$app->database()->mysql([
'host' => '127.0.0.1',
'database' => 'myapp',
'user' => 'root',
'pass' => 'secret',
]);CLI
Gere, execute e gerencie migrations sem sair do terminal.
# make:migration
$ php nyoze make:migration
# migrate
$ php nyoze migrate
# migrate:rollback
$ php nyoze migrate:rollback
# schema:dump
$ php nyoze schema:dumpBenefícios concretos
Manutenção facilitada
Estrutura previsível. Qualquer desenvolvedor navega o projeto sem curva adicional.
Escalabilidade controlada
Adicionar entidades segue sempre o mesmo processo. O projeto cresce sem dívida técnica.
Consistência temporal
Do primeiro endpoint ao centésimo, o padrão é o mesmo.
Persistência desacoplada
Troque de banco sem alterar a lógica de negócio.
Sem lock-in
Sem ORM proprietário, sem globals. Código de domínio portável.
HTTP e CLI
Mesmas entidades, mesmas actions. Dois modos de execução.
Projeto independente, mantido com tempo pessoal. Se o Nyoze fizer sentido no seu fluxo, um café ajuda a manter tudo em movimento.
Oferecer um café