Merge branch 'main' into feature/user-profile

Author: Bentroen

.git-blame-ignore-revs

@@ -1,2 +1,5 @@
 # Apply blank line linting rules
 2bbe554f470c5b7a0d59927dd3b9783314a0d805
+
+# Linting commits
+6efc953b9f7f648f2be59295a78ce1180f12b32d

NoteBlockWorld.code-workspace

@@ -18,7 +18,19 @@
     }
   ],
   "settings": {
+    "editor.formatOnSave": true,
+    "eslint.validate": ["typescript"],
+    "eslint.run": "onType",
+    "eslint.format.enable": true,
     "mdx.server.enable": true,
-    "jest.disabledWorkspaceFolders": ["Root", "Frontend"]
+    "editor.codeActionsOnSave": {
+      "source.fixAll": "explicit"
+    },
+    "jest.disabledWorkspaceFolders": ["Root", "Frontend"],
+    "search.exclude": {
+      "**/.git": true,
+      "**/node_modules": true,
+      "**/dist": true,
+    }
   }
 }

pnpm-lock.yaml

@@ -62,12 +62,6 @@ export class AuthModule {
           useFactory: (configService: ConfigService) =>
             configService.getOrThrow<string>('SERVER_URL'),
         },
-        {
-          inject: [ConfigService],
-          provide: 'MAGIC_LINK_SECRET',
-          useFactory: (configService: ConfigService) =>
-            configService.getOrThrow<string>('MAGIC_LINK_SECRET'),
-        },
         {
           inject: [ConfigService],
           provide: 'FRONTEND_URL',

server/src/auth/auth.module.ts

@@ -0,0 +1,16 @@
+import { User } from '../entity/user.entity';
+
+export class UserDto {
+  username: string;
+  publicName: string;
+  email: string;
+  static fromEntity(user: User): UserDto {
+    const userDto: UserDto = {
+      username: user.username,
+      publicName: user.publicName,
+      email: user.email,
+    };
+
+    return userDto;
+  }
+}

server/src/user/dto/user.dto.ts

@@ -19,13 +19,16 @@ export class User {
   lastEdited: Date;
 
   @Prop({ type: MongooseSchema.Types.Date, required: true, default: Date.now })
-  lastLogin: Date;
+  lastSeen: Date;
+
+  @Prop({ type: Number, required: true, default: 0 })
+  loginCount: number;
 
   @Prop({ type: Number, required: true, default: 0 })
   loginStreak: number;
 
   @Prop({ type: Number, required: true, default: 0 })
-  loginCount: number;
+  maxLoginStreak: number;
 
   @Prop({ type: Number, required: true, default: 0 })
   playCount: number;

server/src/user/entity/user.entity.ts

@@ -200,7 +200,7 @@ describe('UserService', () => {
   describe('getSelfUserData', () => {
     it('should return self user data', async () => {
       const user = { _id: 'test-id' } as UserDocument;
-      const userData = { ...user } as UserDocument;
+      const userData = { ...user, lastSeen: new Date() } as UserDocument;
 
       jest.spyOn(service, 'findByID').mockResolvedValue(userData);
 
@@ -219,6 +219,161 @@ describe('UserService', () => {
         new HttpException('user not found', HttpStatus.NOT_FOUND),
       );
     });
+
+    it('should update lastSeen and increment loginStreak if lastSeen is before today', async () => {
+      const user = { _id: 'test-id' } as UserDocument;
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+      yesterday.setHours(0, 0, 0, 0);
+
+      const userData = {
+        ...user,
+        lastSeen: yesterday,
+        loginStreak: 1,
+        save: jest.fn().mockResolvedValue(true),
+      } as unknown as UserDocument;
+
+      jest.spyOn(service, 'findByID').mockResolvedValue(userData);
+
+      const result = await service.getSelfUserData(user);
+
+      expect(result.lastSeen).toBeInstanceOf(Date);
+      expect(result.loginStreak).toBe(2);
+      expect(userData.save).toHaveBeenCalled();
+    });
+
+    it('should not update lastSeen or increment loginStreak if lastSeen is today', async () => {
+      const user = { _id: 'test-id' } as UserDocument;
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+
+      const userData = {
+        ...user,
+        lastSeen: today,
+        loginStreak: 1,
+        save: jest.fn().mockResolvedValue(true),
+      } as unknown as UserDocument;
+
+      jest.spyOn(service, 'findByID').mockResolvedValue(userData);
+
+      const result = await service.getSelfUserData(user);
+
+      expect(result.lastSeen).toEqual(today);
+      expect(result.loginStreak).toBe(1);
+      expect(userData.save).not.toHaveBeenCalled();
+    });
+
+    it('should reset loginStreak if lastSeen is not yesterday', async () => {
+      const user = { _id: 'test-id' } as UserDocument;
+      const twoDaysAgo = new Date();
+      twoDaysAgo.setDate(twoDaysAgo.getDate() - 2);
+      twoDaysAgo.setHours(0, 0, 0, 0);
+
+      const userData = {
+        ...user,
+        lastSeen: twoDaysAgo,
+        loginStreak: 5,
+        save: jest.fn().mockResolvedValue(true),
+      } as unknown as UserDocument;
+
+      jest.spyOn(service, 'findByID').mockResolvedValue(userData);
+
+      const result = await service.getSelfUserData(user);
+
+      expect(result.lastSeen).toBeInstanceOf(Date);
+      expect(result.loginStreak).toBe(1);
+      expect(userData.save).toHaveBeenCalled();
+    });
+
+    it('should increment loginCount if lastSeen is not today', async () => {
+      const user = { _id: 'test-id' } as UserDocument;
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+      yesterday.setHours(0, 0, 0, 0);
+
+      const userData = {
+        ...user,
+        lastSeen: yesterday,
+        loginCount: 5,
+        save: jest.fn().mockResolvedValue(true),
+      } as unknown as UserDocument;
+
+      jest.spyOn(service, 'findByID').mockResolvedValue(userData);
+
+      const result = await service.getSelfUserData(user);
+
+      expect(result.lastSeen).toBeInstanceOf(Date);
+      expect(result.loginCount).toBe(6);
+      expect(userData.save).toHaveBeenCalled();
+    });
+
+    it('should not increment loginCount if lastSeen is today', async () => {
+      const user = { _id: 'test-id' } as UserDocument;
+
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+
+      const userData = {
+        ...user,
+        lastSeen: today,
+        loginCount: 5,
+        save: jest.fn().mockResolvedValue(true),
+      } as unknown as UserDocument;
+
+      jest.spyOn(service, 'findByID').mockResolvedValue(userData);
+
+      const result = await service.getSelfUserData(user);
+
+      expect(result.lastSeen).toEqual(today);
+      expect(result.loginCount).toBe(5);
+      expect(userData.save).not.toHaveBeenCalled();
+    });
+
+    it('should increment maxLoginStreak if login streak exceeds max', async () => {
+      const user = { _id: 'test-id' } as UserDocument;
+
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+      yesterday.setHours(0, 0, 0, 0);
+
+      const userData = {
+        ...user,
+        lastSeen: yesterday,
+        loginStreak: 8,
+        maxLoginStreak: 8,
+        save: jest.fn().mockResolvedValue(true),
+      } as unknown as UserDocument;
+
+      jest.spyOn(service, 'findByID').mockResolvedValue(userData);
+
+      const result = await service.getSelfUserData(user);
+
+      expect(result.maxLoginStreak).toBe(9);
+      expect(userData.save).toHaveBeenCalled();
+    });
+
+    it('should not increment maxLoginStreak if login streak is less than the max', async () => {
+      const user = { _id: 'test-id' } as UserDocument;
+
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+      yesterday.setHours(0, 0, 0, 0);
+
+      const userData = {
+        ...user,
+        lastSeen: yesterday,
+        loginStreak: 4,
+        maxLoginStreak: 8,
+        save: jest.fn().mockResolvedValue(true),
+      } as unknown as UserDocument;
+
+      jest.spyOn(service, 'findByID').mockResolvedValue(userData);
+
+      const result = await service.getSelfUserData(user);
+
+      expect(result.maxLoginStreak).toBe(8);
+      expect(userData.save).toHaveBeenCalled();
+    });
   });
 
   describe('usernameExists', () => {
@@ -341,7 +496,12 @@ describe('UserService', () => {
 
       const result = await service.updateUsername(user, body);
 
-      expect(result).toEqual(user);
+      expect(result).toEqual({
+        username: 'newuser',
+        publicName: undefined,
+        email: undefined,
+      });
+
       expect(user.username).toBe(body.username);
       expect(service.usernameExists).toHaveBeenCalledWith(body.username);
     });

server/src/user/user.service.spec.ts

@@ -9,6 +9,7 @@ import { UpdateUserProfileDto } from '@shared/validation/user/dto/UpdateUserProf
 import { validate } from 'class-validator';
 import { Model } from 'mongoose';
 
+import { UserDto } from './dto/user.dto';
 import { User, UserDocument } from './entity/user.entity';
 
 @Injectable()
@@ -165,11 +166,36 @@ export class UserService {
   }
 
   public async getSelfUserData(user: UserDocument) {
-    const usedData = await this.findByID(user._id.toString());
-    if (!usedData)
+    const userData = await this.findByID(user._id.toString());
+    if (!userData)
       throw new HttpException('user not found', HttpStatus.NOT_FOUND);
 
-    return usedData;
+    const today = new Date();
+    today.setHours(0, 0, 0, 0); // Set the time to the start of the day
+
+    const lastSeenDate = new Date(userData.lastSeen);
+    lastSeenDate.setHours(0, 0, 0, 0); // Set the time to the start of the day
+
+    if (lastSeenDate < today) {
+      userData.lastSeen = new Date();
+
+      // if the last seen date is not yesterday, reset the login streak
+      const yesterday = new Date(today);
+      yesterday.setDate(today.getDate() - 1);
+
+      if (lastSeenDate < yesterday) userData.loginStreak = 1;
+      else {
+        userData.loginStreak += 1;
+        if (userData.loginStreak > userData.maxLoginStreak)
+          userData.maxLoginStreak = userData.loginStreak;
+      }
+
+      userData.loginCount++;
+
+      userData.save(); // no need to await this, we already have the data to send back
+    } // if equal or greater, do nothing about the login streak
+
+    return userData;
   }
 
   public async usernameExists(username: string) {
@@ -220,8 +246,11 @@ export class UserService {
     }
 
     user.username = username;
+    user.lastEdited = new Date();
 
-    return await user.save();
+    await user.save();
+
+    return UserDto.fromEntity(user);
   }
 
   public async updateProfile(user: UserDocument, body: UpdateUserProfileDto) {

server/src/user/user.service.ts

@@ -0,0 +1,7 @@
+import { deepFreeze } from '../common/deepFreeze';
+
+export const UserConst = deepFreeze({
+  USERNAME_MIN_LENGTH: 3,
+  USERNAME_MAX_LENGTH: 32,
+  ALLOWED_REGEXP: /^[a-zA-Z0-9-_.]*$/,
+});