Is there a way to ensure that the value of an object matches its corresponding key through type enforcement

Question

Is there a way to ensure that the value of an object matches its corresponding key through type enforcement

I have objects that implement types as shown below:

type TMyObject<T extends string> {
  category: T
}

I am trying to store them statically in another object while ensuring that the key of this second object matches the value of the category field, like this:

const myObject: TMyObject<'foo'> = { category: 'foo' }

const dictionary = {
  foo: myObject, // correct
  bar: myObject, // not valid: key 'bar' does not match myObject's category
}

This issue arises because I have interfaces that extend IMyObject and set the category field to a specific value, as demonstrated:

type TMyFooObject = IMyObject<'foo'>

I have spent a significant amount of time attempting to create a type for the dictionary object that functions as described, but I am struggling to find a solution ^^

It is important to note that the category field and the potential types extending TMyObject are dynamic, so a simple union cannot be used here...

Thank you for taking the time to read and potentially respond to this inquiry!

typescript typescript-typings

Answer 1

Answer №1

Using mapped types, we can assign values to an object based on their keys.

type Dictionary<Keys extends string> = {
    [K in Keys]: MyCustomObject<K>
}

If we have prior knowledge of all categories, we can create a map with those as the keys.

const dictionary: Dictionary<'foo' | 'bar'> = {
  foo: { category: 'foo' }, // valid
  bar: { category: 'foo' }, // error: Type '"foo"' is not assignable to type '"bar"'
}

If you wish to restrict the categories but allow some to be missing, consider using

Partial<Dictionary<Category>>

.

This approach works well if your types already provide a union type of all possible categories.

The key-value matching validation for objects can be achieved by creating objects through an identity function. A generic function helps infer the Keys type from the object.

const createDictionary = <Keys extends string>(dict: Dictionary<Keys>) => dict;

const newDict = createDictionary({
  foo: { category: 'foo' }, // valid
  bar: { category: 'foo' }, // error: Type '"foo"' is not assignable to type '"bar"'
});
// newDict now has type: Dictionary<"foo" | "bar">

Check out Typescript Playground Link

Answer 2

Using mapped types, we can assign values to an object based on their keys.

type Dictionary<Keys extends string> = {
    [K in Keys]: MyCustomObject<K>
}

If we have prior knowledge of all categories, we can create a map with those as the keys.

const dictionary: Dictionary<'foo' | 'bar'> = {
  foo: { category: 'foo' }, // valid
  bar: { category: 'foo' }, // error: Type '"foo"' is not assignable to type '"bar"'
}

If you wish to restrict the categories but allow some to be missing, consider using

Partial<Dictionary<Category>>

.

This approach works well if your types already provide a union type of all possible categories.

The key-value matching validation for objects can be achieved by creating objects through an identity function. A generic function helps infer the Keys type from the object.

const createDictionary = <Keys extends string>(dict: Dictionary<Keys>) => dict;

const newDict = createDictionary({
  foo: { category: 'foo' }, // valid
  bar: { category: 'foo' }, // error: Type '"foo"' is not assignable to type '"bar"'
});
// newDict now has type: Dictionary<"foo" | "bar">

Check out Typescript Playground Link

Answer 3

Answer №2

Whenever IMyObject includes a category of type string, it becomes a runtime check rather than a compile-time check.

To make sure the check is done at compile time, you can define specific types for each case:

interface IFooObject {
  category: 'foo';
  foo: number;
  //other foo props
}

interface IBarObject {
  category: 'bar';
  bar: number;
  //other bar props
}

type IObject = IFooObject | IBarObject;

const myObject: IObject = { category: 'foo', foo: 123 }

type Disco<T> = T extends { category: infer U } ? U extends string ? { [P in U]: T } : never : never;

const disco: Disco<IObject> = {
  foo: myObject, // valid
  bar: myObject, // now this fails!
};

Playground link

You can also utilize the generic type, but in that scenario, you need to pass it through like so:

type TMyObject<T extends string> = {
  category: T
}

const myObject: TMyObject<'foo'> = { category: 'foo' }

type Disco<T> = T extends { category: infer U } ? U extends string ? { [P in U]: T } : never : never;

const dico: Disco<typeof myObject> = {
  foo: myObject, // valid
  bar: myObject, // invalid: 'bar' key does not match myObject.category
}

Playground link

Answer 4

Whenever IMyObject includes a category of type string, it becomes a runtime check rather than a compile-time check.

To make sure the check is done at compile time, you can define specific types for each case:

interface IFooObject {
  category: 'foo';
  foo: number;
  //other foo props
}

interface IBarObject {
  category: 'bar';
  bar: number;
  //other bar props
}

type IObject = IFooObject | IBarObject;

const myObject: IObject = { category: 'foo', foo: 123 }

type Disco<T> = T extends { category: infer U } ? U extends string ? { [P in U]: T } : never : never;

const disco: Disco<IObject> = {
  foo: myObject, // valid
  bar: myObject, // now this fails!
};

Playground link

You can also utilize the generic type, but in that scenario, you need to pass it through like so:

type TMyObject<T extends string> = {
  category: T
}

const myObject: TMyObject<'foo'> = { category: 'foo' }

type Disco<T> = T extends { category: infer U } ? U extends string ? { [P in U]: T } : never : never;

const dico: Disco<typeof myObject> = {
  foo: myObject, // valid
  bar: myObject, // invalid: 'bar' key does not match myObject.category
}

Playground link

Is there a way to ensure that the value of an object matches its corresponding key through type enforcement

Answer №1

Answer №2

Similar questions

Exploring and adding elements in a sophisticated array or object through recursive searching

Utilizing TypeScript Generics to Dynamically Set Tag Names in React

Reducing image file sizes in Ionic 3

What is the reason for TypeScript's prioritization of arguments over assignment in generic inference?

Utilizing TypeScript function components within styled-components

What is the reason for the index type being defined twice?

Issue with Readonly modifier not functioning as expected in Angular/Typescript

Error: The function being called in <class> is not recognized as a function

Error in class constructor due to a Typescript typeguard issue

The challenge of handling Set type in TypeScript errors

I am inputting an array in which I am certain about the type of the initial value, however, I am uncertain about the length of the array and the types of the remaining values

Trouble with Typescript in VSCode made easy

Is there a TypeScript definition file available for Google Charts?

Unable to invoke the AppComponent function within ngOnInit due to error message: "Object does not have the specified property or method"

What is the best way to execute an asynchronous request in AngularJs and Typescript?

What steps should I follow to properly set up my tsconfig.json in order to ensure that only the essential files are included when executing npm run build

Troubleshooting: Unable to locate .vue.d.ts file during declaration generation with Vue, webpack, and TypeScript

Issues arise when attempting to enforce type-safety in TypeScript while using the JSON.parse

Sharing parameters between pages in Angular IonicPassing parameters between pages within an Angular Ionic application

Embark on your project with Adonisjs, utilizing both http and https protocols