aah/migration/src/m20220101_000001_create_table.rs

use sea_orm_migration::{
  prelude::*,
  sea_orm::{EnumIter, Iterable},
};

#[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(Service::Table)
          .if_not_exists()
          .col(
            ColumnDef::new(Service::Id)
              .integer()
              .not_null()
              .auto_increment()
              .primary_key(),
          )
          .col(ColumnDef::new(Service::Name).string().not_null())
          .col(ColumnDef::new(Service::Config).string().not_null())
          .col(
            ColumnDef::new(Service::Status)
              .enumeration(Service::Status, OverallStatus::iter())
              .not_null(),
          )
          .col(ColumnDef::new(Service::InProgressSince).date_time())
          .to_owned(),
      )
      .await?;

    manager
      .create_table(
        Table::create()
          .table(Process::Table)
          .if_not_exists()
          .col(
            ColumnDef::new(Process::Id)
              .integer()
              .not_null()
              .auto_increment()
              .primary_key(),
          )
          .col(ColumnDef::new(Process::Name).string().not_null())
          .col(ColumnDef::new(Process::ServiceId).integer())
          .col(ColumnDef::new(Process::ContainerId).string())
          .col(
            ColumnDef::new(Process::Status)
              .enumeration(Process::Status, ProcessStatus::iter())
              .not_null(),
          )
          .foreign_key(
            ForeignKey::create()
              .from(Process::Table, Process::ServiceId)
              .to(Service::Table, Service::Id)
              .on_delete(ForeignKeyAction::Cascade),
          )
          .index(
            Index::create()
              .unique()
              .col(Process::ServiceId)
              .col(Process::Name),
          )
          .to_owned(),
      )
      .await?;

    manager
      .create_table(
        Table::create()
          .table(Secrets::Table)
          .if_not_exists()
          .col(
            ColumnDef::new(Secrets::Id)
              .integer()
              .not_null()
              .auto_increment()
              .primary_key(),
          )
          .col(ColumnDef::new(Secrets::ServiceId).integer().not_null())
          .col(ColumnDef::new(Secrets::Name).string().not_null())
          .col(ColumnDef::new(Secrets::Value).string().not_null())
          .foreign_key(
            ForeignKey::create()
              .from(Secrets::Table, Secrets::ServiceId)
              .to(Service::Table, Service::Id),
          )
          .to_owned(),
      )
      .await?;

    Ok(())
  }

  async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
    manager
      .drop_table(Table::drop().table(Service::Table).to_owned())
      .await?;
    manager
      .drop_table(Table::drop().table(Process::Table).to_owned())
      .await?;
    manager
      .drop_table(Table::drop().table(Secrets::Table).to_owned())
      .await?;
    Ok(())
  }
}

#[derive(DeriveIden)]
enum Service {
  Table,
  Id,
  Name,
  Config,

  Status,
  InProgressSince,
}

#[derive(DeriveIden, EnumIter)]
enum OverallStatus {
  New,
  Healthy,
  NeedsAttention,
  InProgress,
}

#[derive(DeriveIden)]
enum Process {
  Table,
  Id,
  Name,
  ServiceId,
  ContainerId,

  Status,
}

#[derive(DeriveIden, EnumIter)]
enum ProcessStatus {
  New,
  Healthy,
  NeedsAttention,
  InProgress,
}

#[derive(DeriveIden)]
enum Secrets {
  Table,
  Id,
  ServiceId,
  Name,
  Value,
}