Add PaginatedKVStore support to SqliteStore

Implement rust-lightning's PaginatedKVStore/PaginatedKVStoreSync traits
on SqliteStore with a v2→v3 schema migration that adds a created_at
column for tracking insertion order.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: benthecarman

src/io/sqlite_store/migrations.rs

@@ -9,11 +9,15 @@ use lightning::io;
 use rusqlite::Connection;
 
 pub(super) fn migrate_schema(
-	connection: &mut Connection, kv_table_name: &str, from_version: u16, to_version: u16,
+	connection: &mut Connection, kv_table_name: &str, mut from_version: u16, to_version: u16,
 ) -> io::Result<()> {
 	assert!(from_version < to_version);
-	if from_version == 1 && to_version == 2 {
+	if from_version == 1 && to_version >= 2 {
 		migrate_v1_to_v2(connection, kv_table_name)?;
+		from_version = 2;
+	}
+	if from_version == 2 && to_version >= 3 {
+		migrate_v2_to_v3(connection, kv_table_name)?;
 	}
 
 	Ok(())
@@ -65,11 +69,82 @@ fn migrate_v1_to_v2(connection: &mut Connection, kv_table_name: &str) -> io::Res
 	Ok(())
 }
 
+fn migrate_v2_to_v3(connection: &mut Connection, kv_table_name: &str) -> io::Result<()> {
+	let tx = connection.transaction().map_err(|e| {
+		let msg = format!("Failed to migrate table {} from v2 to v3: {}", kv_table_name, e);
+		io::Error::new(io::ErrorKind::Other, msg)
+	})?;
+
+	let old_table = format!("{}_v2_old", kv_table_name);
+	let map_err = |e: rusqlite::Error| -> io::Error {
+		let msg = format!("Failed to migrate table {} from v2 to v3: {}", kv_table_name, e);
+		io::Error::new(io::ErrorKind::Other, msg)
+	};
+
+	// Recreate the table to ensure the correct PRIMARY KEY regardless of migration history.
+	// Tables migrated from v1 have PK (primary_namespace, key) only — missing
+	// secondary_namespace. Recreating normalizes the schema for all databases.
+	tx.execute(&format!("ALTER TABLE {} RENAME TO {}", kv_table_name, old_table), [])
+		.map_err(map_err)?;
+
+	tx.execute(
+		&format!(
+			"CREATE TABLE {} (
+			primary_namespace TEXT NOT NULL,
+			secondary_namespace TEXT DEFAULT \"\" NOT NULL,
+			key TEXT NOT NULL CHECK (key <> ''),
+			value BLOB,
+			created_at INTEGER NOT NULL DEFAULT 0,
+			PRIMARY KEY (primary_namespace, secondary_namespace, key)
+			)",
+			kv_table_name
+		),
+		[],
+	)
+	.map_err(map_err)?;
+
+	// Copy data and backfill created_at from ROWID for relative ordering
+	tx.execute(
+		&format!(
+			"INSERT INTO {} (primary_namespace, secondary_namespace, key, value, created_at)
+			SELECT primary_namespace, secondary_namespace, key, value, ROWID FROM {}",
+			kv_table_name, old_table
+		),
+		[],
+	)
+	.map_err(map_err)?;
+
+	tx.execute(&format!("DROP TABLE {}", old_table), []).map_err(map_err)?;
+
+	// Create composite index for paginated listing
+	let sql = format!(
+		"CREATE INDEX idx_{}_paginated ON {} (primary_namespace, secondary_namespace, created_at DESC, key ASC)",
+		kv_table_name, kv_table_name
+	);
+
+	tx.execute(&sql, []).map_err(map_err)?;
+
+	// Update user_version
+	tx.pragma(Some(rusqlite::DatabaseName::Main), "user_version", 3u16, |_| Ok(())).map_err(
+		|e| {
+			let msg = format!("Failed to upgrade user_version from 2 to 3: {}", e);
+			io::Error::new(io::ErrorKind::Other, msg)
+		},
+	)?;
+
+	tx.commit().map_err(|e| {
+		let msg = format!("Failed to migrate table {} from v2 to v3: {}", kv_table_name, e);
+		io::Error::new(io::ErrorKind::Other, msg)
+	})?;
+
+	Ok(())
+}
+
 #[cfg(test)]
 mod tests {
 	use std::fs;
 
-	use lightning::util::persist::KVStoreSync;
+	use lightning::util::persist::{KVStoreSync, PaginatedKVStoreSync};
 	use rusqlite::{named_params, Connection};
 
 	use crate::io::sqlite_store::SqliteStore;
@@ -159,4 +234,91 @@ mod tests {
 		// Check we can continue to use the store just fine.
 		do_read_write_remove_list_persist(&store);
 	}
+
+	#[test]
+	fn rwrl_post_schema_2_migration() {
+		let old_schema_version = 2u16;
+
+		let mut temp_path = random_storage_path();
+		temp_path.push("rwrl_post_schema_2_migration");
+
+		let db_file_name = "test_db".to_string();
+		let kv_table_name = "test_table".to_string();
+
+		let test_ns = "testspace";
+		let test_sub = "testsub";
+
+		{
+			// Create a v2 database manually
+			fs::create_dir_all(temp_path.clone()).unwrap();
+			let mut db_file_path = temp_path.clone();
+			db_file_path.push(db_file_name.clone());
+
+			let connection = Connection::open(db_file_path.clone()).unwrap();
+
+			connection
+				.pragma(
+					Some(rusqlite::DatabaseName::Main),
+					"user_version",
+					old_schema_version,
+					|_| Ok(()),
+				)
+				.unwrap();
+
+			let sql = format!(
+				"CREATE TABLE IF NOT EXISTS {} (
+					primary_namespace TEXT NOT NULL,
+					secondary_namespace TEXT DEFAULT \"\" NOT NULL,
+					key TEXT NOT NULL CHECK (key <> ''),
+					value BLOB, PRIMARY KEY ( primary_namespace, secondary_namespace, key )
+					);",
+				kv_table_name
+			);
+			connection.execute(&sql, []).unwrap();
+
+			// Insert 3 rows in a known order
+			for i in 0..3 {
+				let key = format!("key_{}", i);
+				let sql = format!(
+					"INSERT INTO {} (primary_namespace, secondary_namespace, key, value) VALUES (:ns, :sub, :key, :value);",
+					kv_table_name
+				);
+				let mut stmt = connection.prepare_cached(&sql).unwrap();
+				stmt.execute(named_params! {
+					":ns": test_ns,
+					":sub": test_sub,
+					":key": key,
+					":value": vec![i as u8; 8],
+				})
+				.unwrap();
+			}
+		}
+
+		// Open with new code, triggering v2→v3 migration
+		let store = SqliteStore::new(temp_path, Some(db_file_name), Some(kv_table_name)).unwrap();
+
+		// Verify data survived
+		for i in 0..3 {
+			let key = format!("key_{}", i);
+			let data = store.read(test_ns, test_sub, &key).unwrap();
+			assert_eq!(data, vec![i as u8; 8]);
+		}
+
+		// Verify paginated listing works and returns entries in ROWID-backfilled order (newest first)
+		let response =
+			PaginatedKVStoreSync::list_paginated(&store, test_ns, test_sub, None).unwrap();
+		assert_eq!(response.keys.len(), 3);
+		// ROWIDs were 1, 2, 3 so created_at was backfilled as 1, 2, 3
+		// Newest first: key_2, key_1, key_0
+		assert_eq!(response.keys, vec!["key_2", "key_1", "key_0"]);
+
+		// Verify we can write new entries and they get proper ordering
+		KVStoreSync::write(&store, test_ns, test_sub, "key_new", vec![99u8; 8]).unwrap();
+		let response =
+			PaginatedKVStoreSync::list_paginated(&store, test_ns, test_sub, None).unwrap();
+		assert_eq!(response.keys[0], "key_new");
+
+		// Check we can continue to use the store just fine.
+		do_read_write_remove_list_persist(&store);
+	}
 }