TypeScript Type Safety Expert

Advanced TypeScript patterns for bulletproof type safety.

Advanced Type Patterns

Branded Types

// Prevent mixing incompatible types
type Brand<K, T> = K & { __brand: T };

type UserId = Brand<string, 'UserId'>;
type ProductId = Brand<string, 'ProductId'>;

const userId = 'user_123' as UserId;
const productId = 'prod_456' as ProductId;

function getUser(id: UserId) { /* ... */ }

getUser(userId);      // ✅ OK
getUser(productId);   // ❌ Type error!

Discriminated Unions

type Success<T> = { success: true; data: T };
type Error = { success: false; error: string };
type Result<T> = Success<T> | Error;

function handleResult<T>(result: Result<T>) {
  if (result.success) {
    // TypeScript knows result.data exists
    console.log(result.data);
  } else {
    // TypeScript knows result.error exists
    console.error(result.error);
  }
}

Template Literal Types

type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type Route = `/${string}`;
type Endpoint = `${HttpMethod} ${Route}`;

const endpoint: Endpoint = 'GET /users';  // ✅
const invalid: Endpoint = 'FETCH /data'; // ❌ Type error

// Dynamic key generation
type EventName = `on${Capitalize<string>}`;
const onClick: EventName = 'onClick';  // ✅
const invalid: EventName = 'click';    // ❌

Recursive Types

type JSONValue =
  | string
  | number
  | boolean
  | null
  | JSONValue[]
  | { [key: string]: JSONValue };

const validJSON: JSONValue = {
  name: "Alice",
  age: 30,
  tags: ["developer", "typescript"],
  metadata: {
    created: "2024-01-01",
    nested: {
      deep: true
    }
  }
};

Utility Type Combinations

// Make all properties optional recursively
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

// Make specific keys required
type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;

// Exclude null and undefined
type NonNullableKeys<T> = {
  [P in keyof T]: NonNullable<T[P]>;
};

// Extract function parameters
type Params<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

Type-Safe API Client

type API = {
  '/users': {
    GET: { response: User[] };
    POST: { body: UserCreate; response: User };
  };
  '/users/:id': {
    GET: { params: { id: string }; response: User };
    PUT: { params: { id: string }; body: UserUpdate; response: User };
    DELETE: { params: { id: string }; response: void };
  };
};

type ExtractParams<T extends string> =
  T extends `${infer _Start}:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof ExtractParams<Rest>]: string }
    : T extends `${infer _}:${infer Param}`
    ? { [K in Param]: string }
    : {};

async function apiCall<
  Path extends keyof API,
  Method extends keyof API[Path]
>(
  method: Method,
  path: Path,
  options?: API[Path][Method] extends { body: infer B }
    ? { body: B; params?: ExtractParams<Path> }
    : { params?: ExtractParams<Path> }
): Promise<API[Path][Method] extends { response: infer R } ? R : never> {
  // Implementation
  return {} as any;
}

// Usage - fully type-safe!
const user = await apiCall('GET', '/users/:id', {
  params: { id: '123' }  // ✅ Required
});

const newUser = await apiCall('POST', '/users', {
  body: { email: 'test@test.com', name: 'Test' }  // ✅ Required
});

Builder Pattern with Type State

class QueryBuilder<T extends Record<string, any>, HasWhere = false> {
  private whereClause?: string;

  where<K extends keyof T>(key: K, value: T[K]): QueryBuilder<T, true> {
    this.whereClause = `${String(key)} = ${value}`;
    return this as any;
  }

  // execute() only available after where() is called
  execute(this: QueryBuilder<T, true>): Promise<T[]> {
    return Promise.resolve([]);
  }
}

const query = new QueryBuilder<User>();
query.execute();  // ❌ Type error - must call where() first
query.where('id', 123).execute();  // ✅ OK

Strict Event Emitter

type EventMap = {
  'user:created': { id: string; name: string };
  'user:deleted': { id: string };
  'data:update': { data: any[] };
};

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) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event]!.push(callback);
  }

  emit<K extends keyof T>(event: K, data: T[K]) {
    this.listeners[event]?.forEach(cb => cb(data));
  }
}

const emitter = new TypedEventEmitter<EventMap>();

emitter.on('user:created', (data) => {
  console.log(data.id, data.name);  // ✅ Fully typed
});

emitter.emit('user:created', { id: '1', name: 'Alice' });  // ✅ OK
emitter.emit('user:created', { wrong: 'data' });  // ❌ Type error

Zod Integration

import { z } from 'zod';

const UserSchema = z.object({
  id: z.string().uuid(),
  email: z.string().email(),
  age: z.number().min(0).max(150),
  role: z.enum(['admin', 'user', 'guest']),
  metadata: z.record(z.unknown()).optional(),
});

type User = z.infer<typeof UserSchema>;

// Runtime validation with compile-time types
function validateUser(data: unknown): User {
  return UserSchema.parse(data);
}

TSConfig Best Practices

{
  "compilerOptions": {
    "strict": true,
    "exactOptionalPropertyTypes": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,
    "noPropertyAccessFromIndexSignature": true,
    "noFallthroughCasesInSwitch": true,
    "allowUnusedLabels": false,
    "allowUnreachableCode": false,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true
  }
}

Quick Patterns

// Const assertions
const config = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
} as const;
// Type: { readonly apiUrl: "https://api.example.com"; readonly timeout: 5000 }

// Satisfies operator
const colors = {
  red: [255, 0, 0],
  green: [0, 255, 0],
} satisfies Record<string, [number, number, number]>;

// Index signatures with template literals
type HTTPHeaders = {
  [K in `x-${string}`]: string;
};

// Conditional types
type IsArray<T> = T extends any[] ? true : false;
type Test1 = IsArray<string[]>;  // true
type Test2 = IsArray<string>;    // false

When to Use: Advanced TypeScript features, eliminating runtime errors, type-safe APIs, complex type systems.