How do TypeScript generics work with constraints, and when would you use keyof with generics?

Generics with Constraints

// Constraint: T must have an 'id' property
function update<T extends { id: string }>(table: string, data: Partial<T>): Promise<T> {
  return db.update(table, data);
}

// keyof constraint: only allow keys that exist on T
function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
  const result = {} as Pick<T, K>;
  keys.forEach(key => { result[key] = obj[key]; });
  return result;
}

const user = { id: "1", name: "Alice", email: "a@b.com" };
pick(user, ["name"]);      // ✅ { name: string }
pick(user, ["name", "id"]); // ✅ { name: string; id: string }
pick(user, ["foo"]);        // ❌ Type error — "foo" not in keyof User

Real-World: Type-Safe API Client

type Model = {
  users: { id: string; name: string; email: string; role: string };
  posts: { id: string; title: string; body: string; authorId: string };
};

type ApiResponse<T, K extends keyof T> = Pick<T, K>;

async function fetchModel<
  M extends keyof Model,
  K extends keyof Model[M]
>(model: M, id: string, fields: K[]): Promise<ApiResponse<Model[M], K>> {
  const data = await db.findById(model, id);
  return pick(data, fields);
}

// Usage — fully type-safe
const result = await fetchModel("users", "1", ["name", "email"]);
// result: { name: string; email: string }

Key Patterns

Pattern	Use Case
T extends X	Require minimum shape
keyof T	Restrict to object's keys
T extends keyof any	T must be string/number/symbol
T[U extends keyof T]	Indexed access
infer	Extract types from conditional