angular - ¿Mi servicio puede extender una clase abstracta? ¿Debería mi clase abstracta ser @Injectable?

Tengo el siguiente código:

import { Injectable } from "@angular/core";

@Injectable()
export abstract class ClientCacheService {
    private subscriptionId: string;
    protected getId(key :string, prefix:string=""): string {
        return `${this.subscriptionId}_${prefix}_${key}`;
    }

    constructor(subscriptionId: string) {
        this.subscriptionId = subscriptionId;
    }

    abstract setCache(key :string, prefix:string, object: any): void;
    abstract getCache(key :string, prefix:string): void;
    abstract removeCache(key :string, prefix:string): any;
}


import { ClientCacheService } from "./client-cache.service";
import { Injectable } from "@angular/core";

@Injectable()
export class SessionCacheService extends ClientCacheService {
    constructor() {
        super("TEST");
    }
    setCache(key: string, prefix: string, object: any): void {
        window.sessionStorage.setItem(this.getId(key, prefix), JSON.stringify(object));
    }    
    getCache(key: string, prefix: string): void | null {
        let res = window.sessionStorage.getItem(this.getId(key, prefix));
        return res ? JSON.parse(res) : null;
    }
    removeCache(key: string, prefix: string) {
        window.sessionStorage.removeItem(this.getId(key, prefix));
    }
}

Estoy recibiendo el siguiente error cuando compilo en modo producción (ng build --prod --output-hashing none --aot false):

No se pueden resolver todos los parámetros para e

Tengo dos preguntas sobre este código:

• ¿Puede mi SessionCacheService extender una clase abstracta?
• ¿Esta clase abstracta debería ser @Injectable() o no?

Respuesta #1

1. Sí, su implementación concreta de la clase de servicio puede extender la clase abstracta
2. No, la clase base no necesita (de hecho, no debería estar) anotada

Con respecto al punto 2, ¿solo considera qué significa @Injectable para Angular? Es una señal para el inyector jerárquico, que esta clase puede ser inyectada en otra clase mediante inyecciones de dependencia. ¿Qué se inyecta? La instancia de la clase. ¿Pueden instanciarse las clases abstractas? No realmente :)

El problema que estás obteniendo al compilar para --prod está relacionado con la eliminación de código muerto y el tree shaking, supongo, donde todas las instancias de @Injectable son rastreadas por referencias para verificar si realmente son necesarias en alguna llamada jerárquica.