TypeScript does not automatically deduce types

Question

TypeScript does not automatically deduce types

Here is a function I am working with:

type DefaultEntity = {
  id: string;
  createdBy: string;
  [fieldName: string]: unknown;
};

abstract find<T, Schema extends string | (new () => T)>(
    schema: Schema,
    id: string,
): Promise<(Schema extends string ? DefaultEntity : T) | null>;

Issue: The return type when calling the function with a string as the schema is DefaultEntity. However, when using MyClass as the schema argument, the return type is unknown instead of MyClass. This is unexpected because T is supposed to become MyClass. Is this a mistake on my end or is it something that TypeScript cannot handle?

typescript typescript-typings typescript-generics

Answer 1

Answer №1

To determine the type of Schema, there is no need for an extra T type parameter. Instead, you can infer the instance-type of the class either by utilizing the infer T keyword or by using the predefined helper InstanceType<Class>. For example:

type DefaultEntity = {
  id: string;
  createdBy: string;
  [fieldName: string]: unknown;
};

abstract class Base {
    // Method 1
    abstract find<Schema extends string | (new () => any)>(
        schema: Schema,
        id: string,
    ): Promise<(Schema extends (new () => infer T) ? T : DefaultEntity) | null>;

    // Another way to achieve the same result
    abstract find2<Schema extends string | (new () => any)>(
        schema: Schema,
        id: string,
    ): Promise<(Schema extends (new () => any) ? InstanceType<Schema> : DefaultEntity) | null>;
}

class UserEntity {
    id: string = ''
    createdBy: string = ''
    name: string = ''
}

class BaseImpl extends Base {
    async a () {
        (await this.find('asdfqer' , 'asdfasd')) satisfies DefaultEntity | null;
        (await this.find(UserEntity, 'asdf') ) satisfies UserEntity | null;
    }
}

Note: It is advisable to use overloads or separate methods like findByName(string, string) and findByEntity(Schema, string), as this approach will make it easier to maintain and understand the code in the future.

Answer 2

To determine the type of Schema, there is no need for an extra T type parameter. Instead, you can infer the instance-type of the class either by utilizing the infer T keyword or by using the predefined helper InstanceType<Class>. For example:

type DefaultEntity = {
  id: string;
  createdBy: string;
  [fieldName: string]: unknown;
};

abstract class Base {
    // Method 1
    abstract find<Schema extends string | (new () => any)>(
        schema: Schema,
        id: string,
    ): Promise<(Schema extends (new () => infer T) ? T : DefaultEntity) | null>;

    // Another way to achieve the same result
    abstract find2<Schema extends string | (new () => any)>(
        schema: Schema,
        id: string,
    ): Promise<(Schema extends (new () => any) ? InstanceType<Schema> : DefaultEntity) | null>;
}

class UserEntity {
    id: string = ''
    createdBy: string = ''
    name: string = ''
}

class BaseImpl extends Base {
    async a () {
        (await this.find('asdfqer' , 'asdfasd')) satisfies DefaultEntity | null;
        (await this.find(UserEntity, 'asdf') ) satisfies UserEntity | null;
    }
}

Note: It is advisable to use overloads or separate methods like findByName(string, string) and findByEntity(Schema, string), as this approach will make it easier to maintain and understand the code in the future.

Answer 3

Answer №2

Implementing multiple find overloads

find<T, Schema extends string>(
    schema: Schema,
    id: string,
): Promise<DefaultEntity | null>;
find<T, Schema extends (new () => T)>(
    schema: Schema,
    id: string,
): Promise<T | null>;
find<T, Schema extends string | (new () => T)>(
    schema: Schema,
    id: string,
): Promise<DefaultEntity | T | null>;

Answer 4

Implementing multiple find overloads

find<T, Schema extends string>(
    schema: Schema,
    id: string,
): Promise<DefaultEntity | null>;
find<T, Schema extends (new () => T)>(
    schema: Schema,
    id: string,
): Promise<T | null>;
find<T, Schema extends string | (new () => T)>(
    schema: Schema,
    id: string,
): Promise<DefaultEntity | T | null>;

TypeScript does not automatically deduce types

Answer №1

Answer №2

Similar questions

What steps should I take to establish a one-to-one relationship with legacy tables?

The implementation of race in React Redux Saga is proving to have negligible impact

Angular Typescript error: Trying to assign a value to 'someProperty' property of an undefined object

An issue has been identified in the node_modules/xterm/typings/xterm.d.ts file at line 10, causing an error with code TS1084. The 'reference' directive syntax used

Tips for associating an id with PrimeNg menu command

The Google Books API has reached its limit for requests

Assigning function types to functions that accept generics: A guide

Is there a way to get this reducer function to work within a TypeScript class?

Guide to leveraging clsx within nested components in React

A guide on how to navigate to a customizable element in React Native

Encountering a 404 error when utilizing ngx-monaco-editor within an Angular application

Exploring the functionality of two-way data binding in Angular - a beginner's guide

Manually Enroll Node Module

Guide on updating a value in a Firestore document using Firebase

Trouble arises when attempting to modify a property inherited from a parent class in TypeScript while

Unable to access the values of the object within the form

Adjust the input width dynamically in Angular

The MUI DataGrid's onCellEditStop event triggers when a cell's value is

Angular 14: Enhance Your User Experience with Dynamic Angular Material Table Row Management

Testing NextJS App Router API routes with Jest: A comprehensive guide