CODEWITHSUNDEEP
typescript
Lev
Lev

Reputation: 15674

Define an object with an optional amount of keys, but at least ONE key

How can I achieve this ?

type Fruit = "apple" | 'banana' | 'coconut'

type FruitCollection = { [f in Fruit]?: number }

const validFruitCollection: FruitCollection = { apple: 1, coconut: 2 } 

const emptyCollectionShouldNotPass: FruitCollection = {} // I don't want typescript to let this pass

Upvotes: 4

Views: 2520

Answers (2)

Titian Cernicova-Dragomir
Titian Cernicova-Dragomir

Reputation: 249536

You can intersect the type with all optional members with a union of all properties, where all in each constituent of the union, one member is required. So basically you will have:


type WhatWeWant = {
    apple?: number | undefined;
    banana?: number | undefined;
    coconut?: number | undefined;
} & (
    | { apple: number; }
    | { banana: number; }
    | { coconut : number ;})

To get this type without writing it out we can use a mapped type:


type RequireOne<T> = T & { [P in keyof T]: Required<Pick<T, P>> }[keyof T]
type FruitCollection = RequireOne<{ [f in Fruit]?: number }>

Playground Link

The idea of the mapped type in RequireOne is to create union in the WhatWeWant type above (T will be the original type will al the optional properties). So what we do, in the mapped type is we take each property in T and type it as Required<Pick<T, P>>. This means for each key, we get a type that only contains that key, basically this type for the example:

{
  apple: { apple: number; }
  banana: { banana: number; }
  coconut: { coconut: number ;}
}

With this type, the matter of getting the union we want is just a matter with indexing keyof T, to get a union of all property types in our object.

Upvotes: 5

Maciej Sikora
Maciej Sikora

Reputation: 20132

What we need is type which will exclude possibility of empty object. In order to achieve that we need utility type and value constructor. Consider:

type Fruit = "apple" | 'banana' | 'coconut'

type FruitCollection = { [f in Fruit]?: number }

// type which will exclude empty object
type NotEmpty<T> = {} extends T ? never : T

// value constructor
const makeFruitCollection = <T extends FruitCollection>(c: NotEmpty<T>) => c; 

// use cases
const validFruitCollection = makeFruitCollection({ apple: 1, coconut: 2 }) // ok 👌
const emptyCollectionShouldNotPass = makeFruitCollection({}) // error 👌

Type NotEmpty is checking if our T which already pass all needs of FruitCollection is not empty object, if it is we get never, and there is no value of type never therefor using function with {} will not compile.

The Playground

Upvotes: 4

Related Questions