feat: Add User DAO

This change introduces a Data Access Object (DAO) for the User model.
This is the first step in a larger effort to abstract the database layer
and eventually migrate to PostgreSQL.

The new UserDAO encapsulates all database interactions for the User model,
and the GraphQL logic for users has been refactored to use this new DAO.
Unit tests for the DAO have also been added.

Author: google-labs-jules[bot]

apps/web/dao/user.dao.test.ts

@@ -0,0 +1,72 @@
+import { UserDao } from "./user.dao";
+import UserModel from "@models/User";
+import mongoose from "mongoose";
+
+afterEach(async () => {
+  await UserModel.deleteMany({});
+});
+
+describe("UserDao", () => {
+  let userDao: UserDao;
+
+  beforeEach(() => {
+    userDao = new UserDao();
+  });
+
+  it("should create a user", async () => {
+    const userData = {
+      email: "test@example.com",
+      name: "Test User",
+      userId: "123",
+      unsubscribeToken: "token",
+      domain: new mongoose.Types.ObjectId().toString(),
+    };
+    const user = await userDao.createUser(userData);
+    expect(user).toBeDefined();
+    expect(user.email).toBe(userData.email);
+  });
+
+  it("should get a user by id", async () => {
+    const userData = {
+      email: "test@example.com",
+      name: "Test User",
+      userId: "123",
+      unsubscribeToken: "token",
+      domain: new mongoose.Types.ObjectId().toString(),
+    };
+    await userDao.createUser(userData);
+    const user = await userDao.getUserById("123", userData.domain);
+    expect(user).toBeDefined();
+    expect(user!.email).toBe(userData.email);
+  });
+
+  it("should get a user by email", async () => {
+    const userData = {
+      email: "test@example.com",
+      name: "Test User",
+      userId: "123",
+      unsubscribeToken: "token",
+      domain: new mongoose.Types.ObjectId().toString(),
+    };
+    await userDao.createUser(userData);
+    const user = await userDao.getUserByEmail("test@example.com", userData.domain);
+    expect(user).toBeDefined();
+    expect(user!.email).toBe(userData.email);
+  });
+
+  it("should update a user", async () => {
+    const userData = {
+      email: "test@example.com",
+      name: "Test User",
+      userId: "123",
+      unsubscribeToken: "token",
+      domain: new mongoose.Types.ObjectId().toString(),
+    };
+    await userDao.createUser(userData);
+    const updatedUser = await userDao.updateUser("123", userData.domain, {
+      name: "Updated Test User",
+    });
+    expect(updatedUser).toBeDefined();
+    expect(updatedUser!.name).toBe("Updated Test User");
+  });
+});

apps/web/dao/user.dao.ts

@@ -0,0 +1,155 @@
+import { User } from "@courselit/common-models";
+import UserModel from "@models/User";
+import { makeModelTextSearchable } from "@/lib/graphql";
+
+export interface IUserDao {
+    getUserById(userId: string, domainId: string): Promise<User | null>;
+    getUserByEmail(email: string, domainId: string): Promise<User | null>;
+    createUser(userData: Partial<User>): Promise<User>;
+    updateUser(
+        userId: string,
+        domainId: string,
+        userData: Partial<User>,
+    ): Promise<User | null>;
+    find(query: any): Promise<User[]>;
+    findOne(query: any): Promise<User | null>;
+    findOneAndUpdate(
+        query: any,
+        update: any,
+        options: any,
+    ): Promise<User | null>;
+    countDocuments(query: any): Promise<number>;
+    updateMany(query: any, update: any): Promise<any>;
+    aggregate(pipeline: any[]): Promise<any[]>;
+    deleteUser(userId: string, domainId: string): Promise<any>;
+    search(
+        {
+            offset,
+            query,
+            graphQLContext,
+        }: { offset: number; query: any; graphQLContext: any },
+        {
+            itemsPerPage,
+            sortByColumn,
+            sortOrder,
+        }: {
+            itemsPerPage: number;
+            sortByColumn: string;
+            sortOrder: number;
+        },
+    ): Promise<User[]>;
+}
+
+export class UserDao implements IUserDao {
+    public async getUserById(
+        userId: string,
+        domainId: string,
+    ): Promise<User | null> {
+        const user = await UserModel.findOne({
+            userId,
+            domain: domainId,
+        }).lean();
+        return user as User;
+    }
+
+    public async getUserByEmail(
+        email: string,
+        domainId: string,
+    ): Promise<User | null> {
+        const user = await UserModel.findOne({
+            email,
+            domain: domainId,
+        }).lean();
+        return user as User;
+    }
+
+    public async createUser(userData: Partial<User>): Promise<User> {
+        const user = new UserModel(userData);
+        const newUser = await user.save();
+        return newUser.toObject();
+    }
+
+    public async updateUser(
+        userId: string,
+        domainId: string,
+        userData: Partial<User>,
+    ): Promise<User | null> {
+        const user = await UserModel.findOneAndUpdate(
+            { userId, domain: domainId },
+            { $set: userData },
+            { new: true },
+        ).lean();
+        return user as User;
+    }
+
+    public async find(query: any): Promise<User[]> {
+        const users = await UserModel.find(query).lean();
+        return users as User[];
+    }
+
+    public async findOne(query: any): Promise<User | null> {
+        const user = await UserModel.findOne(query).lean();
+        return user as User;
+    }
+
+    public async findOneAndUpdate(
+        query: any,
+        update: any,
+        options: any,
+    ): Promise<User | null> {
+        const user = await UserModel.findOneAndUpdate(
+            query,
+            update,
+            options,
+        ).lean();
+        return user as User;
+    }
+
+    public async countDocuments(query: any): Promise<number> {
+        return await UserModel.countDocuments(query);
+    }
+
+    public async updateMany(query: any, update: any): Promise<any> {
+        return await UserModel.updateMany(query, update);
+    }
+
+    public async aggregate(pipeline: any[]): Promise<any[]> {
+        return await UserModel.aggregate(pipeline);
+    }
+
+    public async deleteUser(userId: string, domainId: string): Promise<any> {
+        return await UserModel.deleteOne({ userId, domain: domainId });
+    }
+
+    public async search(
+        {
+            offset,
+            query,
+            graphQLContext,
+        }: { offset: number; query: any; graphQLContext: any },
+        {
+            itemsPerPage,
+            sortByColumn,
+            sortOrder,
+        }: {
+            itemsPerPage: number;
+            sortByColumn: string;
+            sortOrder: number;
+        },
+    ): Promise<User[]> {
+        const searchUsers = makeModelTextSearchable(UserModel);
+        const users = await searchUsers(
+            {
+                offset,
+                query,
+                graphQLContext,
+            },
+            {
+                itemsPerPage,
+                sortByColumn,
+                sortOrder,
+            },
+        );
+        return users.map((user: any) => user.toObject());
+    }
+}