How to fix Cannot use optional operator '?' with mapped type key in TypeScript

// WRONG - using '?' in mapped type key
type WrongType<T> = {
  [K in keyof T]?: T[K];  // Error: Cannot use optional operator '?' with mapped type key
};

// CORRECT - using '+?' modifier to add optionality
type MakeOptional<T> = {
  [K in keyof T]+?: T[K];  // Makes all properties optional
};

// CORRECT - using '-?' modifier to remove optionality
type MakeRequired<T> = {
  [K in keyof T]-?: T[K];  // Makes all properties required
};

// Example usage:
interface User {
  id: number;
  name: string;
  email?: string;
}

type OptionalUser = MakeOptional<User>;
// Equivalent to: { id?: number; name?: string; email?: string; }

type RequiredUser = MakeRequired<User>;
// Equivalent to: { id: number; name: string; email: string; }

// WRONG - trying to conditionally include keys with '?'
type FilterByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]?: T[K];  // Error: '?' not allowed here
};

// CORRECT - remove the '?' from the key mapping
type FilterByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

// CORRECT - add optionality with '+?' modifier if needed
type FilterByTypeOptional<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]+?: T[K];
};

// Example: Filter to only string properties
interface Person {
  id: number;
  name: string;
  age: number;
  email: string;
}

type StringProps = FilterByType<Person, string>;
// Result: { name: string; email: string; }

type StringPropsOptional = FilterByTypeOptional<Person, string>;
// Result: { name?: string; email?: string; }

// WRONG - complex conditional in mapped type key
type ConditionalOptional<T> = {
  [K in keyof T as K extends 'id' ? never : K]?: T[K];  // Error: '?' in wrong place
};

// CORRECT - use a conditional type wrapper
type ConditionalOptional<T> = T extends any ? {
  [K in keyof T as K extends 'id' ? never : K]?: T[K];
} : never;

// CORRECT - alternative: combine mapped types with Pick/Omit
type WithoutId<T> = Omit<T, 'id'>;
type OptionalWithoutId<T> = {
  [K in keyof WithoutId<T>]+?: WithoutId<T>[K];
};

// Example: Make all properties except 'id' optional
interface Product {
  id: string;
  name: string;
  price: number;
  description?: string;
}

type ProductWithoutIdOptional = OptionalWithoutId<Product>;
// Result: { name?: string; price?: number; description?: string; }

// Using built-in utility types:
type PartialExceptId<T> = Omit<Partial<T>, 'id'> & Pick<T, 'id'>;
// This makes all properties optional except 'id'

// Object type with optional properties
type OptionalProps = {
  name?: string;
  age?: number;
  email?: string;
};

// Equivalent mapped type
type OptionalPropsMapped<T extends { name?: string; age?: number; email?: string }> = {
  [K in keyof T]+?: T[K];
};

// If you need to transform property types:
type TransformToOptional<T> = {
  [K in keyof T]+?: K extends 'email' ? string | null : T[K];
};

// Example with transformation
interface UserInput {
  name: string;
  age: number;
  email: string;
}

type UserInputOptional = TransformToOptional<UserInput>;
// Result: { name?: string; age?: number; email?: string | null; }

// For making specific properties optional:
type MakeSpecificOptional<T, Keys extends keyof T> = {
  [K in keyof T]: K extends Keys ? T[K] | undefined : T[K];
};

// Example: Make only 'email' optional
type UserWithOptionalEmail = MakeSpecificOptional<UserInput, 'email'>;
// Result: { name: string; age: number; email: string | undefined; }

// WRONG - '?' in template literal type in mapped type
type AddPrefix<T> = {
  [K in keyof T as `prefix_${K}`]?: T[K];  // Error
};

// CORRECT - add optionality with modifier
type AddPrefix<T> = {
  [K in keyof T as `prefix_${K}`]+?: T[K];
};

// CORRECT - alternative: make non-optional then add prefix
type AddPrefix<T> = {
  [K in keyof T as `prefix_${K}`]: T[K];
};

type OptionalAddPrefix<T> = {
  [K in keyof T as `prefix_${K}`]+?: T[K];
};

// Example: Add 'db_' prefix to all properties
interface Config {
  host: string;
  port: number;
  password?: string;
}

type DbConfig = AddPrefix<Config>;
// Result: { db_host: string; db_port: number; db_password?: string; }

type DbConfigOptional = OptionalAddPrefix<Config>;
// Result: { db_host?: string; db_port?: number; db_password?: string; }

// For conditional prefixing:
type ConditionalPrefix<T> = {
  [K in keyof T as K extends 'password' ? `secure_${K}` : K]: T[K];
};

type SecureConfig = ConditionalPrefix<Config>;
// Result: { host: string; port: number; secure_password?: string; }

// Common utility types for optional properties:
type Partial<T> = { [K in keyof T]+?: T[K]; };  // Make all properties optional
type Required<T> = { [K in keyof T]-?: T[K]; }; // Make all properties required

// Partial for specific keys:
type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

// Required for specific keys:
type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

// Example usage:
interface Settings {
  theme: string;
  fontSize: number;
  darkMode?: boolean;
  notifications?: boolean;
}

// Make only notifications optional (others stay as-is)
type ThemeSettings = PartialBy<Settings, 'notifications'>;
// Result: { theme: string; fontSize: number; darkMode?: boolean; notifications?: boolean; }

// Make darkMode required (others stay as-is)
type RequiredDarkMode = RequiredBy<Settings, 'darkMode'>;
// Result: { theme: string; fontSize: number; darkMode: boolean; notifications?: boolean; }

// Combine utilities:
type UserSettings = Partial<Pick<Settings, 'darkMode' | 'notifications'>> &
                    Required<Pick<Settings, 'theme' | 'fontSize'>>;
// Result: { theme: string; fontSize: number; darkMode?: boolean; notifications?: boolean; }

// For readonly optional properties:
type ReadonlyPartial<T> = { readonly [K in keyof T]+?: T[K]; };