与TypeScript的结合使用

与TypeScript的结合使用

TypeScript为Mongoose提供了强大的类型支持，使得在开发过程中能够更好地捕获潜在的错误。通过定义Schema和Model的类型，可以确保数据的结构和操作符合预期。以下是如何在Mongoose中结合TypeScript的具体实践。

定义Schema与接口

首先，需要定义一个TypeScript接口来描述文档的结构，然后使用该接口来创建Schema。例如，定义一个用户模型：

import { Schema, model, Document } from 'mongoose';

interface IUser extends Document {
  name: string;
  age: number;
  email: string;
  createdAt: Date;
}

const userSchema = new Schema<IUser>({
  name: { type: String, required: true },
  age: { type: Number, required: true },
  email: { type: String, required: true, unique: true },
  createdAt: { type: Date, default: Date.now }
});

const User = model<IUser>('User', userSchema);

这里，IUser接口扩展了Document，确保它包含Mongoose文档的默认属性和方法。userSchema使用泛型<IUser>来指定文档类型。

使用Model进行CRUD操作

创建Model后，可以执行各种数据库操作。TypeScript会检查这些操作是否符合接口定义：

// 创建用户
const createUser = async (userData: Omit<IUser, 'createdAt'>) => {
  const user = new User(userData);
  await user.save();
  return user;
};

// 查询用户
const findUserByEmail = async (email: string) => {
  return await User.findOne({ email }).exec();
};

// 更新用户
const updateUserAge = async (userId: string, newAge: number) => {
  return await User.findByIdAndUpdate(userId, { age: newAge }, { new: true }).exec();
};

// 删除用户
const deleteUser = async (userId: string) => {
  return await User.findByIdAndDelete(userId).exec();
};

处理嵌套文档和数组

对于嵌套文档或数组字段，可以进一步定义子接口。例如，一个博客文章模型可能包含评论数组：

interface IComment {
  content: string;
  author: string;
  createdAt: Date;
}

interface IPost extends Document {
  title: string;
  content: string;
  comments: IComment[];
}

const postSchema = new Schema<IPost>({
  title: { type: String, required: true },
  content: { type: String, required: true },
  comments: [{
    content: { type: String, required: true },
    author: { type: String, required: true },
    createdAt: { type: Date, default: Date.now }
  }]
});

const Post = model<IPost>('Post', postSchema);

使用虚拟属性和方法

虚拟属性和方法也可以通过TypeScript接口定义。例如，为用户添加一个虚拟的全名属性：

interface IUser extends Document {
  firstName: string;
  lastName: string;
  fullName: string;
}

userSchema.virtual('fullName').get(function(this: IUser) {
  return `${this.firstName} ${this.lastName}`;
});

类型安全的查询和聚合

TypeScript还可以帮助确保查询和聚合操作的类型安全。例如，使用Query和Aggregate泛型：

const getAdultUsers = async (): Promise<IUser[]> => {
  return await User.find({ age: { $gte: 18 } }).exec();
};

const getUserStats = async (): Promise<{ _id: string; count: number }[]> => {
  return await User.aggregate([
    { $group: { _id: '$name', count: { $sum: 1 } } }
  ]).exec();
};

处理插件和中间件

如果使用Mongoose插件或中间件，可以通过类型断言或扩展接口来保持类型安全。例如，为Schema添加时间戳插件：

import { plugin } from 'mongoose';

interface ITimestamps {
  createdAt: Date;
  updatedAt: Date;
}

userSchema.plugin((schema: Schema) => {
  schema.add({ createdAt: Date, updatedAt: Date });
  schema.pre('save', function(this: IUser & ITimestamps, next) {
    if (!this.createdAt) this.createdAt = new Date();
    this.updatedAt = new Date();
    next();
  });
});

自定义验证和类型守卫

自定义验证函数可以通过类型守卫确保数据符合预期。例如，验证电子邮件格式：

const isEmail = (value: string): value is string => {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
};

userSchema.path('email').validate(function(this: IUser, value: string) {
  return isEmail(value);
}, 'Invalid email format');

与Express或NestJS集成

在Express或NestJS中，可以进一步利用TypeScript的类型系统。例如，定义一个Express路由处理用户创建：

import { Request, Response } from 'express';

