Resolver Inheritance w/Dependency Injection

[rtnolan]

Hi there,

I'm trying to find the best way to be able to re-use a resolver for two sub-classes while also using dependency injection. I have the following superclass and sub-classes:

@ObjectType({ isAbstract: true })
export abstract class Portfolio {
    @Field(() => String)
    id: string;

    @Field(() => String)
    name: string;

    @Field(() => Date)
    createdOn: Date;

    @Field(() => String)
    userId: string;

    @Field(() => String)
    strategyId: string;

    @Field(() => Boolean)
    closed: boolean;

    @Field(() => Date)
    closedOn: Date;

    @Field(() => [Position])
    Positions: Position[];
}

@ObjectType()
export class PortfolioTypeA extends Portfolio {
    @Field(() => Schedule)
    Schedule: Schedule;
}

@ObjectType()
export class PortfolioTypeB extends Portfolio {
    @Field(() => Date, { nullable: true })
    dateToRecalculateFrom?: Date;

    @Field(() => Boolean, { nullable: true })
    integrated?: boolean;

    @Field(() => [PortfolioPeriod])
    PortfolioPeriods: PortfolioPeriod[];
}

I'm using tsyringe for DI and normally I'd create the Resolver to be something like:

@injectable()
@Resolver(() => Portfolio)
export class BasePortfolioResolver {
    constructor(@inject(PortfolioService) private service: PortfolioService) {}

    @Extensions({ permissions: { operation: "view", resource: "portfolio" } })
    @PermissionHandler(and(isAuthenticated, isOwnerOrAdmin("portfolio")))
    @Query((returns) => PortfolioUnionType)
    async viewPortfolio(@Arg("id") id: string): Promise<typeof PortfolioUnionType> {
        return await this.service.viewPortfolio(id);
    }
}

Instead of having all Queries/Mutations/Field Resolvers in the same file for both sub-classes I wanted to split them out and have a resolver for each sub-class. I've tried following along with the example of creating a base resolver here but I'm running into an issue where my call to my service just results in Can't call "viewPortfolio" of undefined error which leads me to believe that the service just isn't being injected properly. I attempted the following:

export function createBasePortfolioResolver<T extends ClassType>(suffix: string, ObjectTypeCls: T) {
    @injectable() // <--- tsyringe doesn't like this as the class is abstract.
    @Resolver({ isAbstract: true })
    abstract class BasePortfolioResolver {
        constructor(@inject(PortfolioService) private service: PortfolioService) {}

        @Extensions({ permissions: { operation: "view", resource: "portfolio" } })
        @PermissionHandler(and(isAuthenticated, isOwnerOrAdmin("portfolio")))
        @Query((returns) => PortfolioUnionType)
        async viewPortfolio(@Arg("id") id: string): Promise<typeof PortfolioUnionType> {
            console.log("service ", this.service);
            return await this.service.viewPortfolio(id);
        }
    }
    return BasePortfolioResolver;
}

// portfolioAResolver.ts
const PortfolioAResolver = createBasePortfolioResolver("portfolio", Portfolio);

// portfolioBResolver.ts
const PortfolioBResolver = createBasePortfolioResolver("portfolio", Portfolio);

Is there a way I could possibly make this work? Any help would be greatly appreciated.