Object must only use keys from another object in TypeScript

When working with TypeScript, it is often necessary to ensure that an object only uses keys that are defined in another object. This can be particularly useful when you want to enforce a specific structure or prevent accidental typos in your code. In this blog post, we will explore two solutions to this problem.

Solution 1: Using the keyof operator

One way to ensure that an object only uses keys from another object is by utilizing the keyof operator. This operator allows you to extract all the keys from a given object type. By using it in combination with the keyof operator, you can create a type that represents only the keys of another object.

    const allowedKeys = {
      key1: true,
      key2: true,
      key3: true,
    };
    
    type AllowedKeys = keyof typeof allowedKeys;
    
    const myObject: Record = {
      key1: 'value1',
      key2: 'value2',
    };
  

In the code snippet above, we define an object called allowedKeys that contains all the allowed keys. We then create a type called AllowedKeys using the keyof operator on typeof allowedKeys. Finally, we define myObject as an object that can only use keys from AllowedKeys.

Solution 2: Using mapped types

Another solution to this problem is by using mapped types. Mapped types allow you to transform the properties of an object type into a new type. By using mapped types, you can create a type that only allows keys from another object.

    const allowedKeys = {
      key1: true,
      key2: true,
      key3: true,
    };
    
    type AllowedKeys = {
      [K in keyof typeof allowedKeys]: any;
    };
    
    const myObject: AllowedKeys = {
      key1: 'value1',
      key2: 'value2',
    };
  

In the code snippet above, we define allowedKeys as the object that contains all the allowed keys. We then create a type called AllowedKeys using a mapped type that iterates over the keys of typeof allowedKeys and assigns the type any to each key. Finally, we define myObject as an object that can only use keys from AllowedKeys.

Conclusion

By utilizing the keyof operator or mapped types, you can ensure that an object only uses keys from another object in TypeScript. This can help you maintain a consistent structure and prevent potential errors in your code. Choose the solution that best fits your needs and start enforcing key restrictions in your TypeScript projects.