Refactor: Migrate from MongoDB Node.js Driver to Prisma

__mocks__/controllers/api-builder.controller.ts

@@ -0,0 +1,54 @@
+export const apiBuilderController = jest
+  .fn()
+  .mockImplementation((routeType: string, collectionName: string, findWhere: any, routeData: any) => {
+    return {
+      routeType,
+      collectionName,
+      findWhere,
+      routeData,
+      fetchData: jest.fn().mockImplementation((_findType?: string) => {
+        if (collectionName === "users") {
+          const mockUsers = [
+            { id: "1", username: "mock_user", permission_group: "admin", email: "mock1@test.com" },
+            { id: "2", username: "mock_user", permission_group: "admin", email: "mock2@test.com" },
+            { id: "3", username: "mock_user", permission_group: "admin", email: "mock3@test.com" },
+            { id: "4", username: "other_user", permission_group: "editor", email: "other1@test.com" },
+            { id: "5", username: "root_user", permission_group: "root", email: "root@test.com" }
+          ]
+
+          if (routeType === "index") {
+            return mockUsers
+          } else if (routeType === "single-param") {
+            if (findWhere === "permission_group") {
+              return mockUsers.filter((u) => u.permission_group === routeData)
+            } else if (findWhere === "username") {
+              return mockUsers.filter((u) => u.username === routeData)
+            }
+            return mockUsers
+          }
+          return []
+        }
+
+        const mockEntryTypes = [
+          { id: "1", name: "Type 1", namespace: "test-entry-type", slug: "type-1" },
+          { id: "2", name: "Type 2", namespace: "test-entry-type", slug: "type-2" },
+          { id: "3", name: "Type 3", namespace: "newtest.newtest1", slug: "type-3" },
+          { id: "4", name: "Type 4", namespace: "newtest.newtest1", slug: "type-4" },
+          { id: "5", name: "Type 5", namespace: "other-namespace", slug: "type-5" }
+        ]
+
+        if (routeType === "index") {
+          return mockEntryTypes
+        } else if (routeType === "single-param") {
+          if (routeData === "test-entry-type") {
+            return mockEntryTypes.filter((et) => et.namespace === "test-entry-type")
+          }
+          return mockEntryTypes
+        } else if (routeType === "multi-param") {
+          const ns = Array.isArray(routeData) ? routeData.join(".") : routeData
+          return mockEntryTypes.filter((et) => et.namespace === ns)
+        }
+        return []
+      })
+    }
+  })

__mocks__/controllers/api-key.controller.ts

@@ -0,0 +1,3 @@
+export const apiKeyController = jest.fn().mockImplementation(() => ({
+  findKey: jest.fn().mockResolvedValue([{ key: "valid-key" }])
+}))

__mocks__/lib/api/rate-limits.ts

@@ -0,0 +1,2 @@
+// Mock rate limiting to be a direct pass-through to simplify route testing
+export const withRateLimit = (handler: any) => handler

__mocks__/lib/api/utils.ts

@@ -0,0 +1,3 @@
+// Mock API key controller and utility checks
+export const isSystemApiKey = jest.fn().mockImplementation((key: string) => key === "system-key")
+export const isValidApiKey = jest.fn().mockImplementation((_keyData: any, key: string) => key === "valid-key")

__mocks__/lib/check-permission-api.ts

@@ -0,0 +1,3 @@
+// Mock permission checking API helper to isolate controller validation
+const checkPermissionApi = jest.fn()
+export default checkPermissionApi

__tests__/api/entries/entries.api.test.ts

@@ -1,33 +1,59 @@
+/**
+ * @jest-environment node
+ */
+/* eslint-disable @typescript-eslint/no-require-imports */
 import httpMocks from "node-mocks-http"
 import { NextApiRequest, NextApiResponse } from "next"
-import indexRouteHandler from "../../../pages/api/v1/entries/index"
-import slugRouteHandler from "../../../pages/api/v1/entries/[slug]"
-import paramRouteHandler from "../../../pages/api/v1/entries/[...param]"
-import { Entry } from "../../../interfaces"
+import indexRouteHandler from "@/pages/api/v1/entries/index"
+import slugRouteHandler from "@/pages/api/v1/entries/[slug]"
+import paramRouteHandler from "@/pages/api/v1/entries/[...param]"
+import { Entry } from "@/interfaces"
+import checkPermissionApi from "@/lib/check-permission-api"
 
