feat/db: task table

crates/db/migration/src/lib.rs

···
 pub use sea_orm_migration::prelude::*;
 
 mod m20260318_233726_group_table;
+mod m20260319_002245_task_table;
 
 pub struct Migrator;
 
 #[async_trait::async_trait]
 impl MigratorTrait for Migrator {
     fn migrations() -> Vec<Box<dyn MigrationTrait>> {
-        vec![Box::new(m20260318_233726_group_table::Migration)]
+        vec![
+            Box::new(m20260318_233726_group_table::Migration),
+            Box::new(m20260319_002245_task_table::Migration),
+        ]
     }
 }

crates/db/migration/src/m20260318_233726_group_table.rs

···
 #[async_trait::async_trait]
 impl MigrationTrait for Migration {
     async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
-        // Replace the sample below with your own migration scripts
-
         manager
             .create_table(
                 Table::create()
···
 }
 
 #[derive(DeriveIden)]
-enum Group {
+pub enum Group {
     Table,
+
     /// Unique integer id
     Id,
+
     /// Unique nano-id that is userfacing
     NanoId,
+
+    /// Nano-id of the parent of this group
+    ParentGroupId,
+
     /// Name of the group
     Name,
-    /// Nano-id of the parent of this group
-    ParentGroupId,
+
     /// Color of this group
     /// NOTE: color is a string that looks like "#FFFFFF"
     Color,
+
     /// Priority level of the group
     Priority,
+
     /// The relative file path to the location of
     /// the description note for this task
     DescriptionPath,
+
     /// Creation time
     CreatedAt,
+
     /// Last modified
     ModifiedAt,
 }

crates/db/migration/src/m20260319_002245_task_table.rs

···
+use sea_orm_migration::{prelude::*, schema::*};
+
+use crate::m20260318_233726_group_table::Group;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table(
+                Table::create()
+                    .table(Task::Table)
+                    .if_not_exists()
+                    .col(pk_auto(Task::Id))
+                    .col(string(Task::NanoId).unique_key().not_null())
+                    .col(string(Task::Name).not_null())
+                    .col(string(Task::DescriptionPath).not_null())
+                    .col(integer(Task::Priority).not_null().default(0))
+                    .col(timestamp(Task::Due).null())
+                    .col(timestamp(Task::CreatedAt).default(Expr::current_timestamp()))
+                    .col(timestamp(Task::ModifiedAt).default(Expr::current_timestamp()))
+                    .foreign_key(
+                        ForeignKey::create()
+                            .name("fk_task_group_id") // unique constraint name
+                            .from(Task::Table, Task::GroupId)
+                            .to(Group::Table, Group::NanoId) // self-referential to the nano-id
+                            .on_update(ForeignKeyAction::Cascade)
+                            .on_delete(ForeignKeyAction::Cascade),
+                    )
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_index(
+                Index::create()
+                    .name("idx_tasks_pub_id")
+                    .table(Task::Table)
+                    .col(Task::NanoId)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_index(
+                Index::create()
+                    .name("idx_tasks_group_id")
+                    .table(Task::Table)
+                    .col(Task::GroupId)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_index(
+                Index::create()
+                    .name("idx_tasks_due")
+                    .table(Task::Table)
+                    .col(Task::Due)
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_index(Index::drop().name("idx_tasks_due").to_owned())
+            .await?;
+
+        manager
+            .drop_index(Index::drop().name("idx_tasks_group_id").to_owned())
+            .await?;
+
+        manager
+            .drop_index(Index::drop().name("idx_tasks_pub_id").to_owned())
+            .await?;
+
+        manager
+            .drop_table(Table::drop().table(Task::Table).to_owned())
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum Task {
+    Table,
+
+    /// Unique integer id
+    Id,
+
+    /// Unique nano-id that is userfacing
+    NanoId,
+
+    /// Nano-id of the group this task is a part of
+    GroupId,
+
+    /// Name of the Task
+    Name,
+
+    /// Priority level of the group
+    Priority,
+
+    /// The relative file path to the location of
+    /// the description note for this task
+    DescriptionPath,
+
+    /// The duedate for this task
+    Due,
+
+    /// Creation time
+    CreatedAt,
+
+    /// Last modified
+    ModifiedAt,
+}

crates/db/src/lib.rs

···
     conn: DatabaseConnection,
 }
 
-#[expect(dead_code)]
 impl Db {
     async fn connect(path: &Path) -> DbResult<Self> {
         let connection_string = dbg! {format!(