Typescript interface requiring both properties or none at all

Question

Typescript interface requiring both properties or none at all

I possess key-value pairs that must always be presented together in a set. Essentially, if I have one key with its value A:B, then there should also be another key with its value C:D. It is permissible for the object to contain neither pair as well. (An example could be message:string and min-length:number as one pair.) Is there an elegant method to create an interface consisting of any number of such paired elements?

Edit: To clarify, I aim to develop an interface for objects where the following structures would be valid:

{
    //First pair
    message1: string;
    minLength1: number;
    //Second pair
    message2: string;
    minLength2: number;
    // ...
}

{
    //First pair completely omitted

    //Only the second pair present
    message2: string;
    minLength2: number;
}

... but cases like the ones below should not be allowed because they lack one part of a pair:

{
    //First pair
    message1: string;
    // minLength1: number; // This results in an error †
    // ...
}

† Error: including message1 necessitates adding minLength1 as well

typescript interface

Answer 1

Answer №1

When it comes to ensuring that a pair of properties are either both present or both absent, you can create a type that combines both properties along with optional properties of type never, which essentially prevents the properties from existing with any value other than undefined. This concept was inspired by this answer. Although this approach may generate errors in specific scenarios, the error messages might not be very informative. To handle this, you can intersect unions for all property pairs you wish to evaluate, keeping in mind that TypeScript simplifies types by distributing intersections and unions, potentially increasing the size of the type exponentially if you have numerous property pairs (up to around 10).

type AllOrNone<T> = T | {[K in keyof T]?: never};

type MyType = AllOrNone<{
    message1: string;
    minLength1: number;
}> & AllOrNone<{
    message2: string;
    minLength2: number;
}>;

If you prefer to avoid the undefined scenario and are open to using a generic function for validating objects instead of defining a single type, you can implement something like this:

type CheckAllOrNone<A, T> =
    T | (keyof A & keyof T extends never ? {} : never);

type CheckMyType<A> = CheckAllOrNone<A, {
    message1: string;
    minLength1: number;
}> & CheckAllOrNone<A, {
    message2: string;
    minLength2: number;
}>;

function checkMyType<A extends CheckMyType<A>>(arg: A) {
    return arg;
}

Answer 2

When it comes to ensuring that a pair of properties are either both present or both absent, you can create a type that combines both properties along with optional properties of type never, which essentially prevents the properties from existing with any value other than undefined. This concept was inspired by this answer. Although this approach may generate errors in specific scenarios, the error messages might not be very informative. To handle this, you can intersect unions for all property pairs you wish to evaluate, keeping in mind that TypeScript simplifies types by distributing intersections and unions, potentially increasing the size of the type exponentially if you have numerous property pairs (up to around 10).

type AllOrNone<T> = T | {[K in keyof T]?: never};

type MyType = AllOrNone<{
    message1: string;
    minLength1: number;
}> & AllOrNone<{
    message2: string;
    minLength2: number;
}>;

If you prefer to avoid the undefined scenario and are open to using a generic function for validating objects instead of defining a single type, you can implement something like this:

type CheckAllOrNone<A, T> =
    T | (keyof A & keyof T extends never ? {} : never);

type CheckMyType<A> = CheckAllOrNone<A, {
    message1: string;
    minLength1: number;
}> & CheckAllOrNone<A, {
    message2: string;
    minLength2: number;
}>;

function checkMyType<A extends CheckMyType<A>>(arg: A) {
    return arg;
}

Typescript interface requiring both properties or none at all

Answer №1

Similar questions

Obtaining the dimensions of each individual child component within an NgTemplate

Next.js routes taking precedence over storybook routes

What is the best way to simulate global variables that are declared in a separate file?

Angular - Collaborative HTML format function

What is the easiest way to compile a single .ts file in my src folder? I can achieve this by configuring the tsconfig.js file and running the yarn

Tips for tracking the evolution of changes to an array within React State

Creating a signature for a function that can accept multiple parameter types in TypeScript

Using TypeScript to automatically deduce the output type of a function by analyzing the recursive input type

Leveraging Shared Modules Component across multiple modules in Angular can enhance code re

Determine whether a response is not received within 8 seconds

The constructor in a Typescript Angular controller fails to run

Conceal the PayPal Button

WebStorm provides alerts for objects, types, and directives within Angular, yet they function properly

Despite using Enzyme to locate a component again, the expected prop value is still not being returned

Develop a "Read More" button using Angular and JavaScript

Creating React Components with TypeScript: Ensuring Typechecking in Class and Function Components

TypeScript and Next.js failing to properly verify function parameters/arguments

Setting up a project in TypeScript with Angular 2(+) and a Node/Express server is essential for successful

Guide to generating a text string by utilizing the foreach loop

Encountering a service error that results in the inability to read properties of undefined when passing a method as a