Build a Habit Tracking App with Streaks and Insights

npm install @prisma/client@7 @prisma/adapter-pg@7 pg resend dotenv
npm install -D prisma@7 typescript @types/pg
npx prisma init --datasource-provider postgresql

// prisma/schema.prisma
generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String
  timezone  String   @default("UTC") // IANA name, e.g. "Europe/Berlin"
  habits    Habit[]
  partners  AccountabilityPartner[] @relation("user")
  createdAt DateTime @default(now())
}

model Habit {
  id           String   @id @default(cuid())
  userId       String
  user         User     @relation(fields: [userId], references: [id])
  name         String
  icon         String   @default("✅")
  frequency    String   @default("daily") // daily | weekdays
  reminderTime String?  // "08:00" in the user's time zone
  isActive     Boolean  @default(true)
  completions  HabitCompletion[]
  createdAt    DateTime @default(now())
}

model HabitCompletion {
  id        String   @id @default(cuid())
  habitId   String
  habit     Habit    @relation(fields: [habitId], references: [id])
  date      DateTime @db.Date // the user's local calendar day
  createdAt DateTime @default(now())

  @@unique([habitId, date])
}

model AccountabilityPartner {
  id           String   @id @default(cuid())
  userId       String
  user         User     @relation("user", fields: [userId], references: [id])
  partnerEmail String
  token        String   @unique @default(uuid()) // unguessable, used in the invite link
  status       String   @default("pending") // pending | accepted
  createdAt    DateTime @default(now())
}

export DATABASE_URL="postgresql://app:$DB_PASSWORD@127.0.0.1:5432/habits"
npx prisma migrate dev --name init   # also run `npx prisma generate` after schema changes

// lib/db.ts
import { PrismaPg } from '@prisma/adapter-pg'
import { PrismaClient } from '../generated/prisma/client'

export const prisma = new PrismaClient({
  adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL }),
})

// lib/streaks.ts
import { prisma } from './db'

const DAY = 86_400_000

export function todayFor(timeZone: string, now = new Date()): Date {
  // 'en-CA' formats as YYYY-MM-DD; Date.parse reads that as midnight UTC
  const ymd = new Intl.DateTimeFormat('en-CA', { timeZone }).format(now)
  return new Date(ymd)
}

export async function calculateStreak(habitId: string, timeZone: string) {
  const rows = await prisma.habitCompletion.findMany({
    where: { habitId }, orderBy: { date: 'desc' }, select: { date: true },
  })
  if (!rows.length) return { current: 0, longest: 0 }

  const days = rows.map(r => Math.round(r.date.getTime() / DAY)) // descending, unique
  const today = Math.round(todayFor(timeZone).getTime() / DAY)

  // Current streak: alive if the latest check-in is today or yesterday
  let current = 0
  if (today - days[0] <= 1) {
    current = 1
    for (let i = 1; i < days.length && days[i - 1] - days[i] === 1; i++) current++
  }

  let longest = 1
  let run = 1
  for (let i = 1; i < days.length; i++) {
    run = days[i - 1] - days[i] === 1 ? run + 1 : 1
    longest = Math.max(longest, run)
  }
  return { current, longest }
}

export async function getHeatmapData(habitId: string, timeZone: string, days = 365) {
  const since = new Date(todayFor(timeZone).getTime() - days * DAY)
  const rows = await prisma.habitCompletion.findMany({
    where: { habitId, date: { gte: since } }, select: { date: true },
  })
  const heatmap: Record<string, number> = {}
  for (const r of rows) {
    const key = r.date.toISOString().slice(0, 10)
    heatmap[key] = (heatmap[key] ?? 0) + 1
  }
  return heatmap
}

// app/api/cron/reminders/route.ts
import { Resend } from 'resend'
import { prisma } from '@/lib/db'

