fix: format

back/src/auth/auth.controller.ts

@@ -45,9 +45,9 @@ export class AuthController {
 	@Post('register')
 	async register(@Body() registerDto: RegisterDto): Promise<void> {
 		try {
-			const user = await this.usersService.createUser(registerDto)
+			const user = await this.usersService.createUser(registerDto);
 			await this.settingsService.createUserSetting(user.id);
-		} catch(e) {
+		} catch (e) {
 			console.error(e);
 			throw new BadRequestException();
 		}
@@ -116,25 +116,28 @@ export class AuthController {
 
 	@UseGuards(JwtAuthGuard)
 	@ApiBearerAuth()
-	@ApiOkResponse({description: 'Successfully edited settings', type: Setting})
+	@ApiOkResponse({ description: 'Successfully edited settings', type: Setting })
-	@ApiUnauthorizedResponse({description: 'Invalid token'})
+	@ApiUnauthorizedResponse({ description: 'Invalid token' })
 	@Patch('me/settings')
 	udpateSettings(
 		@Request() req: any,
-		@Body() settingUserDto: UpdateSettingDto): Promise<Setting> {
+		@Body() settingUserDto: UpdateSettingDto,
+	): Promise<Setting> {
 		return this.settingsService.updateUserSettings({
-			where: { userId: +req.user.id},
+			where: { userId: +req.user.id },
 			data: settingUserDto,
 		});
 	}
 
 	@UseGuards(JwtAuthGuard)
 	@ApiBearerAuth()
-	@ApiOkResponse({description: 'Successfully edited settings', type: Setting})
+	@ApiOkResponse({ description: 'Successfully edited settings', type: Setting })
-	@ApiUnauthorizedResponse({description: 'Invalid token'})
+	@ApiUnauthorizedResponse({ description: 'Invalid token' })
 	@Get('me/settings')
 	async getSettings(@Request() req: any): Promise<Setting> {
-		const result = await this.settingsService.getUserSetting({ userId: +req.user.id });
+		const result = await this.settingsService.getUserSetting({
+			userId: +req.user.id,
+		});
 		if (!result) throw new NotFoundException();
 		return result;
 	}

back/src/history/dto/SearchHistoryDto.ts

@@ -1,9 +1,9 @@
-import { ApiProperty } from "@nestjs/swagger";
+import { ApiProperty } from '@nestjs/swagger';
 
 export class SearchHistoryDto {
 	@ApiProperty()
 	query: string;
 
 	@ApiProperty()
-	type: "song" | "artist" | "album" | "genre";
+	type: 'song' | 'artist' | 'album' | 'genre';
 }

back/src/history/dto/SongHistoryDto.ts

@@ -1,5 +1,5 @@
-import { ApiProperty } from "@nestjs/swagger";
+import { ApiProperty } from '@nestjs/swagger';
-import { IsNumber } from "class-validator";
+import { IsNumber } from 'class-validator';
 
 export class SongHistoryDto {
 	@ApiProperty()
@@ -15,8 +15,8 @@ export class SongHistoryDto {
 	score: number;
 
 	@ApiProperty()
-	difficulties: Record<string, number>
+	difficulties: Record<string, number>;
 
 	@ApiProperty()
-	info: Record<string, number>
+	info: Record<string, number>;
 }

back/src/history/history.controller.ts

@@ -20,7 +20,7 @@ import { SearchHistoryDto } from './dto/SearchHistoryDto';
 @Controller('history')
 @ApiTags('history')
 export class HistoryController {
-	constructor(private readonly historyService: HistoryService) { }
+	constructor(private readonly historyService: HistoryService) {}
 
 	@Get()
 	@HttpCode(200)
@@ -52,14 +52,17 @@ export class HistoryController {
 		return this.historyService.createSongHistoryRecord(record);
 	}
 
-	@Post("search")
+	@Post('search')
 	@HttpCode(201)
 	@UseGuards(JwtAuthGuard)
-	@ApiUnauthorizedResponse({description: "Invalid token"})
+	@ApiUnauthorizedResponse({ description: 'Invalid token' })
 	async createSearchHistory(
 		@Request() req: any,
-		@Body() record: SearchHistoryDto
+		@Body() record: SearchHistoryDto,
-		): Promise<void> {
+	): Promise<void> {
-			await this.historyService.createSearchHistoryRecord(req.user.id, { query: record.query, type: record.type });
+		await this.historyService.createSearchHistoryRecord(req.user.id, {
-		}
+			query: record.query,
+			type: record.type,
+		});
+	}
 }

back/src/history/history.service.spec.ts

@@ -2,17 +2,17 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { HistoryService } from './history.service';
 
 describe('HistoryService', () => {
-  let service: HistoryService;
+	let service: HistoryService;
 
-  beforeEach(async () => {
+	beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
+		const module: TestingModule = await Test.createTestingModule({
-      providers: [HistoryService],
+			providers: [HistoryService],
-    }).compile();
+		}).compile();
 
-    service = module.get<HistoryService>(HistoryService);
+		service = module.get<HistoryService>(HistoryService);
-  });
+	});
 
-  it('should be defined', () => {
+	it('should be defined', () => {
-    expect(service).toBeDefined();
+		expect(service).toBeDefined();
-  });
+	});
 });

