How to chain records nicely (spreading, adding a property) / feature request for improvement

💬 Question and Help

type A = {
  foo: boolean;
  bar: string;
  fuzz: number;
};

type B = A & {
  buzz: boolean;
};

const recordA = fc.record<A>({
  foo: fc.boolean(),
  bar: fc.string(),
  fuzz: fc.integer(),
});

const recordB: Arbitrary<B> = recordA.chain((a) =>
  fc.constantFrom({
    ...a,
    buzz: fc.boolean(),
  })
);

The above gives an indication of what I am trying to achieve, but doesn’t work (due to the fact that buzz will yield type error 'Arbitrary<boolean>' is not assignable to type 'boolean'.

I’ve solved it like this:

const recordB: Arbitrary<B> = fc
  .tuple(recordA, fc.boolean())
  .chain(([a, bool]) =>
    fc.constantFrom({
      ...a,
      buzz: bool,
    })
  );

but it doesn’t seem that pretty. I’m wondering if there is a better/recommended approach? It would be awesome if you could do something like:

const recordB: Arbitrary<B> = fc.record({ ...recordA, buzz: fc.boolean() });

[waynevanson]

Here is a combinator for you, hope it helps.

const intersect =
  <
    A extends Record<string, unknown>,
    B extends Record<string,unknown>
  >(fa: Arbitrary<A>, fb: Arbitrary<B>): Arbitrary<A & B> =
    fc.tuple(fa, fb).map(([a,b]) => Object.assign({}, a, b))

[waynevanson]

The pattern I’d recommend is lifting your structures from A to Arbitrary<A> and composing it from there, like in the intersect example.