add implementation and tests for pagination for items and keys

examples/stable_b_tree_map_instruction_threshold/src/index.did

@@ -2,6 +2,12 @@ service: () -> {
     insertLargeRecord: (nat32) -> ();
     insertMediumRecord: (nat32) -> ();
     insertSmallRecord: (nat32) -> ();
+    itemsLargeRecord: (nat32) -> (vec record {text; record {id:text; age:nat; signature:vec nat8; internetIdentity:principal; username:text; mediumRecord:record {id:text; age:nat; internetIdentity:principal; username:text}; friends:vec text}}) query;
+    itemsMediumRecord: (nat32) -> (vec record {text; record {id:text; age:nat; internetIdentity:principal; username:text}}) query;
+    itemsSmallRecord: (nat32) -> (vec record {text; record {id:principal}}) query;
+    keysLargeRecord: (nat32) -> (vec text) query;
+    keysMediumRecord: (nat32) -> (vec text) query;
+    keysSmallRecord: (nat32) -> (vec text) query;
     valuesLargeRecord: (nat32) -> (vec record {id:text; age:nat; signature:vec nat8; internetIdentity:principal; username:text; mediumRecord:record {id:text; age:nat; internetIdentity:principal; username:text}; friends:vec text}) query;
     valuesMediumRecord: (nat32) -> (vec record {id:text; age:nat; internetIdentity:principal; username:text}) query;
     valuesSmallRecord: (nat32) -> (vec record {id:principal}) query;

examples/stable_b_tree_map_instruction_threshold/src/index.ts

@@ -8,6 +8,7 @@ import {
     Record,
     StableBTreeMap,
     text,
+    Tuple,
     update,
     Vec,
     Void
@@ -54,9 +55,19 @@ export default Canister({
             });
         }
     }),
+    keysSmallRecord: query([nat32], Vec(text), (numToReturn) => {
+        return smallRecordMap.keys(0, numToReturn);
+    }),
     valuesSmallRecord: query([nat32], Vec(SmallRecord), (numToReturn) => {
         return smallRecordMap.values(0, numToReturn);
     }),
+    itemsSmallRecord: query(
+        [nat32],
+        Vec(Tuple(text, SmallRecord)),
+        (numToReturn) => {
+            return smallRecordMap.items(0, numToReturn);
+        }
+    ),
     insertMediumRecord: update([nat32], Void, (numToInsert) => {
         for (let i = 0; i < numToInsert; i++) {
             const id = v4();
@@ -69,9 +80,19 @@ export default Canister({
             });
         }
     }),
+    keysMediumRecord: query([nat32], Vec(text), (numToReturn) => {
+        return mediumRecordMap.keys(0, numToReturn);
+    }),
     valuesMediumRecord: query([nat32], Vec(MediumRecord), (numToReturn) => {
         return mediumRecordMap.values(0, numToReturn);
     }),
+    itemsMediumRecord: query(
+        [nat32],
+        Vec(Tuple(text, MediumRecord)),
+        (numToReturn) => {
+            return mediumRecordMap.items(0, numToReturn);
+        }
+    ),
     insertLargeRecord: update([nat32], Void, (numToInsert) => {
         for (let i = 0; i < numToInsert; i++) {
             const id = v4();
@@ -92,7 +113,17 @@ export default Canister({
             });
         }
     }),
+    keysLargeRecord: query([nat32], Vec(text), (numToReturn) => {
+        return largeRecordMap.keys(0, numToReturn);
+    }),
     valuesLargeRecord: query([nat32], Vec(LargeRecord), (numToReturn) => {
         return largeRecordMap.values(0, numToReturn);
-    })
+    }),
+    itemsLargeRecord: query(
+        [nat32],
+        Vec(Tuple(text, LargeRecord)),
+        (numToReturn) => {
+            return largeRecordMap.items(0, numToReturn);
+        }
+    )
 });

examples/stable_b_tree_map_instruction_threshold/test/tests.ts

