#### Writing the helper functions

I extracted my code from my naive function
into helper functions and ran the tests.

All tests failed! Immediately I knew there
was work to be done. But because tests
output the differences between your expected output
and the actual output, resolving this is easy.

After fixing the bugs, our functions are defined as follows:

```typescript
export const group = (a: string) => ' (' + a + ') ';

export const _getFieldPath = (_filter: string, _match: string) => {
  const idx = _filter.indexOf(_match);
  const front = _filter.substring(0, idx);
  const spaceIdx = front.trim().lastIndexOf(' ');
  const fieldPath = spaceIdx > 0 ? front.substring(spaceIdx + 1) : front;
  return fieldPath;
}

export const _getValues = (_filter: string, _match: string) => {
  const idx = _filter.indexOf(_match);
  const back = _filter.substring(idx + 1, idx + _match.length);
  return back.trim().substring(1, back.length - 1).split(',');
}

export interface _ReplaceValuesProps {
  filters: string, fieldPath: string, values: string[], body: string
}
export const _replaceValues = ({filters, fieldPath, values, body} : _ReplaceValuesProps) =>
    filters.replace(`${fieldPath}:[${values.join(',')}]`, group(body).trim());
```

Now all test cases for the helper functions are passing.
But the main `replaceMultiValueFilters` still fails its tests.
What's happening? Fortunately we have eliminated potential problem
areas with reasonably high confidence.

Upon taking a closer look at the code, I noticed a very
subtle problem:

```typescript
export const replaceMultiValueFilters = (filters: string) => {
  let filter = filters.trim();
  // ...
  for (const match of matches) {
    // ...
    filter = _replaceValues({ filters, fieldPath, values, body });
    //...
  }
  return filter;
}
```

Can you spot it? The code is designed to take our
input filters and replace each filter one at a time
in a loop. However, I was using `filters.replace`
instead of `filter.replace`. This means each time
I called replace, I was calling it on the original
filter instead of our "under construction" filter.

This is why my tests of two field paths or more were
failing.

I didn't catch this myself! In fact, my tests did.
When I refactored this logic into `_replaceValues`
and wrote tests for it, I discovered it was working just fine.
This left one remaining spot to check in my code, and potential
hours worth of debugging over a small small typo were saved.

After changing this line:

```diff
- filter = _replaceValues({ filters, fieldPath, values, body });
+ filter = _replaceValues({ filters: filter, fieldPath, values, body });
```

The function worked perfectly and passed all our test cases.