Limit function parameter types to object keys

Question

Limit function parameter types to object keys

Is it possible to constrain my function parameter to match the keys of an object? I want to achieve something similar to this:

export const details = {
        x: {
            INFO_x: 'xxx'
        },
    
        y: {
            INFO_y: 'xxx'
        },
    
        z: {
            INFO_z: 'xxx'
        }
    };
    
    export const performAction = (parameter: ???) => {};
    
    performAction("dwdew"); // type error
    performAction(details.x.INFO_x) // valid

typescript

Answer 1

Answer №1

Revise

Upon revisiting the original post, it appears that the inquiry is not exactly in line with what was initially assumed. The function is intended to take a singular nested value as a parameter, rather than the entire object. While the comments on the question hint at potentially restricting the parameter's type to only xxx, there isn't a clear way to control its origin.

Despite this clarification, the initial response I provided could still prove beneficial to either the OP or others:

Suggested Revision

If you anticipate consistent formatting for the parameter structure, consider defining a type or interface for it:

interface Thing {
  a: {
    ROLE_a: string
  },
  b: {
    ROLE_b: string
  }
  // etc.
}

function doSomething(param: Thing) {
  // perform action
  console.log(param.a.ROLE_a); // no errors expected
}

For more adaptability, a combination of generics along with template literal types + key remapping can be utilized:

type Things<Prefix extends string, Keys extends string> = {
    [K in Keys]: {
        [T in K as `${Prefix}_${K}`]: string
    }
};

type ParamsType = Things<'ROLE', 'a' | 'b'>

function doSomething(param: ParamsType) {
    // perform action
    console.log(param.a.ROLE_a); // no errors expected
}

Access Playground Here

Answer 2

Revise

Upon revisiting the original post, it appears that the inquiry is not exactly in line with what was initially assumed. The function is intended to take a singular nested value as a parameter, rather than the entire object. While the comments on the question hint at potentially restricting the parameter's type to only xxx, there isn't a clear way to control its origin.

Despite this clarification, the initial response I provided could still prove beneficial to either the OP or others:

Suggested Revision

If you anticipate consistent formatting for the parameter structure, consider defining a type or interface for it:

interface Thing {
  a: {
    ROLE_a: string
  },
  b: {
    ROLE_b: string
  }
  // etc.
}

function doSomething(param: Thing) {
  // perform action
  console.log(param.a.ROLE_a); // no errors expected
}

For more adaptability, a combination of generics along with template literal types + key remapping can be utilized:

type Things<Prefix extends string, Keys extends string> = {
    [K in Keys]: {
        [T in K as `${Prefix}_${K}`]: string
    }
};

type ParamsType = Things<'ROLE', 'a' | 'b'>

function doSomething(param: ParamsType) {
    // perform action
    console.log(param.a.ROLE_a); // no errors expected
}

Access Playground Here

Limit function parameter types to object keys

Answer №1

Revise

Suggested Revision

Similar questions

Incorporating a module from a nearby component repository into the primary task

Tips for integrating Typescript into a pre-existing Vue 3 project

How can I call a method from a class using Typescript when getting an error saying that the property does not exist on the

Ways to expand the width of mat-dialog-actions component in Angular 8

Angular 2: Issue with disabled functionality not functioning correctly

Is there a way to incorporate a loading spinner into a MaterialUI DataTable without having to specify a fixed height for the parent component?

Is there a way for me to define the type of a prop based on the type of another prop?

Ionic Vue is throwing an error indicating that a property is not found on the type '{ $route(currentRoute: any): void; }'

What is the true function of the `as` keyword within a mapped type?

Enhance the Component Props definition of TypeScript 2.5.2 by creating a separate definition file for it

An action in redux-toolkit has detected the presence of a non-serializable value

Tips for effectively transmitting data while utilizing a declarative/reactive data access method with RxJS in Angular?

Creating templates for both classes and individual objects is an essential part of object-oriented programming

Can we verify if strings can serve as valid property names for interfaces?

Having trouble using the Aceternity interface as it keeps giving me a type error

Issues arise in TypeScript 5.1.3 with lodash due to type errors involving excessively deep type instantiation, which may potentially be infinite

When using Jest + Enzyme to test a stateful class component, encountering problems with Material-UI's withStyles functionality is a common issue

Array of Typed Objects in TypeScript

What is the best way to decouple the data layer from Next.js API routes?

The feature of getDisplayMedia is not included in TypeScript 3.8