Fix(WebDav): add dynamic import helper to support ESM in CommonJS (#751)

package.json

@@ -51,7 +51,7 @@
     "mongoose": "8.19.4",
     "mqtt": "5.14.1",
     "rxjs": "7.8.2",
-    "webdav": "5.8.0",
+    "webdav": "^4.11.2",
     "ws": "8.18.3"
   },
   "devDependencies": {
@@ -81,4 +81,4 @@
     "typescript": "5.9.3",
     "typescript-eslint": "8.46.4"
   }
-}
+}

src/__tests__/friendship/data/builder/FriendRequestDtoBuilder.ts

@@ -0,0 +1,32 @@
+import { ObjectId } from "mongodb";
+import IDataBuilder from "../../../test_utils/interface/IDataBuilder";
+import { FriendRequestDto } from "../../../../friendship/dto/FriendRequest.dto";
+
+export default class FriendRequestDtoBuilder
+    implements IDataBuilder<FriendRequestDto>
+{
+    private readonly base: FriendRequestDto = {
+        friendship_id: new ObjectId().toString(),
+        direction: 'incoming', // 'outgoing'
+        friend: undefined,
+    }
+
+    build(): FriendRequestDto {
+        return {...this.base} as FriendRequestDto;
+    }
+
+    setFriendship_id(friendship_id: string): this {
+        this.base.friendship_id = friendship_id;
+        return this
+    }
+
+    setDirection(direction: string | undefined): this {
+        this.base.direction = direction;
+        return this;
+    }
+
+    setFriend(friend: any): this {
+        this.base.friend = friend;
+        return this;
+    }
+}

src/__tests__/friendship/data/builder/FriendlistDtoBuilder.ts

@@ -0,0 +1,44 @@
+import { ObjectId } from "mongodb";
+import IDataBuilder from "../../../test_utils/interface/IDataBuilder";
+import { FriendlistDto } from "../../../../friendship/dto/friend-list.dto";
+
+export default class FriendlistDtoBuilder 
+    implements IDataBuilder<FriendlistDto>
+{
+    private readonly base: FriendlistDto = {
+        _id: new ObjectId().toString(),
+        name: "defaultName",
+        avatar: undefined,
+        clanName: undefined,
+        clan_id: undefined,
+    }
+
+    build(): FriendlistDto {
+        return {...this.base} as FriendlistDto;
+    }
+
+    setId(Id: string): this {
+        this.base._id = Id;
+        return this;
+    }
+
+    setName(name: string): this {
+        this.base.name = name;
+        return this;
+    }
+
+    setAvatar(avatar: any | undefined): this {
+        this.base.avatar = avatar;
+        return this;
+    }
+
+    setClanName(clanName: string | undefined): this {
+        this.base.clanName = clanName;
+        return this;
+    }
+
+    setClanId(clanId: string | undefined): this {
+        this.base.clan_id = clanId;
+        return this;
+    }
+}

src/__tests__/friendship/data/builder/FriendshipBuilder.ts

@@ -0,0 +1,47 @@
+import IDataBuilder from '../../../test_utils/interface/IDataBuilder';
+import { FriendshipStatus } from '../../../../friendship/enum/friendship-status.enum';
+import { Friendship } from '../../../../friendship/friendship.schema';
+import { ObjectId } from 'mongodb';
+
+export default class FriendshipBuilder implements IDataBuilder<Friendship> {
+  private playerA: string | ObjectId;
+  private playerB: string | ObjectId;
+  private status: FriendshipStatus;
+  private requester?: string | ObjectId;
+  private pairKey?: string;
+
+  build(): Friendship {
+    const friendship: any = {
+      playerA: this.playerA,
+      playerB: this.playerB,
+      status: this.status,
+      pairKey: this.pairKey,
+    };
+
+    if (this.requester !== undefined) {
+      friendship.requester = this.requester;
+    }
+
+    return friendship as Friendship;
+  }
+
+  setPlayerA(playerA: string | ObjectId): this {
+    this.playerA = playerA;
+    return this;
+  }
+
+  setPlayerB(playerB: string | ObjectId): this {
+    this.playerB = playerB;
+    return this;
+  }
+
+  setStatus(status: FriendshipStatus): this {
+    this.status = status;
+    return this;
+  }
+
+  setRequester(requester: string | ObjectId): this {
+    this.requester = requester;
+    return this;
+  }
+}

src/__tests__/friendship/data/friendshipBuilderFactory.ts

@@ -0,0 +1,32 @@
+import FriendlistDtoBuilder from "./builder/FriendlistDtoBuilder";
+import FriendRequestDtoBuilder from "./builder/FriendRequestDtoBuilder";
+import FriendshipBuilder from "./builder/FriendshipBuilder";
+
+type BuilderName =
+    | 'FriendlistDto'
+    | 'FriendRequestDto'
+    | 'Friendship';
+
+type BuilderMap = {
+    FriendlistDto: FriendlistDtoBuilder;
+    FriendRequestDto: FriendRequestDtoBuilder;
+    Friendship: FriendshipBuilder;
+};
+
+export default class FriendshipBuilderFactory {
+    static getBuilder<T extends BuilderName>(builderName: T): BuilderMap[T] {
+        switch (builderName) {
+            case 'FriendlistDto':
+                return new FriendlistDtoBuilder() as BuilderMap[T];
+
+            case 'FriendRequestDto':
+                return new FriendRequestDtoBuilder() as BuilderMap[T];
+
+            case 'Friendship':
+                return new FriendshipBuilder() as BuilderMap[T];
+
+            default:
+                throw new Error(`Unknown builder name: ${builderName}`);
+        }
+    }
+}

