feat: implement dynamodb pagination

src-tauri/src/dynamo/query_table.rs

@@ -25,12 +25,46 @@ pub async fn query_table(
     let pk_name = partition_key.get("name").and_then(|v| v.as_str()).unwrap();
     let pk_value = partition_key.get("value").and_then(|v| v.as_str()).unwrap();
 
-    let mut query = client.query().table_name(input.table_name);
+    let limit = input
+        .payload
+        .get("limit")
+        .and_then(|v| v.as_u64())
+        .map(|v| v as i32)
+        .unwrap();
+    let exclusive_start_key = input
+        .payload
+        .get("exclusive_start_key")
+        .and_then(|v| v.as_object());
+
+    let mut query = client.query().table_name(input.table_name).limit(limit);
 
     if let Some(idx_name) = index_name {
         query = query.index_name(idx_name);
     }
 
+    if let Some(key_map) = exclusive_start_key {
+        let mut last_key_map = std::collections::HashMap::new();
+
+        for (k, v) in key_map {
+            if let Some(s) = v.as_str() {
+                last_key_map.insert(k.clone(), AttributeValue::S(s.to_string()));
+            } else if let Some(n) = v.as_u64() {
+                last_key_map.insert(k.clone(), AttributeValue::N(n.to_string()));
+            } else if let Some(n) = v.as_i64() {
+                last_key_map.insert(k.clone(), AttributeValue::N(n.to_string()));
+            } else if let Some(b) = v.as_bool() {
+                last_key_map.insert(k.clone(), AttributeValue::Bool(b));
+            }
+        }
+
+        if !last_key_map.is_empty() {
+            // Apply each key-value pair individually to match the method signature
+            for (key, value) in last_key_map {
+                query = query.exclusive_start_key(key, value);
+            }
+        }
+    }
+
     // Attribute name placeholders
     let mut expr_attr_names = Vec::<(String, String)>::new();
     expr_attr_names.push(("#attr0".to_string(), pk_name.to_string()));

src-tauri/src/dynamo/scan_table.rs

@@ -11,14 +11,48 @@ pub struct ScanTableInput<'a> {
 pub async fn scan_table(client: &Client, input: ScanTableInput<'_>) -> Result<ApiResponse, String> {
     let index_name = input.payload.get("index_name").and_then(|v| v.as_str());
     let filters = input.payload.get("filters").and_then(|v| v.as_array());
+    let limit = input
+        .payload
+        .get("limit")
+        .and_then(|v| v.as_u64())
+        .map(|v| v as i32)
+        .unwrap();
+    let exclusive_start_key = input
+        .payload
+        .get("exclusive_start_key")
+        .and_then(|v| v.as_object());
+
 
     // Start building the scan
-    let mut scan = client.scan().table_name(input.table_name);
+    let mut scan = client.scan().table_name(input.table_name).limit(limit);
 
     if let Some(idx_name) = index_name {
         scan = scan.index_name(idx_name);
     }
 
+    if let Some(key_map) = exclusive_start_key {
+        let mut last_key_map = std::collections::HashMap::new();
+
+        for (k, v) in key_map {
+            if let Some(s) = v.as_str() {
+                last_key_map.insert(k.clone(), AttributeValue::S(s.to_string()));
+            } else if let Some(n) = v.as_u64() {
+                last_key_map.insert(k.clone(), AttributeValue::N(n.to_string()));
+            } else if let Some(n) = v.as_i64() {
+                last_key_map.insert(k.clone(), AttributeValue::N(n.to_string()));
+            } else if let Some(b) = v.as_bool() {
+                last_key_map.insert(k.clone(), AttributeValue::Bool(b));
+            }
+        }
+
+        if !last_key_map.is_empty() {
+            // Apply each key-value pair individually to match the method signature
+            for (key, value) in last_key_map {
+                scan = scan.exclusive_start_key(key, value);
+            }
+        }
+    }
+
     // Add filters if provided
     if let Some(filter_array) = filters {
         let mut filter_expressions = Vec::new();

src/datasources/dynamoApi.ts

@@ -79,6 +79,8 @@ export type QueryParams = {
     operator: string;
     value: string;
   }>;
+  limit?: number; // Optional limit for the number of items to return
+  exclusiveStartKey?: Record<string, unknown> | null; // For pagination
 };
 
 export type QueryResult = {
@@ -143,6 +145,8 @@ const dynamoApi = {
         partition_key: queryParams.partitionKey,
         sort_key: queryParams.sortKey,
         filters: queryParams.filters,
+        limit: queryParams.limit,
+        exclusive_start_key: queryParams.exclusiveStartKey,
       },
     };
 
@@ -165,7 +169,12 @@ const dynamoApi = {
     const options = {
       table_name: queryParams.tableName,
       operation: 'SCAN_TABLE',
-      payload: { filters: queryParams.filters, index_name: queryParams.indexName },
+      payload: {
+        filters: queryParams.filters,
+        index_name: queryParams.indexName,
+        limit: queryParams.limit,
+        exclusive_start_key: queryParams.exclusiveStartKey,
+      },
     };
 
     const result = await tauriClient.invokeDynamoApi(credentials, options);

src/views/editor/dynamo-editor/components/ui-editor.vue

@@ -349,6 +349,8 @@ const handleSubmit = async (event: MouseEvent) => {
       partitionKey: { name: partitionKeyName, value: partitionKey },
       sortKey: sortKeyName && sortKey ? { name: sortKeyName, value: sortKey } : undefined,
       filters: formFilterItems,
+      limit: 10,
+      exclusiveStartKey: undefined, // For pagination, can be set later
     };
 
     const data = await queryTable(activeConnection.value as DynamoDBConnection, queryParams);