zebbern/claude-code-guide / skills/typescript-pro
typescript-pro
VerifiedUse when building TypeScript applications requiring advanced type systems, generics, or full-stack type safety. Invoke for type guards, utility types, tRPC integration, monorepo setup.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 3.7 KB |
| references/advanced-types.md | markdown | 6.4 KB |
| references/configuration.md | markdown | 9.1 KB |
| references/patterns.md | markdown | 11.1 KB |
| references/type-guards.md | markdown | 7.8 KB |
| references/utility-types.md | markdown | 8.4 KB |
references/patterns.md
View on GitHub# TypeScript Patterns
## Builder Pattern
```typescript
// Type-safe builder with progressive types
class UserBuilder {
private data: Partial<User> = {}
setName(name: string): this {
this.data.name = name
return this
}
setEmail(email: string): this {
this.data.email = email
return this
}
setAge(age: number): this {
this.data.age = age
return this
}
build(): User {
if (!this.data.name || !this.data.email) {
throw new Error("Name and email are required")
}
return this.data as User
}
}
// Fluent API with type safety
const user = new UserBuilder().setName("John").setEmail("john@example.com").setAge(30).build()
// Advanced builder with compile-time validation
type Builder<T, K extends keyof T = never> = {
[P in keyof T as `set${Capitalize<string & P>}`]: (value: T[P]) => Builder<T, K | P>
} & {
build: K extends keyof T ? () => T : never
}
function createBuilder<T>(): Builder<T> {
const data = {} as T
return new Proxy({} as Builder<T>, {
get(_, prop: string) {
if (prop === "build") {
return () => data
}
if (prop.startsWith("set")) {
const key = prop.slice(3).toLowerCase()
return (value: any) => {
;(data as any)[key] = value
return this
}
}
},
})
}
```
## Factory Pattern
```typescript
// Abstract factory with type safety
interface Logger {
log(message: string): void
}
class ConsoleLogger implements Logger {
log(message: string): void {
console.log(message)
}
}
class FileLogger implements Logger {
constructor(private filename: string) {}
log(message: string): void {
// Write to file
}
}
type LoggerType = "console" | "file"
type LoggerConfig<T extends LoggerType> = T extends "file"
? { type: T; filename: string }
: { type: T }
class LoggerFactory {
static create<T extends LoggerType>(config: LoggerConfig<T>): Logger {
switch (config.type) {
case "console":
return new ConsoleLogger()
case "file":
return new FileLogger(config.filename)
default:
throw new Error("Unknown logger type")
}
}
}
const consoleLogger = LoggerFactory.create({ type: "console" })
const fileLogger = LoggerFactory.create({ type: "file", filename: "app.log" })
// Generic factory with dependency injection
type Constructor<T> = new (...args: any[]) => T
class Container {
private instances = new Map<Constructor<any>, any>()
register<T>(token: Constructor<T>, instance: T): void {
this.instances.set(token, instance)
}
resolve<T>(token: Constructor<T>): T {
const instance = this.instances.get(token)
if (!instance) {
throw new Error(`No instance registered for ${token.name}`)
}
return instance
}
}
```
## Repository Pattern
```typescript
// Type-safe repository with generic CRUD
interface Entity {
id: string | number
}
interface Repository<T extends Entity> {
find(id: T["id"]): Promise<T | null>
findAll(): Promise<T[]>
create(data: Omit<T, "id">): Promise<T>
update(id: T["id"], data: Partial<Omit<T, "id">>): Promise<T>
delete(id: T["id"]): Promise<void>
}
class UserRepository implements Repository<User> {
async find(id: User["id"]): Promise<User | null> {
// Database query
return null
}
async findAll(): Promise<User[]> {
return []
}
async create(data: Omit<User, "id">): Promise<User> {
// Insert into database
return { id: 1, ...data }
}
async update(id: User["id"], data: Partial<Omit<User, "id">>): Promise<User> {
// Update database
return { id, name: "", email: "", ...data }
}
async delete(id: User["id"]): Promise<void> {
// Delete from database
}
}
// Query builder with type safety
class QueryBuilder<T> {
private conditions: Array<(item: T) => boolean> = []
where<K extends keyof T>(key: K, value: T[K]): this {
this.conditions.push((item) => item[key] === value)
return this
}
execute(items: T[]): T[] {
return items.filter((item) => this.conditions.every((condition) => condition(item)))
}
}
const query = new QueryBuilder<User>().where("email", "john@example.com").where("age", 30)
```
## Type-Safe API Client
```typescript
// REST API client with type safety
type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH"
type ApiEndpoints = {
"/users": {
GET: { response: User[] }
POST: { body: CreateUserDto; response: User }
}
"/users/:id": {
GET: { params: { id: string }; response: User }
PUT: { params: { id: string }; body: UpdateUserDto; response: User }
DELETE: { params: { id: string }; response: void }
}
"/posts": {
GET: { query: { userId?: string }; response: Post[] }
POST: { body: CreatePostDto; response: Post }
}
}
type ExtractParams<T extends string> = T extends `${infer _Start}/:${infer Param}/${infer Rest}`
? { [K in Param]: string } & ExtractParams<`/${Rest}`>
: T extends `${infer _Start}/:${infer Param}`
? { [K in Param]: string }
: {}
class ApiClient {
async request<Path extends keyof ApiEndpoints, Method extends keyof ApiEndpoints[Path]>(
method: Method,
path: Path,
options?: ApiEndpoints[Path][Method] extends { body: infer B }
? { body: B }
: ApiEndpoints[Path][Method] extends { params: infer P }
? { params: P }
: ApiEndpoints[Path][Method] extends { query: infer Q }
? { query: Q }
: never
): Promise<ApiEndpoints[Path][Method] extends { response: infer R } ? R : never> {
// Make HTTP request
return null as any
}
}
const client = new ApiClient()
// Type-safe API calls
const users = await client.request("GET", "/users")
const user = await client.request("GET", "/users/:id", { params: { id: "1" } })
const newUser = await client.request("POST", "/users", {
body: { name: "John", email: "john@example.com" },
})
```
## State Machine Pattern
```typescript
// Type-safe state machine
type State = "idle" | "loading" | "success" | "error"
type Event =
| { type: "FETCH" }
| { type: "SUCCESS"; data: any }
| { type: "ERROR"; error: Error }
| { type: "RETRY" }
type StateMachine = {
[S in State]: {
[E in Event["type"]]?: State
}
}
const machine: StateMachine = {
idle: { FETCH: "loading" },
loading: { SUCCESS: "success", ERROR: "error" },
success: { FETCH: "loading" },
error: { RETRY: "loading" },
}
class StateManager<S extends string, E extends { type: string }> {
constructor(
private state: S,
private transitions: Record<S, Partial<Record<E["type"], S>>>
) {}
getState(): S {
return this.state
}
dispatch(event: E): S {
const nextState = this.transitions[this.state][event.type]
if (nextState === undefined) {
throw new Error(`Invalid transition from ${this.state} on ${event.type}`)
}
this.state = nextState
return this.state
}
}
const manager = new StateManager<State, Event>("idle", machine)
manager.dispatch({ type: "FETCH" }) // 'loading'
manager.dispatch({ type: "SUCCESS", data: {} }) // 'success'
```
## Decorator Pattern
```typescript
// Method decorators with type safety
function Log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value
descriptor.value = function (...args: any[]) {
console.log(`Calling ${propertyKey} with`, args)
const result = originalMethod.apply(this, args)
console.log(`Result:`, result)
return result
}
return descriptor
}
function Memoize(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value
const cache = new Map<string, any>()
descriptor.value = function (...args: any[]) {
const key = JSON.stringify(args)
if (cache.has(key)) {
return cache.get(key)
}
const result = originalMethod.apply(this, args)
cache.set(key, result)
return result
}
return descriptor
}
class Calculator {
@Log
@Memoize
fibonacci(n: number): number {
if (n <= 1) return n
return this.fibonacci(n - 1) + this.fibonacci(n - 2)
}
}
```
## Result/Either Pattern
```typescript
// Type-safe error handling
type Result<T, E = Error> = { success: true; value: T } | { success: false; error: E }
function ok<T>(value: T): Result<T, never> {
return { success: true, value }
}
function err<E>(error: E): Result<never, E> {
return { success: false, error }
}
async function fetchUser(id: string): Promise<Result<User, string>> {
try {
const response = await fetch(`/api/users/${id}`)
if (!response.ok) {
return err("User not found")
}
const user = await response.json()
return ok(user)
} catch (error) {
return err("Network error")
}
}
// Usage with pattern matching
const result = await fetchUser("123")
if (result.success) {
console.log(result.value.name) // Type-safe access
} else {
console.error(result.error) // Type-safe error
}
// Either monad
class Either<L, R> {
private constructor(
private readonly value: L | R,
private readonly isRight: boolean
) {}
static left<L, R>(value: L): Either<L, R> {
return new Either<L, R>(value, false)
}
static right<L, R>(value: R): Either<L, R> {
return new Either<L, R>(value, true)
}
map<T>(fn: (value: R) => T): Either<L, T> {
if (this.isRight) {
return Either.right(fn(this.value as R))
}
return Either.left(this.value as L)
}
flatMap<T>(fn: (value: R) => Either<L, T>): Either<L, T> {
if (this.isRight) {
return fn(this.value as R)
}
return Either.left(this.value as L)
}
getOrElse(defaultValue: R): R {
return this.isRight ? (this.value as R) : defaultValue
}
}
```
## Singleton Pattern
```typescript
// Type-safe singleton
class Database {
private static instance: Database
private constructor() {
// Private constructor prevents instantiation
}
static getInstance(): Database {
if (!Database.instance) {
Database.instance = new Database()
}
return Database.instance
}
query<T>(sql: string): Promise<T[]> {
// Execute query
return Promise.resolve([])
}
}
const db = Database.getInstance()
// Generic singleton factory
function singleton<T>(factory: () => T): () => T {
let instance: T | undefined
return () => {
if (!instance) {
instance = factory()
}
return instance
}
}
const getConfig = singleton(() => ({
apiUrl: process.env.API_URL,
apiKey: process.env.API_KEY,
}))
```
## Quick Reference
| Pattern | Use Case |
| ------------- | --------------------------------------------- |
| Builder | Construct complex objects step by step |
| Factory | Create objects without specifying exact class |
| Repository | Abstract data access layer |
| API Client | Type-safe HTTP requests |
| State Machine | Manage state transitions |
| Decorator | Add behavior to methods |
| Result/Either | Type-safe error handling |
| Singleton | Ensure single instance |
| Query Builder | Type-safe database queries |
| Container | Dependency injection |
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |