Maintaining Type safety Across Abstract Class instances

Question

I need help ensuring typesafety across the following generic abstract class, that uses a proxy:

proxy.ts

function authHandler<
  F extends Families,
  T extends controllerAbstract<F>
>(): any {
  return {
    get: function (target: T, prop: keyof T): any {
      return (...args: any[]) => {
        target.authorize((controllerClient: Client<F>) => {
            
          return target[prop](controllerClient, args);
        });
      };
    },
  };
}

controllerAbstract.ts

abstract class controllerAbstract<F extends Families> {
  controllerFamily: F;

  constructor(controllerFamily: F) {
    this.controllerFamily = controllerFamily;
    return new Proxy(this, authHandler<F, typeof this>());
  }

  abstract build_client(): Client<F>;
   
  authorize(consume_client: (client: Client<F>) => typeof this[keyof typeof this]) {
    consume_client(this.build_client());
  }
}

concrete.ts

const controllerFamilyName = 'FamilyA';
type ControllerFamliy = typeof controllerFamilyName;

class FamilyAController extends controllerAbstract<ControllerFamliy> {
  constructor() {
    super(controllerFamilyName);
}

  build_client(): Client<ControllerFamliy> {
    // build a client of type "FamilyA"
    const client = { id: 'A' } as Client<ControllerFamliy>;
    return client; 
  }

  // proxy "authorize" provides client object
  useClient(client: any, args: any[]) {
    // i want client to implicitly be of type "FamilyAClient_t" / Client<"FamilyA">
    // currently just using "any" as placeholder
  }
}

types.ts

type FamilyAClient_t = { id: 'A' };

type FamilyBClient_t = { id: 'B' };

interface ClientTable {
  FamilyA: FamilyAClient_t;
  FamilyB: FamilyBClient_t;
}

type Families = keyof ClientTable;

type Client<F extends Families> = ClientTable[F];

N.B where i say "concrete" class, i mean the contents of concrete.ts, i.e. that being a class extending the abstract class, with FamilyAController just being an example of this.

My goal is to make the client parameter of the useClient method in FamilyAController of concrete.ts to reflect the correct type based on the concrete class's controllerFamilyName const, such that i can call client.id, and i get the correct autocomplete of "A" if controllerFamilyName == 'FamilyA', and "B" if controllerFamilyName == 'FamilyB'.

I have changed the explicit types in the proxy to try and get the types to be recognized as i need, based on the solution here. This is where i think the type safety breaks down in my implementation.

However, still this is erroneous, as:

• the proxy target[prop](...) line is giving an error of "this expression is not callable", as target[prop] is of type unknown. This is because not every prop of target is indeed callable, but some are, and i want to be able to restrict the type of target to this subset.
• my attempt at defining a return type for the consume_client function argument of the abstract class authorize method: authorize(consume_client: (client: Client<F>) => typeof this[keyof typeof this]) . is throwing error. The intention is for it to return the type any method return type defined in concrete. For example, if another method existed on the concrete class, then the consume client return type should be able to automatically handle this new method return type. Hopefully you can see what my intention was here - to effectively "see through" the proxy layer to maintain the same return type that would exist based on any callable method of the concrete class.

Another trialed method was to define another abstract class containing just the abstract methods which are consistent with target[props](controllerClient) signature, and use the keyof this class as the props type, to fix thefirst error. This was successful, but i am still unsure how to reach my final goal.

Essentially what i want is, in concrete.ts , to be able to write useClient(client) and the client type be implicitly Client<ControllerFamily> so i don't have to write useClient(client: Client<ControllerFamily>) for each method of each concrete class variation. Is this possible?

Hopefully this helps to clarify my objective with the code, and the current state of my progress with it.

Answer 1

Unfortunately TypeScript cannot currently give class method parameters "implicit" or "contextual" types inherited from superclasses. You are required to manually annotate all method parameters, and these can then be checked against the superclass, so you'll get an error if you do it wrong. But you still have to do it manually. This is definitely annoying. There have been numerous feature requests to improve it (see microsoft/TypeScript#23911 for example), but none of these have made it into the language. There always seems to be a problem with performance, or breaking real world code. For now, the best you can do will be to manually annotate.

---

That being said, the closest I can get to what you want is to try to tell the compiler what ControllerAbstract actually does... which is that any added method must take two arguments, the first is of type Client<F> for the relevant generic type argument F.

I say "try" to tell because there's no perfect way to do this. No direct support exists to describe "all strings except for the known keys", so there's no way to say "any property on ControllerAbstract<F> except for "controllerFamily", "buildClient", and "authorize"". There's a longstanding open feature request for this at microsoft/TypeScript#17867 but who knows when or if it will be implemented. For now there are only workarounds (see How to define Typescript type as a dictionary of strings but with one numeric "id" property for a list of these).

One such workaround is to intersect the known part of the object with an index signature for the "everything else" part. Like this:

abstract class _ControllerAbstract<F extends Families> {
  // ✂ snip ✂
}

type ControllerAbstract<F extends Families> = _ControllerAbstract<F> &
  { [k: string]: (client: Client<F>, args: any[]) => any }

But this is untrue; it implies that, say, the buildClient property will be both a method of type () => Client<F> and a method of type (client: Client<F>, args: any[]) => any. And the compiler knows that's not true, so you can't just add the index signature to the class body directly. Instead you need to do what I did above: rename the actual class body out of the way, and use a type assertion to convince the compiler that ControllerAbstract is a constructor that behaves as desired:

const ControllerAbstract = _ControllerAbstract as abstract new
  <F extends Families>(controllerFamily: F) => ControllerAbstract<F>;

---

Well, let's see if it works:

const controllerFamilyName = 'FamilyA';
type ControllerFamily = typeof controllerFamilyName;    
class FamilyAController extends ControllerAbstract<ControllerFamily> {
  constructor() {
    super(controllerFamilyName);
  }

  build_client() {
    return { id: "A" } as const;
  }

  useClient(client: Client<ControllerFamily>, args: any[]) { }

  useClientBad(client: Client<"FamilyB">, args: any[]) { }
  // Property 'useClientBad' of type '(client: FamilyBClient_t, args: any[]) => void' is
  // not assignable to 'string' index type '(client: FamilyAClient_t, args: any[]) => any'.(2411)
}

Looks good. The useClient() method type checks, while the useClientBad() method does not, and the error there describes the problem, that client is FamilyBClient_t when it should be FamilyAClient_t.

---

So, there you go. It's not perfect, but it's the closest I can get.

Playground link to code