How to fix TypeMismatch: cannot compare to undefined in MongoDB

// Problem: Undefined value in query
const userId = req.params.userId; // Might be undefined
db.collection('users').find({ _id: userId }); // TypeMismatch error

// Solution: Validate before querying
const userId = req.params.userId;
if (!userId) {
  throw new Error('User ID is required');
}
db.collection('users').find({ _id: userId });

// Problem: Comparing to undefined in $expr
db.collection('products').find({
  $expr: {
    $eq: ['$category', undefined] // Cannot compare to undefined
  }
});

// Solution: Use null instead
db.collection('products').find({
  $expr: {
    $eq: ['$category', null]
  }
});

// Problem: Passing undefined from JavaScript
const filters = {
  status: searchParams.status, // Might be undefined
  category: searchParams.category // Might be undefined
};

db.collection('items').find(filters);

// Solution: Filter out undefined values
const filters = {};
if (searchParams.status !== undefined) {
  filters.status = searchParams.status;
}
if (searchParams.category !== undefined) {
  filters.category = searchParams.category;
}

db.collection('items').find(filters);

// Or use a utility function
const cleanFilters = Object.fromEntries(
  Object.entries({
    status: searchParams.status,
    category: searchParams.category
  }).filter(([_, value]) => value !== undefined)
);

db.collection('items').find(cleanFilters);

// Problem: Comparison fails if field is missing
db.collection('orders').aggregate([
  {
    $match: {
      $expr: {
        $gt: ['$discountAmount', 0] // Error if discountAmount is undefined
      }
    }
  }
]);

// Solution: Use $ifNull to provide a default value
db.collection('orders').aggregate([
  {
    $match: {
      $expr: {
        $gt: [{ $ifNull: ['$discountAmount', 0] }, 0]
      }
    }
  }
]);

// Or handle missing fields explicitly
db.collection('orders').aggregate([
  {
    $addFields: {
      discountAmount: { $ifNull: ['$discountAmount', 0] }
    }
  },
  {
    $match: {
      discountAmount: { $gt: 0 }
    }
  }
]);

// Problem: Trying to find documents where field is undefined
db.collection('users').find({
  email: undefined // Error: cannot compare to undefined
});

// Solution: Query for null OR missing field
db.collection('users').find({
  email: null // Matches null values AND missing fields (before MongoDB 8.0)
});

// For MongoDB 8.0+: null no longer matches missing fields
// To match ONLY null values:
db.collection('users').find({
  email: { $eq: null },
  email: { $exists: true } // Field exists but is null
});

// To match missing fields:
db.collection('users').find({
  email: { $exists: false }
});

// To match null OR missing:
db.collection('users').find({
  $or: [
    { email: null },
    { email: { $exists: false } }
  ]
});

// Problem: Conditional with undefined comparison
db.collection('products').aggregate([
  {
    $project: {
      displayPrice: {
        $cond: {
          if: { $eq: ['$salePrice', undefined] }, // Error
          then: '$regularPrice',
          else: '$salePrice'
        }
      }
    }
  }
]);

// Solution 1: Use $ifNull
db.collection('products').aggregate([
  {
    $project: {
      displayPrice: {
        $ifNull: ['$salePrice', '$regularPrice']
      }
    }
  }
]);

// Solution 2: Check field existence
db.collection('products').aggregate([
  {
    $project: {
      displayPrice: {
        $cond: {
          if: { $gt: ['$salePrice', null] }, // true if field exists and not null
          then: '$salePrice',
          else: '$regularPrice'
        }
      }
    }
  }
]);

// Problem: Mongoose passes undefined values
const User = mongoose.model('User');

const filters = {
  email: req.query.email, // May be undefined
  status: req.query.status // May be undefined
};

await User.find(filters); // May cause errors

// Solution 1: Set Mongoose to strip undefined
mongoose.set('strictQuery', true);

// Solution 2: Clean the query object manually
const cleanQuery = Object.fromEntries(
  Object.entries({
    email: req.query.email,
    status: req.query.status
  }).filter(([_, v]) => v !== undefined && v !== null && v !== '')
);

await User.find(cleanQuery);

// Solution 3: Build query conditionally
const query = {};
if (req.query.email) query.email = req.query.email;
if (req.query.status) query.status = req.query.status;

await User.find(query);