Discover the keys of a record using Typescript within a function

Question

Discover the keys of a record using Typescript within a function

I am looking to limit the parameter that can be passed when executing the next function to only the keys of the object provided in createTransitions. This limitation should be applicable across all transitions, as each transition may have different keys.

type Context = { [key: string]: any };

type Action<T extends { [K in keyof T]: any }> = (
  context: Context,
  next: (state?: keyof T) => void,
) => Promise<any> | any;

type Transitions<T extends { [K in keyof T]: any }> = {
  [K in keyof T]: Action<T>;
};

export function createTransitions<T extends { [K in keyof T]: Action<T> }>(
  transitions: T,
): Transitions<T> {
  return transitions;
}

const transitions = createTransitions({
  trans1: (context) => {
    context.payload = context.request.json();
  },
  trans2: (context, next) => {
    if () {
      next("trans3"); // I want this to be valid
      return;
    }

    next("error"); // I want this to be valid
  },
  trans3: (context) => {
    next("any"); // I want this to be invalid
  },
  error: (context) => {
    //
  },
});

Find the complete code here: Codesandbox

typescript

Answer 1

Answer №1

It appears that the issue arises when the function is generic in Type T, an object type with keys of importance. The compiler struggles to infer the self-referencing context needed because it assumes Type T depends on the type of 'next' for each property, while 'next''s callback parameter relies contextually on Type T. The fact that only the keys of Type T need consideration is not apparent to the compiler, resulting in failed inference. There is an ongoing issue related to inferring generic type arguments and callback parameters contextually in cases of perceived, yet non-existent circularity; you can refer to microsoft/TypeScript#47599 for more information. Until a significant change occurs regarding this issue, we have to find an alternate approach.

The focus here seems to be less on the object type itself and more on its keys. To address this, let's make the function generic in Key K, representing the union of keys within Type T. This leads us to:

type Action<K extends PropertyKey> = (
    context: any,
    next: (state?: K) => void,
) => Promise<any> | any;

export function createTransitions<K extends PropertyKey>(
    transitions: Record<K, Action<K>>
) {
    return transitions;
}

This code essentially mirrors yours, but replaces 'keyof T' with 'K'. Upon testing:

const transitions = createTransitions({
    trans1: (context) => {
        context.payload = context.request.json();
    },
    trans2: (context, next) => {
        if (Math.random() < 0.5) {
            next("trans3"); // valid
            return;
        }

        next("error"); // valid
    },
    trans3: (context, next) => {
        next("any"); // error!
    },
    error: (context) => {
        //
    },
});

The code works as expected. The compiler efficiently infers Key K from input keys and provides contextual typing for 'next', bypassing circular inference issues by not requiring knowledge of transition properties to determine Key K.

Link to Playground Code

Answer 2

It appears that the issue arises when the function is generic in Type T, an object type with keys of importance. The compiler struggles to infer the self-referencing context needed because it assumes Type T depends on the type of 'next' for each property, while 'next''s callback parameter relies contextually on Type T. The fact that only the keys of Type T need consideration is not apparent to the compiler, resulting in failed inference. There is an ongoing issue related to inferring generic type arguments and callback parameters contextually in cases of perceived, yet non-existent circularity; you can refer to microsoft/TypeScript#47599 for more information. Until a significant change occurs regarding this issue, we have to find an alternate approach.

The focus here seems to be less on the object type itself and more on its keys. To address this, let's make the function generic in Key K, representing the union of keys within Type T. This leads us to:

type Action<K extends PropertyKey> = (
    context: any,
    next: (state?: K) => void,
) => Promise<any> | any;

export function createTransitions<K extends PropertyKey>(
    transitions: Record<K, Action<K>>
) {
    return transitions;
}

This code essentially mirrors yours, but replaces 'keyof T' with 'K'. Upon testing:

const transitions = createTransitions({
    trans1: (context) => {
        context.payload = context.request.json();
    },
    trans2: (context, next) => {
        if (Math.random() < 0.5) {
            next("trans3"); // valid
            return;
        }

        next("error"); // valid
    },
    trans3: (context, next) => {
        next("any"); // error!
    },
    error: (context) => {
        //
    },
});

The code works as expected. The compiler efficiently infers Key K from input keys and provides contextual typing for 'next', bypassing circular inference issues by not requiring knowledge of transition properties to determine Key K.

Link to Playground Code

Discover the keys of a record using Typescript within a function

Answer №1

Similar questions

Ways to modify a number in grafbase

Detecting the check status of a checkbox in react native: a complete guide

Save geometric shapes data in the SQLite database

Encountering TypeScript errors when trying to reference Angular2 within a Gulp setup

"Exploring the world of 3rd party libraries in Angular2 with Typescript and Webpack

Can you demonstrate how to display the chosen toggle button within Angular 4 alongside the remaining options?

What is preventing React CLI from installing the template as TypeScript?

My customized mat-error seems to be malfunctioning. Does anyone have any insight as to why?

The readiness status of the mongoose connection is resulting in a TypeError: Unable to access undefined properties (reading 'readyState')

Tips for accessing the PR number in a Node.js GitHub Probot listening for the `pull_request` event

Turn off page animation for a specific page in Ionic 4

In Angular, a variable that is exported from a module may not be accessible within a class function

How many times does the CatchError function in Angular 6 response interceptor get executed?

What could be the reason for mat-autocomplete not displaying the loading spinner?

Limit a generic type to only accept literal types

Retrieve a particular element from an array within a JSON object using Ionic

Injecting a component in Angular 2 using an HTML selector

Using Iframe for WooCommerce integration and implementing Facebook login within an Ionic application

Encountering "Unexpected token *" error when using Jest on an import statement

A function that recursively calls itself and uses a promise for iteration