/** * v1.17.0 (F4) — per-user Oura token accessors. * v1.17.1 — per-user BYO client id/secret resolver (DB-first then env). * * Like WHOOP / Fitbit, Oura is now a per-user BYO-key integration: each user may * register their own Oura app and store the client id/secret encrypted on * `User`, with a fall-back to the shared env app for existing single-app * deploys. Also per-user is the granted access + refresh token. The schema * carries NO token-expiry column, so the sync layer refreshes REACTIVELY on a * 401 rather than proactively on an expiry timestamp (persisting both rotated * tokens). */ import { prisma } from "@/lib/db"; import { decrypt, encrypt } from "@/lib/crypto"; import { persistRotatedToken } from "@/lib/integrations/oauth-refresh"; import { getOuraCredentials, type OuraCredentials } from "./client"; /** * Resolve the user's Oura OAuth client id/secret, DB-first then env. * * v1.17.1 makes Oura a per-user BYO-key integration (mirroring WHOOP / Fitbit): * a self-hoster registers their own Oura app and pastes the client id/secret * into Settings, stored encrypted on `User`. When the user has not configured * per-user keys we fall back to the shared env app (`OURA_CLIENT_ID` / * `OURA_CLIENT_SECRET`) so existing single-app deploys keep working. Returns * null when neither source is configured. */ export async function getOuraClientCredentials( userId: string, ): Promise { const user = await prisma.user.findUnique({ where: { id: userId }, select: { ouraClientIdEncrypted: true, ouraClientSecretEncrypted: true, }, }); if (user?.ouraClientIdEncrypted && user?.ouraClientSecretEncrypted) { return { clientId: decrypt(user.ouraClientIdEncrypted), clientSecret: decrypt(user.ouraClientSecretEncrypted), }; } // Fall back to the shared env-configured OAuth app. return getOuraCredentials(); } /** Persist the user's Oura OAuth client id/secret, encrypted at rest. */ export async function storeOuraClientCredentials( userId: string, clientId: string, clientSecret: string, ): Promise { await prisma.user.update({ where: { id: userId }, data: { ouraClientIdEncrypted: encrypt(clientId), ouraClientSecretEncrypted: encrypt(clientSecret), }, }); } /** Clear the user's stored Oura OAuth client id/secret. */ export async function clearOuraClientCredentials( userId: string, ): Promise { await prisma.user.update({ where: { id: userId }, data: { ouraClientIdEncrypted: null, ouraClientSecretEncrypted: null, }, }); } export interface OuraConnection { accessToken: string; refreshToken: string; /** * The exact stored refresh-token ciphertext (NOT the decrypted value). The * rotating-refresh compare-and-swap in `storeOuraTokens` matches on this so a * concurrent sync that already rotated the token is not clobbered. */ refreshTokenCiphertext: string; } export async function getOuraConnection( userId: string, ): Promise { const user = await prisma.user.findUnique({ where: { id: userId }, select: { ouraAccessTokenEncrypted: true, ouraRefreshTokenEncrypted: true, }, }); if (!user?.ouraAccessTokenEncrypted || !user?.ouraRefreshTokenEncrypted) { return null; } return { accessToken: decrypt(user.ouraAccessTokenEncrypted), refreshToken: decrypt(user.ouraRefreshTokenEncrypted), refreshTokenCiphertext: user.ouraRefreshTokenEncrypted, }; } /** * Persist a rotated Oura token pair with compare-and-swap on the stored refresh * ciphertext (the inverse of Fitbit / WHOOP, which key by connection id). Oura's * tokens live on `User` and the refresh is REACTIVE on a 401, so two overlapping * syncs can race the same one-time-use refresh token. The CAS guard writes only * when the stored ciphertext still equals the one this caller spent; on a lost * race (0 rows) it re-reads and returns the peer's freshly rotated access token. * * Returns the access token the caller should use for the current sync (its own * on a win, the peer's on a loss), or null if the connection vanished. */ export async function storeOuraTokens( userId: string, accessToken: string, refreshToken: string, expectedRefreshCiphertext: string, ): Promise { return persistRotatedToken(accessToken, { conditionalUpdate: async () => { const { count } = await prisma.user.updateMany({ where: { id: userId, ouraRefreshTokenEncrypted: expectedRefreshCiphertext, }, data: { ouraAccessTokenEncrypted: encrypt(accessToken), ouraRefreshTokenEncrypted: encrypt(refreshToken), }, }); return count; }, readPeerAccessToken: async () => { const fresh = await prisma.user.findUnique({ where: { id: userId }, select: { ouraAccessTokenEncrypted: true }, }); return fresh?.ouraAccessTokenEncrypted ? decrypt(fresh.ouraAccessTokenEncrypted) : null; }, }); }