Can a default value be assigned to a generic argument in Typescript?

Question

Can a default value be assigned to a generic argument in Typescript?

I'm currently creating versatile methods for use across various frontend applications. The goal is to invoke the function

.postAsync<CustomModel>('www.mysite.com',..., CustomModel);

and receive a CustomModel object as the response.

I want to establish a default value for the second parameter, making it a different model by default, but allowing for customization when necessary.

How can I define a default value for an argument of type Constructable<T>, where the Constructable interface is defined as:

interface Constructable<T> { new(params: any): T; }

I've attempted setting default values for an interface with different argument types, but encountered the error

Type Constructable<CustomModel> is not assignable to type Constructable<T>

. I've also tried setting T to CustomModel in the generic method and encountered the same error.

The expectation was that I wouldn't need to specify a model when calling the postAsync() method and that it would always return a CustomModel object. However, I received the error

Type Constructable<CustomModel> is not assignable to type Constructable<T>

.

typescript generics casting

Answer 1

Answer №1

After encountering an issue where a default needed to be returned when a model was not provided, I successfully resolved the problem by implementing a solution involving a generic object. The key fixes included:

Transitioning from typing the model as the Constructable interface to utilizing a union type of Constructable<T> | object.
Adjusting the default parameter for the model to be passed in as an Object.
The buildModel() function now examines the type of the model - if it's an object, it returns the provided values; if it's a constructable, it generates a new instance.

Discover how this solution is implemented within the postAsync parameters, the ResponseModel interface, and the buildModel method found in requestAsync:

interface Constructable<T> { new(params : any): T ;}
type ResponseModel<T> = Constructable<T> | Object;

export default class WebapiBase {
  static async postAsync<T = Object>(
      {
          uri = '',
          body = {},
          headers = new CustomHeaders(),
      }: PostRequestParams = {},
      // Default implementation provided here
      model: ResponseModel<T> = Object): Promise<T> {
      return this.requestAsync(model, HTTP_METHOD.POST, uri, headers, body);
  }
  private static async requestAsync<T = Object>(
      // This parameter accepts either a class or object
      model: ResponseModel<T>,
      method: HTTP_METHOD,
      uri: string,
      headers: CustomHeaders,
      body?: object): Promise<T> {
      const url = new URL(uri, window.location.origin);
      const request = this.buildRequest(url, method, headers, body);
      const bodyResponse = await fetch(request)
          .then(response => this.validate(response, request.headers))
          .then(validResponse => this.extractBody(validResponse))
          // Class instance or object is returned here
          .then(extractedBody => this.buildModel(model, extractedBody))
          .catch((error) => { throw this.handleError(error); });
      return bodyResponse;
  }

  // Conditional method creating an instance of the specified model
  // or returning the provided object if no model is given
  private static buildModel<T = Object>(
        Model: ResponseModel<T>,
        params: any,
    ): T {
        if (typeof Model === 'object') return params;
        return new Model(params);
  }
}

Answer 2

After encountering an issue where a default needed to be returned when a model was not provided, I successfully resolved the problem by implementing a solution involving a generic object. The key fixes included:

Transitioning from typing the model as the Constructable interface to utilizing a union type of Constructable<T> | object.
Adjusting the default parameter for the model to be passed in as an Object.
The buildModel() function now examines the type of the model - if it's an object, it returns the provided values; if it's a constructable, it generates a new instance.

Discover how this solution is implemented within the postAsync parameters, the ResponseModel interface, and the buildModel method found in requestAsync:

interface Constructable<T> { new(params : any): T ;}
type ResponseModel<T> = Constructable<T> | Object;

export default class WebapiBase {
  static async postAsync<T = Object>(
      {
          uri = '',
          body = {},
          headers = new CustomHeaders(),
      }: PostRequestParams = {},
      // Default implementation provided here
      model: ResponseModel<T> = Object): Promise<T> {
      return this.requestAsync(model, HTTP_METHOD.POST, uri, headers, body);
  }
  private static async requestAsync<T = Object>(
      // This parameter accepts either a class or object
      model: ResponseModel<T>,
      method: HTTP_METHOD,
      uri: string,
      headers: CustomHeaders,
      body?: object): Promise<T> {
      const url = new URL(uri, window.location.origin);
      const request = this.buildRequest(url, method, headers, body);
      const bodyResponse = await fetch(request)
          .then(response => this.validate(response, request.headers))
          .then(validResponse => this.extractBody(validResponse))
          // Class instance or object is returned here
          .then(extractedBody => this.buildModel(model, extractedBody))
          .catch((error) => { throw this.handleError(error); });
      return bodyResponse;
  }

  // Conditional method creating an instance of the specified model
  // or returning the provided object if no model is given
  private static buildModel<T = Object>(
        Model: ResponseModel<T>,
        params: any,
    ): T {
        if (typeof Model === 'object') return params;
        return new Model(params);
  }
}

Can a default value be assigned to a generic argument in Typescript?

Answer №1

Similar questions

Ionic 2 Media Plugin File Status with Ionic Native

What is the best way to organize class usage within other classes to prevent circular dependencies?

While using Angular CLI on GitLab CI, an error occurred indicating that the custom rule directory "codelyzer" could not be

When transmitting data from NodeJS, BackBlaze images may become corrupted

Exploring the capabilities of using the injectGlobal API from styled-components in a TypeScript

Tips for extracting the y-coordinate from a touch event using d3

Creating HTML elements dynamically based on the value of a prop within a React component

Angular, manipulating components through class references instead of creating or destroying them

Troubleshooting a 400 Bad Request Error when calling ValidateClientAuthentication in ASP.NET WebApi, even after using context.Validated()

Developing Your Own Local Variable in Angular with Custom Structural Directive ngForIn

Importing Angular Material modules

Zod: Establishing minimum and maximum values after converting a string to a numerical value

Transforming JavaScript into TypeScript within an Angular 4 component class

Activate the Keypress event to update the input value in React upon pressing the Enter

The Next.js build encountered an error - unable to locate function in next/script module

I encountered an issue while trying to implement a custom pipe using the built-in pipe

Issue: React child components cannot be objects (received: object with keys)

SonarLint versus SonarTS: A Comparison of Code Quality Tools

Issues persist with @typescript-eslint/no-unused-vars not functioning as expected

What could be causing my sinon test to time out instead of throwing an error?