more house keeping

dynamodb/json.odin

@@ -529,45 +529,49 @@ parse_limit :: proc(request_body: []byte) -> int {
 // Returns nil (not an error) when the field is absent.
 // ============================================================================
 
+// Returns (key, ok, body_parse_err).
+//   ok=true,  body_parse_err=false → key present and valid, or key absent (no pagination)
+//   ok=false, body_parse_err=true  → request body is not valid JSON or not an object
+//   ok=false, body_parse_err=false → ExclusiveStartKey present but malformed/invalid
 parse_exclusive_start_key :: proc(
 	request_body: []byte,
 	table_name: string,
 	key_schema: []Key_Schema_Element,
-) -> (result: Maybe([]byte), ok: bool) {
+) -> (result: Maybe([]byte), ok: bool, body_err: bool) {
 	data, parse_err := json.parse(request_body, allocator = context.temp_allocator)
 	if parse_err != nil {
-		return nil, true // no ESK is fine
+		return nil, false, true // body is not valid JSON — real error
 	}
 	defer json.destroy_value(data)
 
 	root, root_ok := data.(json.Object)
 	if !root_ok {
-		return nil, true
+		return nil, false, true // root must be an object — real error
 	}
 
 	esk_val, found := root["ExclusiveStartKey"]
 	if !found {
-		return nil, true // absent → no pagination, that's ok
+		return nil, true, false // absent → no pagination, that's ok
 	}
 
 	// Parse ExclusiveStartKey as a DynamoDB Item
 	key_item, item_ok := parse_item_from_value(esk_val)
 	if !item_ok {
-		return nil, false // present but malformed → real error
+		return nil, false, false // present but malformed → validation error
 	}
 	defer item_destroy(&key_item)
 
 	// Validate and extract key struct using schema
 	key_struct, key_ok := key_from_item(key_item, key_schema)
 	if !key_ok {
-		return nil, false // missing required key attributes
+		return nil, false, false // missing required key attributes
 	}
 	defer key_destroy(&key_struct)
 
 	// Get raw byte values
 	key_values, kv_ok := key_get_values(&key_struct)
 	if !kv_ok {
-		return nil, false
+		return nil, false, false
 	}
 
 	// Build binary storage key
@@ -578,44 +582,41 @@ parse_exclusive_start_key :: proc(
 }
 
 // parse_exclusive_start_key_gsi ... Just a helper for GSI keys
+// Returns (key, ok, body_parse_err) — same contract as parse_exclusive_start_key.
 parse_exclusive_start_key_gsi :: proc(
 	request_body: []byte,
 	table_name: string,
 	metadata: ^Table_Metadata,
 	gsi: ^Global_Secondary_Index,
-) -> (Maybe([]byte), bool) {
-	root, ok := json.parse(request_body)
-	if ok != nil do return nil, false
+) -> (Maybe([]byte), bool, bool) {
+	root, parse_err := json.parse(request_body)
+	if parse_err != nil do return nil, false, true // body not valid JSON
 	defer json.destroy_value(root)
 
-	// Assert the root Value as an Object before indexing
 	obj, obj_ok := root.(json.Object)
-	if !obj_ok do return nil, false
+	if !obj_ok do return nil, false, true // root must be an object
 
 	esk_val, has := obj["ExclusiveStartKey"]
-	if !has do return nil, true
+	if !has do return nil, true, false // absent → no pagination
 
 	key_item, key_ok := parse_item_from_value(esk_val)
-	if !key_ok do return nil, false
+	if !key_ok do return nil, false, false
 	defer item_destroy(&key_item)
 
-	// index key
 	idx_key, idx_ok := key_from_item(key_item, gsi.key_schema)
-	if !idx_ok do return nil, false
+	if !idx_ok do return nil, false, false
 	defer key_destroy(&idx_key)
 
 	idx_vals, idx_vals_ok := key_get_values(&idx_key)
-	if !idx_vals_ok do return nil, false
+	if !idx_vals_ok do return nil, false, false
 
-	// base key
 	base_key, base_ok := key_from_item(key_item, metadata.key_schema)
-	if !base_ok do return nil, false
+	if !base_ok do return nil, false, false
 	defer key_destroy(&base_key)
 
 	base_vals, base_vals_ok := key_get_values(&base_key)
-	if !base_vals_ok do return nil, false
+	if !base_vals_ok do return nil, false, false
 
-	// build the actual RocksDB GSI key
 	k := build_gsi_key(
 		table_name,
 		gsi.index_name,
@@ -624,7 +625,7 @@ parse_exclusive_start_key_gsi :: proc(
 		base_vals.pk,
 		base_vals.sk,
 	)
-	return k, true
+	return k, true, false
 }
 
 // ============================================================================