WIP: Compute balances in database

.github/workflows/check.yml

@@ -9,6 +9,19 @@ jobs:
     runs-on: ubuntu-latest
     env:
       SKIP_ENV_VALIDATION: true
+      DATABASE_URL: "postgresql://postgres:postgres@localhost:5432/postgres"
+    services:
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
 
     steps:
       - name: Checkout
@@ -28,6 +41,11 @@ jobs:
       - name: Install dependencies
         run: pnpm install
 
+      - name: generate typedSQL types
+        run: |
+          pnpm db:dev
+          pnpm generate --sql
+
       - name: Check code formatting
         run: pnpm prettier --check .
 

.gitignore

@@ -11,7 +11,7 @@
 # database
 /prisma/db.sqlite
 /prisma/db.sqlite-journal
-
+/src/prisma/client
 # next.js
 /.next/
 /out/

prisma/migrations/20250618113146_add_expense_participant_userid_index/migration.sql

@@ -0,0 +1,2 @@
+-- CreateIndex
+CREATE INDEX "ExpenseParticipant_userId_idx" ON "ExpenseParticipant" USING HASH ("userId");

prisma/schema.prisma

@@ -3,7 +3,7 @@
 
 generator client {
     provider        = "prisma-client-js"
-    previewFeatures = ["relationJoins"]
+    previewFeatures = ["relationJoins", "typedSQL"]
 }
 
 datasource db {
@@ -172,6 +172,7 @@ model ExpenseParticipant {
     expense   Expense @relation(fields: [expenseId], references: [id], onDelete: Cascade)
 
     @@id([expenseId, userId])
+    @@index([userId], type: Hash)
 }
 
 model ExpenseNote {

prisma/seed.ts

@@ -1,137 +1,120 @@
 import { PrismaClient, SplitType } from '@prisma/client';
-
-import { createGroupExpense } from '~/server/api/services/splitService';
-import { dummyExpenses, dummyUsers } from '~/utils/dummies';
+import { randomInt } from 'crypto';
 
 const prisma = new PrismaClient();
 
 async function createUsers() {
-  await prisma.user.createMany({
-    data: dummyUsers,
+  const data = Array.from({ length: 1000 }, (value, index) => index).map((i) => {
+    return {
+      name: `user${i}`,
+      email: `user${i}@example.com`,
+      currency: 'USD',
+    };
+  });
+  const users = await prisma.user.createMany({
+    data: data,
+  });
+  return prisma.user.findMany({
+    orderBy: {
+      id: 'asc',
+    },
   });
-
-  return prisma.user.findMany();
 }
 
-async function createGroups() {
-  // Assuming Alice creates a group and adds Bob and Charlie
-
-  const users = await prisma.user.findMany();
-
+async function createGroups(users) {
   if (users.length) {
-    const group = await prisma.group.create({
-      data: {
-        name: 'Holiday Trip',
-        publicId: 'holiday-trip-123',
-        defaultCurrency: 'USD',
-        createdBy: { connect: { id: users[0]?.id } },
-      },
-    });
+    for (let i = 0; i < 100; i++) {
+      const s = i * 10;
+      const e = (i + 1) * 10 - 1;
+
+      // group of 10
+      const group = await prisma.group.create({
+        data: {
+          name: `Group_10_${i}`,
+          publicId: `Group-10-${i}`,
+          defaultCurrency: 'EUR',
+          userId: users[s].id,
+        },
+      });
 
-    await prisma.groupUser.createMany({
-      data: users.map((u) => ({ groupId: group.id, userId: u.id })),
-    });
+      await prisma.groupUser.createMany({
+        data: users.slice(s, e).map((u) => {
+          return {
+            groupId: group.id,
+            userId: u.id,
+          };
+        }),
+      });
+    }
   }
-}
-
-async function createGroupExpenses() {
-  const users = await prisma.user.findMany();
-  const group = (await prisma.group.findFirst())!;
-
-  const groupId = group.id;
 
-  const expenses = [];
+  const group = await prisma.group.create({
+    data: {
+      name: `Group_30`,
+      publicId: `Group-30`,
+      defaultCurrency: 'EUR',
+      userId: users[0].id,
+    },
+  });
 
-  for (let i = 0; i < dummyExpenses.length; i++) {
-    const template = dummyExpenses[i]!;
-    const paidBy = users[template.paidByIndex]!;
-    const participants = template.participantIndices.map((index) => users[index]!);
-    const baseAmount = BigInt(template.amount);
+  await prisma.groupUser.createMany({
+    data: users.slice(0, 29).map((u) => {
+      return {
+        groupId: group.id,
+        userId: u.id,
+      };
+    }),
+  });
 
-    let participantsData;
+  return prisma.group.findMany({
+    include: {
+      groupUsers: true,
+    },
+  });
+}
 
-    if (template.splitType === SplitType.EQUAL) {
-      const amountPerPerson = baseAmount / BigInt(participants.length);
-      participantsData = participants.map((user) => ({
-        userId: user.id,
-        amount: user.id === paidBy.id ? baseAmount - amountPerPerson : -amountPerPerson,
-      }));
-    } else if (template.splitType === SplitType.PERCENTAGE) {
-      const percentages =
-        template.participantIndices.length === 4 ? [30, 25, 25, 20] : [40, 35, 25];
-      participantsData = participants.map((user, index) => {
-        const percentage = percentages[index]!;
-        const amount = (baseAmount * BigInt(percentage)) / 100n;
-        return {
-          userId: user.id,
-          amount: user.id === paidBy.id ? baseAmount - amount : -amount,
-        };
-      });
-    } else if (template.splitType === SplitType.EXACT) {
-      const amounts =
-        template.participantIndices.length === 4 ? [4000, 3600, 4000, 4000] : [2750, 2750];
-      participantsData = participants.map((user, index) => {
-        const amount = BigInt(amounts[index]!);
-        return {
-          userId: user.id,
-          amount: user.id === paidBy.id ? baseAmount - amount : -amount,
-        };
-      });
-    } else if (template.splitType === SplitType.SHARE) {
-      const shares = template.participantIndices.length === 3 ? [2, 1, 1] : [3, 2];
-      const totalShares = shares.reduce((sum, share) => sum + share, 0);
-      participantsData = participants.map((user, index) => {
-        const amount = (baseAmount * BigInt(shares[index]!)) / BigInt(totalShares);
-        return {
-          userId: user.id,
-          amount: user.id === paidBy.id ? baseAmount - amount : -amount,
-        };
+async function createExpenses(groups) {
+  const currencies = ['EUR', 'USD'];
+  for (const gid in groups) {
+    const group = groups[gid];
+    for (let i = 0; i < 10000; i++) {
+      const c = randomInt(0, 2);
+      const amount = BigInt(randomInt(1000, 10000));
+
+      const expense = await prisma.expense.create({
+        data: {
+          name: `Expense Group ${group.id} ${i}`,
+          paidBy: group.groupUsers[0].userId,
+          addedBy: group.groupUsers[0].userId,
+          category: 'general',
+          currency: currencies[c],
+          amount: amount,
+          groupId: group.id,
+          splitType: SplitType.EQUAL,
+        },
       });
-    } else {
-      const baseAmountPerPerson = baseAmount / BigInt(participants.length);
-      const adjustments = participants.length === 3 ? [500, -200, -300] : [300, 100, -400];
-      participantsData = participants.map((user, index) => {
-        const adjustment = BigInt(adjustments[index] ?? 0);
-        const amount = baseAmountPerPerson + adjustment;
-        return {
-          userId: user.id,
-          amount: user.id === paidBy.id ? baseAmount - amount : -amount,
-        };
+
+      await prisma.expenseParticipant.createMany({
+        data: [
+          { expenseId: expense.id, userId: group.groupUsers[0].userId, amount: amount },
+          ...group.groupUsers.slice(1).map((u) => {
+            return {
+              expenseId: expense.id,
+              userId: u.userId,
+              amount: -amount / BigInt(group.groupUsers.length),
+            };
+          }),
+        ],
       });
     }
-
-    const expenseDate = new Date('2024-12-01');
-    expenseDate.setDate(expenseDate.getDate() + i);
-
-    const expense = await createGroupExpense(
-      groupId,
-      paidBy.id,
-      template.name,
-      template.category,
-      baseAmount,
-      template.splitType,
-      template.currency,
-      participantsData,
-      paidBy.id,
-      expenseDate,
-    );
-
-    expenses.push(expense);
   }
-
-  return expenses;
 }
 
 async function main() {
-  // await prisma.user.deleteMany();
-  // await prisma.expense.deleteMany();
-  // await prisma.expenseParticipant.deleteMany();
-  // await prisma.group.deleteMany();
-  // await prisma.groupUser.deleteMany();
-  // await prisma.groupBalance.deleteMany();
-  await createUsers();
-  await createGroups();
-  await createGroupExpenses();
+  const users = await createUsers();
+  const groups = await createGroups(users);
+  await createExpenses(groups);
+  console.log('Seeded db with users, groups and expenses');
 }
 
 main()

prisma/sql/getAllBalancesForGroup.sql

@@ -0,0 +1,6 @@
+-- @param {Int} $1:id of the group
+select "groupId", "userId" as "borrowedBy", "paidBy", "currency", CAST(Coalesce(-1 * sum("ExpenseParticipant".amount),0) as BIGINT) as amount FROM "Expense"
+JOIN "ExpenseParticipant" ON "ExpenseParticipant"."expenseId" = "Expense".id
+WhERE "groupId" = $1 AND "userId" != "paidBy" AND "Expense"."deletedAt" IS NULL
+GROUP BY "userId", "paidBy", "currency", "groupId"
+ORDER By "currency"

prisma/sql/getGroupsWithBalances.sql

@@ -0,0 +1,9 @@
+-- @param {Int} $1:id of the user
+SELECT "Group"."id", "Group".name, CAST(Coalesce(sum("ExpenseParticipant".amount),0) as BIGINT) as balance, Coalesce("Expense".currency, "Group"."defaultCurrency") as currency
+FROM "GroupUser"
+JOIN "Group" ON "GroupUser"."groupId" = "Group".id
+LEFT JOIN "Expense" ON "Expense"."groupId" = "Group".id
+LEFT JOIN "ExpenseParticipant" ON "Expense".id = "ExpenseParticipant"."expenseId"
+WHERE "GroupUser"."userId" = $1 AND "deletedAt" IS NULL AND ("ExpenseParticipant"."userId" = $1 OR "Expense".id is null)
+GROUP BY "Group".id, "Group".name, "Expense".currency
+ORDER BY "Group"."createdAt" DESC, balance DESC

src/components/Expense/BalanceList.tsx

@@ -1,4 +1,5 @@
-import type { GroupBalance, User } from '@prisma/client';
+import type { User } from '@prisma/client';
+import { type getAllBalancesForGroup } from '@prisma/client/sql';
 import clsx from 'clsx';
 import { Info } from 'lucide-react';
 import { useMemo } from 'react';
@@ -18,9 +19,10 @@ interface UserWithBalance {
 }
 
 export const BalanceList: React.FC<{
-  groupBalances: GroupBalance[];
+  groupId: number;
+  groupBalances: getAllBalancesForGroup.Result[];
   users: User[];
-}> = ({ groupBalances, users }) => {
+}> = ({ groupId, groupBalances, users }) => {
   const userQuery = api.user.me.useQuery();
 
   const userMap = useMemo(() => {
@@ -32,16 +34,17 @@ export const BalanceList: React.FC<{
       {} as Record<number, UserWithBalance>,
     );
     groupBalances
-      .filter(({ amount }) => BigMath.abs(amount) > 0)
+      .filter(({ amount }) => amount != null && BigMath.abs(amount) > 0)
       .forEach((balance) => {
-        if (!res[balance.userId]!.balances[balance.firendId]) {
-          res[balance.userId]!.balances[balance.firendId] = {};
+        if (!res[balance.paidBy]!.balances[balance.borrowedBy]) {
+          res[balance.paidBy]!.balances[balance.borrowedBy] = {};
         }
-        const friendBalance = res[balance.userId]!.balances[balance.firendId]!;
-        friendBalance[balance.currency] = (friendBalance[balance.currency] ?? 0n) + balance.amount;
+        const friendBalance = res[balance.paidBy]!.balances[balance.borrowedBy]!;
+        friendBalance[balance.currency] =
+          (friendBalance[balance.currency] ?? 0n) + (balance.amount ?? 0n);
 
-        res[balance.userId]!.total[balance.currency] =
-          (res[balance.userId]!.total[balance.currency] ?? 0n) + balance.amount;
+        res[balance.paidBy]!.total[balance.currency] =
+          (res[balance.paidBy]!.total[balance.currency] ?? 0n) + (balance.amount ?? 0n);
       });
 
     return res;
@@ -109,7 +112,7 @@ export const BalanceList: React.FC<{
                           user={user}
                           amount={amount}
                           currency={currency}
-                          groupId={groupBalances[0]!.groupId}
+                          groupId={groupId}
                         >
                           <div className="mb-4 ml-5 flex cursor-pointer items-center gap-3 text-sm">
                             <UserAvatar user={friend} size={20} />