feat(@kampus/gql-utils): add createPrismaCountLoader (#583)

# Description

Create createPrismaCountLoader to use for post and comment upvote counts

packages/gql-utils/prisma/__mocks__/prisma.ts

@@ -1,7 +1,7 @@
 import { beforeEach } from "vitest";
 import { mockDeep, mockReset } from "vitest-mock-extended";
 
-import { type PrismaClient, type User } from "@kampus/prisma";
+import { type PrismaClient, type Upvote, type User } from "@kampus/prisma";
 
 beforeEach(() => {
   mockReset(mockedPrisma);
@@ -23,3 +23,13 @@ export const mockUser = (overrides: Partial<User>): User => ({
   email: "[email protected]",
   ...overrides,
 });
+
+export const mockUpvote = (overrides: Partial<Upvote>): Upvote => ({
+  id: "1",
+  postID: "1",
+  userID: "1",
+  createdAt: mockDate(),
+  updatedAt: mockDate(),
+  deletedAt: null,
+  ...overrides,
+});

packages/gql-utils/prisma/create-connection-loader.test.ts

@@ -26,13 +26,14 @@ describe(createPrismaConnectionLoader, () => {
     });
   });
 
-  it("returns null when there is an identifier but no parentID in key", async () => {
+  it("returns null when there is an identifier but no parentID in key", () => {
     // need to find a better example because "name" doesn't make sense with "parentID"
     // "name" needs to be replaced with an "id" column to represent real usecases.
     const allUsers = createPrismaConnectionLoader(mockedPrisma.user, "name");
 
-    const users = await allUsers.load(new ConnectionKey());
-    expect(users).toEqual(null);
+    void expect(async () => {
+      await allUsers.load(new ConnectionKey());
+    }).rejects.toThrowError(/name/);
   });
 
   it("works", async () => {

packages/gql-utils/prisma/create-count-loader.test.ts

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { mockedPrisma } from "./__mocks__/prisma";
+import { ConnectionKey } from "./connection-key";
+import { createPrismaCountLoader } from "./create-count-loader";
+
+describe(createPrismaCountLoader, () => {
+  beforeEach(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockedPrisma.upvote.count.mockImplementation((args: any): any => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      return Promise.resolve(args?.where?.postID === "1" ? 1 : 0);
+    });
+  });
+
+  it("works", async () => {
+    const byID = createPrismaCountLoader(mockedPrisma.upvote, "postID");
+
+    const result = await byID.load(new ConnectionKey("1"));
+    expect(result).toBe(1);
+  });
+
+  it("returns zero when trying to load a model that doesn't exist", async () => {
+    const byID = createPrismaCountLoader(mockedPrisma.upvote, "postID");
+
+    const result = await byID.load(new ConnectionKey("2"));
+    expect(result).toBe(0);
+  });
+});

packages/gql-utils/prisma/create-count-loader.ts

@@ -0,0 +1,21 @@
+import DataLoader from "dataloader";
+
+import { type ConnectionKey } from "./connection-key";
+import { type PrismaModel } from "./types";
+
+export function createPrismaCountLoader<TPrisma extends { id: string }>(
+  table: PrismaModel<TPrisma>,
+  identifier: string
+) {
+  return new DataLoader(async (keys: readonly ConnectionKey[]) => {
+    const counts = await Promise.all(
+      keys.map((key) => {
+        const where = { [identifier]: key.parentID, deletedAt: null };
+
+        return table.count({ where });
+      })
+    );
+
+    return counts;
+  });
+}

packages/gql-utils/prisma/index.ts

@@ -3,4 +3,5 @@ export * from "./types";
 export * from "./connection-key";
 
 export * from "./create-loader";
+export * from "./create-count-loader";
 export * from "./create-connection-loader";