TypeScript: Indexing into an object type using keyof

Question

I have a nested object by keys that looks like the following:

const OBJECTS = {
    OBJECT1: {
        properties: {
            prop1: { value: "a" },
        },
    },
    OBJECT2: {
        properties: {
            prop2: { value: "b" },
        },
    },
} as const;

I'm trying to create a generic type where I an extract out the property values for a specific object - something like:

type PropertiesForObject<OBJECT_KEY extends keyof typeof OBJECTS> = {
    [PROPERTY_NAME in keyof typeof OBJECTS[OBJECT_KEY]["properties"]]: typeof OBJECTS[OBJECT_KEY]["properties"][PROPERTY_NAME]["value"];
};

However, I'm getting the following error:

Type '"value"' cannot be used to index type '{ readonly OBJECT1: { readonly properties: { readonly prop1: { readonly value: "a"; }; }; }; readonly OBJECT2: { readonly properties: { readonly prop2: { readonly value: "b"; }; }; }; }[OBJECT_KEY]["properties"][PROPERTY_NAME]'.

Is there any way to index into each object's properties, given that the shape of the properties is the same? I could force it into an interface, but I want to keep the strong typings of the values.

What is the type you want as an output? Is it just for PropertiesForObject<'OBJECT1'> to yield { prop1: "a" }? — Alex Wayne
– Alex Wayne, Commented May 21, 2020 at 20:05

jcalz · Accepted Answer · 2020-05-22 01:28:41Z

6

This might well be a bug or design limitation in TypeScript; the compiler doesn't recognize that the generic object will have a literal key. It's a problem with the inferred constraint on typeof OBJECTS[K]["properties"][P]. See microsoft/TypeScript#21760 for more information (and maybe give it a 👍 if you want to see it handled someday, but it doesn't look promising since it's been lying fallow for more than two years as of May 2020).

One way to handle this is to make the type function more general (instead of typeof OBJECTS, use a generic type T that is explicitly constrained to something with the structure we're accessing) and then specialize that to typeof OBJECTS:

type GenericPropertiesForObject<
    T extends Record<K, { properties: { [k: string]: { value: any } } }>,
    K extends PropertyKey
    > = {
        [P in keyof T[K]["properties"]]: T[K]["properties"][P]["value"]
    };

type PropertiesForObject<K extends keyof typeof OBJECTS> =
    GenericPropertiesForObject<typeof OBJECTS, K>;

This compiles without error, even though it's performing essentially the same computation. Let's make sure it works:

type O1Props = PropertiesForObject<'OBJECT1'>;
// type O1Props = { readonly prop1: "a"; }

type O2Props = PropertiesForObject<'OBJECT2'>;
// type O2Props = { readonly prop2: "b"; }

Looks good to me. Okay, hope that helps; good luck!

Playground link to code

answered May 22, 2020 at 1:28

jcalz

339k29 gold badges452 silver badges449 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

user3448296 Over a year ago

This was awesome! The other workaround that I used was to create a type that extracts out the key if it can: typescript type GetValue<T, K extends string> = T extends { [key in K]: infer R } ? R : never; Then, instead of indexing "value", I just used GetValue<T[K]["properties"][P], "value">.

Collectives™ on Stack Overflow

TypeScript: Indexing into an object type using keyof

1 Answer 1

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related