Typescript: paths of all parents of leaves

Question

This post is already covering how to get all paths of leaves of an object. I'm using this

type DotPrefix<T extends string> = T extends '' ? '' : `.${T}`;

/**
 * Extracts paths of all terminal properties ("leaves") of an object.
 */
export type PropertyPath<T> = (
  T extends object
    ? {
        [K in Exclude<keyof T, symbol>]: `${K}${DotPrefix<PropertyPath<T[K]>>}`;
      }[Exclude<keyof T, symbol>]
    : ''
) extends infer D
  ? Extract<D, string>
  : never;

which is based on this #66661477 answer. But now I need to pull all those paths up by one level. That is, instead of picking "album.track.id" in

interface Track {
  album: {
    track: {
      id: string
    }
  }
}

I need to pick "album.track" which is the path of the parent of the leaf "album.track.id".

How can it be done? If you know the leaves' keys, you can do this:

type ParentPath<
  T,
  P extends PropertyPath<T>,
  K extends string
> = P extends `${infer Head}.${K}` ? Head : never;

(which should be improved by constraining K to keyof ...), but what if I don't want to pass the key? The problem is, with setting K to string, Head will be inferred as the string up to the first ".".

Does [this approach](https://tsplay.dev/w6VG6w) work for you? If yes, I'll write an answer explaining; If not, what am I missing? — wonderflame, Aug 22 '23 at 18:52
Yes, that would work for me. I would appreciate it if you could write up an answer, thanks. — DonFuchs, Aug 23 '23 at 14:38

score 0 · Answer 1 · answered Aug 22 '23 at 18:45

Can you see anything wrong with this:?

export type ParentPath<T> = {
  [K in Exclude<keyof T, symbol>]: T[K] extends object
    ? `${K}${DotPrefix<ParentPath<T[K]>>}`
    : '';
}[Exclude<keyof T, symbol>] extends infer D
  ? Extract<D, string>
  : never;

It's just like PropertyPath, only is it ignoring keys of non-object-like properties...

score 0 · Answer 2 · answered Aug 23 '23 at 15:07

Arguments:

T - The type that we traverse
P extends PropertyPath<T> - The path to the leaf property
AccP extends string = '' - The accumulative path of already traversed properties.

The logic:

Check whether P is in the shape of {keyOfT}.${RestOfThePath}
- If not, return never
- Else if there is a . in the RestOfThePath
  - If the RestOfThePath is the property path of the T[keyOfT]
    - Call the PropertyPath recursively for the T[keyOfT] and append .${keyOfT} to the AccP
  - Return never
- If there is not . then return ${AccP}.${keyofT}

Implementation:

type ParentPath<
  T,
  P extends PropertyPath<T>,
  AccP extends string = '',
> = P extends `${infer Head extends keyof T &
  string}.${infer Rest extends string}`
  ? Rest extends `${string}.${string}`
    ? Rest extends PropertyPath<T[Head]>
      ? ParentPath<T[Head], Rest, AccP extends '' ? Head : `${AccP}.${Head}`>
      : never
    : `${AccP}.${Head}`
  : never;

Testing:

//  "album.track"
type Test = ParentPath<Track, 'album.track.id'>;

playground

Typescript: paths of all parents of leaves

2 Answers2