Quiet hours

await notify.upsertRecipient({
  id: user.id,
  email: user.email,
  quietHours: {
    start: "22:00",
    end: "08:00",
    timezone: "America/New_York",
  },
})

export async function GET() {
  const flushed = await notify.flushScheduledSends()
  return Response.json({ flushed: flushed.length })
}

"use server"
import { notify } from "@/lib/notifykit"

export async function updateQuietHours(formData: FormData) {
  const start = formData.get("start") as string
  const end = formData.get("end") as string
  const timezone = formData.get("timezone") as string
  const enabled = formData.get("enabled") === "on"

  await notify.upsertRecipient({
    id: session.userId,
    quietHours: enabled ? { start, end, timezone } : null,
  })
}

"use client"
import { useState, useEffect } from "react"
import { updateQuietHours } from "@/app/actions/quiet-hours"

const PRESETS = [
  { label: "Night owl (10 PM – 8 AM)", start: "22:00", end: "08:00" },
  { label: "Sleep only (11 PM – 7 AM)", start: "23:00", end: "07:00" },
  { label: "Work focus (9 AM – 5 PM)", start: "09:00", end: "17:00" },
] as const

export function QuietHoursForm({ current }: {
  current: { start: string; end: string; timezone: string } | null
}) {
  const [enabled, setEnabled] = useState(!!current)
  const [start, setStart] = useState(current?.start ?? "22:00")
  const [end, setEnd] = useState(current?.end ?? "08:00")
  const [timezone, setTimezone] = useState(
    current?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone
  )

  return (
    <form action={updateQuietHours}>
      <label className="toggle-row">
        <input
          type="checkbox"
          name="enabled"
          checked={enabled}
          onChange={(e) => setEnabled(e.target.checked)}
        />
        <strong>Enable quiet hours</strong>
        <span className="hint">Pause email & SMS during this window</span>
      </label>

      <fieldset disabled={!enabled}>
        {/* Presets */}
        <div className="presets" role="group" aria-label="Quick presets">
          {PRESETS.map((p) => (
            <button
              key={p.label}
              type="button"
              className={start === p.start && end === p.end ? "active" : ""}
              onClick={() => { setStart(p.start); setEnd(p.end) }}
            >
              {p.label}
            </button>
          ))}
        </div>

        {/* Custom time pickers */}
        <div className="time-row">
          <label>
            From
            <input type="time" name="start" value={start} onChange={e => setStart(e.target.value)} />
          </label>
          <label>
            Until
            <input type="time" name="end" value={end} onChange={e => setEnd(e.target.value)} />
          </label>
        </div>

        {/* Timezone */}
        <label>
          Timezone
          <select name="timezone" value={timezone} onChange={e => setTimezone(e.target.value)}>
            {Intl.supportedValuesOf("timeZone").map(tz => (
              <option key={tz} value={tz}>{tz.replace(/_/g, " ")}</option>
            ))}
          </select>
        </label>
      </fieldset>

      <button type="submit">Save</button>
    </form>
  )
}

async function syncTimezone() {
  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone
  await fetch("/api/notifykit-actions/update-timezone", {
    method: "POST",
    body: JSON.stringify({ timezone: tz }),
  })
}

export async function updateTimezone(timezone: string) {
  const recipient = await notify.getRecipient(session.userId)
  if (recipient?.quietHours && recipient.quietHours.timezone !== timezone) {
    await notify.upsertRecipient({
      id: session.userId,
      quietHours: { ...recipient.quietHours, timezone },
    })
  }
}

import { describe, it, expect } from "vitest"

describe("quiet hours", () => {
  it("defers email during quiet window", async () => {
    // Set up a recipient with an always-active quiet window
    await testNotify.upsertRecipient({
      id: "user_1",
      email: "test@example.com",
      quietHours: { start: "00:00", end: "23:59", timezone: "UTC" },
    })

    const result = await testNotify.send({
      recipientId: "user_1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postUrl: "/p/1" },
    })

    // Email was deferred, not delivered
    expect(result.deferredChannels).toContain("email")
    expect(result.deliveries.filter(d => d.channel === "email")).toHaveLength(0)

    // Inbox still delivered immediately (pull channel)
    expect(result.inboxItems).toHaveLength(1)
  })

  it("flushes deferred sends", async () => {
    // After the window "ends" (or in tests, just flush manually)
    const flushed = await testNotify.flushScheduledSends()

    expect(flushed).toHaveLength(1)
    expect(flushed[0].deliveries[0].channel).toBe("email")
    expect(flushed[0].deliveries[0].status).toBe("sent")
  })

  it("explain() reports quiet hours without side effects", async () => {
    const explanation = await testNotify.explain({
      recipientId: "user_1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postUrl: "/p/1" },
    })

    expect(explanation.quietHours.active).toBe(true)
    // No records written, no deliveries queued
  })
})

import { notifyKitSchema } from "@notifykitjs/drizzle"
import { lt, count } from "drizzle-orm"
import { db } from "@/lib/db"

export async function GET() {
  const fiveMinAgo = new Date(Date.now() - 5 * 60_000)

  const [{ stale }] = await db
    .select({ stale: count() })
    .from(notifyKitSchema.scheduledSends)
    .where(lt(notifyKitSchema.scheduledSends.scheduledFor, fiveMinAgo))

  if (stale > 0) {
    return Response.json(
      { status: "unhealthy", staleSends: stale, message: "Flush cron may have stopped" },
      { status: 503 }
    )
  }

  return Response.json({ status: "healthy", staleSends: 0 })
}

export async function GET() {
  const start = Date.now()
  const flushed = await notify.flushScheduledSends()
  const durationMs = Date.now() - start

  metrics.gauge("notifykit.flush.duration_ms", durationMs)
  metrics.gauge("notifykit.flush.count", flushed.length)

  if (durationMs > 5000) {
    logger.warn("Quiet hours flush took >5s", { durationMs, count: flushed.length })
  }

  const failed = flushed.filter(r => r.deliveries.some(d => d.status === "failed"))
  if (failed.length > 0) {
    metrics.inc("notifykit.flush.failures", failed.length)
  }

  return Response.json({ flushed: flushed.length, durationMs })
}