Yet another error: TS2511 - Unable to instantiate an abstract class

Question

Yet another error: TS2511 - Unable to instantiate an abstract class

My issue is very similar to the one mentioned in this thread: Typescript: instance of an abstract class, however, there are some distinctions. If it is indeed a duplicate problem, I would appreciate a clear explanation as I am currently unable to resolve this issue.

I have a Base class:

export abstract class MyBaseClass {
   private thing: Thing;

   constructor(thing: Thing) {
      this.thing = thing;
   }
}

export type MyBaseClassType = typeof MyBaseClass;
export interface IMyBaseClass extends MyBaseClassType {};

The challenge arises because MyBaseClass is part of a library that I am releasing. Users of this library will create a class derived from MyBaseClass, and the library will serve as an executable solution. They should be able to run their code simply by using the following command:

node our-provided-bin run -b /path/to/client-class-extending-base-class

Within that script, we execute:

const ImportedClassRef: IMyBaseClass = require(resolvedPath);

This ImportedClassRef variable undergoes several methods before we reach the point where we attempt to instantiate it with:

const dude = new ImportedClassRef(thing);

However, I encounter the error message:

TS2511: Cannot create an instance of an abstract class.

typescript

Answer 1

Answer №1

Interfaces are simply descriptions of structures and not new named classes.

interface A {
  arg1: string;
}

interface B {
  arg1: string
}

// A and B are essentially the same
let a: A = {arg1: ""};
let b: B = a;

Therefore:

export type MyBaseClassType = typeof MyBaseClass;
export interface IMyBaseClass extends MyBaseClassType {};

is exactly equal to:

type IMyBaseClass = typeof MyBaseClass;

and so your issue is essentially the same as in the question you mentioned.

I am unsure about the type of Thing, but assuming it's a fixed type, I would define it like this:

type Thing = Record<string, any>;

abstract class MyBaseClass {
   constructor( private thing: Thing) {}
}

type InstantiableClass<T extends MyBaseClass> = {
  new(thing: Thing): T
}

class RealClass extends MyBaseClass {} // require(resolvedPath);

const importedClassRef: InstantiableClass<MyBaseClass> = RealClass;

new importedClassRef({}) // no error;

Update: Why does this work?

Abstract classes have a special constructor (playground):

type AbstractConstructor = abstract new(...args: any[]) => any;

const AbstractClass: AbstractConstructor = {} as any;

new AbstractClass() // Error: Cannot create an instance of an abstract class

This constructor is not callable unless called from a derived class. To overcome this, the type InstantiableClass defines a regular constructor that simply returns an instance of T extends MyBaseClass.

type InstantiableClass<T extends MyBaseClass> = {
  /* no abstract */ new(thing: Thing): T
}

Thus, this approach works because it mimics the structure of typeof MyBaseClass while defining a normal constructor instead of an abstract one.

Answer 2

Interfaces are simply descriptions of structures and not new named classes.

interface A {
  arg1: string;
}

interface B {
  arg1: string
}

// A and B are essentially the same
let a: A = {arg1: ""};
let b: B = a;

Therefore:

export type MyBaseClassType = typeof MyBaseClass;
export interface IMyBaseClass extends MyBaseClassType {};

is exactly equal to:

type IMyBaseClass = typeof MyBaseClass;

and so your issue is essentially the same as in the question you mentioned.

I am unsure about the type of Thing, but assuming it's a fixed type, I would define it like this:

type Thing = Record<string, any>;

abstract class MyBaseClass {
   constructor( private thing: Thing) {}
}

type InstantiableClass<T extends MyBaseClass> = {
  new(thing: Thing): T
}

class RealClass extends MyBaseClass {} // require(resolvedPath);

const importedClassRef: InstantiableClass<MyBaseClass> = RealClass;

new importedClassRef({}) // no error;

Update: Why does this work?

Abstract classes have a special constructor (playground):

type AbstractConstructor = abstract new(...args: any[]) => any;

const AbstractClass: AbstractConstructor = {} as any;

new AbstractClass() // Error: Cannot create an instance of an abstract class

This constructor is not callable unless called from a derived class. To overcome this, the type InstantiableClass defines a regular constructor that simply returns an instance of T extends MyBaseClass.

type InstantiableClass<T extends MyBaseClass> = {
  /* no abstract */ new(thing: Thing): T
}

Thus, this approach works because it mimics the structure of typeof MyBaseClass while defining a normal constructor instead of an abstract one.

Answer 3

Answer №2

Within a specific class that requires ImportedClassRef as an argument, I structured the properties in this manner:

interface IProps {
   ...
   ImportedClassRef: MyBaseClass | any;
}

export SomeRunnerClass {
    private dude: MyBaseClass;

    constructor({..., ImportedClassRef}:IProps) {
        ...
        this.dude = new ImportedClassRef(thing);
    }
}

Although adding | any solved the issue, it should not be considered a permanent solution. Refer to the feedback provided by semisecure.

Answer 4

Within a specific class that requires ImportedClassRef as an argument, I structured the properties in this manner:

interface IProps {
   ...
   ImportedClassRef: MyBaseClass | any;
}

export SomeRunnerClass {
    private dude: MyBaseClass;

    constructor({..., ImportedClassRef}:IProps) {
        ...
        this.dude = new ImportedClassRef(thing);
    }
}

Although adding | any solved the issue, it should not be considered a permanent solution. Refer to the feedback provided by semisecure.

Yet another error: TS2511 - Unable to instantiate an abstract class

Answer №1

Answer №2

Similar questions

Troubleshooting Issue with Mongoose Virtual Field Population

What causes a Typescript error when attempting to escape a newline character?

When trying to save a child entity, TypeORM's lazy loading feature fails to update

DiscoverField Component with Button Functionality and Checkbox Dilemma

Discover the most effective method for identifying duplicate items within an array

Concealing the Submit Button During Server Processing (Issues with Binding?)

"Encountered a TypeScript error (2345) when using customElements.define() in Lit 2

This property cannot be found on the specified type

What is the role of the "prepare" function in AWS CDK constructs?

Utilizing Next.js and React to interact with Open AI through API requests

Customize the theme type with @mui/system

What is the process for exporting a plugin from dayjs() in JavaScript?

Using `querySelector` in TypeScript with Vue 3

reading an array of objects using typescript

Is there a method to initiate a 'simple' action when dispatching an action in ngrx?

Is it possible to add new values to a GraphQL query?

react-data-table-component establishes the structure of the expanded element

What is the most effective method to retrieve the current browser URL in Angular 2 with TypeScript?

Tips on excluding node_modules from typescript in Next.js 13

Adding an image to a Select Option label in React: A simple guide