Add persistance for workspace rules

Author: krlvi

Cargo.lock

@@ -0,0 +1,2 @@
+-- This file should undo anything in `up.sql`
+DROP TABLE IF EXISTS `workspace_rules`;

crates/but-db/migrations/2025-07-17-150441_workspace_rules/down.sql

@@ -0,0 +1,9 @@
+-- Your SQL goes here
+CREATE TABLE `workspace_rules`(
+	`id` TEXT NOT NULL PRIMARY KEY,
+	`created_at` TIMESTAMP NOT NULL,
+	`enabled` BOOL NOT NULL,
+	`trigger` TEXT NOT NULL,
+	`filters` TEXT NOT NULL,
+	`action` TEXT NOT NULL
+);

crates/but-db/migrations/2025-07-17-150441_workspace_rules/up.sql

@@ -17,6 +17,8 @@ mod claude_code_sessions;
 pub use claude_code_sessions::ClaudeCodeSession;
 mod file_write_locks;
 pub use file_write_locks::FileWriteLock;
+mod workspace_rules;
+pub use workspace_rules::WorkspaceRule;
 
 use diesel_migrations::{EmbeddedMigrations, MigrationHarness, embed_migrations};
 pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations");

crates/but-db/src/lib.rs

@@ -51,3 +51,14 @@ diesel::table! {
         owner -> Text,
     }
 }
+
+diesel::table! {
+    workspace_rules (id) {
+        id -> Text,
+        created_at -> Timestamp,
+        enabled -> Bool,
+        trigger -> Text,
+        filters -> Text,
+        action -> Text,
+    }
+}

crates/but-db/src/schema.rs

@@ -0,0 +1,68 @@
+use diesel::{ExpressionMethods, OptionalExtension, QueryDsl, RunQueryDsl};
+
+use crate::DbHandle;
+use crate::schema::workspace_rules::dsl::workspace_rules;
+
+use diesel::prelude::{Insertable, Queryable, Selectable};
+use serde::{Deserialize, Serialize};
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Queryable, Selectable, Insertable)]
+#[diesel(table_name = crate::schema::workspace_rules)]
+#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
+pub struct WorkspaceRule {
+    pub id: String,
+    pub created_at: chrono::NaiveDateTime,
+    pub enabled: bool,
+    pub trigger: String,
+    pub filters: String,
+    pub action: String,
+}
+
+impl DbHandle {
+    pub fn workspace_rules(&mut self) -> WorkspaceRulesHandle {
+        WorkspaceRulesHandle { db: self }
+    }
+}
+
+pub struct WorkspaceRulesHandle<'a> {
+    db: &'a mut DbHandle,
+}
+
+impl WorkspaceRulesHandle<'_> {
+    pub fn insert(&mut self, rule: WorkspaceRule) -> Result<(), diesel::result::Error> {
+        diesel::insert_into(workspace_rules)
+            .values(rule)
+            .execute(&mut self.db.conn)?;
+        Ok(())
+    }
+
+    pub fn update(&mut self, id: &str, rule: WorkspaceRule) -> Result<(), diesel::result::Error> {
+        diesel::update(workspace_rules.filter(crate::schema::workspace_rules::id.eq(id)))
+            .set((
+                crate::schema::workspace_rules::enabled.eq(rule.enabled),
+                crate::schema::workspace_rules::trigger.eq(rule.trigger),
+                crate::schema::workspace_rules::filters.eq(rule.filters),
+                crate::schema::workspace_rules::action.eq(rule.action),
+            ))
+            .execute(&mut self.db.conn)?;
+        Ok(())
+    }
+
+    pub fn delete(&mut self, id: &str) -> Result<(), diesel::result::Error> {
+        diesel::delete(workspace_rules.filter(crate::schema::workspace_rules::id.eq(id)))
+            .execute(&mut self.db.conn)?;
+        Ok(())
+    }
+
+    pub fn list(&mut self) -> Result<Vec<WorkspaceRule>, diesel::result::Error> {
+        let rules = workspace_rules.load::<WorkspaceRule>(&mut self.db.conn)?;
+        Ok(rules)
+    }
+
+    pub fn get(&mut self, id: &str) -> Result<Option<WorkspaceRule>, diesel::result::Error> {
+        let rule = workspace_rules
+            .filter(crate::schema::workspace_rules::id.eq(id))
+            .first::<WorkspaceRule>(&mut self.db.conn)
+            .optional()?;
+        Ok(rule)
+    }
+}

crates/but-db/src/workspace_rules.rs

@@ -16,3 +16,6 @@ serde.workspace = true
 regex = "1.11.1"
 chrono = { version = "0.4.41", features = [] }
 serde_regex = "1.1.0"
+serde_json = "1.0.138"
+gitbutler-command-context.workspace = true
+but-db.workspace = true

crates/but-rules/Cargo.toml

@@ -0,0 +1,41 @@
+use anyhow::Result;
+use gitbutler_command_context::CommandContext;
+
+impl TryFrom<but_db::WorkspaceRule> for crate::WorkspaceRule {
+    type Error = anyhow::Error;
+    fn try_from(value: but_db::WorkspaceRule) -> Result<Self, Self::Error> {
+        Ok(crate::WorkspaceRule {
+            id: value.id,
+            created_at: value.created_at,
+            enabled: value.enabled,
+            trigger: serde_json::from_str(&value.trigger)?,
+            filters: serde_json::from_str(&value.filters)?,
+            action: serde_json::from_str(&value.action)?,
+        })
+    }
+}
+
+impl TryFrom<crate::WorkspaceRule> for but_db::WorkspaceRule {
+    type Error = anyhow::Error;
+    fn try_from(value: crate::WorkspaceRule) -> Result<Self, Self::Error> {
+        Ok(but_db::WorkspaceRule {
+            id: value.id,
+            created_at: value.created_at,
+            enabled: value.enabled,
+            trigger: serde_json::to_string(&value.trigger)?,
+            filters: serde_json::to_string(&value.filters)?,
+            action: serde_json::to_string(&value.action)?,
+        })
+    }
+}
+
+pub fn workspace_rules(ctx: &mut CommandContext) -> Result<Vec<crate::WorkspaceRule>> {
+    let rules = ctx
+        .db()?
+        .workspace_rules()
+        .list()?
+        .into_iter()
+        .map(|r| r.try_into())
+        .collect::<Result<Vec<crate::WorkspaceRule>>>()?;
+    Ok(rules)
+}

crates/but-rules/src/db.rs

@@ -1,5 +1,7 @@
 use serde::{Deserialize, Serialize};
 
+pub mod db;
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct WorkspaceRule {