data-sanitizer/README.md

A simple data sanitizer that preserves the removed values for reference.

# data-sanitizer

A simple data sanitizer that preserves the removed values for reference.

## Usage

```
const { sanitizeFields } = require('data-sanitizer')

let data = [
  { id: 1, name: 'Jen' },
  { id: 2, name: 'Derek' }
]

const result = sanitizeFields({ data, fieldNames: ['id'] })

console.log(result)
```

The above code will print

```
{
  data: [
    { id: '[SANITIZED]', name: 'Jen' },
    { id: '[SANITIZED]', name: 'Derek' }
  ],
  removedValues: { id: [ 1, 2 ] }
}
```

## Sanitizing nested data

The sanitization is recursive, so it will work on nested data structures.

## Sanitizing multiple fields

You can sanitize multiple fields: 

```
let data = [
  { 
    id: 1, 
    name: 'Jen', 
    pets: [
      { id: 3, name: 'Frank' }
    ]
  },
  { 
    id: 2, 
    name: 'Derek', 
    pets: [
      { id: 4, name: 'Evey' },
      { id: 5, name: 'Alfie' }
    ]
  }
]

const result = sanitizeFields({ data, fieldNames: ['pets', 'id'] })
```

Be aware that the sanitization operations will run **in field-name order**. 

Depending on the order of the field names you pass in, you may wind up with sanitized values in your `removedValues` result. 

- In the above example, the entire value of the fieldName `pets` would be preserved in `sanitizationResult.removedValues`, including the original numerical IDs. This is because `pets` was listed first in `fieldNames`, so no `id` fields had been sanitized yet at the time of preservation.
- If `id` had been listed first instead, `sanitizationResult.removedValues.pets` would have sanitized IDs in it, rather than numerical ones, as the `id` sanitization operation would run first, impacting the entire data structure.

## Why does this exist?

I use large data snapshots in Jest to test my database seeding modules. Though changes in the row IDs of seed data are often expected, I still want to monitor them. But when row IDs are left in large data snapshots, the volume of snapshot diff output from ID changes can obscure other unexpected changes.

This simple sanitizer lets me isolate IDs (and any other frequently-changing fields) from the original data structure, preserved in their original order so I can snapshot them in isolation. If something changes, I'll know about it -- with only one line of snapshot diff output instead of eleventy billion.