How to fix Cannot assign an abstract constructor type to a non-abstract constructor type in TypeScript

// Non-abstract - expects concrete class only
function createInstance(Ctor: new () => Animal) {
  return new Ctor(); // This calls the constructor directly
}

// ❌ This fails with error
abstract class AnimalBase {
  abstract sound: string;
}

const result = createInstance(AnimalBase); // ERROR: Cannot assign abstract constructor

// Abstract - accepts both abstract and concrete
function checkType(Ctor: abstract new () => Animal) {
  console.log(Ctor.name); // Just checks the constructor, doesn't call it
}

// ✅ This works with both
checkType(AnimalBase);  // Abstract class - OK
checkType(Dog);         // Concrete class - OK

// Before (fails with abstract classes)
function processClass(Ctor: new () => Base) {
  return Ctor.name;
}

// After (accepts both abstract and concrete)
function processClass(Ctor: abstract new () => Base) {
  return Ctor.name; // Now works with abstract classes
}

abstract class AnimalBase {
  abstract makeSound(): void;
}

class Dog extends AnimalBase {
  makeSound() { console.log("Woof"); }
}

processClass(AnimalBase); // ✅ Works
processClass(Dog);        // ✅ Works

// Define once, use everywhere
type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;
type Constructor<T = {}> = new (...args: any[]) => T;

// Function that needs abstract classes
function mixinClass<T extends Constructor>(Base: T) {
  return class extends Base {
    constructor(...args: any[]) {
      super(...args);
      console.log("Mixin applied");
    }
  };
}

// Function that just inspects classes
function getClassName(Ctor: AbstractConstructor) {
  return Ctor.name;
}

getClassName(SomeAbstractClass); // ✅ Works
getClassName(SomeConcreteClass);  // ✅ Works

// Type definition for service constructor
type ServiceConstructor = abstract new (...args: any[]) => any;

// Decorator that works with both abstract and concrete services
function Service(config: any) {
  return function <T extends ServiceConstructor>(constructor: T) {
    // Register service, metadata, etc.
    console.log(`Registered ${constructor.name}`);
    return constructor;
  };
}

// Now this works with abstract classes
@Service({ scope: "transient" })
abstract class BaseUserService {
  abstract getUser(id: string): Promise<User>;
}

// And concrete implementations
@Service({ scope: "transient" })
class UserService extends BaseUserService {
  getUser(id: string) {
    return Promise.resolve({ id, name: "John" });
  }
}

function registerClass(Ctor: new () => Base) {
  // ...
}

// Bypass the type checker
registerClass(AbstractClass as any);

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

function registerAbstractClass<T>(Ctor: AbstractConstructor<T>) {
  // Convert to expected type
  return registerClass(Ctor as any);
}

registerAbstractClass(MyAbstractClass); // ✅ Type-safe wrapper

type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;

// Higher-order function that wraps a class
function withLogging<T extends AbstractConstructor>(
  Base: T
): T {
  return class extends Base as any {
    constructor(...args: any[]) {
      super(...args);
      console.log(`${Base.name} instantiated`);
    }
  } as T;
}

// Abstract class to wrap
abstract class Repository {
  abstract find(id: string): any;
}

// Concrete implementation
class UserRepository extends Repository {
  find(id: string) {
    return { id, name: "User" };
  }
}

// Apply wrapper to both abstract and concrete
const WrappedAbstractRepo = withLogging(Repository);  // ✅ Works
const WrappedConcreteRepo = withLogging(UserRepository); // ✅ Works

tsc --version

# npm
npm install --save-dev typescript@latest

# yarn
yarn add -D typescript@latest

# pnpm
pnpm add -D typescript@latest