How to create an object describing all the paths in an object

[regevbr]

So basically what I want to achieve is the following:

Given an example interface

interface Context {
    str: string;
    num: number;
    nested: {
        value: number;
        nested2: {
            value2: string;
        };
    };
}

I want to be able to produce the following type:

{
    str: {
        propertyPath: 'str',
        type: 'string',
    },
    num: {
        propertyPath: 'num',
        type: 'number',
    },
    'nested.value': {
        propertyPath: 'nested.value',
        type: 'number',
    },
    'nested.nested2.value2': {
        propertyPath: 'nested.nested2.value2',
        type: 'string',
    },
}

Currently what I can get working is as follow:

import {S, List, U, Any} from 'ts-toolbelt';

type GetPartType<V> = V extends string ? 'string' : V extends number ? 'number' : V extends boolean ? 'boolean'
    : V extends Array<infer N> ? GetPartType<N> : never;

interface Part<C extends object, K extends keyof C, P extends List.List<string>> {
    type: GetPartType<C[K]>;
    propertyPath: S.Join<P, '.'>;
}

type Primitive = string | number | boolean;

type Parts<C extends object, P extends List.List<string> = []> = {
    [k in U.Select<keyof C, string>]:
    C[k] extends Primitive ? Part<C, k, [...P, k]>
        : C[k] extends Array<any> ? never
        : Parts<C[k], [...P, k]>;
}

interface Context {
    str: string;
    num: number;
    nested: {
        value: number;
        nested2: {
            value2: string;
        };
    };
}

type Result = Any.Compute<Parts<Context>>;

Which produces:

{
    str: {
        propertyPath: 'str',
        type: 'string',
    },
    num: {
        propertyPath: 'num',
        type: 'number',
    },
    nested: {
        value: {
            propertyPath: 'nested.value',
            type: 'number',
        },
        nested2: {
            value: {
                propertyPath: 'nested.nested2.value',
                type: 'string',
            }
        }
    }
}

In my tries to achieve my goal I came up with:

type StringPaths<O extends object> = S.Join<Object.Paths<O>, '.'>;

type Parts<C extends object> = {
    [K in StringPaths<C>]:
    Object.Path<C, S.Split<K, '.'>> extends Primitive ?
        Part<Object.Path<C, S.Split<K, '.'>>, K>
        : never;
}

type Result = Any.Compute<Parts<Context>>;

Which produces TS2589: Type instantiation is excessively deep and possibly infinite.

I then tried:

type StringPaths<O extends object> = S.Join<List.Required<Object.Paths<O>>, '.'>;

type Parts<C extends object> = {
    [K in StringPaths<C>]:
    Object.Path<C, S.Split<K, '.'>> extends Primitive ?
        Part<Object.Path<C, S.Split<K, '.'>>, K>
        : never;
}

Which produces TS2321: Excessive stack depth comparing types 'Join { [K in keyof Paths ]-?: Paths [K]; }, List >, ".">' and 'string | number | symbol'.

@millsp any thoughts on this matter will be much appreciated :-)

[millsp]

declare const d: unique symbol
interface Context {
    str: string;
    num: number;
    nested: {
        value: number;
        nested2: {
            value2: string;
        };
    };
}

type Keys<A> = S.Join<L.Required<O.Paths<A>>, '.'>

type Regev<A> = {
    [K in Keys<A>]: {
        propertyPath: K
        type: O.Path<A, S.Split<K, '.'>>
    }
}

type t = Regev<Context>

[millsp]

I'll let you do the type conversion

[millsp]

Please install latest :) I pushed a number of fixes

[regevbr]

@millsp Cool the changes you made solved it all. Thanks :-)