@blackcode_sa/metaestetics-api 1.11.1 → 1.11.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/backoffice/expo-safe/index.ts

@@ -34,6 +34,4 @@ export {
 export { Contraindication } from "../types/static/contraindication.types";
 export { ProcedureFamily } from "../types/static/procedure-family.types";
 export { TreatmentBenefit } from "../types/static/treatment-benefit.types";
-export { TreatmentBenefitDynamic } from "../types/";
-export { ContraindicationDynamic } from "../types/";
 export { RequirementType, TimeUnit } from "../types/requirement.types";

package/src/backoffice/services/__tests__/brand.service.test.ts

@@ -0,0 +1,196 @@
+import { BrandService } from "../brand.service";
+import { Brand } from "../../types/brand.types";
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  addDoc,
+  updateDoc,
+  query,
+  where,
+} from "firebase/firestore";
+
+// Mock Firebase
+jest.mock("firebase/firestore");
+jest.mock("../../../config/firebase", () => ({
+  getFirebaseInstance: jest.fn().mockResolvedValue({
+    db: {},
+    auth: {},
+  }),
+}));
+
+const COLLECTION = "backoffice_brands";
+
+describe("BrandService", () => {
+  let service: BrandService;
+
+  const mockBrand: Omit<Brand, "id" | "createdAt" | "updatedAt"> = {
+    name: "Test Brand",
+    manufacturer: "Test Manufacturer",
+    website: "https://test.com",
+    description: "Test Description",
+    isActive: true,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new BrandService();
+  });
+
+  describe("create", () => {
+    it("treba da kreira novi brend sa ispravnim podacima", async () => {
+      const mockDocRef = { id: "test-id" };
+      (collection as jest.Mock).mockReturnValue("brands-collection");
+      (addDoc as jest.Mock).mockResolvedValue(mockDocRef);
+
+      const result = await service.create(mockBrand);
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(addDoc).toHaveBeenCalledWith(
+        "brands-collection",
+        expect.objectContaining({
+          ...mockBrand,
+          createdAt: expect.any(Date),
+          updatedAt: expect.any(Date),
+        })
+      );
+      expect(result).toEqual({
+        id: "test-id",
+        ...mockBrand,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+      });
+    });
+  });
+
+  describe("getAll", () => {
+    it("treba da vrati sve aktivne brendove", async () => {
+      const mockDocs = [
+        {
+          id: "test-id-1",
+          data: () => ({
+            ...mockBrand,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          }),
+        },
+        {
+          id: "test-id-2",
+          data: () => ({
+            ...mockBrand,
+            name: "Test Brand 2",
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          }),
+        },
+      ];
+
+      (collection as jest.Mock).mockReturnValue("brands-collection");
+      (query as jest.Mock).mockReturnValue("filtered-query");
+      (where as jest.Mock).mockReturnValue("where-clause");
+      (getDocs as jest.Mock).mockResolvedValue({ docs: mockDocs });
+
+      const result = await service.getAll();
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(query).toHaveBeenCalledWith("brands-collection", "where-clause");
+      expect(where).toHaveBeenCalledWith("isActive", "==", true);
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({
+        id: "test-id-1",
+        ...mockBrand,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+      });
+    });
+  });
+
+  describe("update", () => {
+    it("treba da ažurira postojeći brend", async () => {
+      const updateData = { name: "Updated Brand" };
+
+      (collection as jest.Mock).mockReturnValue("brands-collection");
+      (doc as jest.Mock).mockReturnValue("doc-ref");
+      (getDoc as jest.Mock).mockResolvedValue({
+        exists: () => true,
+        id: "test-id",
+        data: () => ({
+          ...mockBrand,
+          ...updateData,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        }),
+      });
+      (updateDoc as jest.Mock).mockResolvedValue(undefined);
+
+      const result = await service.update("test-id", updateData);
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(doc).toHaveBeenCalledWith("brands-collection", "test-id");
+      expect(updateDoc).toHaveBeenCalledWith(
+        "doc-ref",
+        expect.objectContaining({
+          ...updateData,
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+  });
+
+  describe("delete", () => {
+    it("treba da izvrši soft delete brenda", async () => {
+      (collection as jest.Mock).mockReturnValue("brands-collection");
+      (doc as jest.Mock).mockReturnValue("doc-ref");
+      (updateDoc as jest.Mock).mockResolvedValue(undefined);
+
+      await service.delete("test-id");
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(doc).toHaveBeenCalledWith("brands-collection", "test-id");
+      expect(updateDoc).toHaveBeenCalledWith("doc-ref", {
+        isActive: false,
+        updatedAt: expect.any(Date),
+      });
+    });
+  });
+
+  describe("getById", () => {
+    it("treba da vrati brend po ID-u", async () => {
+      (collection as jest.Mock).mockReturnValue("brands-collection");
+      (doc as jest.Mock).mockReturnValue("doc-ref");
+      (getDoc as jest.Mock).mockResolvedValue({
+        exists: () => true,
+        id: "test-id",
+        data: () => ({
+          ...mockBrand,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        }),
+      });
+
+      const result = await service.getById("test-id");
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(doc).toHaveBeenCalledWith("brands-collection", "test-id");
+      expect(result).toEqual({
+        id: "test-id",
+        ...mockBrand,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+      });
+    });
+
+    it("treba da vrati null ako brend ne postoji", async () => {
+      (collection as jest.Mock).mockReturnValue("brands-collection");
+      (doc as jest.Mock).mockReturnValue("doc-ref");
+      (getDoc as jest.Mock).mockResolvedValue({
+        exists: () => false,
+      });
+
+      const result = await service.getById("non-existent-id");
+
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/backoffice/services/__tests__/category.service.test.ts

@@ -0,0 +1,201 @@
+import { CategoryService } from "../category.service";
+import { Category } from "../../types/category.types";
+import { ProcedureFamily } from "../../types/static/procedure-family.types";
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  addDoc,
+  updateDoc,
+  query,
+  where,
+} from "firebase/firestore";
+
+// Mock Firebase
+jest.mock("firebase/firestore");
+jest.mock("../../../config/firebase", () => ({
+  getFirebaseInstance: jest.fn().mockResolvedValue({
+    db: {},
+    auth: {},
+  }),
+}));
+
+const COLLECTION = "backoffice_categories";
+
+describe("CategoryService", () => {
+  let service: CategoryService;
+
+  const mockCategory: Omit<Category, "id" | "createdAt" | "updatedAt"> = {
+    name: "Test Category",
+    description: "Test Description",
+    family: ProcedureFamily.AESTHETICS,
+    isActive: true,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new CategoryService();
+  });
+
+  describe("create", () => {
+    it("treba da kreira novu kategoriju", async () => {
+      const mockDocRef = { id: "test-id" };
+      (collection as jest.Mock).mockReturnValue("categories-collection");
+      (addDoc as jest.Mock).mockResolvedValue(mockDocRef);
+
+      const result = await service.create(mockCategory);
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(addDoc).toHaveBeenCalledWith(
+        "categories-collection",
+        expect.objectContaining({
+          ...mockCategory,
+          createdAt: expect.any(Date),
+          updatedAt: expect.any(Date),
+        })
+      );
+      expect(result).toEqual({
+        id: "test-id",
+        ...mockCategory,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+      });
+    });
+  });
+
+  describe("getAll", () => {
+    it("treba da vrati sve aktivne kategorije", async () => {
+      const mockDocs = [
+        {
+          id: "cat-1",
+          data: () => ({
+            ...mockCategory,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          }),
+        },
+        {
+          id: "cat-2",
+          data: () => ({
+            ...mockCategory,
+            name: "Test Category 2",
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          }),
+        },
+      ];
+
+      (collection as jest.Mock).mockReturnValue("categories-collection");
+      (query as jest.Mock).mockReturnValue("filtered-query");
+      (where as jest.Mock).mockReturnValue("where-clause");
+      (getDocs as jest.Mock).mockResolvedValue({ docs: mockDocs });
+
+      const results = await service.getAll();
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(query).toHaveBeenCalledWith(
+        "categories-collection",
+        "where-clause"
+      );
+      expect(where).toHaveBeenCalledWith("isActive", "==", true);
+      expect(results).toHaveLength(2);
+      expect(results[0]).toEqual({
+        id: "cat-1",
+        ...mockCategory,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+      });
+    });
+  });
+
+  describe("getAllByFamily", () => {
+    it("treba da vrati sve kategorije za određenu familiju", async () => {
+      const mockDocs = [
+        {
+          id: "cat-1",
+          data: () => ({
+            ...mockCategory,
+            family: ProcedureFamily.AESTHETICS,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          }),
+        },
+      ];
+
+      (collection as jest.Mock).mockReturnValue("categories-collection");
+      (query as jest.Mock).mockReturnValue("filtered-query");
+      (where as jest.Mock).mockReturnValue("where-clause");
+      (getDocs as jest.Mock).mockResolvedValue({ docs: mockDocs });
+
+      const results = await service.getAllByFamily(ProcedureFamily.AESTHETICS);
+
+      expect(query).toHaveBeenCalledWith(
+        "categories-collection",
+        "where-clause",
+        "where-clause"
+      );
+      expect(where).toHaveBeenCalledWith(
+        "family",
+        "==",
+        ProcedureFamily.AESTHETICS
+      );
+      expect(where).toHaveBeenCalledWith("isActive", "==", true);
+      expect(results).toHaveLength(1);
+      expect(results[0].family).toBe(ProcedureFamily.AESTHETICS);
+    });
+  });
+
+  describe("update", () => {
+    it("treba da ažurira postojeću kategoriju", async () => {
+      const updateData = { name: "Updated Category" };
+
+      (collection as jest.Mock).mockReturnValue("categories-collection");
+      (doc as jest.Mock).mockReturnValue("doc-ref");
+      (updateDoc as jest.Mock).mockResolvedValue(undefined);
+      (getDoc as jest.Mock).mockResolvedValue({
+        exists: () => true,
+        id: "test-id",
+        data: () => ({
+          ...mockCategory,
+          ...updateData,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        }),
+      });
+
+      const result = await service.update("test-id", updateData);
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(doc).toHaveBeenCalledWith("categories-collection", "test-id");
+      expect(updateDoc).toHaveBeenCalledWith("doc-ref", {
+        ...updateData,
+        updatedAt: expect.any(Date),
+      });
+      expect(result).toEqual({
+        id: "test-id",
+        ...mockCategory,
+        ...updateData,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+      });
+    });
+  });
+
+  describe("delete", () => {
+    it("treba da izvrši soft delete kategorije", async () => {
+      (collection as jest.Mock).mockReturnValue("categories-collection");
+      (doc as jest.Mock).mockReturnValue("doc-ref");
+      (updateDoc as jest.Mock).mockResolvedValue(undefined);
+
+      await service.delete("test-id");
+
+      expect(collection).toHaveBeenCalledWith({}, COLLECTION);
+      expect(doc).toHaveBeenCalledWith("categories-collection", "test-id");
+      expect(updateDoc).toHaveBeenCalledWith("doc-ref", {
+        isActive: false,
+        updatedAt: expect.any(Date),
+      });
+    });
+  });
+});