Best practice for typing dynamic machine configs

[AlexZasorin]

I'm currently working on a project where I'm storing machine configs in a database. These machines can take any form so we don't know what states or events they may have. I'm currently working on trying to improve the typing for these configs and would like to ask what the best practice for this is.

I'm looking for a generic machine config type to use for typing the input and return data for my database, as well as my test fixtures. I attempted to use UnknownMachineConfig, but passing in something typed as UnknownMachineConfig to createMachine gives a TypeScript error. createMachine seems to not accept params in ParamterizedObject and id in ProvidedActor being potentially undefined. I've gotten around this with:

// Makes the selected keys required
export type PickRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

// Stricter version of these two xstate types because `createMachine()` expects `params` to be required inside of
//  ParameterizedObject and `id` to be required inside of `ProvidedActor`
export type StrictParameterizedObject = PickRequired<ParameterizedObject, 'params'>;
export type StrictProvidedActor = PickRequired<ProvidedActor, 'id'>;

export type GenericMachineConfig = MachineConfig<
  MachineContext,
  EventObject,
  StrictProvidedActor,
  StrictParameterizedObject,
  StrictParameterizedObject,
  string,
  string,
  any,
  unknown,
  EventObject,
  MetaObject
>;

I'm not sure why I had to do this and it gives me the feeling that I'm approaching this wrong. Any advice?

[RemyMachado]

I found these two exported type while looking for a generic StateMachine type:

// xstate type definitions
export type UnknownMachineConfig = MachineConfig<MachineContext, EventObject>;
export type AnyStateMachine = StateMachine<any, // context
any, // event
any, // children
any, // actor
any, // action
any, // guard
any, // delay
any, // state value
any, // tag
any, // input
any, // output
any, // emitted
any, // TMeta
any>;

With the following import:

import { AnyStateMachine, UnknownMachineConfig } from 'xstate';

However, I'm not sure this is relevant since there's no typing inference...

[zahitrios]

Thanks @RemyMachado

I was struggling building a service capable to operate xstate state machines, something like strategy pattern using machines like strategies.

With typescript it was very difficult to define a generic type for every xstate state machine.