chore: wip

apps/web/src/app/(dashboard)/admin/leaderboard/data-table-leaderboard.tsx

@@ -15,11 +15,10 @@ import { Input } from '@documenso/ui/primitives/input';
 
 export type SigningVolume = {
   id: number;
-  name: string;
+  name: string | null;
   signingVolume: number;
   createdAt: Date;
   planId: string;
-  customerId: string;
 };
 
 type LeaderboardTableProps = {

packages/lib/server-only/admin/get-signing-volume.ts

@@ -1,4 +1,6 @@
-import { kyselyPrisma, sql } from '@documenso/prisma';
+import { Prisma } from '@prisma/client';
+
+import { prisma } from '@documenso/prisma';
 import { DocumentStatus, SubscriptionStatus } from '@documenso/prisma/client';
 
 export type SigningVolume = {
@@ -7,7 +9,6 @@ export type SigningVolume = {
   signingVolume: number;
   createdAt: Date;
   planId: string;
-  customerId: string;
 };
 
 export type GetSigningVolumeOptions = {
@@ -25,86 +26,113 @@ export async function getSigningVolume({
   sortBy = 'signingVolume',
   sortOrder = 'desc',
 }: GetSigningVolumeOptions) {
-  const offset = Math.max(page - 1, 0) * perPage;
+  const skip = (page - 1) * perPage;
 
-  let findQuery = kyselyPrisma.$kysely
+  const baseUserQuery = {
-    .selectFrom('Subscription as s')
+    OR: [
-    .leftJoin('User as u', 's.userId', 'u.id')
+      {
-    .leftJoin('Team as t', 's.teamId', 't.id')
+        subscriptions: {
-    .leftJoin('Document as d', (join) =>
+          some: {
-      join
+            status: SubscriptionStatus.ACTIVE,
-        .on((eb) =>
+          },
-          eb.or([
+        },
-            eb.and([eb('d.userId', '=', eb.ref('u.id')), eb('d.teamId', 'is', null)]),
+      },
-            eb('d.teamId', '=', eb.ref('t.id')),
+      {
-          ]),
+        teamMembers: {
-        )
+          some: {
-        .on('d.status', '=', sql.lit(DocumentStatus.COMPLETED))
+            team: {
-        .on('d.deletedAt', 'is', null),
+              subscription: {
-    )
+                status: SubscriptionStatus.ACTIVE,
-    // @ts-expect-error - Raw SQL enum casting not properly typed by Kysely
+              },
-    .where(sql`s.status = ${SubscriptionStatus.ACTIVE}::"SubscriptionStatus"`)
+            },
-    .where((eb) =>
+          },
-      eb.or([
+        },
-        eb('u.name', 'ilike', `%${search}%`),
+      },
-        eb('u.email', 'ilike', `%${search}%`),
+    ],
-        eb('t.name', 'ilike', `%${search}%`),
+    ...(search
-      ]),
+      ? {
-    )
+          OR: [
-    .select([
+            { name: { contains: search, mode: Prisma.QueryMode.insensitive } },
-      's.id as id',
+            { email: { contains: search, mode: Prisma.QueryMode.insensitive } },
-      's.planId as planId',
+          ],
-      's.createdAt as createdAt',
+        }
-      sql<string>`COALESCE(u."customerId", t."customerId")`.as('customerId'),
+      : {}),
-      sql<string>`COALESCE(u.name, t.name, u.email, 'Unknown')`.as('name'),
+  };
-      sql<number>`COUNT(DISTINCT d.id)`.as('signingVolume'),
-    ])
-    .groupBy([
-      's.id',
-      's.planId',
-      's.createdAt',
-      'u.customerId',
-      't.customerId',
-      'u.name',
-      't.name',
-      'u.email',
-    ]);
 
-  switch (sortBy) {
+  const results = await prisma.user.findMany({
-    case 'name':
+    where: baseUserQuery,
-      findQuery = findQuery.orderBy('name', sortOrder);
+    select: {
-      break;
+      id: true,
-    case 'createdAt':
+      name: true,
-      findQuery = findQuery.orderBy('createdAt', sortOrder);
+      email: true,
-      break;
+      createdAt: true,
-    case 'signingVolume':
+      _count: {
-      findQuery = findQuery.orderBy('signingVolume', sortOrder);
+        select: {
-      break;
+          documents: {
-    default:
+            where: {
-      findQuery = findQuery.orderBy('signingVolume', 'desc');
+              status: DocumentStatus.COMPLETED,
+            },
+          },
+        },
+      },
+      teamMembers: {
+        select: {
+          team: {
+            select: {
+              documents: {
+                where: {
+                  status: DocumentStatus.COMPLETED,
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    skip,
+    take: perPage,
+    orderBy: [
+      ...(sortBy === 'name'
+        ? [{ name: sortOrder }]
+        : sortBy === 'createdAt'
+          ? [{ createdAt: sortOrder }]
+          : []),
+    ],
+  });
+
+  const count = await prisma.user.count({
+    where: baseUserQuery,
+  });
+
+  const transformedResults = results.map((user) => {
+    const personalDocuments = user._count.documents;
+
+    const teamDocuments = user.teamMembers.reduce(
+      (acc, member) => acc + member.team.documents.length,
+      0,
+    );
+
+    const signingVolume = personalDocuments + teamDocuments;
+
+    return {
+      id: user.id,
+      name: user.name,
+      signingVolume,
+      createdAt: user.createdAt,
+      planId: '',
+    };
+  });
+
+  if (sortBy === 'signingVolume') {
+    transformedResults.sort((a, b) => {
+      return sortOrder === 'desc'
+        ? b.signingVolume - a.signingVolume
+        : a.signingVolume - b.signingVolume;
+    });
   }
 
-  findQuery = findQuery.limit(perPage).offset(offset);
-
-  const countQuery = kyselyPrisma.$kysely
-    .selectFrom('Subscription as s')
-    .leftJoin('User as u', 's.userId', 'u.id')
-    .leftJoin('Team as t', 's.teamId', 't.id')
-    // @ts-expect-error - Raw SQL enum casting not properly typed by Kysely
-    .where(sql`s.status = ${SubscriptionStatus.ACTIVE}::"SubscriptionStatus"`)
-    .where((eb) =>
-      eb.or([
-        eb('u.name', 'ilike', `%${search}%`),
-        eb('u.email', 'ilike', `%${search}%`),
-        eb('t.name', 'ilike', `%${search}%`),
-      ]),
-    )
-    .select(({ fn }) => [fn.countAll().as('count')]);
-
-  const [results, [{ count }]] = await Promise.all([findQuery.execute(), countQuery.execute()]);
-
   return {
-    leaderboard: results,
+    leaderboard: transformedResults,
-    totalPages: Math.ceil(Number(count) / perPage),
+    totalPages: Math.ceil(count / perPage),
   };
 }