Typescript Key-Value relation preserving Object.entries type

Question

The typing for Object.entries provided by typescript has the return type [string, T][] but I am searching for a generic type Entries<O> to represent the return value of this function that keeps the relationship between the keys and the values.

Eg. when having an object type like

type Obj = {
    a: number,
    b: string,
    c: number
}

I'm looking for a type Entries<O> that results in one of the types below (or something similar) when provided with Obj:

(["a", number] | ["b", string] | ["c", number])[]
[["a", number], ["b", string], ["c", number]]
(["a" | "c", number] | ["b", string])[]

---

That this isn't correct for all use cases of Object.entries (see here) is no problem for my specific case.

---

Tried and failed solution:

type Entries<O> = [keyof O, O[keyof O]][] doesn't work for this as it only preserves the possible keys and values but not the relationship between these as Entries<Obj> is ["a" | "b" | "c", number | string].

type Entry<O, K extends keyof O> = [K, O[K]]
type Entries<O> = Entry<O, keyof O>[]

Here the definition of Entry works as expected eg. Entry<Obj, "a"> is ["a", number] but the application of it in the second line with keyof O as the second type variable leads again to the same result as the first try.

Answer 1

Here's a solution, but beware when using this as a return type for Object.entries; it is not always safe to do that (see below).

---

When you want to pair each key with something dependent on that key's type, use a mapped type:

type Entries<T> = {
    [K in keyof T]: [K, T[K]];
}[keyof T][];

type Test = Entries<Obj>;
// (["a", number] | ["b", string] | ["c", number])[]

The second version, which has a tuple type containing the properties instead of a union, is much harder to construct; it is possible to convert a union to a tuple but you basically shouldn't do it.

The third version is manageable, but a bit more complicated than the first version: you need PickByValue from this answer.

type Entries3<T> = {
    [K in keyof T]: [keyof PickByValue<T, T[K]>, T[K]]
}[keyof T][];

type Test3 = Entries3<Obj>;
// (["a" | "c", number] | ["b", string])[]

Playground Link

---

I guess I should also explain why Typescript doesn't give a stronger type to Object.entries. When you have a type like type Obj = {a: number, b: string, c: number}, it's only guaranteed that a value has those properties; it is not guaranteed that the value does not also have other properties. For example, the value {a: 1, b: 'foo', c: 2, d: false} is assignable to the type Obj (excess property checking for object literals aside).

In this case Object.entries would return an array containing the element ['d', false]. The type Entries<Obj> says this cannot happen, but in fact it can happen; so Entries<T> is not a sound return type for Object.entries in general. You should only use the above solution with Object.entries when you yourself know that the values will have no excess properties; Typescript won't check this for you.

Answer 2

Currently, a really nice utility library called type-fest has been introduced to include this functionality for you, among others, in the form of Entries. You can use it like so:

import { Entries } from 'type-fest';

Object.entries(obj) as Entries<typeof obj>;

Edit: If you want Object.entries to have this type by default:

declare global {
  interface ObjectConstructor {
    entries<T extends object>(o: T): Entries<T>
  }  
}

Answer 3

I strongly believe the answer to this post should be a combination of two answers on this page:

type Entries<T> = {
    [K in keyof T]: [K, T[K]];
}[keyof T][];

from @kaya3

and

const getEntries = <T extends object>(obj: T) => Object.entries(obj) as Entries<T>;

from @minlare

Thank you both for the excellent answers.

Answer 4

// utils/objectEntries.ts

export { objectEntries }

// https://stackoverflow.com/questions/60141960/typescript-key-value-relation-preserving-object-entries-type/75337277#75337277

type ValueOf<T> = T[keyof T]
type Entries<T> = [keyof T, ValueOf<T>][]

// Same as `Object.entries()` but with type inference
function objectEntries<T extends object>(obj: T): Entries<T> {
  return Object.entries(obj) as Entries<T>
}

Answer 5

Following on from Peter Cardenas answer, I created a helper function as well

const getEntries = <T extends object>(obj: T) => Object.entries(obj) as Entries<T>;

Answer 6

we can make dedicated function as below:

depictObjectKeyType<O>(o: O) {
    return Object.keys(o) as (keyof O)[];
}

depictEntriesKeyType<T>(obj: T): Entries<T> {
    return Object.entries(obj) as any;
}

and use as:

this.depictEntriesKeyType(data).forEach(....