fix(dynamodb): keep inexact decimal keys exact in pagination cursors

Hold every N value a JS number cannot represent exactly as a NumberValue so the
cursor encodes it as {N}; item output keeps the same number/string rule.

Author: waleedlatif1

apps/sim/lib/internal/dynamodb/client.test.ts

@@ -44,6 +44,7 @@ describe('DynamoDB item unmarshalling', () => {
           avatar: { B: new Uint8Array([104, 105]) },
           snowflake: { N: '1234567890123456789' },
           age: { N: '42' },
+          ratio: { N: '0.12345678901234567890123' },
         },
       ],
     })
@@ -61,6 +62,7 @@ describe('DynamoDB item unmarshalling', () => {
           avatar: 'aGk=',
           snowflake: '1234567890123456789',
           age: 42,
+          ratio: 0.12345678901234568,
         },
       ],
       count: 1,
@@ -78,6 +80,7 @@ describe('DynamoDB item unmarshalling', () => {
         sk: { N: '1234567890123456789' },
         bin: { B: new Uint8Array([104, 105]) },
         age: { N: '42' },
+        ratio: { N: '0.12345678901234567890123' },
       },
     })
     const firstPage = await queryItems(pageClient, 'Users', 'pk = :pk', {
@@ -89,6 +92,7 @@ describe('DynamoDB item unmarshalling', () => {
       sk: { N: '1234567890123456789' },
       bin: { B: 'aGk=' },
       age: 42,
+      ratio: { N: '0.12345678901234567890123' },
     })
 
     let sentStartKey: unknown
@@ -105,6 +109,7 @@ describe('DynamoDB item unmarshalling', () => {
       sk: { N: '1234567890123456789' },
       bin: { B: new Uint8Array([104, 105]) },
       age: { N: '42' },
+      ratio: { N: '0.12345678901234567890123' },
     })
     pageClient.destroy()
     client.destroy()

apps/sim/lib/internal/dynamodb/client.ts

@@ -16,26 +16,41 @@ import type { DynamoDBConnectionConfig, DynamoDBTableSchema } from '@/tools/dyna
 type DynamoDBReturnValues = 'NONE' | 'ALL_OLD' | 'UPDATED_OLD' | 'ALL_NEW' | 'UPDATED_NEW'
 
 /**
- * Keeps integers beyond `Number.MAX_SAFE_INTEGER` (and other values a JS number cannot hold)
- * as a `NumberValue` holding the exact DynamoDB string, since the SDK default turns them into a
- * `BigInt` that the JSON response cannot serialize.
+ * Keeps any DynamoDB number a JS number cannot hold exactly (integers beyond
+ * `Number.MAX_SAFE_INTEGER`, high-precision decimals, non-finite values) as a `NumberValue`
+ * with the exact string, so pagination cursors can round-trip it. The SDK default would turn
+ * large integers into a `BigInt` that the JSON response cannot serialize.
  */
 function unwrapNumber(value: string): number | NumberValue {
   const parsed = Number(value)
+  if (Number.isSafeInteger(parsed)) return parsed
+  if (Number.isFinite(parsed) && !Number.isInteger(parsed) && String(parsed) === value) {
+    return parsed
+  }
+  return NumberValue.from(value)
+}
+
+/**
+ * Item output for a number kept as a `NumberValue`: the exact string for integers beyond
+ * `Number.MAX_SAFE_INTEGER` and non-finite values, otherwise the nearest JS number.
+ */
+function numberValueToJson(value: NumberValue): number | string {
+  const exact = value.toString()
+  const parsed = Number(exact)
   if (!Number.isFinite(parsed) || (Number.isInteger(parsed) && !Number.isSafeInteger(parsed))) {
-    return NumberValue.from(value)
+    return exact
   }
   return parsed
 }
 
 /**
  * Converts unmarshalled DynamoDB values into JSON-serializable shapes: string, number and
- * binary sets become arrays, binary values become base64 strings, and numbers a JS number
- * cannot hold become their exact string. Without this a set serializes as `{}` and a binary
+ * binary sets become arrays, binary values become base64 strings, and numbers kept as a
+ * `NumberValue` become a JS number or, when one cannot hold them, their exact string. Without this a set serializes as `{}` and a binary
  * value as an object of byte indexes.
  */
 function toJsonSafe(value: unknown): unknown {
-  if (value instanceof NumberValue) return value.toString()
+  if (value instanceof NumberValue) return numberValueToJson(value)
   if (value instanceof Set) return Array.from(value, toJsonSafe)
   if (value instanceof Uint8Array) return Buffer.from(value).toString('base64')
   if (Array.isArray(value)) return value.map(toJsonSafe)
@@ -53,15 +68,15 @@ function toJsonSafeRecord(
 
 /**
  * Encodes a `LastEvaluatedKey` so it can be passed back as `exclusiveStartKey`. Key
- * attributes are always scalar (S, N or B), so strings and safe numbers stay as-is while a
- * number a JS number cannot hold becomes `{ N }` and a binary key becomes `{ B }` (base64):
+ * attributes are always scalar (S, N or B), so strings and exact numbers stay as-is while a
+ * number a JS number cannot hold exactly becomes `{ N }` and a binary key becomes `{ B }` (base64):
  * plain strings would otherwise be sent back as S and fail the key type check.
  */
 function toCursor(key: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
   if (!key) return undefined
   return Object.fromEntries(
     Object.entries(key).map(([name, value]) => {
-      if (value instanceof NumberValue) return [name, { N: toJsonSafe(value) }]
+      if (value instanceof NumberValue) return [name, { N: value.toString() }]
       if (value instanceof Uint8Array) return [name, { B: toJsonSafe(value) }]
       return [name, value]
     })