Recursive mapped type inference not working as expected #24318

Activity

1. massimonewsuk commented on May 22, 2018

   

   massimonewsuk

   on May 22, 2018

   Last edited by massimonewsuk

   Author

   More actions

   Here are some examples where it works as expected

   // Normal nested stuff
   type Node = {
       always: {
           property: string;
       }
       maybe?: {
           property: string;
       }
       leaf?: Node;
   };
   
   type EverythingPresent<T> = { [P in keyof T]-?: EverythingPresent<T[P]> };
   declare var everythingPresent: EverythingPresent<Node>;
   everythingPresent.maybe.property;
   everythingPresent.leaf.maybe.property;
   everythingPresent.leaf.leaf.maybe.property;
   everythingPresent.leaf.leaf.leaf.maybe.property;
   
   type OnlyLeafsPresent<T> = {
     [P in keyof T]-?: T[P] extends Node
       ? OnlyLeafsPresent<Node>
       : T[P]
   };
   declare var onlyLeafsPresent: OnlyLeafsPresent<Node>;
   // These examples work fine
   onlyLeafsPresent.maybe.property;
   onlyLeafsPresent.leaf.maybe.property;
   onlyLeafsPresent.leaf.leaf.maybe.property;
   onlyLeafsPresent.leaf.leaf.leaf.maybe.property;
   
   // Generic nested stuff
   type GenericNode<T> = {
       always: {
           property: string;
       }
       maybe?: {
           property: T;
       }
       leaf?: GenericNode<T>;
   };
   declare var everythingPresent2: EverythingPresent<GenericNode<string>>;
   everythingPresent2.maybe.property;
   everythingPresent2.leaf.maybe.property;
   everythingPresent2.leaf.leaf.maybe.property;
   everythingPresent2.leaf.leaf.leaf.maybe.property;
   
   type OnlyLeafsPresentGeneric<T> = {
       [P in keyof T]-?: T[P] extends GenericNode<infer U>
         ? OnlyLeafsPresentGeneric<GenericNode<U>>
         : T[P]
     };
   declare var onlyLeafsPresent2: OnlyLeafsPresentGeneric<GenericNode<string>>;
   // These examples work fine
   onlyLeafsPresent2.maybe.property;
   onlyLeafsPresent2.leaf.maybe.property;
   onlyLeafsPresent2.leaf.leaf.maybe.property;
   onlyLeafsPresent2.leaf.leaf.leaf.maybe.property;
2. massimonewsuk

   changed the title [-]Recursive generic parameter inference not working[/-] [+]Recursive mapped type inference not working as expected[/+] on May 22, 2018
4. ghost added

   Needs More InfoThe issue still hasn't been fully clarifiedThe issue still hasn't been fully clarified

   on May 22, 2018
5. massimonewsuk commented on May 22, 2018

   

   massimonewsuk

   on May 22, 2018

   Last edited by massimonewsuk

   Author

   More actions

   Andy (Andrewkraft) (@Andy-MS) Thanks, that's cleared things up a bit... it seems that the Array is a special case where things aren't quite working as expected... the examples with Node all work fine now
7. massimonewsuk commented on May 22, 2018

   

   massimonewsuk

   on May 22, 2018

   Author

   More actions

   You're right - I could have sworn I tried that and it never helped.

   I've updated my original code example to what I actually wanted to achieve.

   It seems to work fine in 2.9.1 so I'm closing the issue. Sorry for taking your time!
8. massimonewsuk

   closed this as completedon May 22, 2018
9. ghost removed

   Needs More InfoThe issue still hasn't been fully clarifiedThe issue still hasn't been fully clarified

   on May 22, 2018
10. ghost added

    QuestionAn issue which isn't directly actionable in codeAn issue which isn't directly actionable in code

    on May 22, 2018
11. massimonewsuk commented on May 22, 2018

    

    massimonewsuk

    on May 22, 2018

    Author

    More actions

    Andy (Andrewkraft) (@Andy-MS) so I've basically replicated the issue I was originally facing. If you had a moment to take a look, here's the code example that I'm having issues with.

    // Entities
    type Order = {
        id: number;
        customer?: Entity<Customer>;
        lineItems?: Entity<OrderLineItem[]>;
    };
    
    type Customer = {
        name: string;
        bestFriend?: Entity<Customer>;
        legacyData?: {
            registered: boolean;
        };
    };
    
    type OrderLineItem = {
        quantity: number;
        options?: Entity<OrderLineItemOption[]>;
        item?: Entity<Item>;
    };
    
    type OrderLineItemOption = {
        colour: string;
    };
    
    type Item = {
        description: string;
    };
    
    // Type helpers
    type PropertiesWithoutNevers<T, U> = {
        [P in keyof T]: T[P] extends U ? never : P
    }[keyof T];
    
    type Mandatory<T> = { [P in keyof T]-?: T[P] };
    
    type Entity<T> = T & { _: "Entity" };
    
    type EagerLoadedRelations<TEntity> = Pick<
      Mandatory<TEntity>,
      PropertiesWithoutNevers<
        {
          [P in keyof TEntity]-?: TEntity[P] extends Entity<infer TRelation> | undefined
            ? Entity<TRelation extends Array<infer TOneToMany> ? Array<Eager<TOneToMany>> : Eager<TRelation>>
            : never
        },
        TEntity
      >
    >;
    
    type NormalFields<TEntity> = Pick<
      TEntity,
      PropertiesWithoutNevers<
        { [P in keyof TEntity]-?: TEntity[P] extends Entity<infer U> | undefined ? never : TEntity[P] },
        TEntity
      >
    >;
    
    type Eager<T> = EagerLoadedRelations<T> & NormalFields<T>;
    
    
    // Without Eager<T> - everything works as expected
    declare var order: Order;
    order.id; // works as expected
    order.customer.name; // error as expected
    order.lineItems[0].quantity; // error as expected
    
    // With Eager<T> - Eager<T> doesn't seem to apply deeper than 1 level
    declare var eagerOrder: Eager<Order>;
    eagerOrder.id; // works as expected
    eagerOrder.customer.name; // works as expected
    eagerOrder.customer.bestFriend.name; // ERROR - doesn't work - bestFriend should be eager loaded
    eagerOrder.customer.legacyData.registered; // errors as expected
    eagerOrder.lineItems[0].quantity; // works as expected
    eagerOrder.lineItems[0].item.description; // ERROR - doesn't work - items should be eager loaded
    eagerOrder.lineItems[0].options[0].colour; // ERROR - doesn't work - options should be eager loaded
13. microsoft

    locked and limited conversation to collaborators on Jul 31, 2018