Eliminate nevers to make union possible

Question

Sorry if my title could be better, I have only been using typescript for about 2 weeks so my vernacular is probably lacking.

I have a structure that is 2 levels deep. For simplicity sake, let's image it such as:

type Structure = {
  foo: {
    a: 1,
    b: 2,
  }
  bar: {
    c: 3,
    d: 4,
  }
}

I have a function that takes a string like "foo.a" and returns that leaf of the structure.

The ultimate goal is to be type safe so that if I run:

const x = lookup("foo.a") // x inferred as 1

And TypeScript will know that "foo.a" is valid and the return type is 1.

I was able to create a type like this:

type Branch = keyof Structure
type Section<B extends Branch> = keyof Structure[B] & string

type Path<B extends Branch, S extends Section<B>> = `${B}.${S}`

This works but I cannot use it like so:

const path:Path = 'foo.a'

I must instead use it like:

const path:Path<"foo","a"> = 'foo.a'

This doesn't help me.

I also tried something like:

type SectionPath = `${Branch}.${Section<Branch>}`

But this becomes never and I am assuming it is never because it would create a union that includes impossibilities like "foo.c" or "bar.a" which are invalid. Is there a way to just get the union of possibilities, in this case: "foo.a" | "foo.b" | "bar.c" | "bar.d"

I know I can define this union manually, but the real structure is much larger and would be hard to maintain them both.

Also once I have this union, and I can accept it as an argument in a function, bonus points if you can tell me how to make the function's return type, the correct type for that leaf of the structure!

Answer 1

type Structure = {
    foo: {
        a: 1,
        b: 2,
    }
    bar: {
        c: 3,
        d: 4,
    }
}

type Values<T> = T[keyof T]

type Elem = string;

type Acc = Record<string, any>

/**
 * Just like Array.prototype.reduce predicate/callback
 * Receives accumulator and current element
 * - if element extends one of accumulators keys -> return  acc[elem]
 * - otherwise return accumulator
 */
type Predicate<Accumulator extends Acc, El extends Elem> =
    El extends keyof Accumulator ? Accumulator[El] : Accumulator

type Reducer<
    Keys extends Elem,
    Accumulator extends Acc = {}
    > =
    /**
     * If Keys extends a string with dot
     */
    Keys extends `${infer Prop}.${infer Rest}`
    /**
     * - Call Reducer recursively with last property
     */
    ? Reducer<Rest, Predicate<Accumulator, Prop>>
    /**
     *  - Otherwise obtain wjole properrty 
     */
    : Keys extends `${infer Last}`
    ? Predicate<Accumulator, Last>
    : never
{

    type Test1 = Reducer<'foo.a', Structure> // 1
    type Test2 = Reducer<'bar.d', Structure> // 4
}

/**
 * Compute all possible property combinations
 */
type KeysUnion<T, Cache extends string = ''> =
    /**
     * If T extends string | number | symbol -> return Cache, this is the end
     */
    T extends PropertyKey ? Cache : {
        /**
         * Otherwise, iterate through keys of T, because T is an object
         */
        [P in keyof T]:
        /**
         * Check if property extends string
         */
        P extends string
        /**
         * Check if it is the first call of this utility,
         * because CAche is empty
         */
        ? Cache extends ''
        /**
         * If it is a first call,
         * call recursively itself, go one level down - T[P] and initialize Cache - `${P}`
         */
        ? KeysUnion<T[P], `${P}`>
        /**
         * If it is not first call of KeysUnion and not the last
         * Unionize Cache with recursive call, go one level dow and update Cache
         */
        : Cache | KeysUnion<T[P], `${Cache}.${P}`>
        : never
    }[keyof T]

{
    //"foo" | "bar" | "foo.a" | "foo.b" | "bar.c" | "bar.d"
    type Test1 = KeysUnion<Structure>
}

const deepPick = <Obj,>(obj: Obj) =>
    <Keys extends KeysUnion<Obj>>(keys: Keys): Reducer<Keys, Obj> =>
        null as any

declare var data: Structure;

const lookup = deepPick(data)

const result = lookup('foo.a') // 1

// "foo" | "bar" | "foo.a" | "foo.b" | "bar.c" | "bar.d"
type Path = KeysUnion<Structure>

Playground

More about iteration over the tuple you can find in my article here

More explanation about typing this function you can find in my article here

Answer 2

Here's a solution: the helper type FlatValue gives the leaf type for a fully-qualified key, and the helper type FlatKeys gives the fully-qualified keys. It should work for arbitrary nesting depths.

type FlatValue<T, K> =
    K extends `${infer I}.${infer J}` ? I extends keyof T ? FlatValue<T[I], J> : never
    : K extends keyof T ? T[K] : never
type FlatKeys<T, P extends string = ''> =
    T extends object
    ? {[K in keyof T]: FlatKeys<T[K], `${P}${P extends '' ? '' : '.'}${K & string}`>}[keyof T]
    : P
type Flatten<T> = {[K in FlatKeys<T>]: FlatValue<T, K>}

Usage:

/* type Test = {
    "foo.a": 1;
    "foo.b": 2;
    "bar.c": 3;
    "bar.d": 4;
} */
type Test = Flatten<Structure>

Usage for a function:

function test<K extends FlatKeys<Structure>>(k: K): FlatValue<Structure, K> {
    // ...
}
// const result: 1
const result = test('foo.a');

Playground Link