Designate as a customizable class property

Question

Designate as a customizable class property

I'm struggling to create a versatile inheritance class for my services. Currently, I have two service classes named Service_A and Service_B that essentially do the same thing. However, Service_A works with Class_A while Service_B works with Class_B. The only difference between them is the type they work with.

My goal is to consolidate the code into a more generic class (EntityService) that both Service_A and Service_B can inherit from. This way, I can write the code once and reuse it without having to override all methods or specify types in each method call.

Here's how EntityService looks like:

declare class Observable<T> { x: T }

declare class Actor {
    doStuff<T>(anything: T): T[];
    getData<I>(): I;
    getObservable<U, I>(data: I): Observable<U[]>;
}

interface Entity {
    param_1: number,
    param_2: number,
}

class EntityObj {
    id: string;
    param_1: number;
    param_2: number;

    constructor(id: string, param_1: number, param_2: number) {
        this.id = id;
        this.param_1 = param_1;
        this.param_2 = param_2;
    }

    static fromInterface(entity: Entity, id: string): EntityObj {
            return new this(id, entity.param_1, entity.param_2);
    }
}

export class EntityService {

    /* Desired functionality:
     * static classTypeAlias: EntityObj;
     * static interfaceTypeAlias: Entity;
     */

    constructor(private readonly actor: Actor) {}

    getEntityObjs(): Observable<EntityObj[]> | null {
        let data: Entity = this.actor.getData()
        let entityObjs: Observable<EntityObj[]> = this.actor.getObservable<EntityObj, Entity>(data);
        return entityObjs;
    }

    getObjFromInterface(): EntityObj {
        let entityObj: EntityObj = EntityObj.fromInterface(this.actor.getData(), "foo");
        return entityObj;
    }

    update(entity: EntityObj): void { let entityDoc = this.actor.doStuff<Entity>(entity); }
}

I want Service_A to be able to use methods like update() with a parameter of type "Class_A" implicitly, and getEntityObjs() to return something of type "Observable<Class_A[]> | null" implicitly as well.

I tried exploring generic types but couldn't figure out how to avoid extending them from EntityObj when accessing properties or using their values associated with the class (like

class EntityService<classType, interfaceType> {...}

) to define argument/return types.

If you have any advice or suggestions on how to solve this issue using proper techniques, please share them. Your help would be greatly appreciated!

typescript generics types

Answer 1

Answer №1

If you wish to parameterize subclasses of EntityService with different types for classTypeAlias and interfaceTypeAlias, the simplest way is to make EntityClass generic in type parameters corresponding to these types, denoted as C and I:

export class EntityService<C, I> {
  ⋯
}

To achieve this, replace every instance of EntityObj with C and Entity with I within EntityService:

export class EntityService<C, I> {

  constructor(private readonly actor: Actor) { }

  getEntityObjs(): Observable<C[]> | null {
    let data: I = this.actor.getData()
    let entityObjs: Observable<C[]> = this.actor.getObservable<C, I>(data);
    return entityObjs;
  }

  getObjFromInterface(): C {
    let entityObj: C = C.fromInterface(this.actor.getData(), "foo"); // error
    return entityObj;
  }

  update(entity: C): void {
    let entityDoc = this.actor.doStuff<I>(entity); // error
  }

}

There are two errors to fix.

The first error occurs because we call doStuff<I>(entity) but pass an entity of type C. To address this, either constrain C to extend

I</code, modify the call to be <code>doStuff<C>(entity)

.

update(entity: C): void {
  let entityDoc = this.actor.doStuff<C>(entity); // okay
}

The second error arises from replacing EntityObj the class constructor with C which is a type. To resolve this, EntityService needs access to a class constructor value of the appropriate type. This requires passing such an object when constructing instances of EntityService:

export class EntityService<C, I> {

  constructor(
    private readonly actor: Actor,
    public ctor: { fromInterface(e: I, id: string): C } // add it
  ) { }

  getEntityObjs(): Observable<C[]> | null {
    let data: I = this.actor.getData<I>()
    let entityObjs: Observable<C[]> = this.actor.getObservable<C, I>(data);
    return entityObjs;
  }

  getObjFromInterface(): C {
    let entityObj: C = this.ctor.fromInterface(this.actor.getData(), "foo");
    return entityObj;
  }

  update(entity: C): void { let entityDoc = this.actor.doStuff<C>(entity); }
}

Now that it's compiling, subclass with specific C and I type arguments and provide the ctor during construction:

class MainEntityService extends EntityService<EntityObj, Entity> {
  constructor(actor: Actor) {
    super(actor, EntityObj);
  }
}

Use it like this:

new MainEntityService(new Actor()).getEntityObjs()
// Observable<EntityObj[]> | null

Another example subclass:

