How to fix Cannot create an instance of an abstract class in TypeScript

// WRONG - Direct instantiation of abstract class
abstract class Animal {
  abstract makeSound(): void;

  move(): void {
    console.log("Moving...");
  }
}

const animal = new Animal(); // ❌ Error TS2511

// CORRECT - Create concrete subclass
abstract class Animal {
  abstract makeSound(): void;

  move(): void {
    console.log("Moving...");
  }
}

class Dog extends Animal {
  makeSound(): void {
    console.log("Woof!");
  }
}

const dog = new Dog(); // ✅ Works!
dog.makeSound(); // "Woof!"
dog.move();      // "Moving..."

abstract class ViewModel {
  abstract id: string;
  abstract getData(): Promise<unknown>;
  abstract render(): void;

  // Concrete method (has implementation)
  log(): void {
    console.log(`ViewModel ${this.id}`);
  }
}

// WRONG - Missing implementations
class UserViewModel extends ViewModel {
  id = "user-vm";
  // ❌ Error: Class 'UserViewModel' must implement getData() and render()
}

// CORRECT - All abstract members implemented
class UserViewModel extends ViewModel {
  id = "user-vm";

  async getData(): Promise<unknown> {
    return { name: "John", age: 30 };
  }

  render(): void {
    console.log("Rendering user view...");
  }
}

const userVm = new UserViewModel(); // ✅ Works!

abstract class Shape {
  abstract area(): number;
  abstract perimeter(): number;
}

class Circle extends Shape {
  constructor(private radius: number) {
    super();
  }

  area(): number {
    return Math.PI * this.radius ** 2;
  }

  perimeter(): number {
    return 2 * Math.PI * this.radius;
  }
}

class Rectangle extends Shape {
  constructor(private width: number, private height: number) {
    super();
  }

  area(): number {
    return this.width * this.height;
  }

  perimeter(): number {
    return 2 * (this.width + this.height);
  }
}

// Use abstract class as TYPE
function calculateArea(shape: Shape): number {
  return shape.area();
}

// But instantiate concrete classes
const circle = new Circle(5);
const rectangle = new Rectangle(4, 6);

console.log(calculateArea(circle));    // ✅ Works
console.log(calculateArea(rectangle)); // ✅ Works

// Before: abstract class
abstract class BaseController {
  abstract handle(): void;
}

// const controller = new BaseController(); // ❌ Error

// After: concrete class
class BaseController {
  handle(): void {
    console.log("Default handler");
  }
}

const controller = new BaseController(); // ✅ Works!

abstract class DatabaseService {
  abstract connect(): Promise<void>;
  abstract query(sql: string): Promise<unknown>;
}

class PostgresService extends DatabaseService {
  async connect(): Promise<void> {
    console.log("Connecting to PostgreSQL...");
  }

  async query(sql: string): Promise<unknown> {
    console.log(`Executing: ${sql}`);
    return [];
  }
}

// WRONG - Trying to inject abstract class
// const db = container.resolve(DatabaseService); // ❌ Can't instantiate

// CORRECT - Register and inject concrete class
class MyApp {
  constructor(private db: DatabaseService) {}

  async start() {
    await this.db.connect();
  }
}

// In DI container setup:
// container.register(DatabaseService, { useClass: PostgresService });
// OR manually:
const app = new MyApp(new PostgresService()); // ✅ Works