♻️ (seaorm): Separa módulo migration de db

- `db::*` queda como API de consultas (connection, fetch_*).
- `migration::*` sube a primer nivel con su propia documentación.
- `DBCONN` y `run_now` se trasladan a la raíz de la extensión.
- Actualiza README.md y docs para reflejar la nueva estructura.

extensions/pagetop-seaorm/README.md

@@ -38,7 +38,8 @@ db_name = "my_app.db"
 max_pool_size = 5
 ```
 
-Para MySQL o PostgreSQL añade también `db_user`, `db_pass`, `db_host` y `db_port`.
+Para MySQL o PostgreSQL añade también `db_user`, `db_pass` y `db_host`. El campo `db_port` es
+opcional; si se omite se usa el puerto predeterminado del motor.
 
 **Declara la extensión** en tu aplicación o en la extensión que la requiera:
 
@@ -68,7 +69,7 @@ async fn main() -> std::io::Result<()> {
 **Escribe las migraciones** usando la API de SeaORM:
 
 ```rust,no_run
-use pagetop_seaorm::db::*;
+use pagetop_seaorm::migration::*;
 
 pub struct Migration;
 
@@ -110,7 +111,7 @@ Este *crate* se apoya en bibliotecas del ecosistema [SeaQL](https://github.com/S
   usada por el módulo de migraciones para interrogar la estructura real de la base de datos (tablas,
   columnas, índices y claves externas).
 
-El módulo de migraciones (`src/db/migration/`) incorpora una adaptación de
+El módulo de migraciones (`src/migration/`) incorpora una adaptación de
 [sea-orm-migration](https://crates.io/crates/sea-orm-migration). El código que se integra procede de
 la versión [**1.1.20**](https://github.com/SeaQL/sea-orm/tree/1.1.20/sea-orm-migration) en lugar de
 usarlo como dependencia ya que su paradigma de CLI no es compatible con el ciclo de vida de las
@@ -118,13 +119,13 @@ extensiones de PageTop, donde las migraciones deben ejecutarse durante la inicia
 extensión. Los ficheros adaptados del original son:
 
 | Archivos              | Observaciones                                                            |
-|----------------------------|--------------------------------------------------------------|
-| `lib.rs` en `migration.rs` | Excluye módulos y exportaciones del CLI                      |
+|-----------------------|--------------------------------------------------------------------------|
+| `lib.rs`              | Incluido en `migration.rs`, descarta módulos y exportaciones del CLI     |
 | `connection.rs`       | Integración completa                                                     |
 | `manager.rs`          | Adapta *features* propias                                                |
 | `migrator.rs`         | Adapta *features* propias y omite gestión de errores del CLI             |
-| `prelude.rs`               | Excluye exportaciones del CLI                                |
-| `schema.rs`                | Integración ajustada con cambios menores                     |
+| `prelude.rs`          | Absorbido en `migration.rs`, descarta exportaciones del CLI              |
+| `schema.rs`           | Integra con ajustes, original de [loco](https://github.com/loco-rs/loco) |
 | `seaql_migrations.rs` | Integración completa                                                     |
 
 

extensions/pagetop-seaorm/src/config.rs

@@ -34,7 +34,6 @@ include_config!(SETTINGS: Settings => [
     "database.db_user"       => "",
     "database.db_pass"       => "",
     "database.db_host"       => "localhost",
-    "database.db_port"       => 0,
     "database.max_pool_size" => 5,
 ]);
 
@@ -57,8 +56,9 @@ pub struct Database {
     pub db_pass: String,
     /// Servidor de conexión a la base de datos (para mysql/postgres).
     pub db_host: String,
-    /// Puerto de conexión a la base de datos, normalmente 3306 (para mysql) ó 5432 (para postgres).
-    pub db_port: u16,
+    /// Puerto de conexión a la base de datos (para mysql/postgres). Si es `None` se usa el puerto
+    /// predeterminado para el motor: 3306 para MySQL y 5432 para PostgreSQL.
+    pub db_port: Option<u16>,
     /// Número máximo de conexiones habilitadas.
     pub max_pool_size: u32,
 }

extensions/pagetop-seaorm/src/db.rs

@@ -1,23 +1,68 @@
-use pagetop::core::TypeInfo;
-use pagetop::trace;
+//! API completa de SeaORM para operaciones con la base de datos.
+//!
+//! Re-exporta el *prelude* de SeaORM (entidades, traits, tipos de valor, macros de derivación…)
+//! y expone tres funciones de consulta propias. Con una sola importación tienes todo lo necesario
+//! para definir entidades y realizar operaciones CRUD:
+//!
+//! ```rust,ignore
+//! use pagetop_seaorm::db::*;
+//! ```
+//!
+//! Para definir el esquema de la base de datos o escribir migraciones usa además
+//! [`crate::migration`].
 
-pub use url::Url as DbUri;
+pub use sea_orm::prelude::*;
 
-pub use sea_orm::error::{DbErr, RuntimeErr};
-pub use sea_orm::{DatabaseConnection as DbConn, ExecResult, QueryResult};
+use sea_orm::sea_query::{
+    MysqlQueryBuilder, PostgresQueryBuilder, QueryStatementWriter, SqliteQueryBuilder,
+};
+use sea_orm::{DatabaseBackend, ExecResult, Statement};
 
-use sea_orm::{ConnectionTrait, DatabaseBackend, Statement};
+/// Devuelve una referencia al pool de conexiones para usarla con el sistema de entidades.
+///
+/// Permite pasar la conexión a los métodos `all`, `one`, `exec`, etc. del sistema de entidades
+/// de SeaORM. El coste de esta llamada es prácticamente nulo: sólo devuelve una referencia a un
+/// valor inicializado una sola vez al arrancar la aplicación.
+///
+/// ```rust,no_run
+/// use pagetop_seaorm::db::*;
+///
+/// // Consultas tipadas con el sistema de entidades de SeaORM:
+/// //   let users = User::find().all(connection()).await?;
+/// //   let user  = User::find_by_id(1).one(connection()).await?;
+/// //   User::insert(model).exec(connection()).await?;
+/// let _conn = connection();
+/// ```
+pub fn connection() -> &'static DatabaseConnection {
+    &super::DBCONN
+}
 
-mod dbconn;
-pub(crate) use dbconn::{run_now, DBCONN};
-
-// Adaptación de `sea-orm-migration` (ver §Créditos en README.md).
-mod migration;
-pub use migration::prelude::*;
-pub use migration::schema::*;
-
-pub async fn query<Q: QueryStatementWriter>(stmt: &mut Q) -> Result<Vec<QueryResult>, DbErr> {
-    let dbconn = &*DBCONN;
+/// Ejecuta una consulta para devolver todas las filas resultantes.
+///
+/// Acepta cualquier tipo que implemente [`crate::migration::QueryStatementWriter`] (p. ej. [`crate::migration::SelectStatement`]) y
+/// serializa la sentencia al dialecto de la base de datos configurada antes de ejecutarla. Cada
+/// fila se devuelve como un [`QueryResult`] sin tipar; extrae los valores con
+/// [`QueryResult::try_get`].
+///
+/// ```rust,no_run
+/// use pagetop_seaorm::db::*;
+/// use pagetop_seaorm::migration::*;
+///
+/// async fn example() -> Result<(), DbErr> {
+///     let mut stmt = Query::select()
+///         .column(Asterisk)
+///         .from(Alias::new("users"))
+///         .to_owned();
+///     let rows = fetch_all(&mut stmt).await?;
+///     for row in rows {
+///         let name: String = row.try_get("", "name")?;
+///         println!("{name}");
+///     }
+///     Ok(())
+/// }
+/// ```
+pub async fn fetch_all<Q: QueryStatementWriter>(stmt: &mut Q) -> Result<Vec<QueryResult>, DbErr> {
+    let dbconn = &*super::DBCONN;
     let dbbackend = dbconn.get_database_backend();
     dbconn
         .query_all(Statement::from_string(
@@ -31,8 +76,32 @@ pub async fn query<Q: QueryStatementWriter>(stmt: &mut Q) -> Result<Vec<QueryRes
         .await
 }
 
-pub async fn exec<Q: QueryStatementWriter>(stmt: &mut Q) -> Result<Option<QueryResult>, DbErr> {
-    let dbconn = &*DBCONN;
+/// Ejecuta una consulta y devuelve sólo la primera fila, si existe.
+///
+/// Funciona igual que [`fetch_all`] pero detiene la ejecución tras la primera fila y devuelve
+/// `None` si la consulta no produce resultados.
+///
+/// ```rust,no_run
+/// use pagetop_seaorm::db::*;
+/// use pagetop_seaorm::migration::*;
+///
+/// async fn example() -> Result<(), DbErr> {
+///     let mut stmt = Query::select()
+///         .column(Asterisk)
+///         .from(Alias::new("users"))
+///         .and_where(Expr::col(Alias::new("id")).eq(1))
+///         .to_owned();
+///     if let Some(row) = fetch_one(&mut stmt).await? {
+///         let name: String = row.try_get("", "name")?;
+///         println!("{name}");
+///     }
+///     Ok(())
+/// }
+/// ```
+pub async fn fetch_one<Q: QueryStatementWriter>(
+    stmt: &mut Q,
+) -> Result<Option<QueryResult>, DbErr> {
+    let dbconn = &*super::DBCONN;
     let dbbackend = dbconn.get_database_backend();
     dbconn
         .query_one(Statement::from_string(
@@ -46,77 +115,26 @@ pub async fn exec<Q: QueryStatementWriter>(stmt: &mut Q) -> Result<Option<QueryR
         .await
 }
 
-pub async fn exec_raw(stmt: String) -> Result<ExecResult, DbErr> {
-    let dbconn = &*DBCONN;
+/// Ejecuta una sentencia SQL en crudo (INSERT, UPDATE, DELETE…) y devuelve el resultado de
+/// la operación.
+///
+/// A diferencia de [`fetch_all`] y [`fetch_one`], no construye la consulta, sino que la recibe
+/// como cadena ya formada. Útil para sentencias avanzadas o para migraciones puntuales. El
+/// [`ExecResult`] devuelto permite consultar las filas afectadas o el último ID insertado.
+///
+/// ```rust,no_run
+/// use pagetop_seaorm::db::*;
+///
+/// async fn example() -> Result<(), DbErr> {
+///     let result = execute("DELETE FROM sessions WHERE expired = 1").await?;
+///     println!("Filas eliminadas: {}", result.rows_affected());
+///     Ok(())
+/// }
+/// ```
+pub async fn execute(stmt: impl Into<String>) -> Result<ExecResult, DbErr> {
+    let dbconn = &*super::DBCONN;
     let dbbackend = dbconn.get_database_backend();
     dbconn
-        .execute(Statement::from_string(dbbackend, stmt))
+        .execute(Statement::from_string(dbbackend, stmt.into()))
         .await
 }
-
-pub trait MigratorBase {
-    fn run_up();
-
-    fn run_down();
-}
-
-#[rustfmt::skip]
-impl<M: MigratorTrait> MigratorBase for M {
-    fn run_up() {
-        if let Err(e) = run_now(Self::up(SchemaManagerConnection::Connection(&DBCONN), None)) {
-            trace::error!("Migration upgrade failed ({})", e);
-        };
-    }
-
-    fn run_down() {
-        if let Err(e) = run_now(Self::down(SchemaManagerConnection::Connection(&DBCONN), None)) {
-            trace::error!("Migration downgrade failed ({})", e);
-        };
-    }
-}
-
-impl<M: MigrationTrait> MigrationName for M {
-    fn name(&self) -> &str {
-        TypeInfo::NameTo(-2).of::<M>()
-    }
-}
-
-pub type MigrationItem = Box<dyn MigrationTrait>;
-
-#[macro_export]
-macro_rules! install_migrations {
-    ( $($migration_module:ident),+ $(,)? ) => {{
-        use $crate::db::{MigrationItem, MigratorBase, MigratorTrait};
-
-        struct Migrator;
-        impl MigratorTrait for Migrator {
-            fn migrations() -> Vec<MigrationItem> {
-                let mut m = Vec::<MigrationItem>::new();
-                $(
-                    m.push(Box::new(migration::$migration_module::Migration));
-                )*
-                m
-            }
-        }
-        Migrator::run_up();
-    }};
-}
-
-#[macro_export]
-macro_rules! uninstall_migrations {
-    ( $($migration_module:ident),+ $(,)? ) => {{
-        use $crate::db::{MigrationItem, MigratorBase, MigratorTrait};
-
-        struct Migrator;
-        impl MigratorTrait for Migrator {
-            fn migrations() -> Vec<MigrationItem> {
-                let mut m = Vec::<MigrationItem>::new();
-                $(
-                    m.push(Box::new(migration::$migration_module::Migration));
-                )*
-                m
-            }
-        }
-        Migrator::run_down();
-    }};
-}

extensions/pagetop-seaorm/src/db/dbconn.rs

@@ -1,69 +0,0 @@
-use pagetop::trace;
-
-use crate::config;
-use crate::db::{DbConn, DbUri};
-
-use std::sync::LazyLock;
-
-use sea_orm::{ConnectOptions, Database};
-
-pub use futures::executor::block_on as run_now;
-
-pub static DBCONN: LazyLock<DbConn> = LazyLock::new(|| {
-    trace::info!(
-        "Connecting to database \"{}\" using a pool of {} connections",
-        &config::SETTINGS.database.db_name,
-        &config::SETTINGS.database.max_pool_size
-    );
-
-    let db_uri = match config::SETTINGS.database.db_type.as_str() {
-        "mysql" | "postgres" => {
-            let mut tmp_uri = DbUri::parse(
-                format!(
-                    "{}://{}/{}",
-                    &config::SETTINGS.database.db_type,
-                    &config::SETTINGS.database.db_host,
-                    &config::SETTINGS.database.db_name
-                )
-                .as_str(),
-            )
-            .unwrap();
-            tmp_uri
-                .set_username(config::SETTINGS.database.db_user.as_str())
-                .unwrap();
-            // https://github.com/launchbadge/sqlx/issues/1624
-            tmp_uri
-                .set_password(Some(config::SETTINGS.database.db_pass.as_str()))
-                .unwrap();
-            if config::SETTINGS.database.db_port != 0 {
-                tmp_uri
-                    .set_port(Some(config::SETTINGS.database.db_port))
-                    .unwrap();
-            }
-            tmp_uri
-        }
-        "sqlite" => DbUri::parse(
-            format!(
-                "{}://{}",
-                &config::SETTINGS.database.db_type,
-                &config::SETTINGS.database.db_name
-            )
-            .as_str(),
-        )
-        .unwrap(),
-        _ => {
-            trace::error!(
-                "Unrecognized database type \"{}\"",
-                &config::SETTINGS.database.db_type
-            );
-            DbUri::parse("").unwrap()
-        }
-    };
-
-    run_now(Database::connect::<ConnectOptions>({
-        let mut db_opt = ConnectOptions::new(db_uri.to_string());
-        db_opt.max_connections(config::SETTINGS.database.max_pool_size);
-        db_opt
-    }))
-    .unwrap_or_else(|_| panic!("Failed to connect to database"))
-});

extensions/pagetop-seaorm/src/db/migration.rs

@@ -1,33 +0,0 @@
-//pub mod cli;
-pub mod connection;
-pub mod manager;
-pub mod migrator;
-pub mod prelude;
-pub mod schema;
-pub mod seaql_migrations;
-//pub mod util;
-
-pub use connection::*;
-pub use manager::*;
-//pub use migrator::*;
-
-pub use async_trait;
-//pub use sea_orm;
-//pub use sea_orm::sea_query;
-use sea_orm::DbErr;
-
-pub trait MigrationName {
-    fn name(&self) -> &str;
-}
-
-/// The migration definition
-#[async_trait::async_trait]
-pub trait MigrationTrait: MigrationName + Send + Sync {
-    /// Define actions to perform when applying the migration
-    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr>;
-
-    /// Define actions to perform when rolling back the migration
-    async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
-        Err(DbErr::Migration("We Don't Do That Here".to_owned()))
-    }
-}

extensions/pagetop-seaorm/src/db/migration/prelude.rs

@@ -1,12 +0,0 @@
-//pub use super::cli;
-
-pub use super::connection::IntoSchemaManagerConnection;
-pub use super::connection::SchemaManagerConnection;
-pub use super::manager::SchemaManager;
-pub use super::migrator::MigratorTrait;
-pub use super::{MigrationName, MigrationTrait};
-pub use async_trait;
-pub use sea_orm;
-pub use sea_orm::sea_query;
-pub use sea_orm::sea_query::*;
-pub use sea_orm::DeriveIden;

extensions/pagetop-seaorm/src/lib.rs

@@ -39,7 +39,8 @@ db_name = "my_app.db"
 max_pool_size = 5
 ```
 
-Para MySQL o PostgreSQL añade también `db_user`, `db_pass`, `db_host` y `db_port`.
+Para MySQL o PostgreSQL añade también `db_user`, `db_pass` y `db_host`. El campo `db_port` es
+opcional; si se omite se usa el puerto predeterminado del motor.
 
 **Declara la extensión** en tu aplicación o en la extensión que la requiera:
 
@@ -69,7 +70,7 @@ async fn main() -> std::io::Result<()> {
 **Escribe las migraciones** usando la API de SeaORM:
 
 ```rust,no_run
-use pagetop_seaorm::db::*;
+use pagetop_seaorm::migration::*;
 
 pub struct Migration;
 
@@ -102,12 +103,75 @@ enum Users {
 
 use pagetop::prelude::*;
 
+use sea_orm::{ConnectOptions, Database, DatabaseConnection};
+use url::Url;
+
+use std::sync::LazyLock;
+
 include_locales!(LOCALES_SEAORM);
 
 pub mod config;
 
 pub mod db;
 
+pub mod migration;
+
+pub(crate) use futures::executor::block_on as run_now;
+
+pub(crate) static DBCONN: LazyLock<DatabaseConnection> = LazyLock::new(|| {
+    trace::info!(
+        "Connecting to database \"{}\" using a pool of {} connections",
+        &config::SETTINGS.database.db_name,
+        &config::SETTINGS.database.max_pool_size
+    );
+
+    let db_uri = match config::SETTINGS.database.db_type.as_str() {
+        "mysql" | "postgres" => {
+            let mut tmp_uri = Url::parse(
+                format!(
+                    "{}://{}/{}",
+                    &config::SETTINGS.database.db_type,
+                    &config::SETTINGS.database.db_host,
+                    &config::SETTINGS.database.db_name
+                )
+                .as_str(),
+            )
+            .unwrap();
+            tmp_uri
+                .set_username(config::SETTINGS.database.db_user.as_str())
+                .unwrap();
+            // https://github.com/launchbadge/sqlx/issues/1624
+            tmp_uri
+                .set_password(Some(config::SETTINGS.database.db_pass.as_str()))
+                .unwrap();
+            if let Some(port) = config::SETTINGS.database.db_port {
+                tmp_uri.set_port(Some(port)).unwrap();
+            }
+            tmp_uri
+        }
+        "sqlite" => Url::parse(
+            format!(
+                "{}://{}",
+                &config::SETTINGS.database.db_type,
+                &config::SETTINGS.database.db_name
+            )
+            .as_str(),
+        )
+        .unwrap(),
+        _ => panic!(
+            "Unrecognized database type \"{}\"",
+            config::SETTINGS.database.db_type
+        ),
+    };
+
+    run_now(Database::connect::<ConnectOptions>({
+        let mut db_opt = ConnectOptions::new(db_uri.to_string());
+        db_opt.max_connections(config::SETTINGS.database.max_pool_size);
+        db_opt
+    }))
+    .unwrap_or_else(|_| panic!("Failed to connect to database"))
+});
+
 /// Implementa la extensión.
 pub struct SeaORM;
 
@@ -121,6 +185,6 @@ impl Extension for SeaORM {
     }
 
     fn initialize(&self) {
-        std::sync::LazyLock::force(&db::DBCONN);
+        std::sync::LazyLock::force(&DBCONN);
     }
 }

extensions/pagetop-seaorm/src/migration.rs

@@ -0,0 +1,156 @@
+//! API para definir y ejecutar migraciones de base de datos.
+//!
+//! Re-exporta los tipos de SeaORM necesarios para escribir migraciones y ofrece las macros
+//! [`crate::install_migrations`] y [`crate::uninstall_migrations`] para aplicarlas o revertirlas al
+//! arrancar la extensión.
+//!
+//! ```rust,ignore
+//! use pagetop_seaorm::db::*;
+//! use pagetop_seaorm::migration::*;
+//! ```
+
+// **< Adaptación de `sea-orm-migration` (ver §Créditos en README.md) >*****************************
+
+//pub mod cli;
+pub mod connection;
+pub mod manager;
+pub mod migrator;
+//pub mod prelude;
+pub mod schema;
+pub mod seaql_migrations;
+//pub mod util;
+
+pub use connection::*;
+pub use manager::*;
+//pub use migrator::*;
+
+pub use async_trait;
+//pub use sea_orm;
+//pub use sea_orm::sea_query;
+pub use sea_orm::DbErr;
+
+pub trait MigrationName {
+    fn name(&self) -> &str;
+}
+
+/// The migration definition
+#[async_trait::async_trait]
+pub trait MigrationTrait: MigrationName + Send + Sync {
+    /// Define actions to perform when applying the migration
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr>;
+
+    /// Define actions to perform when rolling back the migration
+    async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
+        Err(DbErr::Migration(
+            "Rollback not implemented for this migration".to_owned(),
+        ))
+    }
+}
+
+// *************************************************************************************************
+
+pub use migrator::MigratorTrait;
+pub use schema::*;
+pub use sea_orm::sea_query::*;
+pub use sea_orm::DeriveIden;
+
+use pagetop::core::TypeInfo;
+use pagetop::trace;
+
+impl<M: MigrationTrait> MigrationName for M {
+    fn name(&self) -> &str {
+        TypeInfo::NameTo(-2).of::<M>()
+    }
+}
+
+pub type MigrationItem = Box<dyn MigrationTrait>;
+
+pub trait MigratorBase {
+    fn run_up();
+
+    fn run_down();
+}
+
+#[rustfmt::skip]
+impl<M: MigratorTrait> MigratorBase for M {
+    fn run_up() {
+        if let Err(e) = super::run_now(Self::up(SchemaManagerConnection::Connection(&super::DBCONN), None)) {
+            trace::error!("Migration upgrade failed ({})", e);
+        };
+    }
+
+    fn run_down() {
+        if let Err(e) = super::run_now(Self::down(SchemaManagerConnection::Connection(&super::DBCONN), None)) {
+            trace::error!("Migration downgrade failed ({})", e);
+        };
+    }
+}
+
+/// Aplica las migraciones pendientes al arrancar una extensión.
+///
+/// Recibe uno o más módulos de migración y ejecuta el método `up` de los que aún no estén
+/// registrados en la tabla `seaql_migrations`. Se invoca habitualmente desde
+/// [`Extension::initialize`](pagetop::core::extension::Extension::initialize).
+///
+/// ```rust,ignore
+/// impl Extension for MyExt {
+///     fn initialize(&self) {
+///         install_migrations!(
+///             m20240101_000001_create_users_table,
+///             m20240115_000002_add_email_index,
+///         );
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! install_migrations {
+    ( $($migration_module:ident),+ $(,)? ) => {{
+        use $crate::migration::{MigrationItem, MigratorBase, MigratorTrait};
+
+        struct Migrator;
+        impl MigratorTrait for Migrator {
+            fn migrations() -> Vec<MigrationItem> {
+                let mut m = Vec::<MigrationItem>::new();
+                $(
+                    m.push(Box::new(migration::$migration_module::Migration));
+                )*
+                m
+            }
+        }
+        Migrator::run_up();
+    }};
+}
+
+/// Revierte las migraciones de una extensión en orden inverso al de su aplicación.
+///
+/// Ejecuta el método `down` de cada migración indicada. Si alguna no implementa `down`,
+/// detiene el proceso con un error. Complementario a [`crate::install_migrations`].
+///
+/// ```rust,ignore
+/// impl Extension for MyExt {
+///     fn uninitialize(&self) {
+///         uninstall_migrations!(
+///             m20240101_000001_create_users_table,
+///             m20240115_000002_add_email_index,
+///         );
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! uninstall_migrations {
+    ( $($migration_module:ident),+ $(,)? ) => {{
+        use $crate::migration::{MigrationItem, MigratorBase, MigratorTrait};
+
+        struct Migrator;
+        impl MigratorTrait for Migrator {
+            fn migrations() -> Vec<MigrationItem> {
+                let mut m = Vec::<MigrationItem>::new();
+                $(
+                    m.push(Box::new(migration::$migration_module::Migration));
+                )*
+                m
+            }
+        }
+        Migrator::run_down();
+    }};
+}

extensions/pagetop-seaorm/src/migration/schema.rs

@@ -1,17 +1,16 @@
-//! Adapted from <https://github.com/loco-rs/loco/blob/master/src/schema.rs>
+//! Adaptación de <https://github.com/loco-rs/loco/blob/master/src/schema.rs>
 //!
-//! # Database Table Schema Helpers
+//! # Ayudantes de esquema de base de datos
 //!
-//! This module defines functions and helpers for creating database table
-//! schemas using the `sea-orm` and `sea-query` libraries.
+//! Define funciones y ayudantes para crear esquemas de tablas usando `sea-orm` y `sea-query`.
 //!
-//! # Example
+//! # Ejemplo
 //!
-//! The following example shows how the user migration file should be and using
-//! the schema helpers to create the Db fields.
+//! El siguiente ejemplo muestra cómo escribir un archivo de migración usando los ayudantes
+//! de esquema.
 //!
 //! ```rust
-//! use pagetop_seaorm::db::*;
+//! use pagetop_seaorm::migration::*;
 //!
 //! pub struct Migration;
 //!
@@ -38,7 +37,7 @@
 //!     }
 //! }
 //!
-//! #[derive(Iden)]
+//! #[derive(DeriveIden)]
 //! pub enum Users {
 //!     Table,
 //!     Id,
@@ -51,10 +50,9 @@
 //! }
 //! ```
 
-use crate::db::Iden;
-
 use sea_orm::sea_query::{
-    self, Alias, ColumnDef, ColumnType, Expr, IntoIden, PgInterval, Table, TableCreateStatement,
+    self, Alias, ColumnDef, ColumnType, Expr, Iden, IntoIden, PgInterval, Table,
+    TableCreateStatement,
 };
 
 #[derive(Iden)]
@@ -599,7 +597,7 @@ pub fn array_uniq<T: IntoIden>(col: T, elem_type: ColumnType) -> ColumnDef {
     array(col, elem_type).unique_key().take()
 }
 
-/// Add timestamp columns (`CreatedAt` and `UpdatedAt`) to an existing table.
+/// Añade las columnas de timestamp (`CreatedAt` y `UpdatedAt`) a una tabla existente.
 pub fn timestamps(t: TableCreateStatement) -> TableCreateStatement {
     let mut t = t;
     t.col(timestamp(GeneralIds::CreatedAt).default(Expr::current_timestamp()))
@@ -607,7 +605,7 @@ pub fn timestamps(t: TableCreateStatement) -> TableCreateStatement {
         .take()
 }
 
-/// Create an Alias.
+/// Crea un alias.
 pub fn name<T: Into<String>>(name: T) -> Alias {
     Alias::new(name)
 }