Is it possible to specify a key on an object while allowing TypeScript to infer the value's type automatically?

Question

Is it possible to specify a key on an object while allowing TypeScript to infer the value's type automatically?

Currently, I am working on a challenge where I aim to establish specific keys for an object while allowing TypeScript to infer the types of the values. Here is a simple example:


const fooVals = {
  a: null,
  b: null,
  c: null,
  e: null,
}

type TfooVals = typeof fooVals
type JustKeysOfFooVals = { [key in keyof TfooVals]: any};

// TypeScript correctly deduces the types of foo1Vals but does not flag missing key 'e'
const foo1Vals = {
  a: 'string',
  b: 10,
  c: Promise.resolve('string'), 
//  e: () => { console.log('bar') }
}

// Flags missing key 'e', but sets all types as any
const foo2Vals: JustKeysOfFooVals = {
  a: 'string',
  b: 10,
  c: Promise.resolve('string'), 
  e: () => { console.log('bar') }
}

TSPlayground:

Do you think this approach is achievable?

typescript typescript3.0

Answer 1

Answer №1

If you're looking for a more efficient solution, my suggestion would be to implement a versatile helper function that restricts its input to a specific category of JustKeysOfFooVals and simply returns the input without broadening it:

const justKeysOfFooVals = <T extends JustKeysOfFooVals>(t: T)=>t;

To utilize this, follow these steps:

const foo1Vals = justKeysOfFooVals({
  a: 'string',
  b: 10,
  c: Promise.resolve('string') , 
//  e: () => { console.log('bar') }
}); // error! property 'e' is missing

const foo2Vals = justKeysOfFooVals({
  a: 'string',
  b: 10,
  c: Promise.resolve('string') , 
  e: () => { console.log('bar') }
}); // okay
foo2Vals.e(); // okay

This approach will flag any absent keys and maintain accuracy in value types. Best of luck with your implementation!

Link to code

Update: The helper function could potentially eliminate unnecessary property checks. In case you require those (which might not be necessary since a value like {a: "a", b: "b"} aligns with type {a: string}), introducing another generic constraint mimicking exact types might help:

type Exactly<T, U> = T & Record<Exclude<keyof U, keyof T>, never>;
const justKeysOfFooVals = <T extends Exactly<JustKeysOfFooVals, T>>(t: T)=>t;

const foo3Vals = justKeysOfFooVals({
  a: 'string',
  b: 10,
  c: Promise.resolve('string') , 
  e: () => { console.log('bar') },
  f: 1 // error!
}); // number is not assignable to never

Link to code

Wishing you success with your endeavor!

Answer 2

If you're looking for a more efficient solution, my suggestion would be to implement a versatile helper function that restricts its input to a specific category of JustKeysOfFooVals and simply returns the input without broadening it:

const justKeysOfFooVals = <T extends JustKeysOfFooVals>(t: T)=>t;

To utilize this, follow these steps:

const foo1Vals = justKeysOfFooVals({
  a: 'string',
  b: 10,
  c: Promise.resolve('string') , 
//  e: () => { console.log('bar') }
}); // error! property 'e' is missing

const foo2Vals = justKeysOfFooVals({
  a: 'string',
  b: 10,
  c: Promise.resolve('string') , 
  e: () => { console.log('bar') }
}); // okay
foo2Vals.e(); // okay

This approach will flag any absent keys and maintain accuracy in value types. Best of luck with your implementation!

Link to code

Update: The helper function could potentially eliminate unnecessary property checks. In case you require those (which might not be necessary since a value like {a: "a", b: "b"} aligns with type {a: string}), introducing another generic constraint mimicking exact types might help:

type Exactly<T, U> = T & Record<Exclude<keyof U, keyof T>, never>;
const justKeysOfFooVals = <T extends Exactly<JustKeysOfFooVals, T>>(t: T)=>t;

const foo3Vals = justKeysOfFooVals({
  a: 'string',
  b: 10,
  c: Promise.resolve('string') , 
  e: () => { console.log('bar') },
  f: 1 // error!
}); // number is not assignable to never

Link to code

Wishing you success with your endeavor!

Is it possible to specify a key on an object while allowing TypeScript to infer the value's type automatically?

Answer №1

Similar questions

The property 'label' is not found in the 'string' type in Typescript

Utilizing Ionic Storage to set default request headers through an HTTP interceptor in an Angular 5 and Ionic 3 application

Important notice: It is not possible to assign refs to function components. Any attempt to do so will result in failure. If you intended to assign a ref, consider

Is it possible for a class method in Typescript to act as a decorator for another method within the same

Angular Material's compatibility update for Angular 8 version

Search for specific item within an array of objects

Leverage ngFor to loop through a "highly intricate" data structure

Using Angular, you can effortlessly inject elements into the editable div from any location on the page

Unable to assign a value to a constant within the class constructor

The error message "Error: Unable to access property '_router' when null in NativeScript"

Confounding Typescript Type Bindings

When using Google login in React and Node.js, the requested scope may not be returned as expected

Using TypeScript with Angular UI Router for managing nested named views in the application

Creating an interactive questionnaire

Combining generic types in an array into a single union

Is there a way to combine multiple array objects by comparing just one distinct element?

The design of Next.js takes the spotlight away from the actual content on the

Error reported: "require" identifier not found in Typescript. Issue identified in IONIC 3 development environment

Is there a way to execute the run function of a different Component in Angular 7 without causing the current

Can you explain the distinction between using get() and valueChanges() in an Angular Firestore query?