back/src/history/history.service.ts

@@ -6,7 +6,7 @@ import { SongHistoryDto } from './dto/SongHistoryDto';
 
 @Injectable()
 export class HistoryService {
-	constructor(private prisma: PrismaService) { }
+	constructor(private prisma: PrismaService) {}
 
 	async createSongHistoryRecord({
 		songID,
@@ -74,7 +74,7 @@ export class HistoryService {
 
 	async createSearchHistoryRecord(
 		userID: number,
-		{ query, type }: SearchHistoryDto
+		{ query, type }: SearchHistoryDto,
 	): Promise<SearchHistory> {
 		return this.prisma.searchHistory.create({
 			data: {

back/src/main.ts

@@ -2,43 +2,55 @@ import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import { PrismaService } from './prisma/prisma.service';
 import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
-import { CallHandler, ExecutionContext, Injectable, NestInterceptor, ValidationPipe } from '@nestjs/common';
+import {
-import {RequestLogger, RequestLoggerOptions} from 'json-logger-service';
+	CallHandler,
+	ExecutionContext,
+	Injectable,
+	NestInterceptor,
+	ValidationPipe,
+} from '@nestjs/common';
+import { RequestLogger, RequestLoggerOptions } from 'json-logger-service';
 import { tap } from 'rxjs';
 
 @Injectable()
 export class AspectLogger implements NestInterceptor {
-  intercept(context: ExecutionContext, next: CallHandler) {
+	intercept(context: ExecutionContext, next: CallHandler) {
-    const req = context.switchToHttp().getRequest();
+		const req = context.switchToHttp().getRequest();
-	const res = context.switchToHttp().getResponse();
+		const res = context.switchToHttp().getResponse();
-    const { statusCode } = context.switchToHttp().getResponse();
+		const { statusCode } = context.switchToHttp().getResponse();
-    const { originalUrl, method, params, query, body, user} = req;
+		const { originalUrl, method, params, query, body, user } = req;
 
-	const toPrint = {
+		const toPrint = {
-		originalUrl,
+			originalUrl,
-		method,
+			method,
-		params,
+			params,
-		query,
+			query,
-		body,
+			body,
-		"userId": user?.id ?? "not logged in",
+			userId: user?.id ?? 'not logged in',
-		"username": user?.username ?? "not logged in",
+			username: user?.username ?? 'not logged in',
-	  };
+		};
 
-    return next.handle().pipe(
+		return next.handle().pipe(
-      tap((data) =>
+			tap((data) =>
-        console.log(JSON.stringify({
+				console.log(
-			...toPrint,
+					JSON.stringify({
-          statusCode,
+						...toPrint,
-          data
+						statusCode,
-        }))
+						data,
-      )
+					}),
-    );
+				),
-  }
+			),
+		);
+	}
 }
 
 async function bootstrap() {
 	const app = await NestFactory.create(AppModule);
-	app.use(RequestLogger.buildExpressRequestLogger({ doNotLogPaths: ['/health'] } as RequestLoggerOptions));
+	app.use(
+		RequestLogger.buildExpressRequestLogger({
+			doNotLogPaths: ['/health'],
+		} as RequestLoggerOptions),
+	);
 	const prismaService = app.get(PrismaService);
 	await prismaService.enableShutdownHooks(app);
 

back/src/search/search.controller.ts

@@ -21,11 +21,14 @@ import { SearchService } from './search.service';
 @ApiTags('search')
 @Controller('search')
 export class SearchController {
-	constructor(private readonly searchService: SearchService) { }
+	constructor(private readonly searchService: SearchService) {}
 
 	@Get('songs/:query')
 	@UseGuards(JwtAuthGuard)
-	async searchSong(@Request() req: any, @Param('query') query: string): Promise<Song[] | null> {
+	async searchSong(
+		@Request() req: any,
+		@Param('query') query: string,
+	): Promise<Song[] | null> {
 		try {
 			const ret = await this.searchService.songByGuess(query, req.user?.id);
 			if (!ret.length) throw new NotFoundException();
@@ -37,7 +40,10 @@ export class SearchController {
 
 	@Get('genres/:query')
 	@UseGuards(JwtAuthGuard)
-	async searchGenre(@Request() req: any, @Param('query') query: string): Promise<Genre[] | null> {
+	async searchGenre(
+		@Request() req: any,
+		@Param('query') query: string,
+	): Promise<Genre[] | null> {
 		try {
 			const ret = await this.searchService.genreByGuess(query, req.user?.id);
 			if (!ret.length) throw new NotFoundException();
@@ -49,7 +55,10 @@ export class SearchController {
 
 	@Get('artists/:query')
 	@UseGuards(JwtAuthGuard)
-	async searchArtists(@Request() req: any, @Param('query') query: string): Promise<Artist[] | null> {
+	async searchArtists(
+		@Request() req: any,
+		@Param('query') query: string,
+	): Promise<Artist[] | null> {
 		try {
 			const ret = await this.searchService.artistByGuess(query, req.user?.id);
 			if (!ret.length) throw new NotFoundException();
@@ -58,4 +67,4 @@ export class SearchController {
 			throw new InternalServerErrorException();
 		}
 	}
-}
+}

back/src/search/search.service.ts

@@ -5,7 +5,10 @@ import { PrismaService } from 'src/prisma/prisma.service';
 
 @Injectable()
 export class SearchService {
-	constructor(private prisma: PrismaService, private history: HistoryService) { }
+	constructor(
+		private prisma: PrismaService,
+		private history: HistoryService,
+	) {}
 
 	async songByGuess(query: string, userID: number): Promise<Song[]> {
 		return this.prisma.song.findMany({

back/src/settings/settings.module.ts

@@ -3,8 +3,8 @@ import { SettingsService } from './settings.service';
 import { PrismaModule } from 'src/prisma/prisma.module';
 
 @Module({
-    imports: [PrismaModule],
+	imports: [PrismaModule],
-    providers: [SettingsService],
+	providers: [SettingsService],
-    exports: [SettingsService],
+	exports: [SettingsService],
 })
 export class SettingsModule {}

back/src/settings/settings.service.ts

@@ -20,10 +20,10 @@ export class SettingsService {
 				user: {
 					connect: {
 						id: userId,
-					}
+					},
-				}
+				},
-			}
+			},
-		})
+		});
 	}
 
 	async updateUserSettings(params: {
@@ -37,7 +37,9 @@ export class SettingsService {
 		});
 	}
 
-	async deleteUserSettings(where: Prisma.UserSettingsWhereUniqueInput): Promise<UserSettings> {
+	async deleteUserSettings(
+		where: Prisma.UserSettingsWhereUniqueInput,
+	): Promise<UserSettings> {
 		return this.prisma.userSettings.delete({
 			where,
 		});