fix: cloudsync_cleanup now drops the blocks table for block LWW tables

When a table has columns configured with algo=block, cloudsync_cleanup
was leaving the {table}_cloudsync_blocks table behind. This fix drops it
alongside the meta-table during cleanup. Adds a unit test to verify both
companion tables are removed.

Bumps version to 1.0.11.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: marcobambini

CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.0.11] - 2026-04-11
+
+### Fixed
+
+- **cloudsync_cleanup**: Now also drops the `{table}_cloudsync_blocks` table when the table has block LWW columns configured via `cloudsync_set_column(..., 'algo', 'block')`.
+
+### Added
+
+- Unit test `do_test_block_lww_cleanup` verifying that both `{table}_cloudsync` and `{table}_cloudsync_blocks` are removed after `cloudsync_cleanup`.
+
 ## [1.0.10] - 2026-04-08
 
 ### Fixed

src/cloudsync.c

@@ -3378,7 +3378,7 @@ int cloudsync_table_sanity_check (cloudsync_context *data, const char *name, CLO
 
 int cloudsync_cleanup_internal (cloudsync_context *data, cloudsync_table_context *table) {
     if (cloudsync_context_init(data) == NULL) return DBRES_MISUSE;
-    
+
     // drop meta-table
     const char *table_name = table->name;
     char *sql = cloudsync_memory_mprintf(SQL_DROP_CLOUDSYNC_TABLE, table->meta_ref);
@@ -3389,7 +3389,19 @@ int cloudsync_cleanup_internal (cloudsync_context *data, cloudsync_table_context
         snprintf(buffer, sizeof(buffer), "Unable to drop cloudsync table %s_cloudsync in cloudsync_cleanup", table_name);
         return cloudsync_set_error(data, buffer, rc);
     }
-    
+
+    // drop blocks table if this table has block LWW columns
+    if (table->blocks_ref) {
+        sql = cloudsync_memory_mprintf(SQL_DROP_CLOUDSYNC_TABLE, table->blocks_ref);
+        rc = database_exec(data, sql);
+        cloudsync_memory_free(sql);
+        if (rc != DBRES_OK) {
+            char buffer[1024];
+            snprintf(buffer, sizeof(buffer), "Unable to drop blocks table %s_cloudsync_blocks in cloudsync_cleanup", table_name);
+            return cloudsync_set_error(data, buffer, rc);
+        }
+    }
+
     // drop original triggers
     rc = database_delete_triggers(data, table_name);
     if (rc != DBRES_OK) {

src/cloudsync.h

@@ -18,7 +18,7 @@
 extern "C" {
 #endif
 
-#define CLOUDSYNC_VERSION                       "1.0.10"
+#define CLOUDSYNC_VERSION                       "1.0.11"
 #define CLOUDSYNC_MAX_TABLENAME_LEN             512
 
 #define CLOUDSYNC_VALUE_NOTSET                  -1

test/unit.c

@@ -11281,6 +11281,55 @@ bool do_test_block_lww_whitespace(int nclients, bool print_result, bool cleanup_
     return false;
 }
 
+bool do_test_block_lww_cleanup(bool print_result, bool cleanup_databases) {
+    // Test: cloudsync_cleanup removes both the meta-table and the blocks table
+    // when a table has block LWW columns configured.
+    sqlite3 *db = NULL;
+    time_t timestamp = time(NULL);
+    int rc;
+    bool result = false;
+
+    db = do_create_database_file(0, timestamp, test_counter++);
+    if (!db) return false;
+
+    rc = sqlite3_exec(db, "CREATE TABLE docs (id TEXT NOT NULL PRIMARY KEY, body TEXT);", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) { printf("block_cleanup: CREATE TABLE failed: %s\n", sqlite3_errmsg(db)); goto fail; }
+
+    rc = sqlite3_exec(db, "SELECT cloudsync_init('docs');", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) { printf("block_cleanup: cloudsync_init failed: %s\n", sqlite3_errmsg(db)); goto fail; }
+
+    rc = sqlite3_exec(db, "SELECT cloudsync_set_column('docs', 'body', 'algo', 'block');", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) { printf("block_cleanup: set_column failed: %s\n", sqlite3_errmsg(db)); goto fail; }
+
+    // Insert a row to populate the blocks table
+    rc = sqlite3_exec(db, "INSERT INTO docs (id, body) VALUES ('doc1', 'Line 1\nLine 2\nLine 3');", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) { printf("block_cleanup: INSERT failed: %s\n", sqlite3_errmsg(db)); goto fail; }
+
+    // Confirm docs_cloudsync and docs_cloudsync_blocks exist before cleanup
+    int64_t meta_exists = do_select_int(db, "SELECT COUNT(*) FROM sqlite_master WHERE name='docs_cloudsync';");
+    if (meta_exists != 1) { printf("block_cleanup: docs_cloudsync missing before cleanup\n"); goto fail; }
+
+    int64_t blocks_exists = do_select_int(db, "SELECT COUNT(*) FROM sqlite_master WHERE name='docs_cloudsync_blocks';");
+    if (blocks_exists != 1) { printf("block_cleanup: docs_cloudsync_blocks missing before cleanup\n"); goto fail; }
+
+    // Run cleanup
+    rc = sqlite3_exec(db, "SELECT cloudsync_cleanup('docs');", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) { printf("block_cleanup: cloudsync_cleanup failed: %s\n", sqlite3_errmsg(db)); goto fail; }
+
+    // Both companion tables must be gone after cleanup
+    int64_t meta_after = do_select_int(db, "SELECT COUNT(*) FROM sqlite_master WHERE name='docs_cloudsync';");
+    if (meta_after != 0) { printf("block_cleanup: docs_cloudsync still exists after cleanup\n"); goto fail; }
+
+    int64_t blocks_after = do_select_int(db, "SELECT COUNT(*) FROM sqlite_master WHERE name='docs_cloudsync_blocks';");
+    if (blocks_after != 0) { printf("block_cleanup: docs_cloudsync_blocks still exists after cleanup\n"); goto fail; }
+
+    result = true;
+
+fail:
+    if (db) close_db(db);
+    return result;
+}
+
 // MARK: - New edge-case tests
 
 bool do_test_unsupported_algorithms (sqlite3 *db) {
@@ -11997,6 +12046,7 @@ int main (int argc, const char * argv[]) {
     result += test_report("Test Block LWW NonOverlap:", do_test_block_lww_nonoverlap_add(2, print_result, cleanup_databases));
     result += test_report("Test Block LWW LongLine:", do_test_block_lww_long_line(2, print_result, cleanup_databases));
     result += test_report("Test Block LWW Whitespace:", do_test_block_lww_whitespace(2, print_result, cleanup_databases));
+    result += test_report("Test Block LWW Cleanup:", do_test_block_lww_cleanup(print_result, cleanup_databases));
 
     // edge-case tests
     result += test_report("Corrupted Payload Test:", do_test_corrupted_payload(2, print_result, cleanup_databases));