Obtain access to the interface from the base class

Question

Obtain access to the interface from the base class

I am looking for a way to define an interface in a child class that can be accessed by a method in the parent abstract class.

For instance, consider the following code snippet:

export default abstract class MyClass {
    protected foo(arg: this.myInterface): any {
        //
    }
}

export default class FooClass extends MyClass {
    protected myInterface: DataInterface;
}

In this example, the DataInterface interface should be accessible through the foo method in the MyClass abstract class. Is this achievable? If not, what would be the alternative approach?

-- EDIT

Just to provide some context, the Abstract Class I am working with is named BaseService, and I am planning on creating services that inherit from it.

These services will utilize multiple interfaces, and it is crucial for me to be able to access these interfaces from the BaseService to ensure the correct data structure is being used.

The data structures I need to validate are related to attributes for a table in a SQL Server database, which means they could vary widely.

For example:

export interface IVehicleData {
    vehicle_id?: number;
    vehicle_name?: string;
    vehicle_created_at?: Date;
    vehicle_updated_at?: Date;
  }

In different classes, I might have different interfaces with unique attributes. Additionally, there could be several interfaces utilized, not restricted to just one.

typescript

Answer 1

Answer №1

Your explanation is somewhat unclear as the property myInterface in FooClass will represent an object that satisfies the interface, not the interface itself.

Nevertheless, this design pattern is acceptable. The abstract class must acknowledge the presence of a myInterface property. Presumably, there exists a common base interface to facilitate performing similar actions across multiple interfaces with different implementations?

You can make use of generic classes to ensure each class is aware of its specific interface type. By requiring all classes to extend a shared base, the abstract class can handle functions dependent on the base type while allowing child classes to implement behavior unique to their interface.

Note: I have revamped the code so it no longer relies on a shared BaseInterface. Instead, the base class mandates that its children implement certain methods or possess specific properties, thereby enhancing the utility of the base class.


abstract class MyClass<T> {
    protected rawData: T;

    constructor(myInterface: T) {
        this.rawData = myInterface;
    }

    protected foo(arg: T): any {
        //
    }

    abstract getId(): number;

    protected doSomethingWithId(): any {
        // the base class can utilize the id without needing to know how getId is implemented
        const id = this.getId();
    }
}

class VehicleClass extends MyClass<IVehicleData> {

    public okMethod(arg: IVehicleData) {
        this.foo(arg);
    }

    public badMethod(arg: {}) {
        this.foo(arg);  // throws an error since this.foo only accepts the current class's type
    }

    public getId(): number {
        // methods can be specifically implemented based on the data type being used
        return this.rawData.vehicle_id || -1;
    }
}

New Playground Link

Old Playground Link

Answer 2

Your explanation is somewhat unclear as the property myInterface in FooClass will represent an object that satisfies the interface, not the interface itself.

Nevertheless, this design pattern is acceptable. The abstract class must acknowledge the presence of a myInterface property. Presumably, there exists a common base interface to facilitate performing similar actions across multiple interfaces with different implementations?

You can make use of generic classes to ensure each class is aware of its specific interface type. By requiring all classes to extend a shared base, the abstract class can handle functions dependent on the base type while allowing child classes to implement behavior unique to their interface.

Note: I have revamped the code so it no longer relies on a shared BaseInterface. Instead, the base class mandates that its children implement certain methods or possess specific properties, thereby enhancing the utility of the base class.


abstract class MyClass<T> {
    protected rawData: T;

    constructor(myInterface: T) {
        this.rawData = myInterface;
    }

    protected foo(arg: T): any {
        //
    }

    abstract getId(): number;

    protected doSomethingWithId(): any {
        // the base class can utilize the id without needing to know how getId is implemented
        const id = this.getId();
    }
}

class VehicleClass extends MyClass<IVehicleData> {

    public okMethod(arg: IVehicleData) {
        this.foo(arg);
    }

    public badMethod(arg: {}) {
        this.foo(arg);  // throws an error since this.foo only accepts the current class's type
    }

    public getId(): number {
        // methods can be specifically implemented based on the data type being used
        return this.rawData.vehicle_id || -1;
    }
}

New Playground Link

Old Playground Link

Obtain access to the interface from the base class

Answer №1

Similar questions

An issue has occurred: The module named 'ApprovalModule' must be compiled using the JIT compiler, however, the necessary compiler '@angular/compiler' is not currently accessible

Tips for retrieving input values when they are not available in HTML documents

Classifying Union Types based on their distinct characteristics

Manage both the return of an observable and the setting of a value within a single method using

Is there a way to verify if the object's ID within an array matches?

What is the best way to implement a Promise Function within a For loop?

Unleash the power of zod by seamlessly accessing both parameters and queries

Tips for sending arguments to translations

Swap out the traditional for loop with a LINQ query utilizing the any method

The expansion feature of PrimeNG Turbotable

Encountering a "ReferenceError: global is not defined" in Angular 8 while attempting to establish a connection between my client application and Ethereum blockchain

Encountering the error "Unable to access the 'user' property of an undefined object when working with Angular and Firebase

Guide to easily printing a page in Angular 4 using TypeScript

Backdrop styling for Material-UI dialogs/modals

Utilize Angular 9 to fetch data from an API using the Get method, map them to a class, and

Function parameter constrained to a specific property of a generic type T

What steps can I take to have TypeScript limit the type of an array based on filter inference?

How to resolve useState problem in useEffect when state is not null

The issue of broken reactivity arises when utilizing defineStore in Pinia with options instead of storeSetup

Angular 14: Enhance Your User Experience with Dynamic Angular Material Table Row Management