RFC: Support generating factories

When using mock data in tests I would like to

overwrite partial data (and have type-support for it out of the box)
be able to create different variants of the same data-type

From this:

interface Person {
   email: string
   /** @mockType {name.firstName} */
   firstName: string
}
interface Family {
  /** @mockType {name.lastName} */
  name: string
  members: Person[]
}

To this:

import faker from 'faker';
import type * as Types from './types';

export function Person(overwrites: Partial<Types.Person> = {}): Types.Person {
  return {
    email: faker.internet.email(),
    firstName: faker.name.firstName(),
    ...overwrites
  }
}

export function Family(overwrites: Partial<Types.Family> = {}): Types.Family {
  return {
    name: faker.name.lastName(),
    members: Array.from({ length: faker.random.number(8) }).map(() => Person()),
    ...overwrites
  }
}

I guess supporting exactly this would be to specific for this library and possibly extend its scope but a intermediate step would be to support a "raw" outputFormat like this

{
  "Person": {
     "email": { "fake": "internet.email" },
     "firstName": { "fake": "name.firstName" }
  },
  "Family": {
    "firstName": { "fake": "name.lastName" },
    "members": { 
      "array": {
        "range": [1, 8],
        "contains": [{ "type": "Person" }]
      }
    }
  } 
}

which could then be used to create such factories.

What's your opinion on this? If it sounds interesting, I'd like to create a PR.

google / intermock

RFC: Support generating factories #54