ObjectEntries

In this medium-level challenge, you'll implement the type-level version of Object.entries, which converts an object type into a union of key-value tuple pairs while correctly handling optional and undefined properties.

interface Model {
name: string;
age: number;
locations: string[] | null;
}
type modelEntries = ObjectEntries<Model> // ['name', string] | ['age', number] | ['locations', string[] | null];

interface Model {
  name: string
  age: number
  locations: string[] | null
}

type ModelEntries =
  | ['name', string]
  | ['age', number]
  | ['locations', string[] | null]

type cases = [
  Expect<Equal<ObjectEntries<Model>, ModelEntries>>,
  Expect<Equal<ObjectEntries<Partial<Model>>, ModelEntries>>,
  Expect<Equal<ObjectEntries<{ key?: undefined }>, ['key', undefined]>>,
  Expect<Equal<ObjectEntries<{ key: undefined }>, ['key', undefined]>>,
  Expect<
    Equal<
      ObjectEntries<{ key: string | undefined }>,
      ['key', string | undefined]
    >
  >,
]

Detailed Explanation

type ObjectEntries<T> = {
  [K in keyof Required<T>]: [K, Required<T>[K] extends never ? undefined : Required<T>[K]];
}[keyof T];

How it works:

• The type first wraps T with Required<T> to remove all optional modifiers, which prevents undefined from being automatically added to the value types of optional properties (e.g., Partial<Model> would otherwise add undefined to every value)
• It creates a mapped type where each key K maps to a tuple [K, ValueType], representing one entry
• The value type uses Required<T>[K] to get the clean value without the optional undefined injection, but checks for never and replaces it with undefined to handle edge cases like { key?: undefined }
• The indexed access [keyof T] at the end converts the mapped object into a union of all its values, producing the final union of entry tuples
• Using keyof T (not keyof Required<T>) ensures only the original keys are included in the result

An alternative approach using a distributive conditional:

type RemoveUndefined<T> = [T] extends [undefined] ? T : Exclude<T, undefined>;
 
type ObjectEntries<T> = {
  [K in keyof T]-?: [K, RemoveUndefined<T[K]>];
}[keyof T];

This challenge helps you understand mapped types, optional property handling, and indexed access types, and how to apply these concepts in real-world scenarios.