TypeScript Template Literal Types — Type-Safe Strings in 2024

// Combine literal strings
type EventBase = 'user' | 'order' | 'payment';
type EventAction = 'created' | 'updated' | 'deleted';
 
type EventName = `${EventBase}.${EventAction}`;
// 'user.created' | 'user.updated' | 'user.deleted' |
// 'order.created' | 'order.updated' | 'order.deleted' |
// 'payment.created' | 'payment.updated' | 'payment.deleted'
 
// HTTP methods as uppercase
type HttpMethod = Uppercase<'get' | 'post' | 'put' | 'patch' | 'delete'>;
// 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
 
// Type-safe Redis key prefixes
type CacheKey<Resource extends string, Id extends string> = `cache:${Resource}:${Id}`;
type UserCacheKey = CacheKey<'user', string>;
// `cache:user:${string}`
 
function getCacheKey(userId: string): UserCacheKey {
  return `cache:user:${userId}`;
}

// Extract route path parameters
type ExtractParams<T extends string> =
  T extends `${string}:${infer Param}/${infer Rest}`
    ? Param | ExtractParams<`/${Rest}`>
    : T extends `${string}:${infer Param}`
      ? Param
      : never;
 
type UserParams = ExtractParams<'/users/:userId/orders/:orderId'>;
// 'userId' | 'orderId'
 
// Build a type-safe params object from a route pattern
type RouteParams<T extends string> = {
  [K in ExtractParams<T>]: string;
};
 
type UserRouteParams = RouteParams<'/users/:userId/orders/:orderId'>;
// { userId: string; orderId: string }
 
// Parse event namespace
type ExtractNamespace<T extends string> =
  T extends `${infer NS}.${string}` ? NS : never;
 
type Namespace = ExtractNamespace<'user.created' | 'order.shipped' | 'standalone'>;
// 'user' | 'order'

interface DomainEvents {
  'user.created': { userId: string; email: string; timestamp: string };
  'user.deleted': { userId: string; deletedAt: string };
  'order.placed': { orderId: string; userId: string; total: number };
  'order.shipped': { orderId: string; trackingNumber: string };
  'payment.succeeded': { paymentId: string; amount: number };
  'payment.failed': { paymentId: string; reason: string };
}
 
type EventKey = keyof DomainEvents;
 
// Auto-generate listener method names: onUserCreated, onOrderShipped, etc.
type ListenerName<K extends string> =
  K extends `${infer NS}.${infer Action}`
    ? `on${Capitalize<NS>}${Capitalize<Action>}`
    : `on${Capitalize<K>}`;
 
type EventListeners = {
  [K in EventKey as ListenerName<K>]: (payload: DomainEvents[K]) => void | Promise<void>;
};
 
// EventListeners now looks like:
// { onUserCreated: (payload: ...) => ...; onOrderPlaced: (payload: ...) => ...; }
 
class EventBus {
  private handlers = new Map<string, Array<(payload: unknown) => void>>();
 
  on<K extends EventKey>(event: K, handler: (payload: DomainEvents[K]) => void): void {
    const existing = this.handlers.get(event) ?? [];
    this.handlers.set(event, [...existing, handler as (p: unknown) => void]);
  }
 
  async emit<K extends EventKey>(event: K, payload: DomainEvents[K]): Promise<void> {
    const handlers = this.handlers.get(event) ?? [];
    for (const handler of handlers) {
      await handler(payload);
    }
  }
}

type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
type RouteKey = `${HttpMethod} /${string}`;
 
interface RouteRegistry {
  'GET /users': { query: { page?: number; limit?: number } };
  'GET /users/:id': { params: { id: string } };
  'POST /users': { body: { name: string; email: string; password: string } };
  'PUT /users/:id': { params: { id: string }; body: Partial<{ name: string; email: string }> };
  'DELETE /users/:id': { params: { id: string } };
}
 
type MethodOf<R extends string> = R extends `${infer M} ${string}` ? M : never;
type PathOf<R extends string> = R extends `${string} ${infer P}` ? P : never;
 
// Type-safe router
class TypedRouter {
  register<R extends keyof RouteRegistry>(
    route: R,
    handler: (ctx: RouteRegistry[R]) => Promise<unknown>
  ): void {
    const [method, path] = (route as string).split(' ');
    console.log(`Registered ${method} ${path}`);
  }
}
 
const router = new TypedRouter();
router.register('POST /users', async (ctx) => {
  const { name, email, password } = ctx.body;
  return { created: true };
});

// Generate getter and setter method names from data model properties
type GetterName<K extends string> = `get${Capitalize<K>}`;
type SetterName<K extends string> = `set${Capitalize<K>}`;
 
type Getters<T> = {
  [K in keyof T & string as GetterName<K>]: () => T[K];
};
 
type Setters<T> = {
  [K in keyof T & string as SetterName<K>]: (value: T[K]) => void;
};
 
interface Product {
  id: string;
  name: string;
  price: number;
  stock: number;
}
 
type ProductAccessors = Getters<Product> & Setters<Product>;
// {
//   getId: () => string;
//   getName: () => string;
//   setId: (value: string) => void;
//   setName: (value: string) => void;
//   ...
// }

// Enforce naming conventions on environment variables
type BackendEnvKey =
  | `DB_${Uppercase<string>}`
  | `REDIS_${Uppercase<string>}`
  | `JWT_${Uppercase<string>}`
  | `PORT`
  | `NODE_ENV`;
 
// Type-safe environment variable accessor
function getEnv<K extends BackendEnvKey>(key: K): string {
  const value = process.env[key];
  if (!value) throw new Error(`Missing environment variable: ${key}`);
  return value;
}
 
const dbUrl = getEnv('DB_URL');          // valid
const jwtSecret = getEnv('JWT_SECRET');  // valid
// getEnv('api_key');  // Error: 'api_key' doesn't match the pattern