feat: add missing dataloaders and optimize some

src/schema/events/types.ts

@@ -1,9 +1,10 @@
-import { SQL, eq, inArray } from "drizzle-orm";
+import { SQL, inArray } from "drizzle-orm";
 
 import { authHelpers } from "~/authz/helpers";
 import { builder } from "~/builder";
 import {
   ScheduleStatus,
+  SelectTicketSchema,
   selectCommunitySchema,
   selectGalleriesSchema,
   selectImagesSchema,
@@ -16,7 +17,6 @@ import {
   selectUsersSchema,
   ticketStatusEnum,
   ticketVisibilityEnum,
-  ticketsSchema,
   usersSchema,
 } from "~/datasources/db/schema";
 import { lower } from "~/datasources/db/shared";
@@ -342,76 +342,91 @@ export const EventLoadable = builder.loadableObject(EventRef, {
         return tags.map((t) => selectTagsSchema.parse(t));
       },
     }),
-    tickets: t.field({
+    tickets: t.loadableList({
       description:
         "List of tickets for sale or redemption for this event. (If you are looking for a user's tickets, use the usersTickets field)",
-      type: [TicketRef],
+      type: TicketRef,
       args: {
         input: t.arg({
           type: EventsTicketTemplateSearchInput,
           required: false,
         }),
       },
-      resolve: async (root, { input }, { DB, USER }) => {
-        const wheres: SQL[] = [];
-
-        wheres.push(eq(ticketsSchema.eventId, root.id));
-
-        // If the user is an admin, they can see all tickets, otherwise, only
-        // active tickets are shown.
-        let statusCheck: (typeof ticketStatusEnum)[number][] = ["active"];
-        let visibilityCheck: (typeof ticketVisibilityEnum)[number][] = [
-          "public",
-        ];
-
-        if (USER) {
-          if (USER.isSuperAdmin) {
-            statusCheck = ["active", "inactive"];
-
-            visibilityCheck = ["public", "private", "unlisted"];
-          } else {
-            const isAdmin = await authHelpers.isAdminOfEventCommunity({
-              userId: USER.id,
-              eventId: root.id,
-              DB,
-            });
-
-            if (isAdmin) {
+      byPath: true,
+      load: async (eventsIds: string[], context, args) => {
+        const { DB, USER } = context;
+        const { input } = args;
+
+        const idToTicketsMap = new Map<
+          string,
+          SelectTicketSchema[] | undefined
+        >();
+
+        const ticketsPromises = eventsIds.map(async (eventId) => {
+          // If the user is an admin, they can see all tickets, otherwise, only
+          // active tickets are shown.
+          let statusCheck: (typeof ticketStatusEnum)[number][] = ["active"];
+          let visibilityCheck: (typeof ticketVisibilityEnum)[number][] = [
+            "public",
+          ];
+
+          if (USER) {
+            if (USER.isSuperAdmin) {
               statusCheck = ["active", "inactive"];
 
               visibilityCheck = ["public", "private", "unlisted"];
+            } else {
+              const isAdmin = await authHelpers.isAdminOfEventCommunity({
+                userId: USER.id,
+                eventId: eventId,
+                DB,
+              });
+
+              if (isAdmin) {
+                statusCheck = ["active", "inactive"];
+
+                visibilityCheck = ["public", "private", "unlisted"];
+              }
             }
           }
-        }
 
-        const coupon = input?.coupon?.length
-          ? await DB.query.couponsSchema.findFirst({
-              where: (c, { eq, and }) =>
-                and(
-                  eq(c.eventId, root.id),
-                  eq(c.isActive, true),
-                  eq(lower(c.code), input.coupon?.toLowerCase() ?? ""),
-                ),
-              columns: {
-                id: true,
-              },
-            })
-          : null;
-
-        const tickets = await ticketsFetcher.searchTickets({
-          DB,
-          search: {
-            status: statusCheck,
-            visibility: visibilityCheck,
-            eventIds: [root.id],
-            tags: input?.tags ? input.tags : undefined,
-            couponId: coupon?.id,
-          },
-          sort: [["createdAt", "asc"]],
+          const coupon = input?.coupon?.length
+            ? await DB.query.couponsSchema.findFirst({
+                where: (c, { eq, and }) =>
+                  and(
+                    eq(c.eventId, eventId),
+                    eq(c.isActive, true),
+                    eq(lower(c.code), input.coupon?.toLowerCase() ?? ""),
+                  ),
+                columns: {
+                  id: true,
+                },
+              })
+            : null;
+
+          const tickets = await ticketsFetcher.searchTickets({
+            DB,
+            search: {
+              status: statusCheck,
+              visibility: visibilityCheck,
+              eventIds: [eventId],
+              tags: input?.tags ? input.tags : undefined,
+              couponId: coupon?.id,
+            },
+            sort: [["createdAt", "asc"]],
+          });
+
+          idToTicketsMap.set(
+            eventId,
+            tickets.map((t) => selectTicketSchema.parse(t)),
+          );
         });
 
-        return tickets.map((t) => selectTicketSchema.parse(t));
+        await Promise.all(ticketsPromises);
+
+        return eventsIds.map((id) => idToTicketsMap.get(id) || []);
       },
+      resolve: (root) => root.id,
     }),
     schedules: t.field({
       type: [ScheduleRef],

src/schema/purchaseOrder/mutations.tsx

@@ -59,7 +59,7 @@ builder.mutationField("payForPurchaseOrder", (t) =>
           default_redirect_url: PURCHASE_CALLBACK_URL,
           purchaseOrderId,
         });
-      const { purchaseOrder, ticketsIds } = await handlePaymentLinkGeneration({
+      const { purchaseOrder } = await handlePaymentLinkGeneration({
         DB,
         USER,
         purchaseOrderId,
@@ -72,10 +72,7 @@ builder.mutationField("payForPurchaseOrder", (t) =>
       });
 
       // 4. We return the payment link.
-      return {
-        purchaseOrder,
-        ticketsIds,
-      };
+      return purchaseOrder;
     },
   }),
 );
@@ -141,23 +138,11 @@ builder.mutationField("checkPurchaseOrderStatus", (t) =>
         transactionalEmailService: RPC_SERVICE_EMAIL,
       });
 
-      const tickets = await DB.query.userTicketsSchema.findMany({
-        where: (po, { eq }) => eq(po.purchaseOrderId, purchaseOrderId),
-        columns: {
-          id: true,
-        },
-      });
-
       if (!purchaseOrder) {
         throw new Error("Purchase order not found");
       }
 
-      const ticketsIds = tickets.map((t) => t.id);
-
-      return {
-        purchaseOrder: selectPurchaseOrdersSchema.parse(purchaseOrder),
-        ticketsIds,
-      };
+      return selectPurchaseOrdersSchema.parse(purchaseOrder);
     },
   }),
 );

src/schema/purchaseOrder/queries.ts

@@ -47,10 +47,7 @@ builder.queryField("myPurchaseOrders", (t) =>
 
       return {
         data: data.map((po) => {
-          return {
-            purchaseOrder: selectPurchaseOrdersSchema.parse(po),
-            ticketsIds: [],
-          };
+          return selectPurchaseOrdersSchema.parse(po);
         }),
         pagination,
       };