backend/src/contents/contents.service.ts

@@ -100,6 +100,7 @@ export class ContentsService {
 		// 3. Upload vers S3
 		const key = `contents/${userId}/${Date.now()}-${uuidv4()}.${processed.extension}`;
 		await this.s3Service.uploadFile(key, processed.buffer, processed.mimeType);
+		this.logger.log(`File uploaded successfully to S3: ${key}`);
 
 		// 4. Création en base de données
 		return await this.create(userId, {

backend/src/media/media.controller.spec.ts

@@ -28,12 +28,13 @@ describe("MediaController", () => {
 	});
 
 	describe("getFile", () => {
-		it("should stream the file and set headers", async () => {
+		it("should stream the file and set headers with path containing slashes", async () => {
 			const res = {
 				setHeader: jest.fn(),
 			} as any;
 			const stream = new Readable();
 			stream.pipe = jest.fn();
+			const key = "contents/user-id/test.webp";
 
 			mockS3Service.getFileInfo.mockResolvedValue({
 				size: 100,
@@ -41,8 +42,9 @@ describe("MediaController", () => {
 			});
 			mockS3Service.getFile.mockResolvedValue(stream);
 
-			await controller.getFile("test.webp", res);
+			await controller.getFile(key, res);
 
+			expect(mockS3Service.getFileInfo).toHaveBeenCalledWith(key);
 			expect(res.setHeader).toHaveBeenCalledWith("Content-Type", "image/webp");
 			expect(res.setHeader).toHaveBeenCalledWith("Content-Length", 100);
 			expect(stream.pipe).toHaveBeenCalledWith(res);

backend/src/media/media.controller.ts

@@ -9,13 +9,15 @@ export class MediaController {
 	@Get("*key")
 	async getFile(@Param("key") key: string, @Res() res: Response) {
 		try {
-			const stats = await this.s3Service.getFileInfo(key);
+			const stats = (await this.s3Service.getFileInfo(key)) as any;
 			const stream = await this.s3Service.getFile(key);
 
-			res.setHeader(
-				"Content-Type",
-				stats.metaData["content-type"] || "application/octet-stream",
-			);
+			const contentType =
+				stats.metaData?.["content-type"] ||
+				stats.metadata?.["content-type"] ||
+				"application/octet-stream";
+
+			res.setHeader("Content-Type", contentType);
 			res.setHeader("Content-Length", stats.size);
 			res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
 

backend/src/s3/s3.service.spec.ts

@@ -7,7 +7,7 @@ jest.mock("minio");
 
 describe("S3Service", () => {
 	let service: S3Service;
-	let _configService: ConfigService;
+	let configService: ConfigService;
 	// biome-ignore lint/suspicious/noExplicitAny: Fine for testing purposes
 	let minioClient: any;
 
@@ -42,7 +42,7 @@ describe("S3Service", () => {
 		}).compile();
 
 		service = module.get<S3Service>(S3Service);
-		_configService = module.get<ConfigService>(ConfigService);
+		configService = module.get<ConfigService>(ConfigService);
 	});
 
 	it("should be defined", () => {
@@ -185,35 +185,35 @@ describe("S3Service", () => {
 		});
 	});
 
-	describe("moveFile", () => {
-		it("should move file within default bucket", async () => {
-			const source = "source.txt";
-			const dest = "dest.txt";
-			await service.moveFile(source, dest);
-
-			expect(minioClient.copyObject).toHaveBeenCalledWith(
-				"memegoat",
-				dest,
-				"/memegoat/source.txt",
-				expect.any(Minio.CopyConditions),
-			);
-			expect(minioClient.removeObject).toHaveBeenCalledWith("memegoat", source);
+	describe("getPublicUrl", () => {
+		it("should use API_URL if provided", () => {
+			(configService.get as jest.Mock).mockImplementation((key: string) => {
+				if (key === "API_URL") return "https://api.test.com";
+				return null;
+			});
+			const url = service.getPublicUrl("test.webp");
+			expect(url).toBe("https://api.test.com/media/test.webp");
 		});
 
-		it("should move file between different buckets", async () => {
-			const source = "source.txt";
-			const dest = "dest.txt";
-			const sBucket = "source-bucket";
-			const dBucket = "dest-bucket";
-			await service.moveFile(source, dest, sBucket, dBucket);
+		it("should use DOMAIN_NAME and PORT for localhost", () => {
+			(configService.get as jest.Mock).mockImplementation((key: string, def: any) => {
+				if (key === "API_URL") return null;
+				if (key === "DOMAIN_NAME") return "localhost";
+				if (key === "PORT") return 3000;
+				return def;
+			});
+			const url = service.getPublicUrl("test.webp");
+			expect(url).toBe("http://localhost:3000/media/test.webp");
+		});
 
-			expect(minioClient.copyObject).toHaveBeenCalledWith(
-				dBucket,
-				dest,
-				`/${sBucket}/${source}`,
-				expect.any(Minio.CopyConditions),
-			);
-			expect(minioClient.removeObject).toHaveBeenCalledWith(sBucket, source);
+		it("should use api.DOMAIN_NAME for production", () => {
+			(configService.get as jest.Mock).mockImplementation((key: string, def: any) => {
+				if (key === "API_URL") return null;
+				if (key === "DOMAIN_NAME") return "memegoat.fr";
+				return def;
+			});
+			const url = service.getPublicUrl("test.webp");
+			expect(url).toBe("https://api.memegoat.fr/media/test.webp");
 		});
 	});
 });

backend/src/s3/s3.service.ts

@@ -158,17 +158,19 @@ export class S3Service implements OnModuleInit, IStorageService {
 
 	getPublicUrl(storageKey: string): string {
 		const apiUrl = this.configService.get<string>("API_URL");
-		if (apiUrl) {
-			return `${apiUrl.replace(/\/$/, "")}/media/${storageKey}`;
-		}
-
 		const domain = this.configService.get<string>("DOMAIN_NAME", "localhost");
 		const port = this.configService.get<number>("PORT", 3000);
 
-		if (domain === "localhost" || domain === "127.0.0.1") {
-			return `http://${domain}:${port}/media/${storageKey}`;
+		let baseUrl: string;
+
+		if (apiUrl) {
+			baseUrl = apiUrl.replace(/\/$/, "");
+		} else if (domain === "localhost" || domain === "127.0.0.1") {
+			baseUrl = `http://${domain}:${port}`;
+		} else {
+			baseUrl = `https://api.${domain}`;
 		}
 
-		return `https://api.${domain}/media/${storageKey}`;
+		return `${baseUrl}/media/${storageKey}`;
 	}
 }

backend/src/users/users.service.ts

@@ -143,6 +143,7 @@ export class UsersService {
 		// 3. Upload vers S3
 		const key = `avatars/${uuid}/${Date.now()}-${uuidv4()}.${processed.extension}`;
 		await this.s3Service.uploadFile(key, processed.buffer, processed.mimeType);
+		this.logger.log(`Avatar uploaded successfully to S3: ${key}`);
 
 		// 4. Mise à jour de la base de données
 		const user = await this.update(uuid, { avatarUrl: key });