How to fix Cannot make abstract member non-abstract in TypeScript

// Base abstract class
abstract class Animal {
  abstract makeSound(): void; // Must be implemented by concrete classes

  move(): void { // Concrete - has implementation
    console.log("Moving...");
  }
}

// ✅ CORRECT: Concrete class implements abstract member
class Dog extends Animal {
  makeSound(): void { // Implement abstract member
    console.log("Woof!");
  }
}

// ❌ WRONG: Cannot redeclare concrete member as abstract
abstract class IntermediateDog extends Animal {
  makeSound(): void { // This makes it concrete
    console.log("Generic dog sound");
  }
}

// This would cause issues:
abstract class SpecialDog extends IntermediateDog {
  abstract makeSound(): void; // ERROR: Cannot make non-abstract member abstract
}

// BEFORE: Error - abstract keyword on implementation
abstract class Shape {
  abstract calculateArea(): number;
}

abstract class Polygon extends Shape {
  abstract calculateArea(): number; // ERROR if calculateArea is implemented
}

// AFTER: Implement without abstract keyword
abstract class Shape {
  abstract calculateArea(): number;
}

abstract class Polygon extends Shape {
  // Option 1: Leave it abstract (don't declare it again)
  abstract getPerimeter(): number; // Add new abstract member
}

// Or implement it as concrete:
abstract class Polygon extends Shape {
  calculateArea(): number { // Concrete implementation
    return 0; // Default or actual implementation
  }
}

class Rectangle extends Polygon {
  width: number;
  height: number;

  constructor(width: number, height: number) {
    super();
    this.width = width;
    this.height = height;
  }

  calculateArea(): number { // Override with specific implementation
    return this.width * this.height;
  }
}

// PROBLEM: Trying to make a concrete member abstract again
abstract class Vehicle {
  start(): void { // Concrete implementation
    console.log("Starting vehicle...");
  }
}

abstract class Car extends Vehicle {
  // ❌ ERROR: Cannot redeclare concrete member as abstract
  abstract start(): void;
}

// SOLUTION 1: Remove the abstract redeclaration
abstract class Car extends Vehicle {
  // Don't redeclare it - inherit the concrete implementation
  // Or override it with a new concrete implementation:
  start(): void {
    console.log("Starting car...");
  }
}

// SOLUTION 2: If you need abstract behavior, use a different pattern
abstract class Vehicle {
  abstract start(): void; // Keep it abstract from the beginning
}

abstract class Car extends Vehicle {
  // Still abstract - child classes must implement
  abstract start(): void; // This is OK - maintaining abstraction
}

class Sedan extends Car {
  start(): void { // Final concrete implementation
    console.log("Sedan starting...");
  }
}

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

// ✅ CORRECT: Intermediate abstract class with partial implementation
abstract class RelationalDB extends Database {
  // Implement one abstract method
  override async connect(): Promise<void> {
    console.log("Establishing connection...");
  }

  // Leave query abstract for child classes
  // (Don't redeclare it - it stays abstract)
}

// Final concrete class
class PostgresDB extends RelationalDB {
  override async query(sql: string): Promise<any> {
    console.log(`Executing: ${sql}`);
    return [];
  }
}

// ❌ WRONG: Using abstract when implementing
abstract class RelationalDB extends Database {
  abstract async connect(): Promise<void> { // ERROR: abstract with implementation
    console.log("Establishing connection...");
  }
}

// BEFORE: Complex multi-level abstraction
abstract class Base {
  abstract method1(): void;
  abstract method2(): void;
}

abstract class Middle extends Base {
  abstract method1(): void; // Redundant - already abstract
  method2(): void { // Implemented here
    console.log("Method 2");
  }
}

abstract class AlmostConcrete extends Middle {
  method1(): void { // Implement method1
    console.log("Method 1");
  }
}

// AFTER: Simplified and clearer
abstract class Base {
  abstract method1(): void;
  abstract method2(): void;
}

// Skip unnecessary intermediate abstractions
class Concrete extends Base {
  method1(): void {
    console.log("Method 1");
  }

  method2(): void {
    console.log("Method 2");
  }
}

// Or use composition instead of deep inheritance
interface IMethod1 {
  method1(): void;
}

interface IMethod2 {
  method2(): void;
}

class Concrete implements IMethod1, IMethod2 {
  method1(): void {
    console.log("Method 1");
  }

  method2(): void {
    console.log("Method 2");
  }
}

// BEFORE: Abstract class just for contracts
abstract class Repository {
  abstract find(id: string): Promise<any>;
  abstract save(entity: any): Promise<void>;
  abstract delete(id: string): Promise<void>;
}

// Can lead to issues with multi-level abstractions

// AFTER: Interface for pure contracts
interface Repository {
  find(id: string): Promise<any>;
  save(entity: any): Promise<void>;
  delete(id: string): Promise<void>;
}

// Implement directly
class UserRepository implements Repository {
  async find(id: string): Promise<any> {
    return { id, name: "User" };
  }

  async save(entity: any): Promise<void> {
    console.log("Saving user");
  }

  async delete(id: string): Promise<void> {
    console.log("Deleting user");
  }
}

// Can implement multiple interfaces without inheritance complexity
interface Cacheable {
  clearCache(): void;
}

class CachedUserRepository implements Repository, Cacheable {
  async find(id: string): Promise<any> {
    return { id, name: "User" };
  }

  async save(entity: any): Promise<void> {
    console.log("Saving user");
  }

  async delete(id: string): Promise<void> {
    console.log("Deleting user");
  }

  clearCache(): void {
    console.log("Cache cleared");
  }
}