const resend = new Resend(process.env.RESEND_API_KEY)
const esc = (s: string) => s.replace(/[&<>"']/g, c => `&#${c.charCodeAt(0)};`)

function localHHMM(timeZone: string, now: Date) {
  const hhmm = new Intl.DateTimeFormat('en-GB', {
    timeZone, hour: '2-digit', minute: '2-digit', hour12: false,
  }).format(now)
  const [h, m] = hhmm.split(':')
  return `${h}:${String(Math.floor(Number(m) / 15) * 15).padStart(2, '0')}`
}

export async function GET(req: Request) {
  const secret = process.env.CRON_SECRET
  if (!secret || req.headers.get('authorization') !== `Bearer ${secret}`) {
    return new Response('Unauthorized', { status: 401 })
  }

  const now = new Date()
  const habits = await prisma.habit.findMany({
    where: { isActive: true, reminderTime: { not: null } }, include: { user: true },
  })

  const due = new Map<string, { name: string; email: string; items: string[] }>()
  for (const h of habits) {
    if (h.reminderTime !== localHHMM(h.user.timezone, now)) continue
    const entry = due.get(h.userId) ?? { name: h.user.name, email: h.user.email, items: [] }
    entry.items.push(`<li>${esc(h.icon)} <strong>${esc(h.name)}</strong></li>`)
    due.set(h.userId, entry)
  }

  for (const u of due.values()) {
    const { error } = await resend.emails.send({
      from: 'HabitPulse <reminders@habitpulse.app>', // a domain verified in Resend
      to: u.email,
      subject: `Time to check in: ${u.items.length} habit${u.items.length > 1 ? 's' : ''} waiting`,
      html: `<h2>Hey ${esc(u.name)}</h2><ul>${u.items.join('')}</ul>
             <a href="${process.env.APP_URL}/today">Check in now</a>`,
    })
    if (error) console.error('reminder failed', u.email, error.message)
  }
  return Response.json({ sent: due.size })
}

// app/api/habits/[id]/analytics/route.ts
import { prisma } from '@/lib/db'
import { calculateStreak, getHeatmapData, todayFor } from '@/lib/streaks'
import { getSessionUserId } from '@/lib/auth' // your auth layer

export async function GET(_: Request, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params // a Promise in current Next.js
  const userId = await getSessionUserId()
  const habit = await prisma.habit.findFirst({
    where: { id, userId }, // ownership check
    include: { user: { select: { timezone: true } } },
  })
  if (!habit) return new Response('Not found', { status: 404 })

  const tz = habit.user.timezone
  const today = todayFor(tz)
  const monthStart = new Date(Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), 1))

  const [streak, heatmap, all] = await Promise.all([
    calculateStreak(id, tz),
    getHeatmapData(id, tz),
    prisma.habitCompletion.findMany({ where: { habitId: id }, select: { date: true } }),
  ])

  const perWeekday = [0, 0, 0, 0, 0, 0, 0] // Sun-Sat
  for (const c of all) perWeekday[c.date.getUTCDay()]++
  const bestDay = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][perWeekday.indexOf(Math.max(...perWeekday))]

  const daysTracked = Math.max(1, Math.round((today.getTime() - todayFor(tz, habit.createdAt).getTime()) / 86_400_000) + 1)
  return Response.json({
    streak,
    heatmap,
    completionRate: Math.min(100, Math.round((all.length / daysTracked) * 100)),
    thisMonth: all.filter(c => c.date >= monthStart).length,
    bestDay,
  })
}

// lib/partners.ts
import { Resend } from 'resend'
import { prisma } from './db'

const resend = new Resend(process.env.RESEND_API_KEY)
const esc = (s: string) => s.replace(/[&<>"']/g, c => `&#${c.charCodeAt(0)};`)

export async function invitePartner(userId: string, partnerEmail: string) {
  const user = await prisma.user.findUniqueOrThrow({ where: { id: userId } })
  const partner = await prisma.accountabilityPartner.create({ data: { userId, partnerEmail } })
  const { error } = await resend.emails.send({
    from: 'HabitPulse <noreply@habitpulse.app>',
    to: partnerEmail,
    subject: `${user.name} wants you as their accountability partner`,
    html: `<h2>${esc(user.name)} invited you to follow their habit streaks</h2>
           <a href="${process.env.APP_URL}/accept-partner?token=${partner.token}">Accept invitation</a>`,
  })
  if (error) throw new Error(error.message)
  return partner
}