Last week I showed you how to use Pattern Matching and more specifically the Type Pattern in TypeScript. I used a set of commands:
with a corresponding command handler as an example:
While reading the following article I noticed that a TypeScript compiler trick was mentioned to further improve the type safety of our code. In the article the following code was used:
As it wasn’t immediately clear to me what this code does exactly I decided to write a blog post about it.
Explaining the magic
The TypeScript code above defines a generic type alias named CommandTypeOf. This alias takes a type parameter T that must extend from a type named Command. The resulting type of CommandTypeOf<T> is the type of the type property of T.
In simpler terms, this code is used to extract the type of the type property from our Command type. You can use CommandTypeOf<CreateUserCommand> to get the type 'createUser', which is the type of the type property in CreateUserCommand.
This is a powerful pattern for creating type-safe command handling systems, where the type of the command can be used to determine its behavior at compile time.
Let’s see it in action
I’ve created an CommandProcessor interface that can be implemented to link a Command to a CommandHandler. As you can see in the code above I’m using the CommandTypeOf<T> to limit the types that can be provided.
If we now want to call the handle method you see that the compiler only offers us the supported command types:
So if we call the CommandProcessor like this, it will work:
But if we want to provide an unknown command type, the compiler will complain:
