// The million-dollar Node.js bug:
app.post('/charge', async (req, res) => {
  const charge = await stripe.charges.create(req.body); // ⛔ If this throws, the ENTIRE server crashes!
  res.json({ success: true });
});

// unhandled Promise rejection → Node 15+ crashes the process
// All active connections DROP
// Users lose their orders

ERROR HANDLING STRATEGY DECISION TREE

                    Error occurs
                        │
                        ▼
              ┌─────────────────┐
              │  Type of error? │
              └────────┬────────┘
                       │
         ┌─────────────┴─────────────┐
         ▼                           ▼
  ┌──────────────┐          ┌──────────────────┐
  │  Operational │          │  Programmer       │
  │  (Expected)  │          │  (Bug)            │
  └──────┬───────┘          └──────┬───────────┘
         │                         │
         ▼                         ▼
  ┌──────────────┐          ┌──────────────────┐
  │  Catch it    │          │  Fix the code    │
  │  Handle it   │          │  (crash in dev)  │
  │  Retry/log   │          │  (log in prod)   │
  └──────────────┘          └──────────────────┘
         │                         │
         ▼                         ▼
  ┌──────────────┐          ┌──────────────────┐
  │ Continue     │          │ Process.exit(1)  │
  │ (mostly safe)│          │ (unstable state) │
  └──────────────┘          └──────────────────┘

flowchart TD
    Error["Error"] --> Operational["Operational Errors\n(Expected runtime failures)"]
    Error --> Programmer["Programmer Errors\n(Bugs in code)"]

    Operational --> InvalidInput["Invalid user input"]
    Operational --> DBCrash["Database connection failed"]
    Operational --> Timeout["Request timeout"]
    Operational --> RateLimit["Rate limit exceeded"]
    Operational --> NotFound["File/record not found"]

    Programmer --> TypeError["TypeError: reading property\nof undefined"]
    Programmer --> SyntaxError["Syntax error in eval'd code"]
    Programmer --> LogicBug["Incorrect business logic"]
    Programmer --> MemoryLeak["Memory leak (not freed)"]

    style Operational fill:#d97706,color:#fff
    style Programmer fill:#ef4444,color:#fff

flowchart LR
    subgraph ErrorObj["JavaScript Error Object"]
        Name["name: 'TypeError'"]
        Message["message: 'Cannot read\nproperty of undefined'"]
        Stack["stack: 'at ...'\n'at ...'\n'at ...'"]
        Cause["cause: originalError\n(ES2022)"]
    end

    Name --> Stack
    Message --> Stack

    style ErrorObj fill:#ef4444,color:#fff

sequenceDiagram
    participant Express as Express Route
    participant Service as Business Service
    participant DB as Database
    participant ErrorMW as Error Middleware

    Express->>Service: getUser(id)
    Service->>DB: findById(id)
    DB-->>Service: Reject (not found)
    Service->>Service: throw AppError('Not found', 404)
    Note over Service: Error propagates UP<br/>through async/await
    Service-->>Express: Promise rejects
    Express-->>ErrorMW: next(error)
    Note over ErrorMW: 4-parameter middleware<br/>(err, req, res, next)
    ErrorMW->>ErrorMW: Log error
    ErrorMW->>ErrorMW: Send to Sentry
    ErrorMW-->>Client: 404 JSON response

flowchart TB
    subgraph Layers["Error Handling Layers"]
        L1["Layer 1: try/catch in functions\nCatch + transform errors"]
        L2["Layer 2: Express error middleware\nCentral JSON error formatter"]
        L3["Layer 3: Async handler wrapper\nCatch async route errors"]
        L4["Layer 4: process.on('unhandledRejection')\nLog + shutdown"]
        L5["Layer 5: process.on('uncaughtException')\nLast resort"]
    end

    subgraph Monitoring["Error Monitoring"]
        Sentry["Sentry / Bugsnag\n(error tracking)"]
        Logger["Pino / Winston\n(structured logging)"]
        Alert["PagerDuty / Slack\n(alerting)"]
    end

    Layers --> Sentry
    Layers --> Logger
    Logger --> Alert

    style Layers fill:#4f46e5,color:#fff
    style Monitoring fill:#dc2626,color:#fff

sequenceDiagram
    participant Client as Client
    participant Route as Route Handler
    participant Service as Service Layer
    participant Error as Error Handler
    participant Logger as Logger

    Client->>Route: Invalid request
    Route->>Service: process(order)
    Service->>Service: Validation fails
    Service-->>Route: throw AppError('Invalid', 400)
    Route->>Error: next(error)
    Error->>Logger: log.error({ err, requestId })
    Logger->>Logger: JSON log entry
    Error->>Error: Format response
    Error-->>Client: { error: 'Invalid', status: 400 }

// CUSTOM ERROR CLASS
class AppError extends Error {
  constructor(message, statusCode = 500) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true;
    Error.captureStackTrace(this, this.constructor);
  }
}

// ASYNC HANDLER WRAPPER
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

