Type representing a generic class with a private constructor

Question

I have a simple function that asserts that an object is an instance of a class. The object and the class are both passed as arguments to the function.

The following is a simplified example that illustrates the issue (without getting into the nitty-gritty of the real code):

function verifyType<T>(instance: unknown, classType:new () => T):instance is T {
    if (!(instance instanceof classType)) throw(`Expecting instance of ${classType.name}`);

    return true;
}

(TypeScript Playground link)

This function works well with most classes:

class Foo {
    constructor() {
    }
}

const foo:unknown = new Foo();
verifyType(foo, Foo);
// OK

However, I get compiler errors if the class has a private constructor.

I understand the reasons for this and it makes sense. A constructor type implies that the calling code could construct the class and a private constructor means this is not permitted.

However, I can't find an alternative that still allows me to use instanceof:

class Bar {
    private constructor() {
    }
    static create() {
        return new Bar();
    }
}
const bar:unknown = Bar.create();
verifyType(bar, Foo);
// OK
verifyType(bar, Bar);
// Argument of type 'typeof Bar' is not assignable to parameter of type 'new () => Bar'.
//  Cannot assign a 'private' constructor type to a 'public' constructor type.

Trying T extends typeof Object

I read How to refer to a class with private constructor in a function with generic type parameters?

Based on the answer to that question, I thought that maybe I could use the following:

function verifyType<T extends typeof Object>(instance: unknown, classType:T):instance is InstanceType<T>

However, this appears to throw errors because of Object's many static methods:

const foo = new Foo();
verifyType(foo, Foo);
// Argument of type 'typeof Foo' is not assignable to parameter of type 'ObjectConstructor'.
//   Type 'typeof Foo' is missing the following properties from type 'ObjectConstructor': getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertyNames, create, and 16 more.

Getting exotic

I tried many variations on typeof Object to see if I could both satisfy TypeScript and also ensure runtime correctness, including:

function verifyType<T extends Function & Pick<typeof Object, "prototype">>(instance: unknown, classType:T):instance is InstanceType<T>

However, while this solved the compile-time errors, it appears to have done so by allowing types that fail at runtime, which is not acceptable:

verifyType(bar, ()=>{});
// No compile-time errors
// Runtime Error: Function has non-object prototype 'undefined' in instanceof check 

Help me // @ts-expect-error, you're my only hope

In the end, this might be too niche a use-case and I might have to accept that this edge-case won't be supported any time soon and exempt my code accordingly.

// @ts-expect-error Unfortunately, TS has no type representing a generic class with a private constructor
verifyType(bar, Bar);

Answer 1

My suggested approach is to do inference on the prototype property of the classType parameter, like this:

function verifyType<T extends object>(
    instance: unknown,
    classType: Function & { prototype: T }
): asserts instance is T {
    if (!classType.prototype) throw ( 
      `Wait, ${classType.name || "that"} is not a class constructor`);
    if (!(instance instanceof classType)) throw (
      `Expecting instance of ${classType.name}`);
}

Generally speaking TypeScript will let you write x instanceof y if y is of some function type, so hence Function &, and then we infer the generic type parameter T corresponding to the instance type of classType by saying that it's the type of the prototype property (TypeScript models class constructor prototypes as being the same type as an instance of the class, even though in practice that is not usually true. See microsoft/TypeScript#44181 and probably others for more information).

In addition to Function & {protoype: T} I've made a few changes from your code:

• verifyType() is now an assertion function returning asserts instance is T instead of a type guard function returning instance is T. Type guard functions are supposed to return true or false and the compiler uses this in its control flow analysis. Assertion functions on the other hand don't return any value, they just ensure that the narrowable thing is definitely narrowed. If you have a type guard function that always returns true (and throws otherwise) then you probably want an assertion function instead.

• I've done an explicit check inside the body to see if classType.prototype is defined. TypeScript gives Function a prototype property of the any type instead of the safer unknown type, and this unfortunately makes it almost impossible to detect that a non-constructor like ()=>{} would throw a runtime error if made the target of instanceof. Instead of trying to represent that in the type system, then, I just try to harden verifyType()'s implementation against such edge cases. You might want to check (!classType.prototype || typeof classType.prototype !== "object") or any other logic you feel is necessary.

---

Let's test it:

