Using the appropriate parameters is key: TS2345: The argument of type 'T' cannot be assigned to a parameter of type 'new() => any'

Question

Using the appropriate parameters is key: TS2345: The argument of type 'T' cannot be assigned to a parameter of type 'new() => any'

Struggling with Typescript 2, I am attempting to create a universal parser-method for database objects. Utilizing TypedJSON, I am encountering difficulties in correctly organizing the parameters. Here is part of my code:

private static parseToInstance<T>(dbObject: string, model: T): T {
    try {
        console.log("parseToInstance()")
        let a = TypedJSON.stringify(dbObject);
        return TypedJSON.parse(a, new model, "whatever"
    } catch (err) {
        throw new ParseException(err);
    }
}

The method should receive input similar to:

/**
* Converts a JavaScript Object Notation (JSON) string into an instance of the provided class.
* @param text A valid JSON string.
* @param type A class from which an instance is created using the provided JSON string.
* @param settings Per-use serializer settings. Unspecified keys are assigned from global config.
*/
parse<T>(text: string, type: {new (): T;}, settings?: SerializerSettings): T;

An error I am encountering in my code is:

Error:(125, 30) TS2345:Argument of type 'T' is not assignable to parameter of type 'new () => {}'.

Despite attempting multiple solutions, I am unable to resolve this issue. Any assistance would be greatly appreciated.

typescript methods

Answer 1

Answer №1

By utilizing the {new (): T;} type annotation, you are signaling the presence of a constructor.

In order to accommodate this, adjustments need to be made in your parseToInstance function. Instead of simply model: T, it is necessary to specify the type as {new():T} to clearly identify it as a constructor. TypeScript's generics differ from other languages in that they do not always define classes explicitly, hence the need for this specificity. Additionally, avoid calling new on the model before passing it into the function, as this would defeat the purpose of utilizing a constructor function.

private static parseToInstance<T>(dbObject: string, model: {new():T}): T {
    try {
        console.log("parseToInstance()")
        let a = TypedJSON.stringify(dbObject);
        return TypedJSON.parse(a, model, "whatever");
    } catch (err) {
        throw new ParseException(err);
    }
}

p.s. There was a missing closing parenthesis in "parse," which has been rectified.

Answer 2

By utilizing the {new (): T;} type annotation, you are signaling the presence of a constructor.

In order to accommodate this, adjustments need to be made in your parseToInstance function. Instead of simply model: T, it is necessary to specify the type as {new():T} to clearly identify it as a constructor. TypeScript's generics differ from other languages in that they do not always define classes explicitly, hence the need for this specificity. Additionally, avoid calling new on the model before passing it into the function, as this would defeat the purpose of utilizing a constructor function.

private static parseToInstance<T>(dbObject: string, model: {new():T}): T {
    try {
        console.log("parseToInstance()")
        let a = TypedJSON.stringify(dbObject);
        return TypedJSON.parse(a, model, "whatever");
    } catch (err) {
        throw new ParseException(err);
    }
}

p.s. There was a missing closing parenthesis in "parse," which has been rectified.

Answer 3

Answer №2

Consider something along the lines of:

public static deserialize<T>(data: string, type: { new(): T }): T {
    ...
    return TypedJSON.parse(data, type, "custom");
}

There are two important modifications:

Use { new(): T } instead of just T
Pass the type instead of creating a new instance

Answer 4

Consider something along the lines of:

public static deserialize<T>(data: string, type: { new(): T }): T {
    ...
    return TypedJSON.parse(data, type, "custom");
}

There are two important modifications:

Use { new(): T } instead of just T
Pass the type instead of creating a new instance

Using the appropriate parameters is key: TS2345: The argument of type 'T' cannot be assigned to a parameter of type 'new() => any'

Answer №1

Answer №2

Similar questions

Setting up shortcuts for webpack using lerna and typescript

a helpful utility type for extracting a union from a constant array of strings

Identified the category

Tips for handling delayed HTTP API responses in Angular

Vue: Storing selected list values in an array

What is the TypeScript's alternative to ReasonML's option type?

`Developing reusable TypeScript code for both Node.js and Vue.js`

Guide to setting the order of rendering in React applications

Passing RxJs pipes as a parameter

Typescript enhances the functionality of the Express Request body

Creating a unique custom selector with TypeScript that supports both Nodelist and Element types

I was able to use the formGroup without any issues before, but now I'm encountering an error

Eliminate properties from a TypeScript interface object

I'm curious about the origins of the "readme" field within the artifact registry file

What types should be used when passing a NgRx Action as a parameter to a function?

The module 'three/examples/jsm/controls/OrbitControls' or its corresponding type declarations could not be located

Ways to utilize a field from an interface as a type of index

Encountering error TS2307 while using gulp-typescript with requirejs and configuring multiple path aliases and packages

What is the abbreviation for a 'nested' type within a class in TypeScript?

The received data object appears to be currently undefined