@reddb-io/client 1.23.1-rc.340 → 1.23.1-rc.342

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reddb-io/client",
-  "version": "1.23.1-rc.340",
+  "version": "1.23.1-rc.342",
   "description": "Thin remote-only RedDB driver. Downloads the `red_client` binary on install. Speaks RedWire/gRPC/HTTP. Embedded URIs (memory://, file://, red:///path) are rejected — use @reddb-io/sdk for those.",
   "type": "module",
   "main": "src/index.js",

package/src/core/index.js

@@ -17,6 +17,8 @@ export { RedDBError } from './errors.js'
 export { RedDB, Collection } from './reddb.js'
 export {
   serializeParam,
+  serializeJsonValue,
+  normalizeExactNumbers,
   assertSupportedParam,
   normalizeQueryParams,
   bytesToBase64,

package/src/core/ndjson.js

@@ -12,6 +12,7 @@
  */
 
 import { RedDBError } from './errors.js'
+import { normalizeExactNumbers } from './serialization.js'
 
 /**
  * Parse an NDJSON line into a typed read-session frame, or `null` for a
@@ -29,10 +30,10 @@ export function classifyNdjsonFrame(line) {
     throw new RedDBError('STREAM_PROTOCOL', `stream frame is not JSON: ${err.message}`)
   }
   if (parsed && typeof parsed === 'object') {
-    if ('descriptor' in parsed) return { type: 'descriptor', value: parsed.descriptor }
-    if ('cursor' in parsed) return { type: 'cursor', value: parsed.cursor }
-    if ('row' in parsed) return { type: 'row', value: parsed.row }
-    if ('end' in parsed) return { type: 'end', value: parsed.end }
+    if ('descriptor' in parsed) return { type: 'descriptor', value: normalizeExactNumbers(parsed.descriptor) }
+    if ('cursor' in parsed) return { type: 'cursor', value: normalizeExactNumbers(parsed.cursor) }
+    if ('row' in parsed) return { type: 'row', value: normalizeExactNumbers(parsed.row) }
+    if ('end' in parsed) return { type: 'end', value: normalizeExactNumbers(parsed.end) }
     if ('error' in parsed) {
       const e = parsed.error ?? {}
       throw new RedDBError(e.code || 'STREAM_ERROR', e.message || 'stream error', e)

package/src/core/reddb.js

@@ -19,7 +19,7 @@
  */
 
 import { RedDBError } from './errors.js'
-import { normalizeQueryParams } from './serialization.js'
+import { normalizeExactNumbers, normalizeQueryParams, serializeJsonValue } from './serialization.js'
 import { requireInsertId, requireInsertIds } from './insert-ids.js'
 import { CacheClient } from '../cache.js'
 import { KvClient } from '../kv.js'
@@ -124,9 +124,9 @@ export class RedDB {
   query(sql, ...params) {
     const wireParams = normalizeQueryParams(params)
     if (wireParams == null) {
-      return this.client.call('query', { sql })
+      return this.client.call('query', { sql }).then(normalizeExactNumbers)
     }
-    return this.client.call('query', { sql, params: wireParams })
+    return this.client.call('query', { sql, params: wireParams }).then(normalizeExactNumbers)
   }
 
   /** Execute a SQL statement. Alias for `query`, including parameter binding. */
@@ -136,7 +136,8 @@ export class RedDB {
 
   /** Insert one row. Returns `{ affected, rid, id }`; `id` is a legacy alias for `rid`. */
   async insert(collection, payload) {
-    let result = await this.client.call('insert', { collection, payload })
+    let result = await this.client.call('insert', { collection, payload: serializeJsonValue(payload) })
+    result = normalizeExactNumbers(result)
     if (
       result &&
       typeof result === 'object' &&
@@ -150,7 +151,10 @@ export class RedDB {
 
   /** Insert many rows in one call. Returns `{ affected, rids, ids }`; `ids` is a legacy alias. */
   async bulkInsert(collection, payloads) {
-    const result = await this.client.call('bulk_insert', { collection, payloads })
+    const result = await this.client.call('bulk_insert', {
+      collection,
+      payloads: serializeJsonValue(payloads),
+    }).then(normalizeExactNumbers)
     return requireInsertIds(result, payloads.length)
   }
 
@@ -244,7 +248,7 @@ export class RedDB {
 
   /** Get an entity by id. Returns `{ entity }` (entity is `null` if not found). */
   get(collection, id) {
-    return this.client.call('get', { collection, id: String(id) })
+    return this.client.call('get', { collection, id: String(id) }).then(normalizeExactNumbers)
   }
 
   /** Delete an entity by id. Returns `{ affected }`. */

package/src/core/serialization.js

@@ -10,8 +10,15 @@
 
 import { RedDBError } from './errors.js'
 
+const MIN_I64 = -(1n << 63n)
+const MAX_I64 = (1n << 63n) - 1n
+const MAX_U64 = (1n << 64n) - 1n
+
 export function serializeParam(value) {
   assertSupportedParam(value)
+  if (typeof value === 'bigint') {
+    return exactIntegerEnvelope(value)
+  }
   if (value instanceof Float32Array || value instanceof Float64Array) {
     return Array.from(value)
   }
@@ -31,10 +38,59 @@ export function serializeParam(value) {
   return value
 }
 
+export function serializeJsonValue(value) {
+  if (typeof value === 'bigint') {
+    return exactIntegerEnvelope(value)
+  }
+  if (Array.isArray(value)) {
+    return value.map(serializeJsonValue)
+  }
+  if (value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+    if ('$number' in value || '$decimalText' in value) {
+      throw new RedDBError('UNSUPPORTED_EXACT_NUMBER', 'superseded exact-number envelope')
+    }
+    const out = {}
+    for (const [key, item] of Object.entries(value)) out[key] = serializeJsonValue(item)
+    return out
+  }
+  return value
+}
+
+export function normalizeExactNumbers(value) {
+  if (Array.isArray(value)) return value.map(normalizeExactNumbers)
+  if (value && typeof value === 'object') {
+    const keys = Object.keys(value)
+    if (keys.length === 1) {
+      if (typeof value.$int === 'string' || typeof value.$uint === 'string') {
+        return BigInt(value.$int ?? value.$uint)
+      }
+      if (typeof value.$decimal === 'string') return value.$decimal
+      if ('$number' in value || '$decimalText' in value) {
+        throw new RedDBError('UNSUPPORTED_EXACT_NUMBER', 'superseded exact-number envelope')
+      }
+    }
+    const out = {}
+    for (const [key, item] of Object.entries(value)) out[key] = normalizeExactNumbers(item)
+    return out
+  }
+  return value
+}
+
+function exactIntegerEnvelope(value) {
+  if (value >= MIN_I64 && value <= MAX_I64) {
+    return { $int: value.toString() }
+  }
+  if (value >= 0n && value <= MAX_U64) {
+    return { $uint: value.toString() }
+  }
+  throw new RedDBError('UNSUPPORTED_PARAM', 'integer value is outside i64/u64 range')
+}
+
 export function assertSupportedParam(value) {
   if (value == null) return
   if (
     typeof value === 'boolean'
+    || typeof value === 'bigint'
     || typeof value === 'number'
     || typeof value === 'string'
   ) {

package/src/grpc.js

@@ -10,6 +10,7 @@ import { connect as connectHttp2 } from 'node:http2'
 import { Buffer } from 'node:buffer'
 
 import { RedDBError } from './protocol.js'
+import { normalizeExactNumbers, serializeJsonValue } from './core/serialization.js'
 
 const SERVICE = '/reddb.v1.RedDb'
 
@@ -154,7 +155,7 @@ function normalizeQueryReply(reply) {
       throw new RedDBError('QUERY_ERROR', `bad gRPC query JSON: ${err.message}`)
     }
   }
-  const rows = parsed.rows ?? parsed.records ?? []
+  const rows = normalizeExactNumbers(parsed.rows ?? parsed.records ?? [])
   return {
     ok: reply.ok,
     statement: parsed.statement ?? reply.statement ?? '',
@@ -171,7 +172,7 @@ function normalizeEntityReply(reply) {
     affected: reply.ok ? 1 : 0,
     rid,
     id: rid,
-    entity: parseJsonOrNull(reply.entity_json),
+    entity: normalizeExactNumbers(parseJsonOrNull(reply.entity_json)),
   }
 }
 
@@ -231,6 +232,13 @@ function encodeQueryValue(value) {
     return bytesField(7, encodeQueryVector(value))
   }
   if (typeof value === 'object') {
+    if (typeof value.$int === 'string') return int64Field(3, BigInt(value.$int))
+    if ('$uint' in value || '$decimal' in value) {
+      throw new RedDBError(
+        'UNSUPPORTED_PARAM',
+        'exact uint and decimal params require a JSON body transport',
+      )
+    }
     if (typeof value.$bytes === 'string') return bytesField(6, Buffer.from(value.$bytes, 'base64'))
     if (typeof value.$float === 'string') return doubleField(4, Number(value.$float))
     if (value.$ts != null) return int64Field(9, BigInt(value.$ts))
@@ -250,14 +258,14 @@ function encodeQueryVector(values) {
 function encodeJsonCreateRequest(collection, payload) {
   return concat([
     stringField(1, collection ?? ''),
-    stringField(2, JSON.stringify(payload ?? {})),
+    stringField(2, JSON.stringify(serializeJsonValue(payload ?? {}))),
   ])
 }
 
 function encodeJsonBulkCreateRequest(collection, payloads) {
   const fields = [stringField(1, collection ?? '')]
   for (const payload of payloads ?? []) {
-    fields.push(stringField(2, JSON.stringify(payload ?? {})))
+    fields.push(stringField(2, JSON.stringify(serializeJsonValue(payload ?? {}))))
   }
   return concat(fields)
 }
@@ -371,7 +379,11 @@ function uint64Field(no, value) {
 }
 
 function int64Field(no, value) {
-  return concat([varint((BigInt(no) << 3n) | 0n), varint(BigInt.asUintN(64, BigInt(value)))])
+  const raw = BigInt(value)
+  if (raw < -(1n << 63n) || raw > (1n << 63n) - 1n) {
+    throw new RedDBError('UNSUPPORTED_PARAM', 'integer param is outside i64 range')
+  }
+  return concat([varint((BigInt(no) << 3n) | 0n), varint(BigInt.asUintN(64, raw))])
 }
 
 function doubleField(no, value) {

package/src/http.js

@@ -38,6 +38,7 @@
 
 import { RedDBError } from './protocol.js'
 import { classifyNdjsonFrame, splitLines } from './core/ndjson.js'
+import { normalizeExactNumbers, serializeJsonValue } from './core/serialization.js'
 
 export class HttpRpcClient {
   /**
@@ -165,7 +166,7 @@ export class HttpRpcClient {
 
     let opened = false
     let cols = Array.isArray(columns) && columns.length > 0 ? columns.slice() : null
-    const encodeLine = (obj) => writer.write(`${JSON.stringify(obj)}\n`)
+    const encodeLine = (obj) => writer.write(`${JSON.stringify(serializeJsonValue(obj))}\n`)
     const ensureOpen = async (row) => {
       if (opened) return
       if (!cols) {
@@ -177,7 +178,7 @@ export class HttpRpcClient {
           'inputStream() needs a non-empty column set — pass { columns } or write at least one object row',
         )
       }
-      await writer.write(`${JSON.stringify({ open: { target, columns: cols } })}\n`)
+        await writer.write(`${JSON.stringify({ open: { target, columns: cols } })}\n`)
       opened = true
     }
 
@@ -302,9 +303,9 @@ async function parseResponse(response) {
       const code = body.error_code || 'RPC_ERROR'
       throw new RedDBError(code, body.error || 'unknown error', body)
     }
-    return body.result ?? body
+    return normalizeExactNumbers(body.result ?? body)
   }
-  return body
+  return normalizeExactNumbers(body)
 }
 
 // ---------------------------------------------------------------------------
@@ -318,18 +319,18 @@ const ROUTES = {
     url: `${base}/query`,
     init: {
       method: 'POST',
-      body: JSON.stringify(
-        Array.isArray(params) ? { query: sql, params } : { query: sql },
-      ),
+          body: JSON.stringify(
+            Array.isArray(params) ? { query: sql, params } : { query: sql },
+          ),
     },
   }),
   insert: (base, { collection, payload }) => ({
     url: `${base}/collections/${encodeURIComponent(collection)}/rows`,
-    init: { method: 'POST', body: JSON.stringify(payload) },
+    init: { method: 'POST', body: JSON.stringify(serializeJsonValue(payload)) },
   }),
   bulk_insert: (base, { collection, payloads }) => ({
     url: `${base}/collections/${encodeURIComponent(collection)}/bulk/rows`,
-    init: { method: 'POST', body: JSON.stringify({ rows: payloads }) },
+    init: { method: 'POST', body: JSON.stringify(serializeJsonValue({ rows: payloads })) },
   }),
   get: (base, { collection, id }) => ({
     url: `${base}/collections/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`,
@@ -371,7 +372,7 @@ const ROUTES = {
   }),
   'cache.put': (base, { namespace, key, value, ttl_ms, tags, policy }) => ({
     url: `${base}/cache/ns/${encodeURIComponent(namespace)}/${encodeURIComponent(key)}`,
-    init: { method: 'PUT', body: JSON.stringify({ value, ttl_ms, tags, policy }) },
+    init: { method: 'PUT', body: JSON.stringify(serializeJsonValue({ value, ttl_ms, tags, policy })) },
   }),
   'cache.exists': (base, { namespace, key }) => ({
     url: `${base}/cache/ns/${encodeURIComponent(namespace)}/${encodeURIComponent(key)}/exists`,

package/src/redwire-core.js

@@ -65,6 +65,9 @@ export const ValueTag = Object.freeze({
   Bytes: 0x05, Vector: 0x06, Json: 0x07, Timestamp: 0x08, Uuid: 0x09,
 })
 
+const MIN_I64 = -(1n << 63n)
+const MAX_I64 = (1n << 63n) - 1n
+
 /**
  * Typed value tags for the binary fast path. Identical to the
  * engine-side `wire::protocol::VAL_*` table.
@@ -1015,10 +1018,7 @@ export function encodeValue(v) {
   if (v === null || v === undefined) return Uint8Array.of(ValueTag.Null)
   if (typeof v === 'boolean') return Uint8Array.of(ValueTag.Bool, v ? 1 : 0)
   if (typeof v === 'bigint') {
-    const out = new Uint8Array(1 + 8)
-    out[0] = ValueTag.Int
-    new DataView(out.buffer).setBigInt64(1, v, true)
-    return out
+    return encodeInt(v)
   }
   if (typeof v === 'number') {
     if (Number.isInteger(v) && v >= -(2 ** 53) && v <= 2 ** 53) {
@@ -1046,6 +1046,12 @@ export function encodeValue(v) {
     const keys = Object.keys(v)
     if (keys.length === 1) {
       const k = keys[0]
+      if (k === '$int' && typeof v.$int === 'string') {
+        return encodeInt(BigInt(v.$int))
+      }
+      if (k === '$uint' || k === '$decimal') {
+        throw new RedDBError('UNSUPPORTED_PARAM', `${k} params require a JSON body transport`)
+      }
       if (k === '$bytes' && typeof v.$bytes === 'string') {
         return encodeLenPrefixed(ValueTag.Bytes, base64ToBytes(v.$bytes))
       }
@@ -1072,6 +1078,16 @@ export function encodeValue(v) {
   throw new RedDBError('UNSUPPORTED_PARAM', `cannot encode param of type ${typeof v}`)
 }
 
+function encodeInt(value) {
+  if (value < MIN_I64 || value > MAX_I64) {
+    throw new RedDBError('UNSUPPORTED_PARAM', 'integer param is outside i64 range')
+  }
+  const out = new Uint8Array(1 + 8)
+  out[0] = ValueTag.Int
+  new DataView(out.buffer).setBigInt64(1, value, true)
+  return out
+}
+
 function encodeLenPrefixed(tag, bytes) {
   if (bytes.length > MAX_VALUE_PAYLOAD_LEN) {
     throw new RedDBError('PAYLOAD_TOO_LARGE', `value len ${bytes.length} > ${MAX_VALUE_PAYLOAD_LEN}`)