Initial commit

skills/configuring-transaction-isolation/references/complete-examples.md

@@ -0,0 +1,222 @@
+# Complete Examples
+
+## Example 1: Banking Transfer
+
+**Input:** Transfer money between accounts with strict consistency.
+
+**Implementation:**
+
+```typescript
+import { Prisma } from '@prisma/client';
+
+async function transferMoney(
+  fromAccountId: string,
+  toAccountId: string,
+  amount: number
+) {
+  if (amount <= 0) {
+    throw new Error('Amount must be positive');
+  }
+
+  try {
+    const result = await prisma.$transaction(
+      async (tx) => {
+        const fromAccount = await tx.account.findUnique({
+          where: { id: fromAccountId }
+        });
+
+        if (!fromAccount) {
+          throw new Error('Source account not found');
+        }
+
+        if (fromAccount.balance < amount) {
+          throw new Error('Insufficient funds');
+        }
+
+        const toAccount = await tx.account.findUnique({
+          where: { id: toAccountId }
+        });
+
+        if (!toAccount) {
+          throw new Error('Destination account not found');
+        }
+
+        await tx.account.update({
+          where: { id: fromAccountId },
+          data: { balance: { decrement: amount } }
+        });
+
+        await tx.account.update({
+          where: { id: toAccountId },
+          data: { balance: { increment: amount } }
+        });
+
+        const transfer = await tx.transfer.create({
+          data: {
+            fromAccountId,
+            toAccountId,
+            amount,
+            status: 'COMPLETED',
+            completedAt: new Date()
+          }
+        });
+
+        return transfer;
+      },
+      {
+        isolationLevel: Prisma.TransactionIsolationLevel.Serializable,
+        maxWait: 5000,
+        timeout: 10000
+      }
+    );
+
+    return { success: true, transfer: result };
+
+  } catch (error) {
+    if (error.code === 'P2034') {
+      throw new Error('Transaction conflict - please retry');
+    }
+    throw error;
+  }
+}
+```
+
+## Example 2: Inventory Reservation
+
+**Input:** Reserve inventory items for an order.
+
+**Implementation:**
+
+```typescript
+async function reserveInventory(
+  orderId: string,
+  items: Array<{ productId: string; quantity: number }>
+) {
+  const maxRetries = 3;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      await prisma.$transaction(
+        async (tx) => {
+          for (const item of items) {
+            const product = await tx.product.findUnique({
+              where: { id: item.productId }
+            });
+
+            if (!product) {
+              throw new Error(`Product ${item.productId} not found`);
+            }
+
+            if (product.stock < item.quantity) {
+              throw new Error(
+                `Insufficient stock for ${product.name}`
+              );
+            }
+
+            await tx.product.update({
+              where: { id: item.productId },
+              data: { stock: { decrement: item.quantity } }
+            });
+
+            await tx.reservation.create({
+              data: {
+                orderId,
+                productId: item.productId,
+                quantity: item.quantity,
+                reservedAt: new Date()
+              }
+            });
+          }
+        },
+        {
+          isolationLevel: Prisma.TransactionIsolationLevel.Serializable,
+          maxWait: 3000,
+          timeout: 8000
+        }
+      );
+
+      return { success: true };
+
+    } catch (error) {
+      if (error.code === 'P2034' && attempt < maxRetries - 1) {
+        await new Promise(resolve =>
+          setTimeout(resolve, Math.pow(2, attempt) * 200)
+        );
+        continue;
+      }
+
+      throw error;
+    }
+  }
+
+  throw new Error('Reservation failed after retries');
+}
+```
+
+## Example 3: Seat Booking with Status Check
+
+**Input:** Book a seat with concurrent user protection.
+
+**Implementation:**
+
+```typescript
+async function bookSeat(
+  userId: string,
+  eventId: string,
+  seatNumber: string
+) {
+  try {
+    const booking = await prisma.$transaction(
+      async (tx) => {
+        const seat = await tx.seat.findFirst({
+          where: {
+            eventId,
+            seatNumber
+          }
+        });
+
+        if (!seat) {
+          throw new Error('Seat not found');
+        }
+
+        if (seat.status !== 'AVAILABLE') {
+          throw new Error('Seat is no longer available');
+        }
+
+        await tx.seat.update({
+          where: { id: seat.id },
+          data: {
+            status: 'BOOKED',
+            bookedAt: new Date()
+          }
+        });
+
+        const booking = await tx.booking.create({
+          data: {
+            userId,
+            seatId: seat.id,
+            eventId,
+            status: 'CONFIRMED',
+            bookedAt: new Date()
+          }
+        });
+
+        return booking;
+      },
+      {
+        isolationLevel: Prisma.TransactionIsolationLevel.Serializable
+      }
+    );
+
+    return { success: true, booking };
+
+  } catch (error) {
+    if (error.code === 'P2034') {
+      throw new Error(
+        'Seat was just booked by another user - please select another seat'
+      );
+    }
+    throw error;
+  }
+}
+```