Mockydoodle

builder.ts

import { Primitive } from 'type-fest';

type Resolver<T> = (...args: any) => T;
  
type AnyFunc = (...args: any[]) => any;
  
type ArrayType<T> = T extends Array<infer U> ? U : never;

export type Schema<T> = {
  [P in keyof T]: P extends Primitive
    ? Resolver<T[P]>
    : P extends Array<infer U>
    ? U extends Primitive
      ? Resolver<U>
      : Schema<ArrayType<U>>
    : Schema<T[P]>;
};

export function builderBuilder<T extends { [key: string]: any }>(
  schema: Schema<T>,
) {
  return (seed?: Partial<T>) => {
    if (seed) {
      let res: Partial<T> = {};

      for (let key of Object.keys(schema)) {
        // this not being seemless may be my least favorite thing about typescript
        // @ts-ignore
        res[key] = Object.keys(seed).includes(key) ? seed[key] : schema[key]();
      }

      return res as T;
    } else {
      return Object.entries(schema).reduce(
        (acc, [key, resolver]) => ({
          ...acc,
          ...{ [key]: resolver() },
        }),
        {},
      ) as T;
    }
  };
}

user.ts

import { builderBuilder } from './builder'

type User = {
  id: number;
  name: string;
};

let userSchema: Schema<User> = {
  id: () => Math.floor(100000000 + Math.random() * 900000000),
  name: () => ["Alex", "Waller", "Kyle"][Math.floor(Math.random() * 3)],
};

let userBuilder = BuilderBuilder(userSchema);

let liz = userBuilder({ name: "Liz" });

let randomUser = userBuilder();