// EXPRESS ERROR MIDDLEWARE (4 params!)
app.use((err, req, res, next) => {
  const statusCode = err.statusCode || 500;
  res.status(statusCode).json({
    status: 'error',
    message: err.message,
    ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
  });
});

class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true;
  }
}

class NotFoundError extends AppError {
  constructor(resource = 'Resource') {
    super(`${resource} not found`, 404);
  }
}

class ValidationError extends AppError {
  constructor(errors) {
    super('Validation failed', 400);
    this.errors = errors;
  }
}

class AuthError extends AppError {
  constructor() {
    super('Authentication required', 401);
  }
}

// Usage
app.get('/users/:id', asyncHandler(async (req, res) => {
  const user = await findUser(req.params.id);
  if (!user) throw new NotFoundError('User');
  res.json(user);
}));

// Without wrapper — error crashes the process!
app.get('/users', async (req, res) => {
  const users = await getUsers(); // If this rejects → 💥 CRASH
  res.json(users);
});

// With wrapper — error goes to middleware
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

app.get('/users', asyncHandler(async (req, res) => {
  const users = await getUsers();
  res.json(users);
}));

// Or use express-async-errors (auto-wraps everything):
require('express-async-errors');

// Instead of try/catch everywhere, use a Result type
class Result {
  static success(value) {
    return { success: true, value, error: null };
  }

  static failure(error) {
    return { success: false, value: null, error };
  }
}

async function findUser(id) {
  try {
    const user = await db.users.findById(id);
    if (!user) return Result.failure(new NotFoundError('User'));
    return Result.success(user);
  } catch (err) {
    return Result.failure(err);
  }
}

const result = await findUser(id);
if (!result.success) {
  logger.error('User lookup failed:', result.error);
  return res.status(404).json({ error: 'Not found' });
}
const user = result.value; // Type-safe!

// ─── CUSTOM ERRORS ──────────────────────────────────
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true;
  }
}

// ─── PROCESS-LEVEL HANDLERS ────────────────────────
process.on('unhandledRejection', (reason) => {
  logger.error({ err: reason }, 'UNHANDLED REJECTION');
  // Log, then shutdown
  server.close(() => process.exit(1));
  setTimeout(() => process.exit(1), 10000).unref();
});

process.on('uncaughtException', (err) => {
  logger.error({ err }, 'UNCAUGHT EXCEPTION');
  // Must exit — app is unstable
  process.exit(1);
});

// ─── EXPRESS ERROR MIDDLEWARE ──────────────────────
app.use((err, req, res, next) => {
  // Default to 500
  err.statusCode = err.statusCode || 500;

  // Log everything
  logger.error({
    err,
    requestId: req.id,
    method: req.method,
    url: req.url,
    userId: req.user?.id,
  }, 'Request error');

  // Don't leak internals in production
  const message = process.env.NODE_ENV === 'production'
    ? 'Internal Server Error'
    : err.message;

  res.status(err.statusCode).json({
    error: message,
    statusCode: err.statusCode,
    ...(err.errors && { errors: err.errors }), // Validation errors
  });
});

// ─── 404 HANDLER ────────────────────────────────────
app.use((req, res) => {
  res.status(404).json({ error: 'Route not found' });
});

V8 stack trace generation:
1. Error.captureStackTrace(this, constructor)
2. V8 walks the call stack
3. Extracts: file, line number, column, function name
4. Formats as: "at functionName (file:line:col)"
5. Attaches to error.stack

Express error middleware detection:
1. Express checks middleware arity (number of params)
2. 4 params (err, req, res, next) → error middleware
3. Express skips regular middleware on error
4. Calls error middleware in registration order

// MISTAKE 1: Swallowing errors
try { await risky(); } catch (e) {}
// Never do this! At minimum: logger.error(e);

// MISTAKE 2: Not handling promise rejections
async function load() {
  await fetchData(); // If this rejects → unhandled!
}
load(); // No .catch()!

// MISTAKE 3: Catching but not throwing
try { await db.save(); }
catch (err) {
  logger.error(err);
  // Forgot to throw or return error response!
}

// MISTAKE 4: Using uncaughtException to keep running
process.on('uncaughtException', (err) => {
  // Don't just log and continue — app state is corrupted
  // Always exit after uncaughtException
});

// Find and fix 5 error handling bugs:
app.get('/users/:id', async (req, res) => {
  const user = await db.users.findById(req.params.id); // Bug 1
  if (!user) res.status(404).json({ error: 'Not found' }); // Bug 2
  res.json(user);
});
process.on('unhandledRejection', (err) => { /* Bug 3 */ });
process.on('uncaughtException', (err) => { logger.error(err); }); // Bug 4

// Custom error
class AppError extends Error {
  constructor(m, c) { super(m); this.statusCode = c; this.isOperational = true; }
}
// Async wrapper
const asyncHandler = (fn) => (req, res, next) => fn(req, res, next).catch(next);
// Error middleware
app.use((err, req, res, next) => { res.status(err.statusCode || 500).json({error: err.message}); });
// Process handlers
process.on('unhandledRejection', (r) => { logger.error(r); process.exit(1); });
process.on('uncaughtException', (e) => { logger.error(e); process.exit(1); });