ag-referencia-typescript

Skill: TypeScript Patterns

Referencia de patterns para TypeScript em modo strict.

Quando Ativar

• Definindo tipos complexos
• Usando generics
• Implementando error handling tipado
• Trabalhando com Zod e inferencia

Strict Mode (tsconfig recomendado)

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitReturns": true,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true
  }
}

Utility Types

type UpdateUser = Partial<User>;
type RequiredUser = Required<User>;
type UserPreview = Pick<User, 'id' | 'name' | 'email'>;
type PublicUser = Omit<User, 'password' | 'secretKey'>;
type RolePermissions = Record<UserRole, Permission[]>;
type Config = Readonly<{ apiUrl: string; timeout: number }>;
type ServiceResult = ReturnType<typeof userService.findAll>;
type Users = Awaited<ReturnType<typeof userService.findAll>>;

Generics

function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

interface ApiResponse<T = unknown> {
  data: T;
  error: string | null;
  status: number;
}

interface Repository<T, CreateInput, UpdateInput> {
  findById(id: string): Promise<T | null>;
  findAll(): Promise<T[]>;
  create(input: CreateInput): Promise<T>;
  update(id: string, input: UpdateInput): Promise<T>;
  delete(id: string): Promise<void>;
}

Discriminated Unions

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

function divide(a: number, b: number): Result<number, string> {
  if (b === 0) return { success: false, error: 'Divisao por zero' };
  return { success: true, data: a / b };
}

const result = divide(10, 2);
if (result.success) {
  console.log(result.data); // TypeScript sabe que e number
}

Zod + TypeScript

import { z } from 'zod';

const userSchema = z.object({
  id: z.string().uuid(),
  email: z.string().email(),
  name: z.string().min(1),
  role: z.enum(['admin', 'user', 'guest']),
});

type User = z.infer<typeof userSchema>;

// Validacao segura
const result = userSchema.safeParse(rawData);
if (result.success) {
  const user = result.data; // Tipado corretamente
}