typescript-rules

TypeScript Rules: Zero Tolerance for Type Errors + Community Wisdom

🚨 CRITICAL TYPE SAFETY RULES

NEVER Use These (Auto-Reject)

// ❌ FORBIDDEN - Will break our type safety
any
@ts-ignore  // without detailed explanation
@ts-expect-error  // without test case
as any
<any>
Function  // Use proper function signatures
Object    // Use proper object types
{}        // Use proper interface/type

ALWAYS Use These Patterns

// ✅ REQUIRED - Proper type definitions
interface UserData {
  readonly id: string;
  readonly name: string;
  readonly email: string;
  readonly createdAt: Date;
}

// ✅ REQUIRED - Proper error types
type ApiError = {
  readonly code: string;
  readonly message: string;
  readonly details?: Record<string, unknown>;
};

// ✅ REQUIRED - Proper function signatures
type ProcessUser = (user: UserData) => Promise<ProcessResult>;
type ValidateInput = <T>(input: unknown, schema: Schema<T>) => T;

📝 COMMUNITY-PROVEN PATTERNS

1. Functional Programming with Types

// ✅ REQUIRED - Functional and declarative patterns
// From cursor.directory research: "Use functional and declarative programming patterns; avoid classes"

// ❌ FORBIDDEN - Classes
class UserProcessor {
  process(user: User): Result { /* ... */ }
}

// ✅ REQUIRED - Functional approach with proper types
type UserProcessor = (user: User) => Result;
type ProcessResult<T> = {
  readonly success: boolean;
  readonly data?: T;
  readonly error?: string;
};

const processUser: UserProcessor = (user) => {
  // Process functionally
  return { success: true, data: transformedUser };
};

2. Interface over Types (Community Standard)

// ✅ REQUIRED - Use interfaces for object shapes
// From research: "Use TypeScript for all code; prefer interfaces over types"

interface ComponentProps {
  readonly title: string;
  readonly onComplete: (result: CompletionResult) => void;
  readonly isLoading?: boolean;
}

interface ApiResponse<T> {
  readonly data: T;
  readonly status: number;
  readonly message: string;
}

// ✅ REQUIRED - Types for unions and computations
type Status = 'idle' | 'loading' | 'success' | 'error';
type EventHandler<T> = (event: T) => void;