TypeScript中处理MongoDB findOne返回null的类型匹配问题

Hey there, let's tackle this TypeScript type issue with MongoDB's findOne method—super common when working with typed collections!

The root of the problem is straightforward: TypeScript enforces strict type checking, and findOne explicitly returns a type of UserStructure | null (since it can return null when no document matches your query). Your variable is typed as UserStructure, which doesn't accept null, hence the error.

Here are practical, actionable solutions tailored to different scenarios:

1. Explicitly check for null (most recommended) #

Add a guard clause to handle the "no document found" case first. TypeScript will automatically narrow the type to UserStructure once you eliminate null:

// First, make sure you're typing the collection correctly
const userCollection = db.collection<UserStructure>('users');
const user = await userCollection.findOne({ _id: userId });

// Handle the null case upfront
if (!user) {
  return res.status(404).json({ message: 'User not found' });
}

// Now TypeScript knows `user` is definitely a UserStructure
const targetUser: UserStructure = user;

This is the safest approach because it forces you to handle edge cases where the document doesn't exist, preventing runtime errors later.

2. Use the non-null assertion operator (only if you're 100% sure the document exists) #

If you have prior knowledge that the document must exist (e.g., you just created it in the same request), you can use the ! operator to tell TypeScript to ignore the null possibility:

const user = await db.collection<UserStructure>('users').findOne({ _id: userId })!;
const targetUser: UserStructure = user;

Warning: Use this sparingly! If the document doesn't exist, this will cause a runtime error (you'll be trying to access properties on null).

3. Adjust your variable type to accept null #

If your business logic allows the variable to be null, update its type to match what findOne returns:

const targetUser: UserStructure | null = await db.collection<UserStructure>('users').findOne({ _id: userId });

// Remember to handle the null case when using targetUser later
if (targetUser) {
  // Do something with the user
} else {
  // Handle missing user
}

This is useful if you need to keep the null value for further processing instead of returning early.

4. Use a type guard for stricter validation #

For more complex scenarios where you want to ensure the returned object actually matches your UserStructure interface (not just rely on MongoDB's typing), create a custom type guard:

function isUserStructure(obj: unknown): obj is UserStructure {
  // Adjust this check to match the fields in your UserStructure
  return (
    typeof obj === 'object' &&
    obj !== null &&
    '_id' in obj &&
    'email' in obj &&
    'username' in obj
  );
}

const user = await db.collection<UserStructure>('users').findOne({ _id: userId });

if (!isUserStructure(user)) {
  return res.status(400).json({ message: 'Invalid user data returned' });
}

const targetUser: UserStructure = user;

This adds an extra layer of safety, especially if you're dealing with untrusted data or want to validate MongoDB's response against your interface.

内容的提问来源于stack exchange，提问作者Pablo Verduzco