Data Corruption from Bad Serialization — When Your Data Silently Changes

// ❌ Never store money as float — floating point arithmetic is imprecise
const price = 19.99
const tax = price * 0.1
console.log(tax)  // → 1.9999999999999998 (not 2.00!)

const total = price + tax
console.log(total)  // → 21.988999999999997 (not 21.99!)

// After storing and retrieving: the stored value is wrong
await db.query('UPDATE products SET price = $1', [price * 1.1])
// price is now 21.988999999999997... stored in the database

// ✅ Use integer cents (multiply by 100)
const priceInCents = 1999  // $19.99
const taxInCents = Math.round(priceInCents * 0.1)   // 200 cents = $2.00
const totalInCents = priceInCents + taxInCents       // 2199 cents = $21.99

// Display: divide by 100 only for display
const display = (totalInCents / 100).toFixed(2)  // "21.99"

// Or use a decimal library
import Decimal from 'decimal.js'

const price = new Decimal('19.99')
const tax = price.mul('0.1')
console.log(tax.toString())   // "1.999" → Math.round to "2.00"
const total = price.add(tax.toDecimalPlaces(2, Decimal.ROUND_HALF_UP))
console.log(total.toString())  // "21.99" — exact

// Database returns a BIGINT: 9007199254740993 (> MAX_SAFE_INTEGER)
const id = 9007199254740993n  // bigint in JS

// ❌ JSON.stringify BigInt throws:
JSON.stringify({ id })  // TypeError: Do not know how to serialize a BigInt

// ❌ Converting to Number loses precision:
Number(9007199254740993n)  // → 9007199254740992 (WRONG — last digit changed!)

// ✅ Serialize as string — no precision loss
JSON.stringify({ id: id.toString() })  // { "id": "9007199254740993" }

// In Express response:
res.json({ id: row.id.toString() })

// pg (node-postgres) returns BIGINT as string by default — use it!
const result = await db.query('SELECT id FROM users WHERE email = $1', [email])
const userId = result.rows[0].id  // "9007199254740993" — already a string ✅

// Never do this:
const userId = parseInt(result.rows[0].id)  // loses precision for large IDs!

// ❌ Parsing date without timezone — depends on system locale
const date = new Date('2026-03-15')
// On UTC server: midnight UTC
// On EST server: midnight EST (= 5 AM UTC)
// If you store this in DB as UTC, it's wrong

// ❌ toLocaleDateString() — produces non-parseable string
const stored = new Date().toLocaleDateString()  // "3/15/2026" — no timezone info!
// When you try to parse this back:
new Date('3/15/2026')  // locale-dependent, might even fail

// ✅ Always use ISO 8601 UTC
const stored = new Date().toISOString()  // "2026-03-15T14:00:00.000Z"
// Parseable, timezone-aware, sortable as a string

// ✅ Parse with explicit timezone context
import { parseISO } from 'date-fns'
import { fromZonedTime } from 'date-fns-tz'

// User input "2026-03-15 14:00" in America/New_York:
const utc = fromZonedTime('2026-03-15T14:00:00', 'America/New_York')
const stored = utc.toISOString()  // Always stored as UTC

// ❌ Storing a class instance as JSON loses methods and type info
class Price {
  constructor(public cents: number, public currency: string) {}

  format() { return `${this.currency} ${(this.cents / 100).toFixed(2)}` }
}

const price = new Price(1999, 'USD')
const stored = JSON.stringify(price)  // '{"cents":1999,"currency":"USD"}'

const retrieved = JSON.parse(stored)  // plain object, not a Price instance
retrieved.format()  // TypeError: retrieved.format is not a function

// ✅ Use plain data objects for serialization, reconstruct on retrieval
const serialized = { cents: price.cents, currency: price.currency }
const retrieved = new Price(serialized.cents, serialized.currency)
retrieved.format()  // works

// ❌ JSON.stringify silently converts NaN and Infinity to null
const data = { score: NaN, ratio: Infinity, rate: -Infinity }
JSON.stringify(data)  // '{"score":null,"ratio":null,"rate":null}'

// ❌ You store null, retrieve null, think the value was missing
// But it was NaN/Infinity from a division error

// ✅ Validate before storing
function sanitizeNumber(value: number, fieldName: string): number {
  if (!isFinite(value)) {
    throw new Error(`Invalid numeric value for ${fieldName}: ${value}`)
  }
  return value
}

const score = calculateScore()  // might return NaN if input was bad
const safeScore = sanitizeNumber(score, 'score')  // throws instead of silently corrupting

// ❌ JSON.stringify drops undefined properties
const user = {
  id: '123',
  name: 'Sanjeev',
  middleName: undefined,  // user has no middle name
}

JSON.stringify(user)
// '{"id":"123","name":"Sanjeev"}'
// middleName is completely gone — when you parse this, there's no way to distinguish
// "no middle name" from "middle name not loaded from DB"

// ✅ Use null explicitly for "no value"
const user = {
  id: '123',
  name: 'Sanjeev',
  middleName: null,  // explicit null
}

JSON.stringify(user)
// '{"id":"123","name":"Sanjeev","middleName":null}'
// Now you know the field exists and is empty