@@ -13,13 +13,26 @@ export function getTests(
                     10_000
                 );
 
-                const result =
+                const keysResult =
+                    await stableBTreeMapInstructionThresholdCanister.keysSmallRecord(
+                        5_000
+                    );
+
+                const valuesResult =
                     await stableBTreeMapInstructionThresholdCanister.valuesSmallRecord(
                         6_000
                     );
 
+                const itemsResult =
+                    await stableBTreeMapInstructionThresholdCanister.itemsSmallRecord(
+                        2_000
+                    );
+
                 return {
-                    Ok: result.length === 6_000
+                    Ok:
+                        keysResult.length === 5_000 &&
+                        valuesResult.length === 6_000 &&
+                        itemsResult.length === 2_000
                 };
             }
         },
@@ -30,13 +43,26 @@ export function getTests(
                     5_000
                 );
 
-                const result =
+                const keysResult =
+                    await stableBTreeMapInstructionThresholdCanister.keysMediumRecord(
+                        1_000
+                    );
+
+                const valuesResult =
                     await stableBTreeMapInstructionThresholdCanister.valuesMediumRecord(
                         1_000
                     );
 
+                const itemsResult =
+                    await stableBTreeMapInstructionThresholdCanister.itemsMediumRecord(
+                        1_000
+                    );
+
                 return {
-                    Ok: result.length === 1_000
+                    Ok:
+                        keysResult.length === 1_000 &&
+                        valuesResult.length === 1_000 &&
+                        itemsResult.length === 1_000
                 };
             }
         },
@@ -47,13 +73,26 @@ export function getTests(
                     2_000
                 );
 
-                const result =
+                const keysResult =
+                    await stableBTreeMapInstructionThresholdCanister.keysLargeRecord(
+                        500
+                    );
+
+                const valuesResult =
                     await stableBTreeMapInstructionThresholdCanister.valuesLargeRecord(
                         500
                     );
 
+                const itemsResult =
+                    await stableBTreeMapInstructionThresholdCanister.itemsLargeRecord(
+                        400
+                    );
+
                 return {
-                    Ok: result.length === 500
+                    Ok:
+                        keysResult.length === 500 &&
+                        valuesResult.length === 500 &&
+                        itemsResult.length === 400
                 };
             }
         }

property_tests/tests/stable_b_tree_map/test/test.ts

