How to make all properties optional.
One type, every field.

// ─── The base type ───────────────────────────
interface User {
id: string;
name: string;
email: string;
age: number;
}

// ─── Partial — every property optional ───────
type UserPatch = Partial;
// { id?: string; name?: string; email?: string; age?: number }

// ─── Any subset is valid ─────────────────────
const p1: UserPatch = {}; // ✅ all empty
const p2: UserPatch = { name: 'Alice' }; // ✅ one field
const p3: UserPatch = { email: 'a@x.com', age: 28 }; // ✅ two fields
const p4: UserPatch = { // ✅ all fields
id: '1', name: 'Alice', email: 'a@x.com', age: 28
};

// ─── Wrong types still rejected ──────────────
// const bad: UserPatch = { age: 'not a number' }; // ❌ type mismatch

// ─── The PATCH pattern ───────────────────────
function updateUser(id: string, patch: UserPatch): void {
// Only apply fields the caller provided
console.log('PATCH /users/' + id, patch);
}

updateUser('1', { name: 'Alicia' }); // ✅ only name
updateUser('1', { age: 29, email: 'a@y.com' }); // ✅ two fields

// ─── How Partial is defined ──────────────────
// This is the actual source:
//
// type Partial = { [K in keyof T]?: T[K] };
//
// A mapped type — iterates over keys, adds ? to each.

console.log(p2, p3, p4);

// ─── Shallow Partial — only the top level ────
interface Profile {
name: string;
address: {
street: string;
city: string;
};
}

type ShallowPatch = Partial;
// { name?: string; address?: { street: string; city: string } }
// ⚠️ address is optional — but if present, requires BOTH street and city

const sp1: ShallowPatch = { name: 'Alice' }; // ✅
const sp2: ShallowPatch = { address: { street: 'Main', city: 'X' } }; // ✅ full address
// const sp3: ShallowPatch = { address: { city: 'X' } };
// ❌ Property 'street' is missing

// ─── DeepPartial — recursive ─────────────────
type DeepPartial = {
[K in keyof T]?: T[K] extends object ? DeepPartial : T[K]
};

type DeepPatch = DeepPartial;
// { name?: string; address?: { street?: string; city?: string } }

const dp1: DeepPatch = { name: 'Alice' }; // ✅
const dp2: DeepPatch = { address: { city: 'X' } }; // ✅ street optional
const dp3: DeepPatch = { address: {} }; // ✅ empty nested
const dp4: DeepPatch = {}; // ✅

// ─── The real-world merge function ──────────
function mergeDeep(base: T, patch: DeepPartial): T {
if (typeof base !== 'object' || base === null) return base;
const result = { ...base } as Record<string, unknown>;
for (const k in patch) {
const v = patch[k];
if (v !== undefined) {
if (typeof v === 'object' && v !== null) {
result[k] = mergeDeep(result[k], v as DeepPartial<unknown>);
} else {
result[k] = v;
}
}
}
return result as T;
}

const base: Profile = {
name: 'Alice',
address: { street: 'Main St', city: 'Springfield' }
};
const updated = mergeDeep(base, { address: { city: 'Shelbyville' } });
console.log(updated);
// { name: 'Alice', address: { street: 'Main St', city: 'Shelbyville' } }

interface User {
id: string;
name: string;
email: string;
password: string;
createdAt: Date;
}

// ─── Partial + Omit: any subset of safe fields ─
type UserUpdate = Partial<Omit'id' | 'createdAt'>>;
// { name?: string; email?: string; password?: string }
// Client can send any subset — but not id or createdAt.

function updateUser(id: string, patch: UserUpdate): void {
console.log('PATCH', id, patch);
}

updateUser('1', { name: 'Alicia' }); // ✅
updateUser('1', { email: 'a@y.com' }); // ✅
// updateUser('1', { id: '2' }); // ❌ 'id' not in UserUpdate
// updateUser('1', { createdAt: new Date() }); // ❌ 'createdAt' not allowed

// ─── Partial + Pick: only specific fields ────
type ContactUpdate = Partial<Pick'email' | 'name'>>;
// { email?: string; name?: string }

function updateContact(id: string, patch: ContactUpdate): void {
console.log('PATCH contact', id, patch);
}

updateContact('1', { name: 'Alicia' }); // ✅
updateContact('1', { email: 'a@y.com' }); // ✅
// updateContact('1', { password: 'hack' }); // ❌ not allowed

// ─── Required + Partial: specific fields ─────
// "All fields optional EXCEPT id" — useful for
// update operations that require an identifier.
type PatchWithId = Partial & Pick'id'>;
// { id: string; name?: string; email?: string; password?: string; createdAt?: Date }

const wp: PatchWithId = { id: '1', name: 'Alice' }; // ✅
// const bad: PatchWithId = { name: 'Alice' }; // ❌ id required

// ─── The API endpoint pattern ────────────────
// This is how production APIs type PATCH bodies:
//
// type PatchBody =
// Partial>;
//
// type UserPatch = PatchBody;

console.log('composed patches ready');