How to fix unknown operator: $invalidOperator in MongoDB

// Example of incorrect query
db.collection.find({
  age: { $get: 18 }  // ERROR: Should be $gte
});

// Correct query
db.collection.find({
  age: { $gte: 18 }  // CORRECT
});

// Another common mistake
db.collection.find({
  tags: { $inn: ['mongodb', 'nodejs'] }  // ERROR: Should be $in
});

// Correct
db.collection.find({
  tags: { $in: ['mongodb', 'nodejs'] }  // CORRECT
});

# In mongosh or mongo shell
db.version()

# Or from command line
mongod --version

// MongoDB 5.0+ operator (won't work in 4.x)
db.collection.updateOne(
  { _id: 1 },
  { $setField: { field: "status", value: "active" } }  // ERROR in MongoDB 4.x
);

// Alternative for older versions
db.collection.updateOne(
  { _id: 1 },
  { $set: { status: "active" } }  // Works in all versions
);

# Example: Check if $unionWith is available
# Requires MongoDB 4.4+
# If running MongoDB 4.2, this will fail

db.collection.aggregate([
  { $unionWith: "otherCollection" }  // ERROR in MongoDB < 4.4
]);

// ERROR: $match is an aggregation operator, not a query operator
db.collection.find({ $match: { status: "active" } });

// CORRECT: Use standard query operators
db.collection.find({ status: "active" });

// CORRECT: $match in aggregation pipeline
db.collection.aggregate([{ $match: { status: "active" } }]);

// ERROR: $gt is a query operator, not an update operator
db.collection.updateOne({}, { $gt: { count: 5 } });

// CORRECT: Use update operators
db.collection.updateOne({}, { $inc: { count: 1 } });

// CORRECT: $gt in query filter, update operators in update
db.collection.updateOne(
  { count: { $gt: 5 } },  // Query filter
  { $set: { status: "high" } }  // Update operation
);

// ERROR: $and at wrong level
db.collection.find({
  $and: { status: "active", age: { $gt: 18 } }  // Should be array
});

// CORRECT: $and expects array of conditions
db.collection.find({
  $and: [
    { status: "active" },
    { age: { $gt: 18 } }
  ]
});

// Even better: implicit $and
db.collection.find({
  status: "active",
  age: { $gt: 18 }
});

// ERROR: $size on non-array field
db.collection.find({ name: { $size: 5 } });

// CORRECT: $size only works on arrays
db.collection.find({ tags: { $size: 5 } });

// CORRECT: For strings, use $strLenBytes or $strLenCP (aggregation)
// or application-level string length check

# Start mongod with verbose logging
mongod --verbose

# Or enable profiling
db.setProfilingLevel(2)  // Log all queries

# Check the profiler for failed queries
db.system.profile.find({ err: { $exists: true } }).pretty()

const { MongoClient } = require('mongodb');

async function validateQuery(collection, query) {
  try {
    // Try to explain the query (validates without executing)
    await collection.find(query).explain();
    console.log('Query is valid');
    return true;
  } catch (error) {
    console.log('Query validation failed:', error.message);

    // Check if it's an unknown operator error
    if (error.message.includes('unknown operator')) {
      // Extract operator name from error message
      const match = error.message.match(/\$(\w+)/);
      if (match) {
        console.log('Invalid operator detected: $' + match[1]);
      }
    }
    return false;
  }
}

// Usage
const client = new MongoClient('mongodb://localhost:27017');
await client.connect();
const db = client.db('test');
const collection = db.collection('users');

const invalidQuery = { age: { $get: 18 } };  // Invalid operator
await validateQuery(collection, invalidQuery);

const validOperators = new Set([
  // Comparison operators
  'eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin',
  // Logical operators
  'and', 'or', 'not', 'nor',
  // Element operators
  'exists', 'type',
  // Evaluation operators
  'expr', 'jsonSchema', 'mod', 'regex', 'text', 'where',
  // Array operators
  'all', 'elemMatch', 'size'
]);

function validateQueryOperators(query, path = '') {
  for (const [key, value] of Object.entries(query)) {
    if (key.startsWith('$')) {
      const operator = key.substring(1);
      if (!validOperators.has(operator)) {
        throw new Error('Invalid operator $' + operator + ' at path: ' + path);
      }
    }

    if (value && typeof value === 'object' && !Array.isArray(value)) {
      validateQueryOperators(value, path ? path + '.' + key : key);
    }
  }
}

// Usage
try {
  validateQueryOperators({ age: { $get: 18 } });
} catch (error) {
  console.log('Validation error:', error.message);
}

