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 [email protected]

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

@navix Your solution there is great for typescript 3.0, unfortunately the use of infer breaks the ability to get code completion when using DeepPartial in argument position (you get type verification only). So for typescript 3.1 and later, the following is much better:

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

@insidewhy you're right!

Thanks for the update. 😎

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]>
}