@@ -65,8 +65,8 @@ const StableBTreeMapTestArb = fc
                 );
         }),
         {
-            minLength: 20,
-            maxLength: 50
+            minLength: 10,
+            maxLength: 30
         }
     )
     .map((canisterConfigs) => {

src/compiler/rust/canister/src/ic/stable_b_tree_map_items.rs

@@ -16,11 +16,31 @@ pub fn native_function<'a>(
         .try_into()?;
     let memory_id: u8 = memory_id_string.parse()?;
 
+    let start_index_string: String = args
+        .get(1)
+        .expect("stable_b_tree_map_items argument 1 is undefined")
+        .to_js_value()?
+        .try_into()?;
+    let start_index: usize = start_index_string.parse()?;
+
+    let length_string: String = args
+        .get(2)
+        .expect("stable_b_tree_map_items argument 2 is undefined")
+        .to_js_value()?
+        .try_into()?;
+
     let items: Vec<Vec<Vec<u8>>> = STABLE_B_TREE_MAPS.with(|stable_b_tree_maps| {
         let stable_b_tree_maps = stable_b_tree_maps.borrow();
+        let stable_b_tree_map = &stable_b_tree_maps[&memory_id];
 
-        stable_b_tree_maps[&memory_id]
+        stable_b_tree_map
             .iter()
+            .skip(start_index)
+            .take(if length_string == "NOT_SET" {
+                stable_b_tree_map.len().try_into().unwrap()
+            } else {
+                length_string.parse().unwrap()
+            })
             .map(|(key, value)| vec![key.bytes, value.bytes])
             .collect()
     });

src/compiler/rust/canister/src/ic/stable_b_tree_map_keys.rs

@@ -16,11 +16,31 @@ pub fn native_function<'a>(
         .try_into()?;
     let memory_id: u8 = memory_id_string.parse()?;
 
+    let start_index_string: String = args
+        .get(1)
+        .expect("stable_b_tree_map_keys argument 1 is undefined")
+        .to_js_value()?
+        .try_into()?;
+    let start_index: usize = start_index_string.parse()?;
+
+    let length_string: String = args
+        .get(2)
+        .expect("stable_b_tree_map_keys argument 2 is undefined")
+        .to_js_value()?
+        .try_into()?;
+
     let keys: Vec<Vec<u8>> = STABLE_B_TREE_MAPS.with(|stable_b_tree_maps| {
         let stable_b_tree_maps = stable_b_tree_maps.borrow();
+        let stable_b_tree_map = &stable_b_tree_maps[&memory_id];
 
-        stable_b_tree_maps[&memory_id]
+        stable_b_tree_map
             .iter()
+            .skip(start_index)
+            .take(if length_string == "NOT_SET" {
+                stable_b_tree_map.len().try_into().unwrap()
+            } else {
+                length_string.parse().unwrap()
+            })
             .map(|(key, _)| key.bytes)
             .collect()
     });

src/lib/ic/types/azle_ic.ts

@@ -99,8 +99,16 @@ export type AzleIc = {
         encodedValue: ArrayBufferLike
     ) => ArrayBuffer | undefined;
     stableBTreeMapIsEmpty: (memoryId: string) => boolean;
-    stableBTreeMapItems: (memoryId: string) => [ArrayBuffer, ArrayBuffer][];
-    stableBTreeMapKeys: (memoryId: string) => ArrayBuffer[];
+    stableBTreeMapItems: (
+        memoryId: string,
+        startIndex: string,
+        length: string
+    ) => [ArrayBuffer, ArrayBuffer][];
+    stableBTreeMapKeys: (
+        memoryId: string,
+        startIndex: string,
+        length: string
+    ) => ArrayBuffer[];
     stableBTreeMapLen: (memoryId: string) => ArrayBuffer;
     stableBTreeMapRemove(
         memoryId: string,

src/lib/stable_structures/stable_b_tree_map.ts

@@ -107,15 +107,20 @@ export function StableBTreeMap<Key = any, Value = any>(
         },
         /**
          * Retrieves the items in the map in sorted order.
+         * @param startIndex the starting index to begin retrieval
+         * @param length the number of items to retrieve
          * @returns tuples representing key/value pairs.
          */
-        items(): [Key, Value][] {
+        items(startIndex?: number, length?: number): [Key, Value][] {
             if (globalThis._azleIc === undefined) {
                 return undefined as any;
             }
 
-            const encodedItems =
-                globalThis._azleIc.stableBTreeMapItems(memoryId);
+            const encodedItems = globalThis._azleIc.stableBTreeMapItems(
+                memoryId,
+                startIndex?.toString() ?? '0',
+                length?.toString() ?? 'NOT_SET'
+            );
 
             // TODO too much copying
             return encodedItems.map(([encodedKey, encodedValue]) => {
@@ -127,14 +132,20 @@ export function StableBTreeMap<Key = any, Value = any>(
         },
         /**
          * The keys for each element in the map in sorted order.
+         * @param startIndex the starting index to begin retrieval
+         * @param length the number of keys to retrieve
          * @returns they keys in the map.
          */
-        keys(): Key[] {
+        keys(startIndex?: number, length?: number): Key[] {
             if (globalThis._azleIc === undefined) {
                 return undefined as any;
             }
 
-            const encodedKeys = globalThis._azleIc.stableBTreeMapKeys(memoryId);
+            const encodedKeys = globalThis._azleIc.stableBTreeMapKeys(
+                memoryId,
+                startIndex?.toString() ?? '0',
+                length?.toString() ?? 'NOT_SET'
+            );
 
             // TODO too much copying
             return encodedKeys.map((encodedKey) => {