feat(streaks): add connection_event and hackathon_attendance tables

Author: Satvik-art-creator

apps/backend/README.md

@@ -26,3 +26,11 @@ Due to LinkedIn's modern API restrictions preventing programmatic connection req
    - DOM Observation: The injected Javascript queries for structural indicators of successful invitation (e.g. "Pending" button state or toaster text) and posts a serialized message back to the native layer.
 6. **Robust Fallback**: If network or WebView loading times out (>10s), the engine gracefully falls back to native deep links (`linkedin://profile?id={username}`) or launches the default browser with an interactive custom in-app overlay.
 7. **Telemetry Logging**: Upon client-side success (detected via state changes or DOM indicators), the mobile app makes a `POST /api/follow/:platform/:targetUsername/log` request to the backend. This writes a record to the `FollowLog` database table for auditing and analytics tracking.
+
+## Analytics & Streaks
+
+DevCard tracks connection events and hackathon attendance to compute streaks. 
+
+### Privacy Rule: Anonymous Connections
+
+To protect user privacy, when recording a `ConnectionEvent`, the `receiver_id` is **ONLY** stored if the receiver is explicitly signed in and consents to the connection tracking. If the connection is anonymous or consent is missing, `receiver_id` is omitted (`null`). The analytics layer strictly enforces this at the service level (`streakService`).

apps/backend/prisma/schema.prisma

@@ -44,6 +44,10 @@ model User {
   attendedEvents   EventAttendee[]
   ownedTeams       Team[]            @relation("TeamOwner")
   teamMemberships  TeamMember[]      @relation("TeamMember")
+
+  initiatedConnections ConnectionEvent[] @relation("InitiatedConnections")
+  receivedConnections  ConnectionEvent[] @relation("ReceivedConnections")
+  hackathonAttendances HackathonAttendance[]
   webhookEndpoints WebhookEndpoint[]
 
   @@map("users")
@@ -301,4 +305,31 @@ model TeamMember {
   @@unique([userId, teamId])
   @@index([userId])
   @@map("team_members")
+}
+
+model ConnectionEvent {
+  id          String   @id @default(uuid())
+  initiatorId String   @map("initiator_id")
+  receiverId  String?  @map("receiver_id") // Nullable to enforce privacy rule for anonymous connections
+  connectedAt DateTime @default(now()) @map("connected_at")
+
+  initiator User  @relation("InitiatedConnections", fields: [initiatorId], references: [id], onDelete: Cascade)
+  receiver  User? @relation("ReceivedConnections", fields: [receiverId], references: [id], onDelete: SetNull)
+
+  @@index([initiatorId])
+  @@index([receiverId])
+  @@map("connection_events")
+}
+
+model HackathonAttendance {
+  id          String   @id @default(uuid())
+  userId      String   @map("user_id")
+  hackathonId String   @map("hackathon_id")
+  attendedAt  DateTime @default(now()) @map("attended_at")
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([userId, hackathonId])
+  @@index([userId])
+  @@map("hackathon_attendance")
 }

apps/backend/src/__tests__/streakService.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect, vi } from 'vitest';
+import { recordConnectionEvent } from '../services/streakService';
+import type { FastifyInstance } from 'fastify';
+
+describe('streakService', () => {
+  it('should enforce privacy rule: anonymous connections never write a receiver_id', async () => {
+    const mockCreate = vi.fn().mockResolvedValue({ id: 'test-event' });
+    const mockApp = {
+      prisma: {
+        connectionEvent: {
+          create: mockCreate,
+        },
+      },
+    } as unknown as FastifyInstance;
+
+    // Test with signed in and consented (should store receiverId)
+    await recordConnectionEvent(mockApp, 'initiator-1', 'receiver-1', true);
+    expect(mockCreate).toHaveBeenCalledWith({
+      data: {
+        initiatorId: 'initiator-1',
+        receiverId: 'receiver-1',
+      },
+    });
+
+    // Test with anonymous/not consented (should store null for receiverId)
+    await recordConnectionEvent(mockApp, 'initiator-1', 'receiver-1', false);
+    expect(mockCreate).toHaveBeenCalledWith({
+      data: {
+        initiatorId: 'initiator-1',
+        receiverId: null,
+      },
+    });
+  });
+});

apps/backend/src/services/streakService.ts

@@ -0,0 +1,34 @@
+import type { FastifyInstance } from 'fastify';
+
+/**
+ * Records a connection event when one user connects with another.
+ * Privacy Rule: receiverId is ONLY recorded if the receiver is signed in and consents.
+ * If the connection is anonymous or unconsented, receiverId MUST be null.
+ */
+export async function recordConnectionEvent(
+  app: FastifyInstance,
+  initiatorId: string,
+  receiverId: string | null,
+  isConsentedAndSignedIn: boolean
+) {
+  // Structural typing to bypass IDE cache lags after Prisma schema changes
+  interface PrismaWithConnectionEvent {
+    connectionEvent: {
+      create: (args: { data: { initiatorId: string; receiverId: string | null } }) => Promise<unknown>;
+    };
+  }
+
+  const prismaClient = app.prisma as unknown as PrismaWithConnectionEvent;
+
+  // Enforce privacy rule
+  const finalReceiverId = isConsentedAndSignedIn ? receiverId : null;
+
+  const event = await prismaClient.connectionEvent.create({
+    data: {
+      initiatorId,
+      receiverId: finalReceiverId,
+    },
+  });
+
+  return event;
+}