flat.test.ts

import { nested, nestedFieldSeparator } from '../nested';

type NestedInput = {
  name: string;
  inputs: NestedInput[];
};

const flatInputs = (inputs: NestedInput[]) => {
  const recur = (inputs: NestedInput[], path: string[]) =>
    inputs.flatMap(({ name, inputs }) => {
      if (inputs.length) {
        return recur(inputs, [...path, name]);
      }
      return nested(...path, name);
    });

  return recur(inputs, []);
};

const flatValues = (
  inputs: NestedInput[],
  values: any,
  separator = nestedFieldSeparator
) => {
  const recur = (inputs: NestedInput[], values: any, path: string[]) =>
    inputs.flatMap(({ name, inputs }) => {
      if (inputs.length) {
        return recur(inputs, values[name], [...path, name]);
      }
      return [[[...path, name].join(separator), values[name]]];
    });

  return Object.fromEntries(recur(inputs, values, []));
};

const inputs = [
  { name: 'x', inputs: [] },
  {
    name: 'y',
    inputs: [
      { name: 'a', inputs: [] },
      { name: 'b', inputs: [] }
    ]
  }
];

test('flatInputs', () => {
  expect(flatInputs(inputs)).toEqual([
    'x',
    `y${nestedFieldSeparator}a`,
    `y${nestedFieldSeparator}b`
  ]);
});

test('flatValues', () => {
  const values = {
    x: 'whatever',
    y: {
      a: 'foo',
      b: 'bar'
    }
  };
  expect(flatValues(inputs, values, '.')).toEqual({
    x: 'whatever',
    'y.a': 'foo',
    'y.b': 'bar'
  });
});