Type-First Development

// 1. Define data model first
interface User {
  id: string;
  email: string;
  name: string;
  createdAt: Date;
}

type CreateUserRequest = Omit<User, 'id' | 'createdAt'>;
type UpdateUserRequest = Partial<CreateUserRequest>;

// 2. Define function signatures
async function createUser(req: CreateUserRequest): Promise<User>;
async function updateUser(id: string, req: UpdateUserRequest): Promise<User>;
async function getUser(id: string): Promise<User | null>;

// 3. Implement to satisfy types
async function createUser(req: CreateUserRequest): Promise<User> {
  const id = crypto.randomUUID();
  const createdAt = new Date();
  const user: User = { ...req, id, createdAt };
  await db.users.insert(user);
  return user;
}

// Implementation first, types inferred
function processData(data) {
  if (data.status === 'active') {
    return data.items.map(i => i.value);
  }
  return [];
}

// Types first, implementation second
type Status = 'active' | 'inactive';

interface DataItem {
  value: number;
}

interface Data {
  status: Status;
  items: DataItem[];
}

function processData(data: Data): number[] {
  if (data.status === 'active') {
    return data.items.map(i => i.value);
  }
  return [];
}

import { z } from 'zod';

// Schema as source of truth
const UserSchema = z.object({
  id: z.string().uuid(),
  email: z.string().email(),
  name: z.string().min(1),
  createdAt: z.date(),
});

// Infer TypeScript type from schema
type User = z.infer<typeof UserSchema>;

// Validate at runtime boundaries
function parseUser(data: unknown): User {
  return UserSchema.parse(data);
}