@drax/media-back 3.11.0 → 3.12.0

package/test/{modules/media/File → endpoints}/File-endpoints.test.ts

@@ -1,8 +1,8 @@
 import { describe, it, beforeAll, afterAll, expect } from "vitest"
-import FileRoutes from "../../../../src/routes/FileRoutes.js"
-import FilePermissions from "../../../../src/permissions/FilePermissions.js"
-import TestSetup from "../../../setup/TestSetup.js"
-import type { IFileBase } from "../../../../src/interfaces/IFile.js"
+import FileRoutes from "../../src/routes/FileRoutes.js"
+import FilePermissions from "../../src/permissions/FilePermissions.js"
+import TestSetup from "../setup/TestSetup.js"
+import type { IFileBase } from "../../src/interfaces/IFile.js"
 
 describe("File Endpoints Test", function () {
 

package/test/endpoints/Media-endpoints.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+// @ts-ignore
+import FormData from "form-data";
+import { readFileSync } from "node:fs";
+import { access, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import MediaRoutes from "../../src/routes/MediaRoutes.js";
+import MediaPermissions from "../../src/permissions/MediaPermissions.js";
+import FilePermissions from "../../src/permissions/FilePermissions.js";
+import { FileServiceFactory } from "../../src/factory/services/FileServiceFactory.js";
+import TestSetup from "../setup/TestSetup.js";
+
+// @ts-ignore
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const fixturePath = join(__dirname, "..", "data", "test.jpg");
+const storePath = join(process.cwd(), "packages/media/media-back/test/store");
+
+describe("Media Endpoints Test", function () {
+    const testSetup = new TestSetup({
+        routes: [MediaRoutes],
+        permissions: [MediaPermissions, FilePermissions],
+    });
+
+    beforeAll(async () => {
+        await testSetup.setup();
+    });
+
+    afterAll(async () => {
+        await rm(storePath, {recursive: true, force: true});
+        await testSetup.dropAndClose();
+    });
+
+    async function uploadFile(accessToken: string, dir: string = "inbox") {
+        const form = new FormData();
+        form.append("file", readFileSync(fixturePath), {
+            filename: "test.jpg",
+            contentType: "image/jpeg",
+        });
+
+        return await testSetup.fastifyInstance.inject({
+            method: "POST",
+            url: `/api/file/${dir}`,
+            payload: form.getBuffer(),
+            headers: {
+                ...form.getHeaders(),
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+    }
+
+    it("should upload a file and register metadata", async () => {
+        const {accessToken} = await testSetup.rootUserLogin();
+        await testSetup.dropCollection("File");
+
+        const resp = await uploadFile(accessToken, "emails");
+        const body = await resp.json();
+
+        expect(resp.statusCode).toBe(200);
+        expect(body.filename).toMatch(/test\.jpg$/);
+        expect(body.filepath).toContain("packages/media/media-back/test/store/emails/");
+        expect(body.url).toContain("/api/file/emails/");
+
+        const metadata = await FileServiceFactory.instance.findOneBy("relativePath", body.filepath);
+        expect(metadata).toBeTruthy();
+        expect(metadata?.filename).toBe(body.filename);
+
+        await access(join(process.cwd(), body.filepath));
+    });
+
+    it("should download a file and register a hit", async () => {
+        const {accessToken} = await testSetup.rootUserLogin();
+        await testSetup.dropCollection("File");
+
+        const uploadResp = await uploadFile(accessToken, "download-test");
+        const uploaded = await uploadResp.json();
+        const metadataBefore = await FileServiceFactory.instance.findOneBy("relativePath", uploaded.filepath);
+
+        const url = new URL(uploaded.url);
+        const downloadResp = await testSetup.fastifyInstance.inject({
+            method: "GET",
+            url: url.pathname,
+        });
+
+        expect(downloadResp.statusCode).toBe(200);
+        expect(downloadResp.headers["content-type"]).toContain("image/jpeg");
+        expect(downloadResp.body.length).toBeGreaterThan(0);
+
+        const metadataAfter = await FileServiceFactory.instance.findOneBy("relativePath", uploaded.filepath);
+        expect((metadataAfter?.hits || 0)).toBe((metadataBefore?.hits || 0) + 1);
+    });
+
+    it("should reject upload for invalid directory", async () => {
+        const {accessToken} = await testSetup.rootUserLogin();
+
+        const resp = await uploadFile(accessToken, "invalid.dir");
+        const body = await resp.json();
+
+        expect(resp.statusCode).toBe(400);
+        expect(body.message).toBe("Invalid directory name");
+    });
+
+    it("should return 404 when downloading a missing file", async () => {
+        const resp = await testSetup.fastifyInstance.inject({
+            method: "GET",
+            url: "/api/file/emails/2024/03/missing.jpg",
+        });
+
+        const body = await resp.json();
+        expect(resp.statusCode).toBe(404);
+        expect(body.message).toBe("File not found");
+    });
+
+    it("should reject download for invalid month", async () => {
+        const resp = await testSetup.fastifyInstance.inject({
+            method: "GET",
+            url: "/api/file/emails/2024/3/test.jpg",
+        });
+
+        const body = await resp.json();
+        expect(resp.statusCode).toBe(400);
+        expect(body.message).toBe("Invalid month");
+    });
+});

package/test/service/Media-service.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { createReadStream } from "node:fs";
+import { access, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { BadRequestError, NotFoundError } from "@drax/common-back";
+import MediaService from "../../src/services/MediaService.js";
+import { FileServiceFactory } from "../../src/factory/services/FileServiceFactory.js";
+import TestSetup from "../setup/TestSetup.js";
+
+// @ts-ignore
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const fixturePath = join(__dirname, "..", "data", "test.jpg");
+const storePath = join(process.cwd(), "packages/media/media-back/test/store");
+
+describe("Media Service Test", function () {
+    const mediaService = new MediaService();
+    const testSetup = new TestSetup();
+
+    beforeAll(async () => {
+        await testSetup.setup();
+    });
+
+    afterAll(async () => {
+        await rm(storePath, {recursive: true, force: true});
+        await testSetup.dropAndClose();
+    });
+
+    it("should save a file and register metadata", async () => {
+        await testSetup.dropCollection("File");
+
+        const saved = await mediaService.saveFile({
+            dir: "emails",
+            file: {
+                filename: "test.jpg",
+                fileStream: createReadStream(fixturePath),
+                mimetype: "image/jpeg",
+            },
+            createdBy: {
+                id: "507f1f77bcf86cd799439011",
+                username: "email-provider",
+            },
+            date: new Date("2024-03-15T10:00:00.000Z"),
+        });
+
+        expect(saved.filename).toMatch(/test\.jpg$/);
+        expect(saved.relativePath).toBe(`packages/media/media-back/test/store/emails/2024/03/${saved.filename}`);
+        expect(saved.url).toBe(`http://localhost/api/file/emails/2024/03/${saved.filename}`);
+
+        await access(saved.absolutePath);
+
+        const metadata = await FileServiceFactory.instance.findOneBy("relativePath", saved.relativePath);
+        expect(metadata).toBeTruthy();
+        expect(metadata?.createdBy?.username).toBe("email-provider");
+    });
+
+    it("should get a file and increment metadata hits", async () => {
+        await testSetup.dropCollection("File");
+
+        const saved = await mediaService.saveFile({
+            dir: "attachments",
+            file: {
+                filename: "test.jpg",
+                fileStream: createReadStream(fixturePath),
+                mimetype: "image/jpeg",
+            },
+            createdBy: {
+                id: "507f1f77bcf86cd799439011",
+                username: "email-provider",
+            },
+            date: new Date("2024-04-20T10:00:00.000Z"),
+        });
+
+        const before = await FileServiceFactory.instance.findOneBy("relativePath", saved.relativePath);
+        const file = await mediaService.getFile({
+            dir: "attachments",
+            year: "2024",
+            month: "04",
+            filename: saved.filename,
+        });
+
+        expect(file.relativePath).toBe(saved.relativePath);
+        expect(file.absolutePath).toBe(saved.absolutePath);
+
+        const after = await FileServiceFactory.instance.findOneBy("relativePath", saved.relativePath);
+        expect((after?.hits || 0)).toBe((before?.hits || 0) + 1);
+    });
+
+    it("should reject invalid directory names", async () => {
+        await expect(
+            mediaService.saveFile({
+                dir: "../emails",
+                file: {
+                    filename: "test.jpg",
+                    fileStream: createReadStream(fixturePath),
+                    mimetype: "image/jpeg",
+                },
+            })
+        ).rejects.toBeInstanceOf(BadRequestError);
+    });
+
+    it("should throw not found when the file does not exist", async () => {
+        await expect(
+            mediaService.getFile({
+                dir: "emails",
+                year: "2024",
+                month: "03",
+                filename: "missing.jpg",
+            })
+        ).rejects.toBeInstanceOf(NotFoundError);
+    });
+});

package/test/setup/TestSetup.ts

@@ -1,5 +1,8 @@
 import Fastify, { FastifyInstance, FastifyPluginAsync } from "fastify";
 import { LoadCommonConfigFromEnv } from "@drax/common-back";
+import fastifyMultipart from "@fastify/multipart";
+import fastifyStatic from "@fastify/static";
+import path from "node:path";
 import {
     LoadIdentityConfigFromEnv,
     CreateTenantIfNotExist,
@@ -72,6 +75,9 @@ class TestSetup {
         // Define environment variables
         process.env.DRAX_DB_ENGINE = "mongo";
         process.env.DRAX_JWT_SECRET = "xxx";
+        process.env.DRAX_FILE_DIR = "packages/media/media-back/test/store";
+        process.env.DRAX_BASE_URL = "http://localhost";
+        process.env.DRAX_MAX_UPLOAD_SIZE = "1000000";
     }
 
     setupConfig() {
@@ -108,6 +114,11 @@ class TestSetup {
             reply.status(500).send({ statusCode: 500, error: "InternalServerError", message: error?.message });
         });
         this._fastifyInstance.setValidatorCompiler(() => () => true)
+        this._fastifyInstance.register(fastifyMultipart as any)
+        this._fastifyInstance.register(fastifyStatic as any, {
+            root: path.resolve(process.cwd(), process.env.DRAX_FILE_DIR || "packages/media/media-back/test/store"),
+            prefix: "/",
+        })
         this._fastifyInstance.addHook('onRequest', jwtMiddleware)
         this._fastifyInstance.addHook('onRequest', rbacMiddleware)
         this._fastifyInstance.addHook('onRequest', apiKeyMiddleware)

package/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "extends": "../../../tsconfig.base.json",
   "compilerOptions": {
+    "module": "esnext",
     "rootDir": "src",
     "outDir": "dist",
     "declarationDir": "./types",