Subject property types possible improvement

[raegen]

Hey! There might be a reason why this is already not in place, but in the improbable case - the nested key type for the implemented dotted notation can be inferred with something along the lines of:

export type Keys<T> = T extends any ? keyof T : never;

export type PickType<T, K extends Keys<T>> = T extends { [k in K]: infer V } ? V : never;

export type Merge<T extends object> = {
  [K in Keys<T>]: PickType<T, K>;
};

export type PrefixKeys<P, T> = {
  [Key in `${P & string}.${keyof T & string}`]: T[Key extends `${P & string}.${infer R}`
    ? R & keyof T
    : never];
};

export type Flatten<T> = T &
  Merge<
    {
      [Key in keyof T]: T[Key] extends object ? PrefixKeys<Key, T[Key]> : never;
    }[keyof T]
  >;

And those could be used for

interface SomeSubject {
  kind: 'SomeSubject';
  rootPropA: any;
  rootPropB: any;
  rootPropC: {
    nestedPropA: any;
    nestedPropB: any;
  }
}
type Abilities = | ['manage', 'all']
  | ['SomeAction', InferSubjects<SomeSubject>]

there are multiple ways to go about where would the flattening be introduced (I didn't follow the types deep enough to say where the inference would be of least complexity), but lets say for showcasing purposes, that it's done on

type InstanceOf<T extends AnyAbility, S extends SubjectType> = Flatten<
    S extends AnyClass<infer R>
      ? R
      : S extends (...args: any[]) => infer O
      ? O
      : S extends string
      ? Exclude<Normalize<Generics<T>['abilities']>[1], SubjectType> extends TaggedInterface<string>
        ? Extract<Normalize<Generics<T>['abilities']>[1], TaggedInterface<S>>
        : AnyObject
      : never
  >;

Would result in the following:

// valid
defineAbility<MongoAbility<Abilities, MongoQuery>>((can, cannot) => {
     can[not](
            'SomeAction',
            'SomeSubject',
            ['rootPropA', 'rootPropC.nestedPropA'] //valid
            {
              'rootPropC.nestedPropA': { // valid
                // condition
              }
            }
      );
})

// invalid
defineAbility<MongoAbility<Abilities, MongoQuery>>((can, cannot) => {
     can[not](
            'SomeAction',
            'SomeSubject',
            ['rootPropA', 'rootPropC.nestedPropX'], //invalid
            {
              'rootPropC.nestedPropX': { // invalid
                // condition
              }
            }
      );
})