How to fix Required parameter cannot follow optional parameter in TypeScript

// ERROR: Required parameter cannot follow optional parameter
function greet(name?: string, greeting: string): void {
  // name is optional, greeting is required - WRONG ORDER
  console.log(`${greeting}, ${name || "Guest"}!`);
}

// CORRECT: Optional parameters come after required ones
function greet(greeting: string, name?: string): void {
  // greeting is required, name is optional - CORRECT ORDER
  console.log(`${greeting}, ${name || "Guest"}!`);
}

// Now you can call it correctly:
greet("Hello"); // Works: name is optional
greet("Hello", "John"); // Also works

// Using default values instead of optional syntax
function greet(greeting: string, name: string = "Guest"): void {
  console.log(`${greeting}, ${name}!`);
}

// Both calls work:
greet("Hello"); // Uses default "Guest"
greet("Hello", "John"); // Uses provided name

// This also works with multiple optional parameters:
function createUser(
  username: string, // required
  email: string = "", // optional with default
  isAdmin: boolean = false // optional with default
) {
  // ...
}

interface UserService {
  // ERROR: Optional before required
  findUsers(filter?: string, limit: number): User[];
}

interface UserService {
  // CORRECT: Required before optional
  findUsers(limit: number, filter?: string): User[];
}

class UserRepository {
  // ERROR in class method
  save(user?: User, validate: boolean): void {}
  
  // CORRECT
  save(validate: boolean, user?: User): void {}
}

// Function type declaration
type GreetFunction = (name?: string, greeting: string) => void; // ERROR

type GreetFunction = (greeting: string, name?: string) => void; // CORRECT

// Callback parameter
type Callback = (error?: Error, data: any) => void; // Common Node.js pattern - ERROR!

// Node.js callback pattern should use:
type Callback = (error: Error | null, data?: any) => void; // CORRECT
// OR
type Callback = (error: Error | null | undefined, data: any) => void; // Also works

// Instead of many optional parameters:
function createUser(
  username: string,
  email?: string,
  age?: number,
  isAdmin?: boolean,
  createdAt?: Date
) {
  // Hard to manage, error-prone
}

// Use a parameter object:
interface UserOptions {
  username: string;
  email?: string;
  age?: number;
  isAdmin?: boolean;
  createdAt?: Date;
}

function createUser(options: UserOptions) {
  // All options are accessible via options.property
  // No ordering issues
}

// Clean usage:
createUser({
  username: "john_doe",
  email: "[email protected]",
  isAdmin: true
});

// ERROR: Overload with incorrect ordering
function process(input: string, validate?: boolean): string;
function process(input: number, validate?: boolean): number;
function process(input: string | number, validate?: boolean) {
  // Implementation
}

// Actually this is CORRECT since optional is last
// But if you had:
function process(validate?: boolean, input: string): string; // ERROR in overload
function process(validate?: boolean, input: number): number; // ERROR in overload
function process(validate: boolean, input: string | number) {
  // Implementation would be wrong
}

// Instead of many optional parameters:
function join(
  separator?: string,
  ...items: string[] // ERROR: rest parameter must be last
): string {
  return items.join(separator);
}

// CORRECT: Required first, then optional, then rest
function join(
  items: string[], // required
  separator: string = ",", // optional with default
  ...extraOptions: any[] // rest parameter last
): string {
  return items.join(separator);
}