const createUserHandler = async (req: Request<{}, {}, Omit<IUser, 'createdAt'>>, res: Response) => {
  try {
    const user = await createUser(req.body);
    res.status(201).json(user);
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
};

类型安全的Populate操作

当使用populate时，可以通过泛型指定填充字段的类型。例如，填充用户的朋友列表：

interface IUser extends Document {
  friends: IUser[];
}

const getUserWithFriends = async (userId: string) => {
  return await User.findById(userId).populate<{ friends: IUser[] }>('friends').exec();
};

处理可选字段和默认值

对于可选字段，可以在接口中使用?标记，并在Schema中设置默认值：

interface IProduct extends Document {
  name: string;
  price: number;
  stock?: number;
}

const productSchema = new Schema<IProduct>({
  name: { type: String, required: true },
  price: { type: Number, required: true },
  stock: { type: Number, default: 0 }
});

使用枚举和联合类型

TypeScript的枚举和联合类型可以与Mongoose结合使用。例如，定义用户角色：

enum UserRole {
  Admin = 'admin',
  User = 'user',
  Guest = 'guest'
}

interface IUser extends Document {
  role: UserRole;
}

const userSchema = new Schema<IUser>({
  role: { type: String, enum: Object.values(UserRole), default: UserRole.User }
});

类型安全的实例方法

为文档添加实例方法时，可以通过接口扩展确保类型安全：

interface IUser extends Document {
  greet(): string;
}

userSchema.methods.greet = function(this: IUser): string {
  return `Hello, ${this.name}!`;
};

静态方法的类型定义

静态方法也可以通过接口扩展定义：

interface IUserModel extends Model<IUser> {
  findByEmail(email: string): Promise<IUser | null>;
}

userSchema.statics.findByEmail = async function(email: string): Promise<IUser | null> {
  return this.findOne({ email }).exec();
};

const User = model<IUser, IUserModel>('User', userSchema);

处理复杂查询条件

对于复杂查询条件，可以使用TypeScript的实用类型。例如，定义一个部分更新的类型：

type PartialUserUpdate = Partial<Omit<IUser, 'createdAt'>>;

const updateUser = async (userId: string, update: PartialUserUpdate) => {
  return await User.findByIdAndUpdate(userId, update, { new: true }).exec();
};

类型安全的插件开发

开发自定义Mongoose插件时，可以通过泛型保持类型安全：

function timestampPlugin<T extends Document>(schema: Schema<T>) {
  schema.add({ createdAt: Date, updatedAt: Date });
  schema.pre('save', function(this: T & { createdAt?: Date; updatedAt?: Date }, next) {
    if (!this.createdAt) this.createdAt = new Date();
    this.updatedAt = new Date();
    next();
  });
}

与GraphQL集成

如果使用GraphQL，可以定义对应的TypeScript类型。例如，定义一个GraphQL用户类型：

import { GraphQLObjectType, GraphQLString, GraphQLInt } from 'graphql';

const UserType = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: { type: GraphQLString },
    name: { type: GraphQLString },
    age: { type: GraphQLInt },
    email: { type: GraphQLString }
  })
});

性能优化与类型检查

TypeScript的类型检查可以帮助避免一些性能问题。例如，确保查询时只选择需要的字段：

const getUsersWithMinimalData = async (): Promise<Pick<IUser, 'name' | 'email'>[]> => {
  return await User.find().select('name email').exec();
};

错误处理与类型断言

在处理数据库错误时，可以使用类型断言确保错误类型：

const safeDeleteUser = async (userId: string) => {
  try {
    const result = await User.findByIdAndDelete(userId).exec();
    if (!result) throw new Error('User not found');
    return result;
  } catch (error) {
    if (error instanceof Error) {
      console.error('Deletion failed:', error.message);
    }
    throw error;
  }
};

使用装饰器简化定义

如果使用TypeScript装饰器，可以进一步简化模型定义。例如，使用typegoose库：

import { prop, getModelForClass } from '@typegoose/typegoose';

class UserClass {
  @prop({ required: true })
  public name!: string;

  @prop({ required: true })
  public age!: number;

  @prop({ required: true, unique: true })
  public email!: string;
}

const User = getModelForClass(UserClass);

类型安全的迁移脚本

编写数据库迁移脚本时，TypeScript可以提供额外的安全保障：

const migrateUserData = async () => {
  const users = await User.find().exec();
  for (const user of users) {
    if (!user.email.includes('@')) {
      user.email = `${user.name.toLowerCase()}@example.com`;
      await user.save();
    }
  }
};

测试中的类型检查

在编写测试时，TypeScript可以帮助确保测试数据的正确性：

describe('User Model', () => {
  it('should create a new user', async () => {
    const userData: Omit<IUser, 'createdAt'> = {
      name: 'Test User',
      age: 25,
      email: 'test@example.com'
    };
    const user = await createUser(userData);
    expect(user).toHaveProperty('_id');
    expect(user.email).toBe(userData.email);
  });
});