references/details.md GitHub Copy Downloadtypescript-advanced-types — detailed worked examples
Advanced Patterns
Pattern 1: Type-Safe Event Emitter
type EventMap = {
"user:created" : { id : string ; name : string };
"user:updated" : { id : string };
"user:deleted" : { id : string };
};
class TypedEventEmitter <T extends Record <string , any >> {
private listeners : {
[K in keyof T]?: Array <(data : T[K] ) => void >;
} = {};
on<K extends keyof T>(event : K, callback : (data : T[K] ) => void ): void {
if (!this .listeners [event]) {
this .listeners [event] = [];
}
this .listeners [event]!.push (callback);
}
emit<K extends keyof T>(event : K, data : T[K]): void {
const callbacks = this .listeners [event];
if (callbacks) {
callbacks.forEach ((callback ) => callback (data));
}
}
}
const emitter = new TypedEventEmitter <EventMap >();
emitter.on ("user:created" , (data ) => {
console .log (data.id , data.name );
});
emitter.emit ("user:created" , { id : "1" , name : "John" });
Pattern 2: Type-Safe API Client
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" ;
type EndpointConfig = {
"/users" : {
GET : { response : User [] };
POST : { body : { name : string ; email : string }; response : User };
};
"/users/:id" : {
GET : { params : { id : string }; response : User };
PUT : { params : { id : string }; body : Partial <User >; response : User };
DELETE : { params : { id : string }; response : void };
};
};
type ExtractParams <T> = T extends { params : infer P } ? P : never ;
type ExtractBody <T> = T extends { body : infer B } ? B : never ;
type ExtractResponse <T> = T extends { response : infer R } ? R : never ;
class APIClient <Config extends Record <string , Record <HTTPMethod , any >>> {
async request<Path extends keyof Config , Method extends keyof Config [Path ]>(
path : Path ,
method : Method ,
...[options]: ExtractParams <Config [Path ][Method ]> extends never
? ExtractBody <Config [Path ][Method ]> extends never
? []
: [{ body : ExtractBody <Config [Path ][Method ]> }]
: [
{
params : ExtractParams <Config [Path ][Method ]>;
body ?: ExtractBody <Config [Path ][Method ]>;
},
]
): Promise <ExtractResponse <Config [Path ][Method ]>> {
return {} as any ;
}
}
const api = new APIClient <EndpointConfig >();
const users = await api.request ("/users" , "GET" );
const newUser = await api.request ("/users" , "POST" , {
body : { name : "John" , email : "john@example.com" },
});
const user = await api.request ("/users/:id" , "GET" , {
params : { id : "123" },
});
Pattern 3: Builder Pattern with Type Safety
type BuilderState <T> = {
[K in keyof T]: T[K] | undefined ;
};
type RequiredKeys <T> = {
[K in keyof T]-?: {} extends Pick <T, K> ? never : K;
}[keyof T];
type OptionalKeys <T> = {
[K in keyof T]-?: {} extends Pick <T, K> ? K : never ;
}[keyof T];
type IsComplete <T, S> =
RequiredKeys <T> extends keyof S
? S[RequiredKeys <T>] extends undefined
? false
: true
: false ;
class Builder <T, S extends BuilderState <T> = {}> {
private state : S = {} as S;
set<K extends keyof T>(key : K, value : T[K]): Builder <T, S & Record <K, T[K]>> {
this .state [key] = value;
return this as any ;
}
build (this : IsComplete <T, S> extends true ? this : never ): T {
return this .state as T;
}
}
interface User {
id : string ;
name : string ;
email : string ;
age ?: number ;
}
const builder = new Builder <User >();
const user = builder
.set ("id" , "1" )
.set ("name" , "John" )
.set ("email" , "john@example.com" )
.build ();
Pattern 4: Deep Readonly/Partial
type DeepReadonly <T> = {
readonly [P in keyof T]: T[P] extends object
? T[P] extends Function
? T[P]
: DeepReadonly <T[P]>
: T[P];
};
type DeepPartial <T> = {
[P in keyof T]?: T[P] extends object
? T[P] extends Array <infer U>
? Array <DeepPartial <U>>
: DeepPartial <T[P]>
: T[P];
};
interface Config {
server : {
host : string ;
port : number ;
ssl : {
enabled : boolean ;
cert : string ;
};
};
database : {
url : string ;
pool : {
min : number ;
max : number ;
};
};
}
type ReadonlyConfig = DeepReadonly <Config >;
type PartialConfig = DeepPartial <Config >;
type ValidationRule <T> = {
validate : (value : T ) => boolean ;
message : string ;
};
type FieldValidation <T> = {
[K in keyof T]?: ValidationRule <T[K]>[];
};
type ValidationErrors <T> = {
[K in keyof T]?: string [];
};
class FormValidator <T extends Record <string , any >> {
constructor (private rules : FieldValidation <T> ) {}
validate (data : T): ValidationErrors <T> | null {
const errors : ValidationErrors <T> = {};
let hasErrors = false ;
for (const key in this .rules ) {
const fieldRules = this .rules [key];
const value = data[key];
if (fieldRules) {
const fieldErrors : string [] = [];
for (const rule of fieldRules) {
if (!rule.validate (value)) {
fieldErrors.push (rule.message );
}
}
if (fieldErrors.length > 0 ) {
errors[key] = fieldErrors;
hasErrors = true ;
}
}
}
return hasErrors ? errors : null ;
}
}
interface LoginForm {
email : string ;
password : string ;
}
const validator = new FormValidator <LoginForm >({
email : [
{
validate : (v ) => v.includes ("@" ),
message : "Email must contain @" ,
},
{
validate : (v ) => v.length > 0 ,
message : "Email is required" ,
},
],
password : [
{
validate : (v ) => v.length >= 8 ,
message : "Password must be at least 8 characters" ,
},
],
});
const errors = validator.validate ({
email : "invalid" ,
password : "short" ,
});
Pattern 6: Discriminated Unions
type Success <T> = {
status : "success" ;
data : T;
};
type Error = {
status : "error" ;
error : string ;
};
type Loading = {
status : "loading" ;
};
type AsyncState <T> = Success <T> | Error | Loading ;
function handleState<T>(state : AsyncState <T>): void {
switch (state.status ) {
case "success" :
console .log (state.data );
break ;
case "error" :
console .log (state.error );
break ;
case "loading" :
console .log ("Loading..." );
break ;
}
}
type State =
| { type : "idle" }
| { type : "fetching" ; requestId : string }
| { type : "success" ; data : any }
| { type : "error" ; error : Error };
type Event =
| { type : "FETCH" ; requestId : string }
| { type : "SUCCESS" ; data : any }
| { type : "ERROR" ; error : Error }
| { type : "RESET" };
function reducer (state : State , event : Event ): State {
switch (state.type ) {
case "idle" :
return event.type === "FETCH"
? { type : "fetching" , requestId : event.requestId }
: state;
case "fetching" :
if (event.type === "SUCCESS" ) {
return { type : "success" , data : event.data };
}
if (event.type === "ERROR" ) {
return { type : "error" , error : event.error };
}
return state;
case "success" :
case "error" :
return event.type === "RESET" ? { type : "idle" } : state;
}
}
Type Inference Techniques
1. Infer Keyword
type ElementType <T> = T extends (infer U)[] ? U : never ;
type NumArray = number [];
type Num = ElementType <NumArray >;
type PromiseType <T> = T extends Promise <infer U> ? U : never ;
type AsyncNum = PromiseType <Promise <number >>;
type Parameters <T> = T extends (...args : infer P) => any ? P : never ;
function foo (a : string , b : number ) {}
type FooParams = Parameters <typeof foo>;
2. Type Guards
function isString (value : unknown ): value is string {
return typeof value === "string" ;
}
function isArrayOf<T>(
value : unknown ,
guard : (item : unknown ) => item is T,
): value is T[] {
return Array .isArray (value) && value.every (guard);
}
const data : unknown = ["a" , "b" , "c" ];
if (isArrayOf (data, isString)) {
data.forEach ((s ) => s.toUpperCase ());
}
3. Assertion Functions
function assertIsString (value : unknown ): asserts value is string {
if (typeof value !== "string" ) {
throw new Error ("Not a string" );
}
}
function processValue (value : unknown ) {
assertIsString (value);
console .log (value.toUpperCase ());
}