Add manual transaction API with commit and automatic rollback support (#48)

## Summary
- Add `Transaction` struct with explicit commit() method for manual
transaction control
- Implement automatic rollback via `Drop` trait when transaction is not
committed
- Add `begin_transaction()` method to Database for creating manual
transactions
- Include comprehensive unit tests for both commit and rollback
scenarios

## Changes
- `Database::begin_transaction()` - creates a new manual transaction
- `Transaction::commit()` - explicitly commits the transaction
- `Transaction` Drop implementation - automatically rolls back if not
committed
- Unit tests covering both commit and rollback behavior
- Updated existing tests to use new collection APIs

## API Design
The new Transaction API complements the existing `in_transaction()`
callback approach:
- **Manual transactions**: More flexible for complex logic and
cross-function usage
- **Callback transactions**: Simpler for basic cases with automatic
cleanup

## Usage Example
```rust
// Manual transaction with explicit commit
let mut db = Database::open("mydb", None)?;
let transaction = db.begin_transaction()?;
// ... perform operations ...
transaction.commit()?;

// Automatic rollback via Drop
{
    let _transaction = db.begin_transaction()?;
    // ... perform operations ...
} // automatic rollback here
```

## Test plan
- [x] Unit tests for successful transaction commit
- [x] Unit tests for automatic rollback on Drop
- [x] All existing tests still pass
- [x] Code formatting and linting checks pass

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: Claude <[email protected]>

Author: TonyMasson

src/database.rs

@@ -353,6 +353,15 @@ impl Database {
         result
     }
 
+    /// Creates a new transaction that can be committed or rolled back manually.
+    /// Returns a Transaction object that must be committed explicitly, otherwise
+    /// it will be rolled back when dropped.
+    ///
+    /// For simpler cases, consider using `in_transaction()` instead.
+    pub fn begin_transaction(&mut self) -> Result<Transaction> {
+        Transaction::new(self.get_ref())
+    }
+
     /// Encrypts or decrypts a database, or changes its encryption key.
     #[cfg(feature = "enterprise")]
     pub fn change_encryption_key(&mut self, encryption_key: &EncryptionKey) -> Result<()> {
@@ -594,6 +603,51 @@ impl Database {
     }
 }
 
+/// A database transaction that can be committed or rolled back.
+/// When dropped without being committed, the transaction is automatically rolled back.
+pub struct Transaction {
+    db_ref: *mut CBLDatabase,
+    committed: bool,
+}
+
+impl Transaction {
+    fn new(db_ref: *mut CBLDatabase) -> Result<Self> {
+        unsafe {
+            let mut err = CBLError::default();
+            if !CBLDatabase_BeginTransaction(db_ref, &mut err) {
+                return failure(err);
+            }
+        }
+        Ok(Transaction {
+            db_ref,
+            committed: false,
+        })
+    }
+
+    /// Commits the transaction, making all changes permanent.
+    pub fn commit(mut self) -> Result<()> {
+        unsafe {
+            let mut err = CBLError::default();
+            if !CBLDatabase_EndTransaction(self.db_ref, true, &mut err) {
+                return failure(err);
+            }
+        }
+        self.committed = true;
+        Ok(())
+    }
+}
+
+impl Drop for Transaction {
+    fn drop(&mut self) {
+        if !self.committed {
+            unsafe {
+                let mut err = CBLError::default();
+                let _ = CBLDatabase_EndTransaction(self.db_ref, false, &mut err);
+            }
+        }
+    }
+}
+
 impl Drop for Database {
     fn drop(&mut self) {
         unsafe { release(self.get_ref()) }

tests/database_tests.rs

@@ -116,7 +116,9 @@ fn in_transaction() {
     utils::with_db(|db| {
         let result = db.in_transaction(|db| {
             let mut doc = Document::new_with_id("document");
-            db.save_document_with_concurency_control(&mut doc, ConcurrencyControl::LastWriteWins)
+            let mut collection = db.default_collection_or_error().unwrap();
+            collection
+                .save_document_with_concurency_control(&mut doc, ConcurrencyControl::LastWriteWins)
                 .unwrap();
             Ok("document".to_string())
         });
@@ -126,15 +128,60 @@ fn in_transaction() {
 
         let result = db.in_transaction(|db| -> Result<String> {
             let mut doc = Document::new_with_id("document_error");
-            db.save_document_with_concurency_control(&mut doc, ConcurrencyControl::LastWriteWins)
+            let mut collection = db.default_collection_or_error().unwrap();
+            collection
+                .save_document_with_concurency_control(&mut doc, ConcurrencyControl::LastWriteWins)
                 .unwrap();
             Err(couchbase_lite::Error::default())
         });
 
         assert!(result.is_err());
 
-        assert!(db.get_document("document").is_ok());
-        assert!(db.get_document("document_error").is_err());
+        let mut collection = db.default_collection_or_error().unwrap();
+        assert!(collection.get_document("document").is_ok());
+        assert!(collection.get_document("document_error").is_err());
+    });
+}
+
+#[test]
+fn manual_transaction_commit() {
+    utils::with_db(|db| {
+        let initial_count = db.count();
+
+        {
+            let transaction = db.begin_transaction().unwrap();
+            let mut doc = Document::new_with_id("manual_commit_doc");
+            let mut collection = db.default_collection_or_error().unwrap();
+            collection
+                .save_document_with_concurency_control(&mut doc, ConcurrencyControl::LastWriteWins)
+                .unwrap();
+            transaction.commit().unwrap();
+        }
+
+        assert_eq!(db.count(), initial_count + 1);
+        let mut collection = db.default_collection_or_error().unwrap();
+        assert!(collection.get_document("manual_commit_doc").is_ok());
+    });
+}
+
+#[test]
+fn manual_transaction_rollback() {
+    utils::with_db(|db| {
+        let initial_count = db.count();
+
+        {
+            let _transaction = db.begin_transaction().unwrap();
+            let mut doc = Document::new_with_id("rollback_doc");
+            let mut collection = db.default_collection_or_error().unwrap();
+            collection
+                .save_document_with_concurency_control(&mut doc, ConcurrencyControl::LastWriteWins)
+                .unwrap();
+            // Transaction dropped here without commit -> automatic rollback
+        }
+
+        assert_eq!(db.count(), initial_count);
+        let mut collection = db.default_collection_or_error().unwrap();
+        assert!(collection.get_document("rollback_doc").is_err());
     });
 }