Bdtjtk

I have a base class ApiModel:

class ApiModel {

    static async fetch (params = {}, Model = this, apiPath = this.apiPath): Promise<any | PaginatedResponse> {

        let { data } = await axios.get(apiPath, { params })

        return Model.transformResponse(data)

    }

}

and models that inherit from it:

class User extends ApiModel {

}

Typescript does not like my return definition (any) in combination with the variable type User:

let users: User = await User.fetch() // Assigned expression type any | PaginatedResponse is not assignable to type User

How can I replace any without explicitly using User (it needs to be generic, based on extended class)

The error you are getting is not due to any vs User it due to the union with PaginatedResponse.

A union between any and PaginatedResponse and will not be assignable to User. You need to use a type-guard to distinguish between the array result and the PaginatedResponse

So this will work event with any (since any is assignable to any other type including User)

let result = await User.fetch()

if(result instanceof Array) {

    const user: User = result;

}else {

    const paged = result;

}

That being said, you should still avoid any (like the plague IMO, if you don't know the type prefer unknown (see here for unknown vs any))

To get the type of the current class in the static method you can use a generic type parameter in conjunction with the this parameter annotation.

The exact solution may vary on whether the class is abstract or not and on whether the constructor has parameters or not (and whether derived types have different parameter signatures or not).

The solution below works for non-abstract base class and if derived classes have the same constructor signature (or compatible) as the base class.

interface PaginatedResponse<T> {

    start: number;

    end: number;

    data: T

}

class ApiModel {

    static apiPath = ""

    static async fetch<T extends typeof ApiModel>(this: T, params = {}, Model = this, apiPath = this.apiPath): Promise<Array<InstanceType<T>> | PaginatedResponse<InstanceType<T>>> {

        return null!;

    }

}

class User extends ApiModel {

}



(async function (){

    let result = await User.fetch()

    if(result instanceof Array) {

        const user = result; // is User

    }else {

        const paged = result; // PaginatedResponse<User>

    }

})()

Note I filled in PaginatedResponse with an interface as I was not sure what that type looked like, if the type is under your control I would make it generic to reflect the returned result type.