class Foo {
    constructor() {
    }
    a = 1;
}
const foo: unknown = new Foo();
foo.a // error! Object is of type unknown
verifyType(foo, Foo);
foo.a // okay
console.log(foo.a.toFixed(1)) // "1.0"

Looks good, the compiler sees that foo is a Foo after (but not before) verifyType(foo, Foo) has been called.

class Bar {
    private constructor() {
    }
    static create() {
        return new Bar();
    }
    b = "z"
}
const bar: unknown = Bar.create();
verifyType(bar, Bar);
console.log(bar.b.toUpperCase()); // "Z"

Also looks good. The compiler is happy to allow verifyType(bar, Bar) because Bar has a prototype property of type Bar (or so it appears to the compiler) and thus you can then access the b property of Bar. It doesn't matter that Bar has a private constructor.

And finally:

const baz: unknown = new Date();
verifyType(baz, () => { }); //  Wait, that is not a class constructor
baz // any

We weren't able to flag verifyType(baz, ()=>{}) at compile time, but at least you get a meaningful runtime error, so the subsequent "narrowing" of baz from unknown to any (ugh, thanks any) doesn't affect us.

Playground link to code

Answer 2

It's possible if you also allow any classes that have a create method like this:

function verifyType<C extends (Function & { create(...args: any[]): unknown }) | (new (...args: any[]) => unknown)>(
  instance: unknown,
  classType: C
): instance is C extends { create(...args: any[]): infer T } ? T : C extends new (...args: any[]) => unknown ? InstanceType<C> : never {
  if (!(instance instanceof classType)) throw `Expecting instance of ${classType.name}`;

  return true;
}

While it does work, it's not the best since if you have other classes that have differently named factory methods, you'll have to update the function's signature to include these.

Playground

---

P.S. If you have an async factory method, simply change create(): T to create(): T | Promise<T>.

Answer 3

Thankfully there exists a simple workaround

I ran into the same problem some time ago. You are effectively using the built-in InstanceType<TClass> which resolves the instance type but comes with the requirement of a public constructor:

type InstanceType<T extends abstract new (...args: any) => any> = ....

However the requirement for InstanceType<TClass> to have a public constructor is very limiting; It's ok if we only need runtime results, but useless if we want to write open generic types (TS Conditional Types have an abnoxious tendency to mix and match runtime type results with compile-time type results willy-nilly!)

Thankfully we can take full advantage of how the compiler resolves types to the best matching signature and ignore the accessibility modifier to accept private / protected constructors like so:

type InstanceTypeSpy<TClass> = InstanceType<{ new(): never } & TClass>;

It works because technically new(): never does fulfill the expectations of InstanceType<> however the compiler (which evaluates and can see all signature match possibilities regardless of access modifier) will choose not to match against new(): never to avoid never if possible - giving us the real type (or falling back to never if there actually does not exist any constructor on TClass).

Trivia

To explain what I mean by runtime vs compile-time types, consider the recently added Awaited<T> - it gives us the runtime type of awaiting an instance of T. Now consider we are writing a generic library that needs to handle async / T = Promise<U> such that the exact type T is not known at library compile time (because U is unknown).

That would be an "open" generic type - Once U is known it becomes a "closed" generic type.
For example Map<K,V> is an open type, and Map<string,object> is a closed type.

In such cases what we need is the compile-time type; i.e. if T = Promise<U> then we need U.

We cannot solve it with Awaited<T> because it might not be equal to U. If you write some unit-tests and try to assign a value of type U to something that expects Awaited<T> you will get a compile-error saying it's not assignable.

To understand why, remember that await is actually recursive! Ponder what happens if at runtime U is of type Promise<V>, which would mean our T is of type Promise<Promise<V>>. At runtime awaiting an instance of type T will yield a result of type V which is indeed very different from a result of type Promise<V>. So for an unknown T the compiler cannot guarantee correctness of such library code.

For completeness here is Awaited made non-recursive:

/**
 * Identical to Awaited<T> except it is NOT recursive, thus giving the compile-time type
 * (rather than the runtime type) which is what you need when writing generics.
 */
export type PromiseResolveType<T> =
  T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
  T extends object & { then(onfulfilled: infer F): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
    F extends ((value: infer V, ...args: any) => any) ? V : // if the argument to `then` is callable, extracts the unwrapped value
    never : // the argument to `then` was not callable
  T; // non-object or non-thenable