-describe("/api/v1/entries/", () => {
-  afterEach(() => {
+// Mock rate limiting to be a direct pass-through to simplify route testing
+jest.mock("@/lib/api/rate-limits", () => require("@/__mocks__/lib/api/rate-limits"))
+
+// Mock permission checking API helper to isolate controller validation
+jest.mock("@/lib/check-permission-api", () => require("@/__mocks__/lib/check-permission-api"))
+
+// Mock API key controller and utility checks
+jest.mock("@/lib/api/utils", () => require("@/__mocks__/lib/api/utils"))
+
+jest.mock("@/controllers/api-key.controller", () => require("@/__mocks__/controllers/api-key.controller"))
+
+// Mock apiBuilderController to bypass MongoDB queries and return mock objects directly
+jest.mock("@/controllers/api-builder.controller", () =>
+  require("@/__mocks__/controllers/api-builder.controller")
+)
+
+describe("/api/v1/entries", () => {
+  const mockCheckPermissionApi = checkPermissionApi as jest.Mock
+
+  beforeEach(() => {
     jest.clearAllMocks()
   })
+
   it("GET / - should return all entries", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
       query: {
-        apikey: "dbbf764d6ce785adb15a184699867b24"
+        apikey: "system-key"
       }
     })
 
     const response = httpMocks.createResponse<NextApiResponse>()
-
     await indexRouteHandler(request, response)
     const data = await response._getJSONData()
+
     expect(response._getStatusCode()).toBe(200)
-    expect(data.message).not.toBe({ message: "You're not authorized!" })
     expect(Array.isArray(data)).toBe(true)
+    expect(data.length).toBe(5)
   })
 
-  it("GET / - should return 'You're not authorized' if there is no API key ", async () => {
+  it("GET / - should return 'You're not authorized' if there is no API key", async () => {
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
@@ -37,143 +63,183 @@ describe("/api/v1/entries/", () => {
     })
 
     const response = httpMocks.createResponse<NextApiResponse>()
-
     await indexRouteHandler(request, response)
     const data = await response._getJSONData()
-    expect(response._getStatusCode()).toBe(200)
+
+    expect(response._getStatusCode()).toBe(401)
     expect(data.message).toBe("You're not authorized!")
   })
 
-  it("GET /first_X -  should return first X entries", async () => {
+  it("GET /first_X - should return first X entries", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
       query: {
-        apikey: "dbbf764d6ce785adb15a184699867b24",
+        apikey: "system-key",
         slug: "first_3"
       }
     })
     const response = httpMocks.createResponse<NextApiResponse>()
 
     await slugRouteHandler(request, response)
     const data = await response._getJSONData()
+
     expect(response._getStatusCode()).toBe(200)
-    expect(data.message).not.toBe({ message: "You're not authorized!" })
     expect(data.length).toBeLessThanOrEqual(3)
   })
 
-  it("GET /last_X -  should return last X entries", async () => {
+  it("GET /last_X - should return last X entries", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
       query: {
-        apikey: "dbbf764d6ce785adb15a184699867b24",
+        apikey: "system-key",
         slug: "last_3"
       }
     })
     const response = httpMocks.createResponse<NextApiResponse>()
 
     await slugRouteHandler(request, response)
     const data = await response._getJSONData()
+
     expect(response._getStatusCode()).toBe(200)
-    expect(data.message).not.toBe({ message: "You're not authorized!" })
     expect(data.length).toBeLessThanOrEqual(3)
   })
 
-  it("GET /random_X -  should return random X entries", async () => {
+  it("GET /random_X - should return random X entries", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
       query: {
-        apikey: "dbbf764d6ce785adb15a184699867b24",
+        apikey: "system-key",
         slug: "random_3"
       }
     })
     const response = httpMocks.createResponse<NextApiResponse>()
 
     await slugRouteHandler(request, response)
     const data = await response._getJSONData()
+
     expect(response._getStatusCode()).toBe(200)
-    expect(data.message).not.toBe({ message: "You're not authorized!" })
     expect(data.length).toBeLessThanOrEqual(3)
   })
 
-  it("GET /api/v1/entries/:namespace -  should return entries from a namespace", async () => {
+  it("GET /api/v1/entries/:namespace - should return entries from a namespace", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
       query: {
-        apikey: "dbbf764d6ce785adb15a184699867b24",
+        apikey: "system-key",
         slug: "test-entry-type"
       }
     })
     const response = httpMocks.createResponse<NextApiResponse>()
 
     await slugRouteHandler(request, response)
     const data = await response._getJSONData()
+
     expect(response._getStatusCode()).toBe(200)
     data.forEach((entry: Entry) => {
       expect(entry.namespace).toEqual("test-entry-type")
     })
   })
 
-  it("GET /api/v1/entries/:namespace/first_X - should return first X entries from a namespace", async () => {
+  it("GET /api/v1/entries/:namespace-part-1/:namespace-part-2/ - should return entries from sub-namespace", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
       query: {
-        apikey: "dbbf764d6ce785adb15a184699867b24",
-        param: ["test-entry-type", "first_3"]
+        apikey: "system-key",
+        param: ["newtest", "newtest1"]
       }
     })
     const response = httpMocks.createResponse<NextApiResponse>()
 
     await paramRouteHandler(request, response)
     const data = await response._getJSONData()
+
+    expect(response._getStatusCode()).toBe(200)
+    data.forEach((entry: Entry) => {
+      expect(entry.namespace).toEqual("newtest.newtest1")
+    })
+  })
+
+  it("GET /api/v1/entries/:namespace-part-1/:namespace-part-2/first_x - should return first X entries from sub-namespace", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
+    const request = httpMocks.createRequest<NextApiRequest>({
+      method: "GET",
+      url: "/api/v1/entries",
+      query: {
+        apikey: "system-key",
+        param: ["newtest", "newtest1", "first_3"]
+      }
+    })
+    const response = httpMocks.createResponse<NextApiResponse>()
+
+    await paramRouteHandler(request, response)
+    const data = await response._getJSONData()
+
     expect(response._getStatusCode()).toBe(200)
     expect(data.length).toBeLessThanOrEqual(3)
     data.forEach((entry: Entry) => {
-      expect(entry.namespace).toEqual("test-entry-type")
+      expect(entry.namespace).toEqual("newtest.newtest1")
     })
   })
 
