TypeScript Deep Partial Interface

readme.md

TypeScript Deep Partial Interface

export type DeepPartial<T> = T extends Function ? T : (T extends object ? { [P in keyof T]?: DeepPartial<T[P]>; } : T);

Before typescript@3.1

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends Array<infer U>
    ? Array<DeepPartial<U>>
    : T[P] extends ReadonlyArray<infer U>
      ? ReadonlyArray<DeepPartial<U>>
      : DeepPartial<T[P]>
};

---

• 25/12/2018, updated by: https://stackoverflow.com/a/49936686/2500707
• 18/04/2020, updated by:
  • https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#typescript-29
  • https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-1.html#mapped-types-on-tuples-and-arrays

Function type are convert into {}.
Here a correction:

export type DeepPartial<T> = T extends Function ? T : (T extends object ? { [P in keyof T]?: DeepPartial<T[P]>; } : T);

@baanloh Thanks, updated! 🐱‍💻

Array elements are made optional too, which is quite disputable.
Example:

type Shape = {
  color: string;
  points: {x: number; y: number}[];
}

I'd expect this result from DeepPartial<Shape> :

{
  color?: string;
  points?: {x?: number; y?: number}[];
}

However it currently resolves this way:

{
  color?: string;
  points?: ({x?: number; y?: number} | undefined)[];
}

It is disputable since Partial<string[]> resolves to (string | undefined)[], but this is intuitive when I apply Partial directly on an array. But if I apply DeepPartial to express some large partial structure, I would not expect undefined in array elements.

It can be fixed this way:

export type DeepPartial<T> = T extends Function
  ? T
  : (T extends object
    ? T extends unknown[]
      ? DeepPartial<T[number]>[]
      : { [P in keyof T]?: DeepPartial<T[P]>; }
    : T
  );

For typeorm:

import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';

and be used like:

QueryDeepPartialEntity<User[]>

this does the same trick.

I did this workaround to keep promises:

export type DeepPartial<T> = 
    T extends Promise<infer Y>        ? Promise<DeepPartial<Y>>
  : T extends (...args: any[]) => any ? T
  : T extends object                  ? { [P in keyof T]?: DeepPartial<T[P]> }
  : T

For me, I need that Partial<T[K]> instead of T

export type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : Partial<T[K]>
}