// WRONG
db.collection.find({ age: { $get: 18 } });

// CORRECT
db.collection.find({ age: { $gte: 18 } });

// WRONG (common misconception)
db.collection.find({ tags: { $contains: 'mongodb' } });

// CORRECT: Check if array contains value
db.collection.find({ tags: 'mongodb' });  // Shorthand

// CORRECT: Check if value is in array
db.collection.find({ role: { $in: ['admin', 'editor'] } });

// WRONG (SQL habit)
db.collection.find({ name: { $like: '%john%' } });

// CORRECT: Use $regex
db.collection.find({ name: { $regex: 'john', $options: 'i' } });

// CORRECT: Case-insensitive search
db.collection.find({ name: { $regex: '^john', $options: 'i' } });

// WRONG (SQL habit)
db.collection.find({ age: { $between: [18, 65] } });

// CORRECT: Use $gte and $lte
db.collection.find({
  age: { $gte: 18, $lte: 65 }
});

// OR use $and for clarity
db.collection.find({
  $and: [
    { age: { $gte: 18 } },
    { age: { $lte: 65 } }
  ]
});

// WRONG: $length doesn't exist
db.collection.find({ name: { $length: 5 } });

// CORRECT: Use aggregation for string length
db.collection.aggregate([
  { $match: { $expr: { $eq: [{ $strLenCP: "$name" }, 5] } } }
]);

// CORRECT: Application-level filtering
// Fetch then filter in application code

// WRONG: $empty doesn't exist
db.collection.find({ comments: { $empty: true } });

// CORRECT: Check for null/empty array
db.collection.find({
  $or: [
    { comments: null },
    { comments: { $size: 0 } }
  ]
});

// CORRECT: $exists check
db.collection.find({ comments: { $exists: false } });

import { MongoClient, Filter, UpdateFilter } from 'mongodb';

// Type-safe query construction
const query: Filter<Document> = {
  age: { $gte: 18 },  // TypeScript will catch $get typo
  status: { $in: ['active', 'pending'] }
};

const update: UpdateFilter<Document> = {
  $set: { lastLogin: new Date() },
  $inc: { loginCount: 1 }
};

// TypeScript error for invalid operator
const invalidQuery = {
  age: { $get: 18 }  // TypeScript error: $get not assignable
};

// operator-utils.js
const Operators = {
  COMPARISON: {
    EQ: '$eq',
    NE: '$ne',
    GT: '$gt',
    GTE: '$gte',
    LT: '$lt',
    LTE: '$lte',
    IN: '$in',
    NIN: '$nin'
  },
  LOGICAL: {
    AND: '$and',
    OR: '$or',
    NOT: '$not',
    NOR: '$nor'
  }
  // ... other operator categories
};

// Usage
const query = {
  age: { [Operators.COMPARISON.GTE]: 18 },
  status: { [Operators.COMPARISON.IN]: ['active', 'pending'] }
};

// This prevents typos

// query-validator.js
const validOperators = require('./valid-operators.json');

function validateMongoQuery(query, context = 'find') {
  const errors = [];

  function traverse(obj, path = '') {
    for (const [key, value] of Object.entries(obj)) {
      if (key.startsWith('$')) {
        const operator = key.substring(1);
        if (!validOperators[context].includes(operator)) {
          errors.push('Invalid ' + context + ' operator $' + operator + ' at ' + path);
        }
      }

      if (value && typeof value === 'object') {
        traverse(value, path ? path + '.' + key : key);
      }
    }
  }

  traverse(query);
  return errors;
}

// Usage in application
const query = { age: { $get: 18 } };
const errors = validateMongoQuery(query, 'find');
if (errors.length > 0) {
  console.log('Query validation errors:', errors);
  throw new Error('Invalid query');
}

// version-aware-queries.js
const MONGODB_VERSION = process.env.MONGODB_VERSION || '5.0';

const versionConstraints = {
  '5.0': ['$getField', '$setField', '$unsetField'],
  '4.4': ['$unionWith', '$convert', '$toBool'],
  '4.2': ['$merge'],
  '4.0': ['$convert', '$toObjectId']
};

function isOperatorSupported(operator) {
  const version = MONGODB_VERSION;
  for (const [minVersion, operators] of Object.entries(versionConstraints)) {
    if (compareVersions(version, minVersion) >= 0) {
      if (operators.includes(operator)) {
        return true;
      }
    }
  }
  return false; // Assume supported if not in constraints
}

function buildSafeQuery(baseQuery) {
  const safeQuery = { ...baseQuery };
  // Remove unsupported operators
  // ... implementation
  return safeQuery;
}