Database Schema

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider  = "postgresql"
  url       = env("DATABASE_URL")
  directUrl = env("DIRECT_URL")
}

datesAsA  TpoDate[] @relation("DateUserA")
datesAsB  TpoDate[] @relation("DateUserB")

const user = await db.tpoUser.create({
  data: {
    phoneNumber: "+12125551234",
    status: "ONBOARDING",
    onboardingStep: "AWAITING_ABOUT",
    onboardingQuestionIndex: 0,
  },
});

userAId  String
userA    TpoUser @relation("DateUserA", fields: [userAId], references: [id])

userBId  String
userB    TpoUser @relation("DateUserB", fields: [userBId], references: [id])

messages TpoMessage[]

const date = await db.tpoDate.create({
  data: {
    userAId: "clx123...",
    userBId: "clx456...",
    status: "ACTIVE",
    schedulingPhase: "WAITING_FOR_A_REPLY",
    proposedSlot: "Friday, March 7th at 7pm",
  },
  include: {
    userA: true,
    userB: true,
  },
});

date  TpoDate @relation(fields: [dateId], references: [id])

const message = await db.tpoMessage.create({
  data: {
    dateId: "clx789...",
    fromPhone: "system",
    toPhone: "+12125551234",
    body: "you've been matched!",
    blocked: false,
  },
});

photoTransform PhotoTransform?
leftVotes      Vote[]  @relation("LeftPhoto")
rightVotes     Vote[]  @relation("RightPhoto")
label          PhotoLabel?
ick            Ick[]

user       User   @relation(fields: [userId], references: [id], onDelete: Cascade)
leftPhoto  Photo  @relation(name: "LeftPhoto", fields: [leftPhotoId], references: [id], onDelete: Cascade)
rightPhoto Photo  @relation(name: "RightPhoto", fields: [rightPhotoId], references: [id], onDelete: Cascade)

votes Vote[]

model PhotoLabel {
  id        String   @id @default(cuid())
  createdAt DateTime @default(now())
  photoId   String   @unique
  photo     Photo    @relation(fields: [photoId], references: [id], onDelete: Cascade)
  labels    Json
}

model Ick {
  id        String   @id @default(cuid())
  createdAt DateTime @default(now())
  photoId   String
  photo     Photo    @relation(fields: [photoId], references: [id], onDelete: Cascade)
  userId    String
  
  @@unique([photoId, userId])
}

model PhotoTransform {
  id        String   @id @default(cuid())
  createdAt DateTime @default(now())
  photoId   String   @unique
  photo     Photo    @relation(fields: [photoId], references: [id], onDelete: Cascade)
  x         Float
  y         Float
  scale     Float
}

model BannedUser {
  id        String   @id @default(cuid())
  createdAt DateTime @default(now())
  userId    String   @default("")
  ipAddress String   @default("")
}

model MutualLike {
  id        String   @id @default(cuid())
  createdAt DateTime @default(now())
  from      String
  to        String
  fromName  String
  toName    String
}

model MutualTestUser {
  id          String   @id @default(cuid())
  createdAt   DateTime @default(now())
  phoneNumber String   @unique
}

enum TpoUserStatus {
  ONBOARDING      // Currently completing intake
  PENDING_REVIEW  // Awaiting admin approval
  APPROVED        // Can be matched
  REJECTED        // Denied entry
  BANNED          // Blocked from platform
}

enum TpoOnboardingStep {
  INTRO_SENT       // Welcome message sent
  AWAITING_ABOUT   // Collecting profile info
  AWAITING_PREFERENCES // Legacy step (now merged with ABOUT)
  AWAITING_CITY    // Legacy step (now part of ABOUT)
  AWAITING_PHOTOS  // Collecting 2+ photos
  AWAITING_ID      // Collecting driver's license
  COMPLETE         // Ready for review
}

enum TpoDateStatus {
  ACTIVE  // Currently active
  ENDED   // Terminated by admin or system
}

enum TpoSchedulingPhase {
  PROPOSING_TO_A           // Bot proposing initial time to User A
  WAITING_FOR_A_REPLY      // Awaiting A's response to proposal
  PROPOSING_TO_B           // Forwarding A's time to User B
  WAITING_FOR_B_REPLY      // Awaiting B's response
  WAITING_FOR_A_ALTERNATIVE // A declined, waiting for counter-proposal
  WAITING_FOR_B_ALTERNATIVE // B declined, waiting for counter-proposal
  AGREED                   // Both confirmed, portal enabled
  FAILED                   // Could not reach agreement
  ESCALATED                // Requires manual intervention
}

enum Gender {
  MALE
  FEMALE
  OTHER
}

enum Side {
  LEFT
  RIGHT
}

enum Person {
  JOSH
  JONATHAN
}

const user = await db.tpoUser.findUnique({
  where: { phoneNumber: "+12125551234" },
  include: {
    datesAsA: true,
    datesAsB: true,
  },
});

const activeDate = await db.tpoDate.findFirst({
  where: {
    status: "ACTIVE",
    OR: [
      { userA: { phoneNumber: senderPhone } },
      { userB: { phoneNumber: senderPhone } },
    ],
  },
  include: { userA: true, userB: true },
});

const pendingUsers = await db.tpoUser.findMany({
  where: { status: "PENDING_REVIEW" },
  orderBy: { createdAt: "desc" },
});

const messages = await db.tpoMessage.findMany({
  where: { dateId: "clx789..." },
  orderBy: { createdAt: "asc" },
});