BC-7124 - Add delete sessions endpoint

apps/server/src/infra/etherpad-client/etherpad-client.adapter.spec.ts

@@ -85,20 +85,40 @@ describe(EtherpadClientAdapter.name, () => {
 				return { userId, username };
 			};
 
-			it('should return author id', async () => {
-				const { userId, username } = setup();
+			describe('When user name parameter is set', () => {
+				it('should return author id', async () => {
+					const { userId, username } = setup();
+
+					const result = await service.getOrCreateAuthorId(userId, username);
+
+					expect(result).toBe('authorId');
+				});
+
+				it('should call createAuthorIfNotExistsForUsingGET with correct params', async () => {
+					const { userId, username } = setup();
 
-				const result = await service.getOrCreateAuthorId(userId, username);
+					await service.getOrCreateAuthorId(userId, username);
 
-				expect(result).toBe('authorId');
+					expect(authorApi.createAuthorIfNotExistsForUsingGET).toBeCalledWith(userId, username);
+				});
 			});
 
-			it('should call createAuthorIfNotExistsForUsingGET with correct params', async () => {
-				const { userId, username } = setup();
+			describe('When user name parameter is not set', () => {
+				it('should return author id', async () => {
+					const { userId } = setup();
+
+					const result = await service.getOrCreateAuthorId(userId);
+
+					expect(result).toBe('authorId');
+				});
+
+				it('should call createAuthorIfNotExistsForUsingGET with correct params', async () => {
+					const { userId } = setup();
 
-				await service.getOrCreateAuthorId(userId, username);
+					await service.getOrCreateAuthorId(userId);
 
-				expect(authorApi.createAuthorIfNotExistsForUsingGET).toBeCalledWith(userId, username);
+					expect(authorApi.createAuthorIfNotExistsForUsingGET).toBeCalledWith(userId, undefined);
+				});
 			});
 		});
 
@@ -310,7 +330,7 @@ describe(EtherpadClientAdapter.name, () => {
 					data: {
 						code: EtherpadResponseCode.OK,
 						// @ts-expect-error wrong type mapping
-						data: { 'session-id-1': { groupID: 'groupId', authorID: authorId } },
+						data: { 'session-id-1': { groupID: 'groupId', authorID: authorId }, 'session-id-2': null },
 					},
 				});
 

apps/server/src/infra/etherpad-client/etherpad-client.adapter.ts

@@ -33,7 +33,7 @@ export class EtherpadClientAdapter {
 		private readonly padApi: PadApi
 	) {}
 
-	public async getOrCreateAuthorId(userId: EntityId, username: string): Promise<AuthorId> {
+	public async getOrCreateAuthorId(userId: EntityId, username?: string): Promise<AuthorId> {
 		const response = await this.tryCreateAuthor(userId, username);
 		const user = this.handleEtherpadResponse<InlineResponse2003>(response, { userId });
 
@@ -42,7 +42,7 @@ export class EtherpadClientAdapter {
 		return authorId;
 	}
 
-	private async tryCreateAuthor(userId: string, username: string): Promise<AxiosResponse<InlineResponse2003>> {
+	private async tryCreateAuthor(userId: string, username?: string): Promise<AxiosResponse<InlineResponse2003>> {
 		try {
 			const response = await this.authorApi.createAuthorIfNotExistsForUsingGET(userId, username);
 
@@ -149,9 +149,12 @@ export class EtherpadClientAdapter {
 			throw new InternalServerErrorException('Etherpad session ids response is not an object');
 		}
 
-		const sessionIds = Object.keys(sessions);
+		const validSessionIds = Object.entries(sessions)
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			.filter(([key, value]) => value !== null)
+			.map(([key]) => key);
 
-		return sessionIds;
+		return validSessionIds;
 	}
 
 	private isObject(value: any): value is object {
@@ -269,11 +272,9 @@ export class EtherpadClientAdapter {
 		}
 	}
 
-	public async deleteSession(sessionId: SessionId): Promise<InlineResponse2001 | undefined> {
+	public async deleteSession(sessionId: SessionId): Promise<void> {
 		const response = await this.tryDeleteSession(sessionId);
-		const responseData = this.handleEtherpadResponse<InlineResponse2001>(response, { sessionId });
-
-		return responseData;
+		this.handleEtherpadResponse<InlineResponse2001>(response, { sessionId });
 	}
 
 	private async tryDeleteSession(sessionId: SessionId): Promise<AxiosResponse<InlineResponse2001>> {

apps/server/src/modules/collaborative-text-editor/api/collaborative-text-editor.controller.ts

@@ -1,5 +1,5 @@
 import { Authenticate, CurrentUser, ICurrentUser } from '@modules/authentication';
-import { Controller, ForbiddenException, Get, NotFoundException, Param, Res } from '@nestjs/common';
+import { Controller, Delete, ForbiddenException, Get, NotFoundException, Param, Res } from '@nestjs/common';
 import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { ApiValidationError } from '@shared/common';
 import { Response } from 'express';
@@ -30,13 +30,24 @@
 			getCollaborativeTextEditorForParentParams
 		);
 
-		res.cookie('sessionID', textEditor.sessions.toString(), {
+		res.cookie('sessionID', textEditor.sessionId, {
 			expires: textEditor.sessionExpiryDate,
 			secure: true,
+			path: textEditor.path,
 		});
 
 		const dto = CollaborativeTextEditorMapper.mapCollaborativeTextEditorToResponse(textEditor);
 
 		return dto;
 	}
+
+	@ApiOperation({ summary: 'Delete all etherpad sessions for user' })
+	@ApiResponse({ status: 200, type: CollaborativeTextEditorResponse })
+	@ApiResponse({ status: 400, type: ApiValidationError })
+	@ApiResponse({ status: 403, type: ForbiddenException })
+	@ApiResponse({ status: 404, type: NotFoundException })
+	@Delete('/delete-sessions')
+	async deleteSessionsByUser(@CurrentUser() currentUser: ICurrentUser): Promise<void> {
+		await this.collaborativeTextEditorUc.deleteSessionsByUser(currentUser.userId);
+	}
 }

apps/server/src/modules/collaborative-text-editor/api/collaborative-text-editor.uc.ts

@@ -36,6 +36,12 @@ export class CollaborativeTextEditorUc {
 		return textEditor;
 	}
 
+	async deleteSessionsByUser(userId: string): Promise<void> {
+		const user = await this.authorizationService.getUserWithPermissions(userId);
+
+		await this.collaborativeTextEditorService.deleteSessionsByUser(user.id);
+	}
+
 	private async authorizeByParentType(params: GetCollaborativeTextEditorForParentParams, user: User) {
 		if (params.parentType === CollaborativeTextEditorParentType.BOARD_CONTENT_ELEMENT) {
 			await this.authorizeForContentElement(params, user);

apps/server/src/modules/collaborative-text-editor/api/tests/delete-sessions.api.spec.ts

@@ -0,0 +1,77 @@
+import { createMock, DeepMocked } from '@golevelup/ts-jest';
+import { EntityManager } from '@mikro-orm/mongodb';
+import { HttpStatus, INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { cleanupCollections, TestApiClient, UserAndAccountTestFactory } from '@shared/testing';
+import { EtherpadClientAdapter } from '@src/infra/etherpad-client';
+import { ServerTestModule } from '@src/modules/server';
+
+describe('Collaborative Text Editor Controller (API)', () => {
+	let app: INestApplication;
+	let em: EntityManager;
+	let testApiClient: TestApiClient;
+	let etherpadClientAdapter: DeepMocked<EtherpadClientAdapter>;
+
+	beforeAll(async () => {
+		const module = await Test.createTestingModule({
+			imports: [ServerTestModule],
+		})
+			.overrideProvider(EtherpadClientAdapter)
+			.useValue(createMock<EtherpadClientAdapter>())
+			.compile();
+
+		app = module.createNestApplication();
+		await app.init();
+		em = app.get(EntityManager);
+		testApiClient = new TestApiClient(app, 'collaborative-text-editor');
+		etherpadClientAdapter = module.get(EtherpadClientAdapter);
+	});
+
+	beforeEach(async () => {
+		await cleanupCollections(em);
+	});
+
+	afterAll(async () => {
+		await app.close();
+	});
+
+	describe('delete sessions by user', () => {
+		describe('when no user is logged in', () => {
+			it('should return 401', async () => {
+				const response = await testApiClient.delete(`delete-sessions`);
+
+				expect(response.status).toEqual(HttpStatus.UNAUTHORIZED);
+			});
+		});
+
+		describe('when user is logged in', () => {
+			const setup = async () => {
+				const { studentAccount, studentUser } = UserAndAccountTestFactory.buildStudent();
+
+				await em.persistAndFlush([studentAccount, studentUser]);
+				em.clear();
+
+				const loggedInClient = await testApiClient.login(studentAccount);
+
+				const authorId = 'authorId';
+				etherpadClientAdapter.getOrCreateAuthorId.mockResolvedValueOnce(authorId);
+
+				const otherSessionIds = ['otherSessionId1', 'otherSessionId2'];
+				etherpadClientAdapter.listSessionIdsOfAuthor.mockResolvedValueOnce(otherSessionIds);
+
+				etherpadClientAdapter.deleteSession.mockResolvedValueOnce();
+				etherpadClientAdapter.deleteSession.mockResolvedValueOnce();
+
+				return {
+					loggedInClient,
+				};
+			};
+
+			it('should resolve successfully', async () => {
+				const { loggedInClient } = await setup();
+
+				await loggedInClient.delete(`delete-sessions`);
+			});
+		});
+	});
+});

apps/server/src/modules/collaborative-text-editor/api/tests/get.api.spec.ts → apps/server/src/modules/collaborative-text-editor/api/tests/get-collaborative-text-editor.api.spec.ts

@@ -139,8 +139,6 @@ describe('Collaborative Text Editor Controller (API)', () => {
 				const basePath = Configuration.get('ETHERPAD__PAD_URI') as string;
 				const expectedPath = `${basePath}/${editorId}`;
 
-				const expectedSessions = encodeURIComponent([...otherSessionIds, sessionId].join(','));
-
 				const cookieExpiresMilliseconds = Number(Configuration.get('ETHERPAD_COOKIE__EXPIRES_SECONDS')) * 1000;
 				// Remove the last 8 characters from the string to prevent conflict between time of test and code execution
 				const sessionCookieExpiryDate = new Date(Date.now() + cookieExpiresMilliseconds).toUTCString().slice(0, -8);
@@ -149,8 +147,9 @@ describe('Collaborative Text Editor Controller (API)', () => {
 					loggedInClient,
 					collaborativeTextEditorElement,
 					expectedPath,
-					expectedSessions,
+					sessionId,
 					sessionCookieExpiryDate,
+					editorId,
 				};
 			};
 
@@ -159,8 +158,9 @@ describe('Collaborative Text Editor Controller (API)', () => {
 					loggedInClient,
 					collaborativeTextEditorElement,
 					expectedPath,
-					expectedSessions,
+					sessionId,
 					sessionCookieExpiryDate,
+					editorId,
 				} = await setup();
 
 				const response = await loggedInClient.get(`content-element/${collaborativeTextEditorElement.id}`);
@@ -170,7 +170,7 @@ describe('Collaborative Text Editor Controller (API)', () => {
 				expect(response.body['url']).toEqual(expectedPath);
 				// eslint-disable-next-line @typescript-eslint/dot-notation, @typescript-eslint/no-unsafe-member-access
 				expect(response.headers['set-cookie'][0]).toContain(
-					`sessionID=${expectedSessions}; Path=/; Expires=${sessionCookieExpiryDate}`
+					`sessionID=${sessionId}; Path=/p/${editorId}; Expires=${sessionCookieExpiryDate}`
 				);
 			});
 		});

apps/server/src/modules/collaborative-text-editor/domain/do/collaborative-text-editor.ts

@@ -1,5 +1,8 @@
+import { SessionId } from '@src/infra/etherpad-client/interface';
+
 export interface CollaborativeTextEditor {
 	url: string;
-	sessions: string[];
+	path: string;
+	sessionId: SessionId;
 	sessionExpiryDate: Date;
 }

apps/server/src/modules/collaborative-text-editor/service/collaborative-text-editor.service.ts

@@ -33,14 +33,13 @@ export class CollaborativeTextEditorService {
 			parentId,
 			sessionExpiryDate
 		);
-		const authorsSessionIds = await this.collaborativeTextEditorAdapter.listSessionIdsOfAuthor(authorId);
 
 		const url = this.buildPath(padId);
-		const uniqueSessionIds = this.removeDuplicateSessions([...authorsSessionIds, sessionId]);
 
 		return {
-			sessions: uniqueSessionIds,
+			sessionId,
 			url,
+			path: `/p/${padId}`,
 			sessionExpiryDate,
 		};
 	}
@@ -51,10 +50,13 @@ export class CollaborativeTextEditorService {
 		await this.collaborativeTextEditorAdapter.deleteGroup(groupId);
 	}
 
-	private removeDuplicateSessions(sessions: string[]): string[] {
-		const uniqueSessions = [...new Set(sessions)];
+	async deleteSessionsByUser(userId: string): Promise<void> {
+		const authorId = await this.collaborativeTextEditorAdapter.getOrCreateAuthorId(userId);
+		const sessionIds = await this.collaborativeTextEditorAdapter.listSessionIdsOfAuthor(authorId);
 
-		return uniqueSessions;
+		const promises = sessionIds.map((sessionId) => this.collaborativeTextEditorAdapter.deleteSession(sessionId));
+
+		await Promise.all(promises);
 	}
 
 	private buildSessionExpiryDate(): Date {