TypeScript Abstract Class

abstract class AbstractBase {
    // Abstract property: defines type, but no initialization
    abstract identifier: string;

    // Abstract method: defines signature, but no body
    abstract executeAction(payload: string): boolean;

    // Concrete method: fully implemented, inherited by subclasses
    logAction(message: string): void {
        console.log(`[LOG]: ${message}`);
    }
}

abstract class DataProcessor<T> {
    constructor(protected processorName: string) {}

    // Must be implemented by derived classes
    abstract dataFormat: string;
    abstract process(data: T): void;

    // Inherited as-is
    getProcessorInfo(): string {
        return `Processor: ${this.processorName}, Format: ${this.dataFormat}`;
    }
}

class JSONProcessor extends DataProcessor<string> {
    // Fulfilling the abstract property contract
    dataFormat = "JSON";

    // Explicit constructor requires a call to super()
    constructor() {
        super("JSON_V1"); 
    }

    // Fulfilling the abstract method contract
    process(data: string): void {
        const parsed = JSON.parse(data);
        console.log(parsed);
    }
}

class XMLProcessor extends DataProcessor<string> {
    dataFormat = "XML";

    // Constructor omitted; TypeScript automatically calls the base constructor.
    // Instantiation requires passing the base constructor arguments.

    process(data: string): void {
        console.log(`<xml>${data}</xml>`);
    }
}

// const base = new DataProcessor<string>("Base"); // TS Error: Cannot create an instance of an abstract class.

const jsonProc = new JSONProcessor(); // Valid: constructor takes 0 arguments
jsonProc.process('{"key": "value"}');

const xmlProc = new XMLProcessor("XML_V1"); // Valid: inherits base constructor signature
xmlProc.process('data');