Check if an interface has a required field

Question

Is it possible to check whether an interface has a required field using Typescript's Conditional Types?

type AllRequired = { a: string; b: string }
type PartiallyRequired = { a: string; b?: string }
type Optional = { a?: string; b?: string }

// Is it possible to change this, so the below works
type HasRequiredField<T> = T extends {} ? true : false

type A = HasRequiredField<AllRequired> // true
type B = HasRequiredField<PartiallyRequired> // true
type C = HasRequiredField<Optional> // false

score 5 · Accepted Answer · answered Mar 19 '19 at 18:33

5

Yes, you can detect if properties are optional. It gets a bit iffy with index signatures, but your types don't have them so I'm not going to worry about them.

Here's how you can extract just the keys of the non-optional properties of an object type

type RequiredKeys<T> = { [K in keyof T]-?:
  ({} extends { [P in K]: T[K] } ? never : K)
}[keyof T]

And then you can just check if it has any of them or not (if RequiredKeys<T> is never then it does not):

type HasRequiredField<T> = RequiredKeys<T> extends never ? false : true

And that gives your desired results:

type A = HasRequiredField<AllRequired> // true
type B = HasRequiredField<PartiallyRequired> // true
type C = HasRequiredField<Optional> // false

Hope that helps; good luck!

answered Mar 19 '19 at 18:33

jcalz

264,269
27
359
360

I don't really get how to use HasRequiredField. I'm trying to perform a check with a property to see if it is required in an interface. How can I do that with HasRequiredField? I'd basically like to have it return a boolean by passing in a property and have it check that property against an interface to see if that property is required or optional. – MatTaNg Dec 17 '20 at 23:49
Maybe you want `type IsRequired = {} extends Pick ? false : true;` but it's hard to tell from your comment. Do you have a [mcve] of what you're trying to accomplish? If so, you may want to ask your own question since the comments on a 1.5-yr-old answer is not necessarily the best place to get a new problem solved. – jcalz Dec 18 '20 at 02:32

score 1 · Answer 2 · answered Apr 24 '21 at 01:00

Found another, simpler way to do this that works in at least TS 3.8.3.

// if Partial<T> extends T none of the fields are required.
type HasRequiredFeilds<T> = Partial<T> extends T ? false : true

Example use cases

type Info<TInfo> = Partial<TInfo> extends TInfo
   ? { info?: TInfo }
   : { info: TInfo };

type A = { type: 'A' } & Info<{ abc?: string }>
type B = { type: 'B' } & Info<{ abc: string }>

// Valid
let a1: A = { type: 'A' };
// Valid
let a2: A = { type: 'A', info: {} };
// Valid
let a3: A = { type: 'A', info: { abc: 'hello' } };
// Invalid
let a4: A = { type: 'A', info: { abc: 3 } };

// Invalid
let b1: B = { type: 'B' }
// Invalid
let b2: B = { type: 'B', info: {} };
// Valid
let b3: B = { type: 'B', info: { abc: 'Hello' } };
// Invalid
let b4: B = { type: 'B', info: { abc: 5 } };

Check if an interface has a required field

2 Answers2