Support dotted path notation

[nandorojo]

🍩 Feature Request

Is your feature request related to a problem?

TypeScript 4.1 has template literals, and they're super useful. However, the only solutions out there are quite hacky to use, and result in some bugs.

I want to be able to get a nested object path, as shown in this repo.

Describe the solution you'd like

import { Object } from 'ts-toolbelt'

type I = { hi: { hey: true } }

type Nested = Object.NestedPath<I, 'hi.hey'>

I want to know how do I get the nested object path using dot notation of an object. I'd then like to get the value that matches that object with the path.

I'd like to achieve this:

This is the idea:

type Path<T, Key extends keyof T = keyof T> =
Key extends string
? T[Key] extends Record<string, any>
  ? | `${Key}.${Path<T[Key], Exclude<keyof T[Key], keyof Array<any>>> & string}`
    | `${Key}.${Exclude<keyof T[Key], keyof Array<any>> & string}`
    | Key
  : never
: never;

type PathValue<T, P extends Path<T>> =
  P extends `${infer Key}.${infer Rest}`
  ? Key extends keyof T
    ? Rest extends Path<T[Key]>
      ? PathValue<T[Key], Rest>
      : never
    : never
  : P extends keyof T
    ? T[P]
    : never;


declare function get<T, P extends Path<T>>(obj: T, path: P): PathValue<T, P>;

However, this code block above seems to be buggy. I occasionally get infinite loop errors from typescript if I use it (but not always), so someone who has a better understanding of TS than I do should probably make it.

Describe alternatives you've considered

I tried the code sample above. However, it is not very robust. Someone put it on twitter, but I think it would make more sense for it to live in TS toolbelt (which is always so helpful.)

Teachability, Documentation, Adoption, Migration Strategy

This is a great article describing the template literals. Surprisingly, if you google "TypeScript template literals," it's hard to find content, even though it's such a cool addition. Do you think you might be able to help @millsp? Thank you so much!

[millsp]

¡Hola Nando! ¿Como mola?

We already have something similar here https://millsp.github.io/ts-toolbelt/modules/_object_paths_.html

I can start from there and do this for you in the next week, with a better implementation that won't crash on circular references and that is certainly easier to read and understand/maintain :)

[nandorojo]

Todo bien!

Thank you, great to hear. A key part of the new syntax is that it enforces strict paths for nested strings. I use object paths, but I don't think it quite does the same for nested for notation of only certain paths.

Thanks again!

[nandorojo]

PS I think your link is broken

[millsp]

Fixed

[millsp]

but I don't think it quite does the same for nested for notation of only certain paths

what do you mean?

[nandorojo]

Notice how this allows post.type, but it should only allow post.url, or car.type. Code here.

The correct behavior would be like this:

Code here.

[millsp]

Yep, it works correctly, though. The problem here is that TypeScript replaced ['post', ''] as a type [string, ...] because it widens primitive types in objects - which can definitely be confusing and impractical in your scenario. Reason why we'd rather use the "dot" notation with strings, since string parameters don't undergo such widening.

The implementation I'll work on will have a common limitation with the implementation you linked above: it cannot handle circular references. When this case happens, it won't crash, instead, it will allow any path and not provide auto-completion. Maybe you see a different way of handling this scenario - let me know.

[millsp]

Never mind, I was able to solve this limitation by preventing excess depth. It actually improved the previous implementation - so we can now enjoy circular references to a certain extent.

[millsp]

I limited the output to 10, that's when ts starts complaining that it's too deep (usually 11). I'm going to think over this in the next week to provide you with the full solution.

[nandorojo]

Wow very cool! Is there any shot you could share your temporary solution here to try in the meantime?

Thank you again.

[millsp]

Giving it to you "as is", let me know if we can improve it. I embeds a few safe-guards already. Try to crash it please 🥇

import {A, I, L, M} from 'ts-toolbelt'

type _Paths<O, Paths extends L.List<A.Key> = [], Limit extends I.Iteration = I.IterationOf<'0'>> =
  10 extends I.Pos<Limit>
  ? Paths
  : O extends M.BuiltInObject
    ? Paths
    : O extends object
      ? Paths | {
          [K in keyof O]: _Paths<O[K], L.Append<Paths, K>, I.Next<Limit>>
        }[keyof O]
      : Paths

export type Paths<O extends object> =
    _Paths<O>

type Joinable = string | number | boolean | bigint

type Join<
  L extends L.List<Joinable>,
  D extends Joinable,
  J extends Joinable = '',
  I extends I.Iteration = I.IterationOf<'0'>> = {
    0: Join<L, D, `${J}${D}${L[I.Pos<I>]}`, I.Next<I>>
    1: J extends `.${infer J}` ? J : never
}[A.Extends<I.Pos<I>, L.Length<L>>]

type StringPaths<O extends object> =
  Paths<O> extends infer P
  ? P extends unknown
    ? Join<A.Cast<P, L.List<string | number>>, '.'>
    : never
  : never

declare function get<O extends object, P extends StringPaths<O>>(obj: O, path: P | String): P;

declare const object: O

get(object, '')

type O = {
  h: {
    b: {
      c: {
        d: {
          e: {
            f: O
          }
        }
      }
    }
  },
  b: {
    b: {
      c: {
        d: {
          e: {
            f: O
          }
        }
      }
    }
  },
  c: {
    b: {
      c: {
        d: {
          e: {
            f: O
          }
        }
      }
    }
  },
  d: {
    b: {
      c: {
        d: {
          e: {
            f: O
          }
        }
      }
    }
  }
}

[millsp]

Heya, I woke up fresher this morning. Here's a shorter, cleaner version:

import {I, M} from 'ts-toolbelt'

type _PathsDot<O, Paths extends string = '', Limit extends I.Iteration = I.IterationOf<'0'>> =
  11 extends I.Pos<Limit> ? Paths :
  O extends M.BuiltInObject ? Paths :
  O extends object ? Paths | {
    [K in keyof O]: _PathsDot<O[K], `${Paths}.${K & string}`, I.Next<Limit>>
  }[keyof O]
  : Paths

export type PathsDot<O extends object> =
  _PathsDot<O> extends `.${infer P}` | infer _
  ? P
  : ''

declare function get<O extends object, P extends PathsDot<O>>(obj: O, path: P | String): P;

declare const object: O

get(object, '')

type O = {
  h: {
    b: {
      c: {
        d: {
          e: {
            f: O
          }
        }
      }
    }
  },
  b: {
    b: {
      c: {
        d: {
          e: {
            f: O
          }
        }
      }
    }
  },
  c: {
    b: {
      c: {
        d: {
          e: {
            f: O
          }
        }
      }
    }
  },
  d: {
    b: {
      c: {
        d: {
          e: {
            f: O
          }
        }
      }
    }
  }
}

Notice that I added String into the get definition because I felt like we should be able to pass unknown strings too.

[nandorojo]

Wow, this looks great, I'll test it and report back. Thank you so much!