如何基于设计模式使用Mongoose并实现数据库无缝切换？

当前技术栈：MongoDB + Mongoose ORM，现有User模型代码如下：

import { Schema, model } from 'mongoose'

export interface IUser {
    _id: string,
    email: string,
    name: string,
    password: string,
    picture: string,
    description: string,
    plans: [
        {
            name: string,
            price: string,
            monthsDuration: number,
        }
    ],
    role: string,
    balance: number,
    createdAt: Date,
}

const UserSchema = new Schema<IUser>({
    email: {
        type: String,
        index: true,
    },
    name: String,
    password: String,
    picture: String,
    description: String,
    plans: [],
    role: String,
    balance: Number,
    createdAt: {
        type: Date,
        default: Date.now
    }
})

const UserModel = model('pvf2_users', UserSchema)
export { UserModel }

负责新增用户的仓储类代码：

import { User } from "@domain/entities/user.entity.js";
import { UserModel } from "@domain/models/user.model.js";
import { UserRepositoryInterface } from "@domain/repositories/user.repository.js";

export class UserDatabaseRepository implements UserRepositoryInterface {

    async insert(user: User): Promise<void> {
        await UserModel.create(user.data)
    }

}

核心问题：如果后续要从MongoDB切换到PostgreSQL等其他数据库，当前直接调用Mongoose Schema的写法需要修改所有仓储文件，违背设计模式。请问如何构建架构才能无需重写查询文件即可轻松切换数据库？是否可行？

完全可行，核心思路是把数据库具体实现和业务逻辑彻底解耦，通过抽象接口和依赖倒置原则实现无缝切换。具体步骤如下：

1. 强化仓储层抽象，剥离ORM依赖 #

你已经定义了UserRepositoryInterface，需要确保这个接口只包含业务语义的方法，完全不涉及任何ORM或数据库特定语法。比如：

// user.repository.ts
export interface UserRepositoryInterface {
  create(user: User): Promise<void>;
  findById(id: string): Promise<User | null>;
  findByEmail(email: string): Promise<User | null>;
  updateBalance(userId: string, amount: number): Promise<void>;
  // 仅定义业务所需方法，只约定输入输出，不涉及具体查询逻辑
}

2. 为每种数据库实现独立仓储类 #

针对MongoDB（Mongoose）、PostgreSQL（如TypeORM/Prisma）分别实现上述接口，每个实现类只处理对应数据库的具体操作：

MongoDB（Mongoose）实现 #

// user.mongo.repository.ts
import { User } from "@domain/entities/user.entity.js";
import { UserModel } from "@domain/models/user.model.js";
import { UserRepositoryInterface } from "@domain/repositories/user.repository.js";

export class UserMongoRepository implements UserRepositoryInterface {
  async create(user: User): Promise<void> {
    await UserModel.create(user.data);
  }

  async findById(id: string): Promise<User | null> {
    const doc = await UserModel.findById(id);
    return doc ? new User(doc.toObject()) : null;
  }

  // 其他方法的Mongoose实现...
}

PostgreSQL（TypeORM）实现 #

// user.postgres.repository.ts
import { User } from "@domain/entities/user.entity.js";
import { UserEntity } from "@infra/db/postgres/entities/user.entity.js";
import { Repository } from "typeorm";
import { UserRepositoryInterface } from "@domain/repositories/user.repository.js";

export class UserPostgresRepository implements UserRepositoryInterface {
  constructor(private readonly repo: Repository<UserEntity>) {}

  async create(user: User): Promise<void> {
    const postgresUser = this.repo.create(user.data);
    await this.repo.save(postgresUser);
  }

  async findById(id: string): Promise<User | null> {
    const entity = await this.repo.findOneBy({ id });
    return entity ? new User(entity) : null;
  }

  // 其他方法的TypeORM实现...
}

3. 用依赖注入（DI）管理仓储实例 #

通过DI容器（如NestJS内置DI、Inversify等）在应用启动时注入指定的仓储实现，业务层只依赖抽象接口，不关心具体数据库：

// 示例：NestJS模块配置
import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { UserMongoRepository } from './user.mongo.repository';
// import { UserPostgresRepository } from './user.postgres.repository';
import { UserRepositoryInterface } from './user.repository';

@Module({
  providers: [
    UserService,
    {
      provide: UserRepositoryInterface,
      useClass: UserMongoRepository, // 切换数据库时仅修改这一行
      // useClass: UserPostgresRepository,
    },
  ],
})
export class UserModule {}

4. 统一领域实体层 #

确保业务层使用的User是纯领域对象，不包含任何数据库特定的装饰器或字段。不同数据库的实体（如Mongoose Schema、TypeORM Entity）仅在各自仓储实现中做转换：

// domain/entities/user.entity.ts
export class User {
  constructor(public data: {
    id: string;
    email: string;
    name: string;
    // ...其他业务字段
  }) {}

  // 领域方法，比如余额校验、权限判断等
}

关键注意事项 #

• 复杂查询的兼容处理：如果业务中有复杂聚合、联表查询，不同数据库语法差异较大，需要在抽象层封装统一的查询参数，再在各仓储实现中转换为对应数据库的语法。
• 数据库迁移工具：切换数据库时，使用对应数据库的迁移工具（如MongoDB Migrations、TypeORM Migrations）处理Schema同步。
• 分层测试：针对每个仓储实现编写单元测试，确保切换后业务逻辑不受影响。

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