Framework PHP

Simplicidad y Consistencia

Un framework centrado en entidades. Declara la estructura del dominio una vez y Nyoze resuelve rutas, validación y persistencia.

Consistencia de principio a fin.

Ver documentación Explorar en GitHub Invítame un café
UserEntity.php 
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);
    }
}

Consistencia

Modelo centrado en entidades. Un patrón. Cada proyecto.

01

Entidad como núcleo

Campos, relaciones y restricciones declarados en un solo lugar. El sistema se organiza a partir de esa definición.

02

Estandarización estructural

Las entidades definen estructura, las actions definen comportamiento, los repositories manejan los datos. Sin variación.

03

Previsibilidad

Cualquier desarrollador localiza cualquier parte del código sin orientación. El patrón comunica por sí mismo.

Simplicidad

Menos conceptos, menos archivos, menos decisiones.

Complejidad reducida

Sin rutas manuales, sin service providers, sin configs dispersos. La entidad declara, el framework resuelve.

Lectura clara

Una entidad se lee como una especificación. Campos, actions y reglas visibles en un único archivo.

Menor costo cognitivo

El desarrollador se enfoca en el dominio, no en la infraestructura del framework.

Cómo funciona

La entidad es el núcleo. Todo parte de ella.

1

Define la entidad

Campos, tipos y restricciones con API fluida.

ProjectEntity.php 
$entity->fields(
    Field::ref('id_user', 'users'),
    Field::string('title')->required(),
    Field::string('status')->default('draft'),
);
2

Conecta el comportamiento

Cada ->can() se convierte en un endpoint HTTP.

$entity
    ->can('create', CreateAction::class)->post()
    ->can('list', ListAction::class)->get();
3

Aísla la lógica

Una action, un ActionContext, un Result.

CreateAction.php 
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);
    }
}
4

Ejecuta

Kernel, repositorio, entidades. Listo.

index.php 
$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 conectables, schema automático y CLI integrada.

Providers conectables

MySQL, SQLite o tu propio provider. La generación de SQL está desacoplada — cambia de base de datos sin alterar entidades.

Schema automático

Nyoze lee tus entidades y genera migrations SQL automáticamente. Sin escribir DDL manual.

IDs configurables

Snowflake, AutoIncrement, UUID o ULID. Elige la estrategia global o por entidad.

CLI integrada

Genera migrations, ejecuta, revierte e inspecciona el schema directo desde la terminal.

Configuración fluida

Configura la base de datos con una sola llamada. El provider, la conexión y la estrategia de ID quedan centralizados.

index.php 
$app->database()->mysql([
    'host'     => '127.0.0.1',
    'database' => 'myapp',
    'user'     => 'root',
    'pass'     => 'secret',
]);

CLI

Genera, ejecuta y gestiona migrations sin salir de la terminal.

terminal 
# make:migration
$ php nyoze make:migration

# migrate
$ php nyoze migrate

# migrate:rollback
$ php nyoze migrate:rollback

# schema:dump
$ php nyoze schema:dump

Beneficios concretos

Mantenimiento facilitado

Estructura previsible. Cualquier desarrollador navega el proyecto sin curva adicional.

Escalabilidad controlada

Agregar entidades sigue siempre el mismo proceso. El proyecto crece sin deuda técnica.

Consistencia temporal

Del primer endpoint al centésimo, el patrón es el mismo.

Persistencia desacoplada

Cambia de base de datos sin alterar la lógica de negocio.

Sin lock-in

Sin ORM propietario, sin globals. Código de dominio portable.

HTTP y CLI

Mismas entidades, mismas actions. Dos modos de ejecución.

Proyecto independiente, mantenido con tiempo personal. Si Nyoze tiene sentido en tu flujo de trabajo, un café ayuda a mantener todo en movimiento.

Invítame un café

Consistencia de principio a fin.


Ver documentación Explorar en GitHub 
$ composer require pollauf/nyoze