-  it("GET /api/v1/entries/:namespace/last_X - should return last X entries from a namespace", async () => {
+  it("GET /api/v1/entries/:namespace-part-1/:namespace-part-2/last_x - should return last X entries from sub-namespace", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
       query: {
-        apikey: "dbbf764d6ce785adb15a184699867b24",
-        param: ["test-entry-type", "last_3"]
+        apikey: "system-key",
+        param: ["newtest", "newtest1", "last_3"]
       }
     })
     const response = httpMocks.createResponse<NextApiResponse>()
 
     await paramRouteHandler(request, response)
     const data = await response._getJSONData()
+
     expect(response._getStatusCode()).toBe(200)
     expect(data.length).toBeLessThanOrEqual(3)
     data.forEach((entry: Entry) => {
-      expect(entry.namespace).toEqual("test-entry-type")
+      expect(entry.namespace).toEqual("newtest.newtest1")
     })
   })
 
-  it("GET /api/v1/entries/:namespace/random_X - should return random X entries from a namespace", async () => {
+  it("GET /api/v1/entries/:namespace-part-1/:namespace-part-2/random_x - should return random X entries from sub-namespace", async () => {
+    mockCheckPermissionApi.mockResolvedValue(true)
+
     const request = httpMocks.createRequest<NextApiRequest>({
       method: "GET",
       url: "/api/v1/entries",
       query: {
-        apikey: "dbbf764d6ce785adb15a184699867b24",
-        param: ["test-entry-type", "random_3"]
+        apikey: "system-key",
+        param: ["newtest", "newtest1", "random_3"]
       }
     })
     const response = httpMocks.createResponse<NextApiResponse>()
 
     await paramRouteHandler(request, response)
     const data = await response._getJSONData()
+
     expect(response._getStatusCode()).toBe(200)
     expect(data.length).toBeLessThanOrEqual(3)
     data.forEach((entry: Entry) => {
-      expect(entry.namespace).toEqual("test-entry-type")
+      expect(entry.namespace).toEqual("newtest.newtest1")
     })
   })
 })