src/__tests__/friendship/data/mockData/createData.mock.ts

@@ -0,0 +1,55 @@
+import { Player } from '../../../../player/schemas/player.schema';
+import FriendshipModule from '../../modules/friendship.module';
+import PlayerBuilder from '../../../player/data/player/playerBuilder';
+import { Clan } from '../../../../clan/clan.schema';
+import ClanBuilder from '../../../clan/data/clan/ClanBuilder';
+import { Friendship } from 'src/friendship/friendship.schema';
+import FriendshipBuilderFactory from '../friendshipBuilderFactory';
+
+export async function createMockFriendships(
+  overides: Partial<Friendship>[]
+): Promise<void> {
+  const model = FriendshipModule.getFriendshipModel();
+
+  for (const overide of overides) {
+    const builder = FriendshipBuilderFactory.getBuilder('Friendship')
+      .setPlayerA(overide.playerA)
+      .setPlayerB(overide.playerB)
+      .setStatus(overide.status);
+
+    if (overide.requester) builder.setRequester(overide.requester);
+    await model.create(builder.build());
+  }
+}
+
+export async function createMockPlayers(
+  overides: Partial<Player>[]
+): Promise<void> {
+  const model = FriendshipModule.getPlayerModel();
+
+  for (const overide of overides) {
+    const builder = new PlayerBuilder()
+      .setId(overide._id)
+      .setName(overide.name)
+      .setUniqueIdentifier(overide.uniqueIdentifier)
+      .setClanId(overide.clan_id)
+      .build();
+
+    await model.create(builder);
+  }
+}
+
+export async function createMockClans(
+  overides: Partial<Clan>[]
+): Promise<void> {
+  const model = FriendshipModule.getClanModel();
+
+  for (const overide of overides) {
+    const builder = new ClanBuilder()
+      .setId(overide._id)
+      .setName(overide.name)
+      .build();
+
+    await model.create(builder);
+  }
+}

src/__tests__/friendship/friendshipService/addFriend.test.ts

@@ -0,0 +1,94 @@
+import { ObjectId } from 'mongodb';
+import { FriendshipService } from '../../../friendship/friendship.service';
+import FriendshipModule from '../modules/friendship.module';
+import { FriendshipStatus } from '../../../friendship/enum/friendship-status.enum';
+import {
+    createMockClans,
+    createMockFriendships,
+    createMockPlayers,
+} from '../data/mockData/createData.mock';
+import { Friendship } from 'src/friendship/friendship.schema';
+
+describe('FriendshipService.sendNewFriendRequestNotification()', () => {
+    let friendshipService: FriendshipService;
+
+    const player1_id = new ObjectId().toString();
+    const player2_id = new ObjectId().toString();
+    const player3_id = new ObjectId().toString();
+
+    const clan_id = new ObjectId().toString();
+
+    const friendshipConfigs: Partial<Friendship>[] = [
+        {
+            playerA: player1_id,
+            playerB: player2_id,
+            status: FriendshipStatus.PENDING,
+            requester: player1_id,
+        },
+        {
+            playerA: player1_id,
+            playerB: player3_id,
+            status: FriendshipStatus.ACCEPTED,
+        },
+    ];
+
+    beforeEach(async () => {
+        friendshipService = await FriendshipModule.getFriendshipService();
+
+        await createMockClans([{ _id: clan_id, name: 'TestClan' }]);
+        await createMockPlayers([
+            {
+                _id: player1_id,
+                name: 'Player1',
+                clan_id,
+                uniqueIdentifier: 'unique-1',
+            },
+            {
+                _id: player2_id,
+                name: 'Player2',
+                clan_id,
+                uniqueIdentifier: 'unique-2',
+            },
+            {
+                _id: player3_id,
+                name: 'Player3',
+                clan_id,
+                uniqueIdentifier: 'unique-3',
+            },
+        ]);
+        await createMockFriendships(friendshipConfigs);
+    });
+
+    it('Should return undefined if addFriend is successful', async () => {
+        // void function if success
+        await expect(friendshipService.addFriend(player2_id, player3_id))
+            .resolves
+            .toBeUndefined();
+    });
+
+    it(
+        'Should return NOT_UNIQUE from pairkey if 2 players have friendship with status PENDING',
+        async () => {
+            const [friendship, err] = await friendshipService.addFriend(
+                player1_id,
+                player2_id
+            );
+
+            expect(err).toContainSE_NOT_UNIQUE();
+            expect(friendship).toBeNull();
+        }
+    );
+
+    it(
+        'Should return NOT_UNIQUE from pairkey if 2 players have friendship with status ACCEPTED',
+        async () => {
+            const [friendship, err] = await friendshipService.addFriend(
+                player1_id,
+                player3_id
+            );
+
+            expect(err).toContainSE_NOT_UNIQUE();
+            expect(friendship).toBeNull();
+        }
+    );
+});