Can we make trait names type safe?

[jackfranklin]

If you've defined traits on a builder, it would be awesome if when you called that builder we checked if the provided traits were defined.

So rather than traits being string[], it could calculate the list of available options.

The goal here would be that when I create:

const userBuilder = build<User>({
  fields: { isAdmin: false },
  traits: {
    admin: { overrides: { isAdmin: true } },
    someOtherThing: {...}
  },
});

I can then call it:

const user = userBuilder({ traits: ['admin'] });

But the type of traits in this call should now be ('admin'|'someOtherThing')[], because TS has figured out the keys of the traits I provided when I created the builder.

Currently, traits is typed as string[], so we don't get any type checks should you pass in a trait that doesn't exist.

[CristianAUnisa]

Hey Jack, could declaring traits as Partial<T> solve the problem?
Btw I'm the person who watched your stream yesterday 🤣

Edit: I checked the code on the fly, and I think that something like this:

export interface BuildTimeConfig<FactoryResultType> {
  overrides?: Overrides<FactoryResultType>;
  map?: (builtThing: FactoryResultType) => FactoryResultType;
  traits?:
    | Partial<FactoryResultType>
    | [keyof FactoryResultType]
    | keyof FactoryResultType;
}

and

const buildTimeTraitsArray = <FactoryResultType>(
  buildTimeConfig: BuildTimeConfig<FactoryResultType>
): string[] => {
  const { traits = [] } = buildTimeConfig;
  return Array.isArray(traits)
    ? traits.map((trait) => trait.toString())
    : [...traits.toString()];
};

Or something with a more permissive or even stricter type checking depending on what's needed could work