aigroup-workflow 2.1.2 → 2.2.0

package/skills/typescript-pro/references/patterns.md

@@ -1,484 +0,0 @@
-# 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 |