interface Foo {
  a: string;
  b: number;
}

class Bar implements Foo {
  ...
}

class SomeOtherThing extends EntityService<Bar, Foo> {
  constructor(actor: Actor) { super(actor, Bar) }
}
new SomeOtherThing(new Actor()).getEntityObjs()
// Observable<Bar[]> | null

This method works, though there are alternative approaches depending on your requirements.

Playground link to code

Answer 2

If you wish to parameterize subclasses of EntityService with different types for classTypeAlias and interfaceTypeAlias, the simplest way is to make EntityClass generic in type parameters corresponding to these types, denoted as C and I:

export class EntityService<C, I> {
  ⋯
}

To achieve this, replace every instance of EntityObj with C and Entity with I within EntityService:

export class EntityService<C, I> {

  constructor(private readonly actor: Actor) { }

  getEntityObjs(): Observable<C[]> | null {
    let data: I = this.actor.getData()
    let entityObjs: Observable<C[]> = this.actor.getObservable<C, I>(data);
    return entityObjs;
  }

  getObjFromInterface(): C {
    let entityObj: C = C.fromInterface(this.actor.getData(), "foo"); // error
    return entityObj;
  }

  update(entity: C): void {
    let entityDoc = this.actor.doStuff<I>(entity); // error
  }

}

There are two errors to fix.

The first error occurs because we call doStuff<I>(entity) but pass an entity of type C. To address this, either constrain C to extend

I</code, modify the call to be <code>doStuff<C>(entity)

.

update(entity: C): void {
  let entityDoc = this.actor.doStuff<C>(entity); // okay
}

The second error arises from replacing EntityObj the class constructor with C which is a type. To resolve this, EntityService needs access to a class constructor value of the appropriate type. This requires passing such an object when constructing instances of EntityService:

export class EntityService<C, I> {

  constructor(
    private readonly actor: Actor,
    public ctor: { fromInterface(e: I, id: string): C } // add it
  ) { }

  getEntityObjs(): Observable<C[]> | null {
    let data: I = this.actor.getData<I>()
    let entityObjs: Observable<C[]> = this.actor.getObservable<C, I>(data);
    return entityObjs;
  }

  getObjFromInterface(): C {
    let entityObj: C = this.ctor.fromInterface(this.actor.getData(), "foo");
    return entityObj;
  }

  update(entity: C): void { let entityDoc = this.actor.doStuff<C>(entity); }
}

Now that it's compiling, subclass with specific C and I type arguments and provide the ctor during construction:

class MainEntityService extends EntityService<EntityObj, Entity> {
  constructor(actor: Actor) {
    super(actor, EntityObj);
  }
}

Use it like this:

new MainEntityService(new Actor()).getEntityObjs()
// Observable<EntityObj[]> | null

Another example subclass:

interface Foo {
  a: string;
  b: number;
}

class Bar implements Foo {
  ...
}

class SomeOtherThing extends EntityService<Bar, Foo> {
  constructor(actor: Actor) { super(actor, Bar) }
}
new SomeOtherThing(new Actor()).getEntityObjs()
// Observable<Bar[]> | null

This method works, though there are alternative approaches depending on your requirements.

Playground link to code

Designate as a customizable class property

Answer №1

Similar questions

I'm having trouble importing sqlite3 and knex-js into my Electron React application

Excluding properties based on type in Typescript using the Omit or Exclude utility types

Whenever I attempt to host my Node.js app using the GCP deploy command, it fails to work properly. The error message that appears states: "Module 'express' cannot be found."

Issues may arise in TypeScript when you are working with an array of objects along with other properties within a type

The issue encountered in Cocos Creator 3.8 is the error message "FBInstant games SDK throws an error stating 'FBInstant' name cannot be found.ts(2304)"

Issue with FormControlLabel not properly implementing disableCloseOnSelect in Material UI v5 Autocomplete

Differences between ng build --prod and ng --build aot in Angular 7

atom-typescript encounters difficulty locating typings

Guide on importing videojs-offset library

A step-by-step guide on incorporating a .env file into a React JS project that is written with TypeScript

Can you share the appropriate tsconfig.json configuration for a service worker implementation?

No response from NgClass after executing the function

Encountering a type error in Typescript when assigning a transition component to a Material UI Snackbar

Unable to modify the value of a key within an object using TypeScript

Having trouble opening a JPEG file that was generated using the Writefile Api in Ionic-Cordova

How do I make functions from a specific namespace in a handwritten d.ts file accessible at the module root level?

Angular Service singleton constructor being invoked multiple times

In what way can a piped operator in rxjs be influenced by the value returned by a subsequent operator?

Tips for configuring identical libraries under different names

Ensure that the interface limits the key value to match precisely the value of a constant in Typescript