Bake provisioning into admin tool

src/application/administration.rs

@@ -20,6 +20,7 @@ use super::authentication::hash;
 
 #[async_trait]
 pub trait AdministrationService {
+    async fn provision(&self) -> Result<(), Error>;
     async fn reset_password(&self, user: &str, team: &str, password: &str) -> Result<(), Error>;
     async fn import(
         &self,
@@ -138,6 +139,16 @@ impl<
         MemberRepo,
     >
 {
+    async fn provision(&self) -> Result<(), Error> {
+        self.team_repository.provision().await?;
+        self.user_repository.provision().await?;
+        self.role_repository.provision().await?;
+        self.token_repository.provision().await?;
+        self.talk_repository.provision().await?;
+        self.member_repository.provision().await?;
+        Ok(())
+    }
+
     async fn reset_password(&self, user: &str, team: &str, password: &str) -> Result<(), Error> {
         let Some(team_id) = self.team_repository.get_id_by_name(team).await? else {
             eprintln!("unknown team");

src/bin/admin.rs

@@ -22,6 +22,7 @@ struct Arguments {
 
 #[derive(Subcommand)]
 enum Command {
+    Provision,
     ResetPassword {
         user: String,
         team: String,
@@ -61,6 +62,7 @@ async fn main() {
     );
 
     match arguments.command {
+        Command::Provision => service.provision().await.unwrap(),
         Command::ResetPassword {
             user,
             team,

src/persistence/member.rs

@@ -6,6 +6,7 @@ use sqlx::{query, query_as, Error, Pool, Sqlite};
 
 #[async_trait]
 pub trait MemberRepository {
+    async fn provision(&self) -> Result<(), Error>;
     async fn get_state_by_user_and_talk(&self, user_id: i64, talk_id: i64) -> Result<State, Error>;
     async fn set_state_by_user_and_talk(
         &self,
@@ -44,6 +45,23 @@ impl SqliteMemberRepository {
 
 #[async_trait]
 impl MemberRepository for SqliteMemberRepository {
+    async fn provision(&self) -> Result<(), Error> {
+        query("DROP TABLE IF EXISTS members")
+            .execute(self.pool.as_ref())
+            .await?;
+        query(
+            "CREATE TABLE members (
+                user INTEGER REFERENCES users(id) NOT NULL,
+                talk INTEGER REFERENCES talks(id) NOT NULL,
+                is_nerd INTEGER NOT NULL,
+                CONSTRAINT user_and_talk UNIQUE (user, talk)
+            )",
+        )
+        .execute(self.pool.as_ref())
+        .await?;
+        Ok(())
+    }
+
     async fn get_state_by_user_and_talk(&self, user_id: i64, talk_id: i64) -> Result<State, Error> {
         match query_as("SELECT is_nerd FROM members WHERE user = ? AND talk = ?")
             .bind(user_id)

src/persistence/role.rs

@@ -5,6 +5,7 @@ use sqlx::{query, query_as, Error, Pool, Sqlite};
 
 #[async_trait]
 pub trait RoleRepository {
+    async fn provision(&self) -> Result<(), Error>;
     async fn get_roles_by_id(&self, user_id: i64) -> Result<Vec<Role>, Error>;
     async fn get_all(&self) -> Result<Vec<UserRole>, Error>;
     async fn clear(&self) -> Result<(), Error>;
@@ -33,6 +34,21 @@ impl SqliteRoleRepository {
 
 #[async_trait]
 impl RoleRepository for SqliteRoleRepository {
+    async fn provision(&self) -> Result<(), Error> {
+        query("DROP TABLE IF EXISTS roles")
+            .execute(self.pool.as_ref())
+            .await?;
+        query(
+            "CREATE TABLE roles (
+                user INTEGER REFERENCES users(id) NOT NULL,
+                role INTEGER NOT NULL
+            )",
+        )
+        .execute(self.pool.as_ref())
+        .await?;
+        Ok(())
+    }
+
     async fn get_roles_by_id(&self, user_id: i64) -> Result<Vec<Role>, Error> {
         let roles = query_as("SELECT role FROM roles WHERE user = ?")
             .bind(user_id)

src/persistence/talk.rs

@@ -8,6 +8,7 @@ use sqlx::{query, query_as, Error, Pool, Sqlite};
 
 #[async_trait]
 pub trait TalkRepository {
+    async fn provision(&self) -> Result<(), Error>;
     async fn insert(
         &self,
         creator_id: i64,
@@ -55,6 +56,26 @@ impl SqliteTalkRepository {
 
 #[async_trait]
 impl TalkRepository for SqliteTalkRepository {
+    async fn provision(&self) -> Result<(), Error> {
+        query("DROP TABLE IF EXISTS talks")
+            .execute(self.pool.as_ref())
+            .await?;
+        query(
+            "CREATE TABLE talks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                creator INTEGER REFERENCES users(id) NOT NULL,
+                title TEXT NOT NULL,
+                description TEXT NOT NULL,
+                scheduled_at INTEGER,
+                duration INTEGER NOT NULL,
+                location TEXT
+            )",
+        )
+        .execute(self.pool.as_ref())
+        .await?;
+        Ok(())
+    }
+
     async fn insert(
         &self,
         creator_id: i64,

src/persistence/team.rs

@@ -5,6 +5,7 @@ use sqlx::{query, query_as, Error, Pool, Sqlite};
 
 #[async_trait]
 pub trait TeamRepository {
+    async fn provision(&self) -> Result<(), Error>;
     async fn get_name_by_id(&self, id: i64) -> Result<Option<String>, Error>;
     async fn get_id_by_name(&self, name: &str) -> Result<Option<i64>, Error>;
     async fn get_all(&self) -> Result<Vec<Team>, Error>;
@@ -29,6 +30,21 @@ impl SqliteTeamRepository {
 
 #[async_trait]
 impl TeamRepository for SqliteTeamRepository {
+    async fn provision(&self) -> Result<(), Error> {
+        query("DROP TABLE IF EXISTS teams")
+            .execute(self.pool.as_ref())
+            .await?;
+        query(
+            "CREATE TABLE teams (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL
+            )",
+        )
+        .execute(self.pool.as_ref())
+        .await?;
+        Ok(())
+    }
+
     async fn get_name_by_id(&self, id: i64) -> Result<Option<String>, Error> {
         query_as("SELECT name FROM teams WHERE id = ?")
             .bind(id)

src/persistence/token.rs

@@ -8,6 +8,7 @@ use sqlx::{query, query_as, Error, Pool, Sqlite};
 
 #[async_trait]
 pub trait TokenRepository {
+    async fn provision(&self) -> Result<(), Error>;
     async fn insert_or_update_token_for_user(
         &self,
         token: &str,
@@ -39,6 +40,22 @@ impl SqliteTokenRepository {
 
 #[async_trait]
 impl TokenRepository for SqliteTokenRepository {
+    async fn provision(&self) -> Result<(), Error> {
+        query("DROP TABLE IF EXISTS tokens")
+            .execute(self.pool.as_ref())
+            .await?;
+        query(
+            "CREATE TABLE tokens (
+                token TEXT PRIMARY KEY,
+                user INTEGER REFERENCES users(id) NOT NULL,
+                expires_at INTEGER NOT NULL
+            )",
+        )
+        .execute(self.pool.as_ref())
+        .await?;
+        Ok(())
+    }
+
     async fn insert_or_update_token_for_user(
         &self,
         token: &str,

src/persistence/user.rs

@@ -5,6 +5,7 @@ use sqlx::{error::ErrorKind, query, query_as, Error, Pool, Sqlite};
 
 #[async_trait]
 pub trait UserRepository {
+    async fn provision(&self) -> Result<(), Error>;
     async fn exists(&self, id: i64) -> Result<bool, Error>;
     async fn get_name_and_team_id_by_id(&self, id: i64) -> Result<Option<(String, i64)>, Error>;
     async fn get_id_by_name_and_team(&self, name: &str, team_id: i64)
@@ -45,6 +46,24 @@ impl SqliteUserRepository {
 
 #[async_trait]
 impl UserRepository for SqliteUserRepository {
+    async fn provision(&self) -> Result<(), Error> {
+        query("DROP TABLE IF EXISTS users")
+            .execute(self.pool.as_ref())
+            .await?;
+        query(
+            "CREATE TABLE users (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                team INTEGER REFERENCES teams(id) NOT NULL,
+                hash TEXT NOT NULL,
+                CONSTRAINT name_and_team UNIQUE (name, team)
+            )",
+        )
+        .execute(self.pool.as_ref())
+        .await?;
+        Ok(())
+    }
+
     async fn exists(&self, id: i64) -> Result<bool, Error> {
         query_as("SELECT id FROM users WHERE id = ?")
             .bind(id)