refactor: pre-pano chores

apps/gql/clients/__mocks__/clients.ts

@@ -1,6 +1,5 @@
-import { type Clients } from "../types";
 import { mockedPrisma } from "./prisma";
 
-export const mockedClients: Clients = {
-  prisma: mockedPrisma
-};
+export const mockedClients = {
+  prisma: mockedPrisma,
+};

apps/gql/clients/index.ts

@@ -1,7 +1,8 @@
 import { createPrismaClient } from "./prisma";
-import { type Clients } from "./types";
 
-export const createClients = (): Clients => {
+export type Clients = ReturnType<typeof createClients>;
+
+export const createClients = () => {
   return {
     prisma: createPrismaClient(),
   };

apps/gql/codegen.ts

@@ -1,13 +1,39 @@
 import type { CodegenConfig } from "@graphql-codegen/cli";
 
+const scalars = { Date: "string", DateTime: "string" };
+
 const config: CodegenConfig = {
   schema: "schema/schema.graphql",
   generates: {
     "./schema/types.generated.ts": {
       plugins: ["typescript", "typescript-resolvers"],
       config: {
-        avoidOptionals: true,
+        // wraps the resolver types with following:
+        // type WithIndex<T> = T & Record<string, any>;
+        // this ensures the resolvers can only be dictionaries with string
+        // keys to avoid using number or symbol keys which are normally
+        // allowed in regular objects
+        useIndexSignature: true,
+
+        // Enforce __typename in return values of resolvers for types that
+        // implements an interface, or part of a union.
+        resolversNonOptionalTypename: true,
+        optionalResolveType: true,
+        //
+        // interfaces are only responsible for defining a __resolveType resolver
+        // and implementing types are responsible for returning the fields.
+        onlyResolveTypeForInterfaces: true,
+
+        // our custom context type so we have access to it in resolvers
         contextType: "./types#KampusGQLContext",
+        avoidOptionals: true,
+        enumsAsTypes: true,
+        makeResolverTypeCallable: true,
+        optionalInfoArgument: true,
+        useTypeImports: true,
+
+        // scalars config
+        scalars,
       },
     },
   },

apps/gql/loaders/index.ts

@@ -1,11 +1,12 @@
-import { type Clients } from "~/clients/types";
+import { type Clients } from "~/clients";
 import { createSozlukLoaders } from "./sozluk";
-import { type DataLoaders } from "./types";
-import { createUsersLoader } from "./users";
+import { createUserLoaders } from "./user";
 
-export const createLoaders = (clients: Clients): DataLoaders => {
+export type DataLoaders = ReturnType<typeof createLoaders>;
+
+export const createLoaders = (clients: Clients) => {
   return {
-    users: createUsersLoader(clients),
-    sozluk: createSozlukLoaders(clients),
+    user: createUserLoaders(clients),
+    sozluk: createSozlukLoaders(),
   };
 };

apps/gql/loaders/sozluk.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
 
-import { mockedClients } from "../clients/__mocks__/clients";
 import { createSozlukLoaders } from "./sozluk";
 
 // mock runs before everything so import needs to be handled here.
@@ -14,24 +13,24 @@ vi.mock("@kampus/sozluk-content", async () => {
 describe("Sozluk Loader", () => {
   describe("term loader", () => {
     it("should load terms", async () => {
-      const loader = createSozlukLoaders(mockedClients);
+      const loader = createSozlukLoaders();
 
       const result = await loader.term.load("1");
 
       expect(result).toMatchObject({
         body: {
-          code: "code",
-          html: "mdxHtml",
           raw: "raw",
+          code: "code",
         },
+        mdxHtml: "mdxHtml",
         id: "1",
         tags: ["tag1", "tag2"],
         title: "title",
       });
     });
 
     it("should return null if term not found", () => {
-      const loader = createSozlukLoaders(mockedClients);
+      const loader = createSozlukLoaders();
 
       void expect(async () => {
         await loader.term.load("2");

apps/gql/loaders/sozluk.ts

@@ -1,28 +1,25 @@
 import DataLoader from "dataloader";
 import hash from "object-hash";
 
+import { ConnectionArguments, type Connection } from "@kampus/gql-utils/connection";
 import { allTerms, type Term } from "@kampus/sozluk-content";
 
 import { applyPagination, generatePageInfo } from "~/features/relay/pagination";
-import { type Clients } from "~/clients/types";
-import {
-  type SozlukQueryTermsArgs,
-  type SozlukTerm,
-  type SozlukTermConnection,
-} from "~/schema/types.generated";
+import { type SozlukQueryTermsArgs, type SozlukTermConnection } from "~/schema/types.generated";
 
-export const createSozlukLoaders = (clients: Clients) => {
+export const createSozlukLoaders = () => {
   return {
-    term: createTermLoader(clients),
-    terms: createTermsLoader(clients),
+    term: createTermLoader(),
+    terms: createTermsLoader(),
   };
 };
 
 export type SozlukTermLoader = ReturnType<typeof createTermLoader>;
 export type SozlukTermsLoader = ReturnType<typeof createTermsLoader>;
 
-const transformTerm = (term: Term) => {
+export const transformSozlukTerm = (term: Term) => {
   return {
+    __typename: "SozlukTerm" as const,
     id: term.id,
     title: term.title,
     tags: term.tags,
@@ -34,17 +31,22 @@ const transformTerm = (term: Term) => {
   };
 };
 
-// eslint-disable-next-line @typescript-eslint/require-await
-const loadTerm = async (id: string) => {
+export const transformSozlukTermsConnection = (connection: Connection<Term>) => ({
+  ...connection,
+  nodes: connection.nodes.map(transformSozlukTerm),
+  edges: connection.edges.map((edge) => ({ ...edge, node: transformSozlukTerm(edge.node) })),
+});
+
+const loadTerm = (id: string) => {
   const term = allTerms.find((term) => term.id === id);
   if (!term) {
     return null;
   }
-  return transformTerm(term);
+  return Promise.resolve(term);
 };
 
-const createTermLoader = (_: Clients) =>
-  new DataLoader<string, SozlukTerm>(async (keys) => {
+const createTermLoader = () =>
+  new DataLoader<string, Term>(async (keys) => {
     return await Promise.all(
       keys.map(async (key) => {
         const term = await loadTerm(key);
@@ -56,32 +58,29 @@ const createTermLoader = (_: Clients) =>
     );
   });
 
-const createTermsLoader = (_: Clients) =>
-  new DataLoader<Partial<SozlukQueryTermsArgs>, SozlukTermConnection, string>(termsLoaderBatchFn, {
-    cacheKeyFn: (key) => hash(key),
-  });
-
-const termsLoaderBatchFn = async (keys: readonly Partial<SozlukQueryTermsArgs>[]) => {
-  const results: SozlukTermConnection[] = [];
-
-  for (const key of keys) {
-    const { before, after, first, last } = key;
-
-    const terms = applyPagination<Term>({ data: allTerms, before, after, first, last });
+const createTermsLoader = () =>
+  new DataLoader<ConnectionArguments, Connection<Term>, string>(
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async (keys) => {
+      const results: Connection<Term>[] = [];
 
-    const edges = terms.map((term) => ({ cursor: term.id, node: transformTerm(term) }));
+      for (const key of keys) {
+        const nodes = applyPagination<Term>({ data: allTerms, ...key });
+        const edges = nodes.map((term) => ({ cursor: term.id, node: term }));
 
-    const totalCount = allTerms.length;
+        const result = {
+          nodes,
+          edges,
+          pageInfo: generatePageInfo({ data: allTerms, ...key }),
+          totalCount: allTerms.length,
+        };
 
-    const result = {
-      edges,
-      // need to pass the same args to generatePageInfo
-      pageInfo: generatePageInfo({ data: allTerms, before, after, first, last }),
-      totalCount,
-    };
+        results.push(result);
+      }
 
-    results.push(result);
-  }
-
-  return results;
-};
+      return results;
+    },
+    {
+      cacheKeyFn: (key) => hash(key),
+    }
+  );

apps/gql/loaders/user.test.ts

@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { mockedClients } from "../clients/__mocks__/clients";
+import { createUserLoaders } from "./user";
+
+describe(createUserLoaders, () => {
+  beforeEach(() => {
+    mockedClients.prisma.user.findMany.mockResolvedValueOnce([
+      {
+        username: "test",
+        emailVerified: new Date(),
+        name: "test",
+        image: null,
+        id: "1",
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        email: "[email protected]",
+      },
+    ]);
+  });
+
+  describe("byID", () => {
+    it("fetches users by id", async () => {
+      const { byID } = createUserLoaders(mockedClients);
+
+      const result = await byID.load("1");
+
+      expect(result.id).toBe("1");
+      expect(result.username).toBe("test");
+      expect(result.email).toBe("[email protected]");
+    });
+
+    it("should throw error if user not found with id", async () => {
+      const { byID } = createUserLoaders(mockedClients);
+      await expect(() => byID.load("2")).rejects.toThrowError(/not found/);
+    });
+  });
+
+  describe("byUsername", () => {
+    it("fetches users by username", async () => {
+      const { byUsername } = createUserLoaders(mockedClients);
+
+      const result = await byUsername.load("test");
+
+      expect(result.id).toBe("1");
+      expect(result.username).toBe("test");
+      expect(result.email).toBe("[email protected]");
+    });
+
+    it("should throw error if user not found with username", async () => {
+      const { byUsername } = createUserLoaders(mockedClients);
+      await expect(() => byUsername.load("mock")).rejects.toThrowError(/not found/);
+    });
+  });
+});

apps/gql/loaders/user.ts

@@ -0,0 +1,34 @@
+import { createPrismaLoader } from "@kampus/gql-utils";
+import { type User } from "@kampus/prisma";
+
+import { type Clients } from "~/clients";
+import { LoaderKey } from "./utils/loader-key";
+
+export class UserLoaderKey extends LoaderKey<"id" | "username", string> {}
+
+export function createUserLoaders(clients: Clients) {
+  const byID = createPrismaLoader(clients.prisma.user, "id", (users) => {
+    users.forEach((user) => {
+      if (user.username) {
+        byUsername.prime(user.username, user);
+      }
+    });
+  });
+
+  const byUsername = createPrismaLoader(clients.prisma.user, "username", (users) => {
+    users.forEach((user) => {
+      byUsername.prime(user.id, user);
+    });
+  });
+
+  return {
+    byID,
+    byUsername,
+  };
+}
+
+export const transformUser = (user: User) => ({
+  ...user,
+  __typename: "User" as const,
+  username: user.username ?? "",
+});