How to fix TypeError: Cannot read property 'foo' of undefined in Node.js

// Bad: Direct access without checking
function getUserName(user) {
  return user.name; // Throws if user is null/undefined
}

// Good: Check before accessing
function getUserName(user) {
  if (user === null || user === undefined) {
    return 'Guest';
  }
  return user.name;
}

// Alternative: Check for truthy value
function getUserName(user) {
  if (!user) {
    return 'Guest';
  }
  return user.name;
}

// Bad: Assumes nested structure exists
const city = data.user.address.city;

// Good: Check each level
let city = null;
if (data && data.user && data.user.address) {
  city = data.user.address.city;
}

// Instead of manual null checks
const city = data?.user?.address?.city;

// Returns undefined if any part of the chain is null/undefined
// No error is thrown

// Combine with nullish coalescing for defaults
const city = data?.user?.address?.city ?? 'Unknown';

// Works with function calls too
const result = obj.method?.();

// Works with array access
const firstItem = arr?.[0];

// Express route handler
app.get('/user/:id', async (req, res) => {
  const user = await db.users.findById(req.params.id);

  // Safe access to potentially missing data
  res.json({
    name: user?.name ?? 'Unknown',
    email: user?.email,
    city: user?.address?.city
  });
});

// Bad: Properties might be undefined
function processConfig(config) {
  const { host, port, timeout } = config;
  // If config.timeout is undefined, timeout variable is undefined
}

// Good: Provide defaults during destructuring
function processConfig(config = {}) {
  const {
    host = 'localhost',
    port = 3000,
    timeout = 5000
  } = config;

  console.log(`Connecting to ${host}:${port}`);
}

// Works with nested objects
function processUser(data) {
  const {
    user: {
      name = 'Guest',
      email = '[email protected]'
    } = {}
  } = data;

  return { name, email };
}

function validateUser(user) {
  if (!user || typeof user !== 'object') {
    throw new Error('Invalid user object');
  }

  if (!user.id || !user.email) {
    throw new Error('User missing required fields: id, email');
  }

  return true;
}

// Use in API handlers
app.post('/users', async (req, res) => {
  try {
    validateUser(req.body);
    const user = await db.users.create(req.body);
    res.json(user);
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});

import { z } from 'zod';

const UserSchema = z.object({
  id: z.string(),
  email: z.string().email(),
  name: z.string(),
  address: z.object({
    city: z.string(),
    country: z.string()
  }).optional()
});

// Parse and validate
app.post('/users', async (req, res) => {
  const result = UserSchema.safeParse(req.body);

  if (!result.success) {
    return res.status(400).json({ errors: result.error.issues });
  }

  // Now result.data is guaranteed to have the correct structure
  const user = await db.users.create(result.data);
  res.json(user);
});

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "strictNullChecks": true
  }
}

interface User {
  id: string;
  name: string;
  email?: string; // Optional property
  address?: {
    city: string;
    country: string;
  };
}

function getUserCity(user: User | null): string {
  // TypeScript error: Object is possibly null
  // return user.address.city;

  // Correct: Handle null case
  if (!user || !user.address) {
    return 'Unknown';
  }
  return user.address.city;

  // Or use optional chaining
  return user?.address?.city ?? 'Unknown';
}

// Add strategic console.log statements
function processOrder(order) {
  console.log('Order:', order); // Check if order exists
  console.log('Customer:', order.customer); // Check nested object

  return order.customer.name;
}

// Use debugger statement
function processOrder(order) {
  debugger; // Execution pauses here in dev tools
  return order.customer.name;
}

// Use try-catch to get stack trace
function processOrder(order) {
  try {
    return order.customer.name;
  } catch (error) {
    console.error('Error processing order:', error);
    console.error('Order object:', JSON.stringify(order, null, 2));
    throw error;
  }
}

// With error monitoring service
app.use((err, req, res, next) => {
  console.error('Unhandled error:', err);
  console.error('Request body:', req.body);
  console.error('Request params:', req.params);

  // Send to monitoring service (Sentry, Rollbar, etc.)
  errorMonitor.captureException(err, {
    extra: {
      body: req.body,
      params: req.params,
      query: req.query
    }
  });

  res.status(500).json({ error: 'Internal server error' });
});