feat: status page unsubscription (#1736) · openstatus.dev/openstatus@25c3cd6

+2

apps/dashboard/src/app/(dashboard)/status-pages/[id]/subscribers/page.tsx

··· 39 39 token: null, 40 40 acceptedAt: new Date(), 41 41 expiresAt: new Date(), 42 + unsubscribedAt: null, 42 43 }, 43 44 { 44 45 id: 2, ··· 49 50 token: null, 50 51 acceptedAt: new Date(), 51 52 expiresAt: new Date(), 53 + unsubscribedAt: null, 52 54 }, 53 55 ]; 54 56

+36

apps/dashboard/src/components/data-table/subscribers/columns.tsx

··· 1 1 "use client"; 2 2 3 + import { Badge } from "@/components/ui/badge"; 3 4 import { formatDate } from "@/lib/formatter"; 4 5 import type { RouterOutputs } from "@openstatus/api"; 5 6 import type { ColumnDef } from "@tanstack/react-table"; ··· 15 16 enableHiding: false, 16 17 }, 17 18 { 19 + id: "status", 20 + header: "Status", 21 + enableSorting: false, 22 + enableHiding: false, 23 + cell: ({ row }) => { 24 + const unsubscribedAt = row.original.unsubscribedAt; 25 + const acceptedAt = row.original.acceptedAt; 26 + 27 + if (unsubscribedAt) { 28 + return <Badge variant="destructive">Unsubscribed</Badge>; 29 + } 30 + 31 + if (!acceptedAt) { 32 + return <Badge variant="outline">Pending</Badge>; 33 + } 34 + 35 + return <Badge variant="secondary">Active</Badge>; 36 + }, 37 + }, 38 + { 18 39 accessorKey: "createdAt", 19 40 header: "Created At", 20 41 enableSorting: false, ··· 36 57 enableHiding: false, 37 58 cell: ({ row }) => { 38 59 const value = row.getValue("acceptedAt"); 60 + if (value instanceof Date) return formatDate(value); 61 + if (!value) return "-"; 62 + return value; 63 + }, 64 + meta: { 65 + cellClassName: "font-mono", 66 + }, 67 + }, 68 + { 69 + accessorKey: "unsubscribedAt", 70 + header: "Unsubscribed At", 71 + enableSorting: false, 72 + enableHiding: false, 73 + cell: ({ row }) => { 74 + const value = row.getValue("unsubscribedAt"); 39 75 if (value instanceof Date) return formatDate(value); 40 76 if (!value) return "-"; 41 77 return value;

+2

apps/server/src/routes/public/index.ts

··· 3 3 import { timing } from "hono/timing"; 4 4 5 5 import { status } from "./status"; 6 + import { unsubscribe } from "./unsubscribe"; 6 7 7 8 export const publicRoute = new Hono(); 8 9 publicRoute.use("*", cors()); 9 10 publicRoute.use("*", timing()); 10 11 11 12 publicRoute.route("/status", status); 13 + publicRoute.route("/unsubscribe", unsubscribe);

+62

apps/server/src/routes/public/unsubscribe.ts

··· 1 + import { Hono } from "hono"; 2 + 3 + import { db, eq } from "@openstatus/db"; 4 + import { pageSubscriber } from "@openstatus/db/src/schema"; 5 + 6 + /** 7 + * RFC 8058 One-Click Unsubscribe Endpoint 8 + * 9 + * This endpoint handles POST requests from email clients that support one-click unsubscribe. 10 + * Email clients send a POST request with form-urlencoded body containing "List-Unsubscribe=One-Click". 11 + * 12 + * @see https://datatracker.ietf.org/doc/html/rfc8058 13 + */ 14 + export const unsubscribe = new Hono(); 15 + 16 + unsubscribe.post("/:token", async (c) => { 17 + try { 18 + const { token } = c.req.param(); 19 + 20 + // Validate token is a valid UUID format 21 + const uuidRegex = 22 + /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; 23 + if (!uuidRegex.test(token)) { 24 + return c.json({ error: "Invalid token format" }, 400); 25 + } 26 + 27 + // Find the subscriber by token 28 + const subscriber = await db 29 + .select() 30 + .from(pageSubscriber) 31 + .where(eq(pageSubscriber.token, token)) 32 + .get(); 33 + 34 + // Return 404 if subscriber not found 35 + if (!subscriber) { 36 + return c.json({ error: "Subscriber not found" }, 404); 37 + } 38 + 39 + // Check if subscriber has verified their subscription 40 + if (!subscriber.acceptedAt) { 41 + return c.json({ error: "Subscription not verified" }, 400); 42 + } 43 + 44 + // Check if already unsubscribed 45 + if (subscriber.unsubscribedAt) { 46 + // Return 200 OK even if already unsubscribed (idempotent) 47 + return c.json({ message: "Already unsubscribed" }, 200); 48 + } 49 + 50 + // Set unsubscribedAt timestamp 51 + await db 52 + .update(pageSubscriber) 53 + .set({ unsubscribedAt: new Date() }) 54 + .where(eq(pageSubscriber.id, subscriber.id)); 55 + 56 + // Return 200 OK on success 57 + return c.json({ message: "Successfully unsubscribed" }, 200); 58 + } catch (e) { 59 + console.error(`Error in one-click unsubscribe: ${e}`); 60 + return c.json({ error: "Internal server error" }, 500); 61 + } 62 + });

+13 -2

apps/server/src/routes/v1/maintenances/post.ts

··· 141 141 }, 142 142 }); 143 143 144 - if (_page && subscribers.length > 0) { 144 + const validSubscribers = subscribers.filter( 145 + (s): s is typeof s & { token: string } => 146 + s.token !== null && 147 + s.acceptedAt !== null && 148 + s.unsubscribedAt === null, 149 + ); 150 + if (_page && validSubscribers.length > 0) { 145 151 await emailClient.sendStatusReportUpdate({ 146 - to: subscribers.map((subscriber) => subscriber.email), 152 + subscribers: validSubscribers.map((subscriber) => ({ 153 + email: subscriber.email, 154 + token: subscriber.token, 155 + })), 147 156 pageTitle: _page.title, 157 + pageSlug: _page.slug, 158 + customDomain: _page.customDomain, 148 159 reportTitle: _maintenance.title, 149 160 status: "maintenance", 150 161 message: _maintenance.message,

+15 -3

apps/server/src/routes/v1/statusReportUpdates/post.ts

··· 1 1 import { createRoute } from "@hono/zod-openapi"; 2 2 3 - import { and, db, eq, isNotNull } from "@openstatus/db"; 3 + import { and, db, eq, isNotNull, isNull } from "@openstatus/db"; 4 4 import { 5 5 page, 6 6 pageSubscriber, ··· 99 99 and( 100 100 eq(pageSubscriber.pageId, _statusReport.pageId), 101 101 isNotNull(pageSubscriber.acceptedAt), 102 + isNull(pageSubscriber.unsubscribedAt), 102 103 ), 103 104 ) 104 105 .all(); ··· 114 115 }, 115 116 }); 116 117 117 - if (_page && subscribers.length > 0) { 118 + const validSubscribers = subscribers.filter( 119 + (s): s is typeof s & { token: string } => 120 + s.token !== null && 121 + s.acceptedAt !== null && 122 + s.unsubscribedAt === null, 123 + ); 124 + if (_page && validSubscribers.length > 0) { 118 125 await emailClient.sendStatusReportUpdate({ 119 - to: subscribers.map((subscriber) => subscriber.email), 126 + subscribers: validSubscribers.map((subscriber) => ({ 127 + email: subscriber.email, 128 + token: subscriber.token, 129 + })), 120 130 pageTitle: _page.title, 131 + pageSlug: _page.slug, 132 + customDomain: _page.customDomain, 121 133 reportTitle: _statusReport.title, 122 134 status: _statusReportUpdate.status, 123 135 message: _statusReportUpdate.message,

+14 -2

apps/server/src/routes/v1/statusReports/post.ts

··· 143 143 and( 144 144 eq(pageSubscriber.pageId, _newStatusReport.pageId), 145 145 isNotNull(pageSubscriber.acceptedAt), 146 + isNull(pageSubscriber.unsubscribedAt), 146 147 ), 147 148 ) 148 149 .all(); ··· 174 175 }); 175 176 } 176 177 177 - if (pageInfo && subscribers.length > 0) { 178 + const validSubscribers = subscribers.filter( 179 + (s): s is typeof s & { token: string } => 180 + s.token !== null && 181 + s.acceptedAt !== null && 182 + s.unsubscribedAt === null, 183 + ); 184 + if (pageInfo && validSubscribers.length > 0) { 178 185 await emailClient.sendStatusReportUpdate({ 179 - to: subscribers.map((subscriber) => subscriber.email), 186 + subscribers: validSubscribers.map((subscriber) => ({ 187 + email: subscriber.email, 188 + token: subscriber.token, 189 + })), 180 190 pageTitle: pageInfo.title, 191 + pageSlug: pageInfo.slug, 192 + customDomain: pageInfo.customDomain, 181 193 reportTitle: _newStatusReport.title, 182 194 status: _newStatusReportUpdate.status, 183 195 message: _newStatusReportUpdate.message,

+275

apps/server/src/routes/v1/statusReports/subscriber-filtering.integration.test.ts

··· 1 + import { afterAll, beforeAll, describe, expect, test } from "bun:test"; 2 + import { and, db, eq, isNotNull, isNull } from "@openstatus/db"; 3 + import { page, pageSubscriber } from "@openstatus/db/src/schema"; 4 + 5 + /** 6 + * Integration tests for subscriber filtering in status report email queries. 7 + * These tests verify that unsubscribed users are excluded from email notifications. 8 + */ 9 + 10 + let testPageId: number; 11 + const testWorkspaceId = 1; // Use existing test workspace from seed data 12 + 13 + beforeAll(async () => { 14 + // Clean up any existing test data 15 + await db 16 + .delete(pageSubscriber) 17 + .where(eq(pageSubscriber.email, "active-sub@test.com")); 18 + await db 19 + .delete(pageSubscriber) 20 + .where(eq(pageSubscriber.email, "unsubscribed-sub@test.com")); 21 + await db 22 + .delete(pageSubscriber) 23 + .where(eq(pageSubscriber.email, "pending-sub@test.com")); 24 + await db.delete(page).where(eq(page.slug, "test-filtering-page")); 25 + 26 + // Create a test page 27 + const testPage = await db 28 + .insert(page) 29 + .values({ 30 + workspaceId: testWorkspaceId, 31 + title: "Test Filtering Page", 32 + description: "A test page for subscriber filtering tests", 33 + slug: "test-filtering-page", 34 + customDomain: "", 35 + }) 36 + .returning() 37 + .get(); 38 + 39 + testPageId = testPage.id; 40 + 41 + // Create test subscribers with different states 42 + // 1. Active subscriber (verified, not unsubscribed) 43 + await db.insert(pageSubscriber).values({ 44 + pageId: testPageId, 45 + email: "active-sub@test.com", 46 + token: crypto.randomUUID(), 47 + acceptedAt: new Date(), 48 + unsubscribedAt: null, 49 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 50 + }); 51 + 52 + // 2. Unsubscribed subscriber (verified, then unsubscribed) 53 + await db.insert(pageSubscriber).values({ 54 + pageId: testPageId, 55 + email: "unsubscribed-sub@test.com", 56 + token: crypto.randomUUID(), 57 + acceptedAt: new Date(), 58 + unsubscribedAt: new Date(), 59 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 60 + }); 61 + 62 + // 3. Pending subscriber (not verified) 63 + await db.insert(pageSubscriber).values({ 64 + pageId: testPageId, 65 + email: "pending-sub@test.com", 66 + token: crypto.randomUUID(), 67 + acceptedAt: null, 68 + unsubscribedAt: null, 69 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 70 + }); 71 + }); 72 + 73 + afterAll(async () => { 74 + // Clean up test data 75 + await db 76 + .delete(pageSubscriber) 77 + .where(eq(pageSubscriber.email, "active-sub@test.com")); 78 + await db 79 + .delete(pageSubscriber) 80 + .where(eq(pageSubscriber.email, "unsubscribed-sub@test.com")); 81 + await db 82 + .delete(pageSubscriber) 83 + .where(eq(pageSubscriber.email, "pending-sub@test.com")); 84 + await db.delete(page).where(eq(page.slug, "test-filtering-page")); 85 + }); 86 + 87 + describe("Subscriber filtering for email notifications", () => { 88 + test("should exclude unsubscribed users from email queries", async () => { 89 + // This query mirrors the exact query used in statusReports/post.ts and statusReportUpdates/post.ts 90 + const subscribers = await db 91 + .select() 92 + .from(pageSubscriber) 93 + .where( 94 + and( 95 + eq(pageSubscriber.pageId, testPageId), 96 + isNotNull(pageSubscriber.acceptedAt), 97 + isNull(pageSubscriber.unsubscribedAt), 98 + ), 99 + ) 100 + .all(); 101 + 102 + // Should only include active subscriber, not unsubscribed or pending 103 + expect(subscribers.length).toBe(1); 104 + expect(subscribers[0].email).toBe("active-sub@test.com"); 105 + }); 106 + 107 + test("should exclude pending (unverified) users from email queries", async () => { 108 + const subscribers = await db 109 + .select() 110 + .from(pageSubscriber) 111 + .where( 112 + and( 113 + eq(pageSubscriber.pageId, testPageId), 114 + isNotNull(pageSubscriber.acceptedAt), 115 + isNull(pageSubscriber.unsubscribedAt), 116 + ), 117 + ) 118 + .all(); 119 + 120 + const pendingEmails = subscribers.filter( 121 + (s) => s.email === "pending-sub@test.com", 122 + ); 123 + expect(pendingEmails.length).toBe(0); 124 + }); 125 + 126 + test("should not include unsubscribed user even if acceptedAt is set", async () => { 127 + const subscribers = await db 128 + .select() 129 + .from(pageSubscriber) 130 + .where( 131 + and( 132 + eq(pageSubscriber.pageId, testPageId), 133 + isNotNull(pageSubscriber.acceptedAt), 134 + isNull(pageSubscriber.unsubscribedAt), 135 + ), 136 + ) 137 + .all(); 138 + 139 + const unsubscribedEmails = subscribers.filter( 140 + (s) => s.email === "unsubscribed-sub@test.com", 141 + ); 142 + expect(unsubscribedEmails.length).toBe(0); 143 + }); 144 + 145 + test("should return all subscribers without unsubscribedAt filter", async () => { 146 + // Query without the unsubscribedAt filter - should include unsubscribed users 147 + const allVerifiedSubscribers = await db 148 + .select() 149 + .from(pageSubscriber) 150 + .where( 151 + and( 152 + eq(pageSubscriber.pageId, testPageId), 153 + isNotNull(pageSubscriber.acceptedAt), 154 + ), 155 + ) 156 + .all(); 157 + 158 + // Should include both active and unsubscribed (both have acceptedAt set) 159 + expect(allVerifiedSubscribers.length).toBe(2); 160 + 161 + const emails = allVerifiedSubscribers.map((s) => s.email); 162 + expect(emails).toContain("active-sub@test.com"); 163 + expect(emails).toContain("unsubscribed-sub@test.com"); 164 + }); 165 + 166 + test("should correctly filter subscribers with valid tokens", async () => { 167 + const subscribers = await db 168 + .select() 169 + .from(pageSubscriber) 170 + .where( 171 + and( 172 + eq(pageSubscriber.pageId, testPageId), 173 + isNotNull(pageSubscriber.acceptedAt), 174 + isNull(pageSubscriber.unsubscribedAt), 175 + ), 176 + ) 177 + .all(); 178 + 179 + // Filter for valid tokens (non-null) 180 + const validSubscribers = subscribers.filter( 181 + (s): s is typeof s & { token: string } => s.token !== null, 182 + ); 183 + 184 + expect(validSubscribers.length).toBe(1); 185 + expect(validSubscribers[0].token).toBeDefined(); 186 + expect(validSubscribers[0].token).toMatch( 187 + /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, 188 + ); 189 + }); 190 + }); 191 + 192 + describe("Subscriber state transitions", () => { 193 + test("should allow re-subscribing after unsubscription", async () => { 194 + // Get the unsubscribed subscriber 195 + const unsubscribedSub = await db.query.pageSubscriber.findFirst({ 196 + where: eq(pageSubscriber.email, "unsubscribed-sub@test.com"), 197 + }); 198 + 199 + expect(unsubscribedSub?.unsubscribedAt).not.toBeNull(); 200 + 201 + // Simulate re-subscription by clearing unsubscribedAt 202 + await db 203 + .update(pageSubscriber) 204 + .set({ 205 + unsubscribedAt: null, 206 + acceptedAt: null, // Reset for re-verification 207 + token: crypto.randomUUID(), // Generate new token 208 + }) 209 + .where(eq(pageSubscriber.id, unsubscribedSub?.id)); 210 + 211 + // After re-subscription + verification, subscriber should be included 212 + // (we need to set acceptedAt for verification) 213 + await db 214 + .update(pageSubscriber) 215 + .set({ acceptedAt: new Date() }) 216 + .where(eq(pageSubscriber.id, unsubscribedSub?.id)); 217 + 218 + const subscribers = await db 219 + .select() 220 + .from(pageSubscriber) 221 + .where( 222 + and( 223 + eq(pageSubscriber.pageId, testPageId), 224 + isNotNull(pageSubscriber.acceptedAt), 225 + isNull(pageSubscriber.unsubscribedAt), 226 + ), 227 + ) 228 + .all(); 229 + 230 + // Now should include both active and re-subscribed users 231 + expect(subscribers.length).toBe(2); 232 + 233 + // Restore original state for other tests 234 + await db 235 + .update(pageSubscriber) 236 + .set({ unsubscribedAt: new Date() }) 237 + .where(eq(pageSubscriber.id, unsubscribedSub?.id)); 238 + }); 239 + 240 + test("should track unsubscription timestamp", async () => { 241 + const subscriber = await db.query.pageSubscriber.findFirst({ 242 + where: eq(pageSubscriber.email, "unsubscribed-sub@test.com"), 243 + }); 244 + 245 + expect(subscriber?.unsubscribedAt).toBeInstanceOf(Date); 246 + }); 247 + }); 248 + 249 + describe("Query performance considerations", () => { 250 + test("should use proper index-friendly query conditions", async () => { 251 + // This test verifies the query uses conditions that can leverage indexes 252 + // The conditions: pageId = X AND acceptedAt IS NOT NULL AND unsubscribedAt IS NULL 253 + // can all be optimized with appropriate indexes 254 + 255 + const startTime = performance.now(); 256 + 257 + const subscribers = await db 258 + .select() 259 + .from(pageSubscriber) 260 + .where( 261 + and( 262 + eq(pageSubscriber.pageId, testPageId), 263 + isNotNull(pageSubscriber.acceptedAt), 264 + isNull(pageSubscriber.unsubscribedAt), 265 + ), 266 + ) 267 + .all(); 268 + 269 + const endTime = performance.now(); 270 + 271 + // Query should complete quickly (under 100ms for small datasets) 272 + expect(endTime - startTime).toBeLessThan(100); 273 + expect(subscribers).toBeDefined(); 274 + }); 275 + });

+13 -2

apps/server/src/routes/v1/statusReports/update/post.ts

··· 110 110 ) 111 111 .all(); 112 112 113 - if (_statusReportWithRelations?.page) { 113 + const validSubscribers = subscribers.filter( 114 + (s): s is typeof s & { token: string } => 115 + s.token !== null && 116 + s.acceptedAt !== null && 117 + s.unsubscribedAt === null, 118 + ); 119 + if (_statusReportWithRelations?.page && validSubscribers.length > 0) { 114 120 await emailClient.sendStatusReportUpdate({ 115 - to: subscribers.map((subscriber) => subscriber.email), 121 + subscribers: validSubscribers.map((subscriber) => ({ 122 + email: subscriber.email, 123 + token: subscriber.token, 124 + })), 116 125 pageTitle: _statusReportWithRelations.page.title, 126 + pageSlug: _statusReportWithRelations.page.slug, 127 + customDomain: _statusReportWithRelations.page.customDomain, 117 128 reportTitle: _statusReportWithRelations.title, 118 129 status: _statusReportUpdate.status, 119 130 message: _statusReportUpdate.message,

+36

apps/status-page/src/app/(status-page)/[domain]/(public)/unsubscribe/[token]/layout.tsx

··· 1 + "use client"; 2 + 3 + import { 4 + Status, 5 + StatusContent, 6 + StatusDescription, 7 + StatusHeader, 8 + StatusTitle, 9 + } from "@/components/status-page/status"; 10 + import { useTRPC } from "@/lib/trpc/client"; 11 + import { useQuery } from "@tanstack/react-query"; 12 + import { useParams } from "next/navigation"; 13 + 14 + export default function UnsubscribeLayout({ 15 + children, 16 + }: { 17 + children: React.ReactNode; 18 + }) { 19 + const { domain } = useParams<{ domain: string }>(); 20 + const trpc = useTRPC(); 21 + const { data: page } = useQuery( 22 + trpc.statusPage.get.queryOptions({ slug: domain }), 23 + ); 24 + 25 + if (!page) return null; 26 + 27 + return ( 28 + <Status> 29 + <StatusHeader> 30 + <StatusTitle>{page.title}</StatusTitle> 31 + <StatusDescription>{page.description}</StatusDescription> 32 + </StatusHeader> 33 + <StatusContent>{children}</StatusContent> 34 + </Status> 35 + ); 36 + }

+123

apps/status-page/src/app/(status-page)/[domain]/(public)/unsubscribe/[token]/page.tsx

··· 1 + "use client"; 2 + 3 + import { 4 + StatusBlankContainer, 5 + StatusBlankContent, 6 + StatusBlankDescription, 7 + StatusBlankLink, 8 + StatusBlankTitle, 9 + } from "@/components/status-page/status-blank"; 10 + import { Button } from "@/components/ui/button"; 11 + import { useTRPC } from "@/lib/trpc/client"; 12 + import { useMutation, useQuery } from "@tanstack/react-query"; 13 + import { useParams } from "next/navigation"; 14 + 15 + export default function UnsubscribePage() { 16 + const trpc = useTRPC(); 17 + const { token, domain } = useParams<{ token: string; domain: string }>(); 18 + 19 + const subscriberQuery = useQuery( 20 + trpc.statusPage.getSubscriberByToken.queryOptions({ token, domain }), 21 + ); 22 + 23 + const unsubscribeMutation = useMutation( 24 + trpc.statusPage.unsubscribe.mutationOptions({}), 25 + ); 26 + 27 + const handleUnsubscribe = () => { 28 + unsubscribeMutation.mutate({ token, domain }); 29 + }; 30 + 31 + // Loading state 32 + if (subscriberQuery.isLoading) { 33 + return ( 34 + <StatusBlankContainer> 35 + <StatusBlankContent> 36 + <StatusBlankTitle>Loading...</StatusBlankTitle> 37 + </StatusBlankContent> 38 + </StatusBlankContainer> 39 + ); 40 + } 41 + 42 + // Invalid/expired token or already unsubscribed 43 + if (!subscriberQuery.data) { 44 + return ( 45 + <StatusBlankContainer> 46 + <StatusBlankContent> 47 + <StatusBlankTitle className="text-destructive"> 48 + Invalid or expired link 49 + </StatusBlankTitle> 50 + <StatusBlankDescription> 51 + This unsubscribe link is no longer valid. You may have already 52 + unsubscribed. 53 + </StatusBlankDescription> 54 + <StatusBlankLink href="../">Go back</StatusBlankLink> 55 + </StatusBlankContent> 56 + </StatusBlankContainer> 57 + ); 58 + } 59 + 60 + // Success state after unsubscribing 61 + if (unsubscribeMutation.isSuccess) { 62 + return ( 63 + <StatusBlankContainer> 64 + <StatusBlankContent> 65 + <StatusBlankTitle className="text-success"> 66 + Successfully unsubscribed 67 + </StatusBlankTitle> 68 + <StatusBlankDescription> 69 + You will no longer receive email notifications from{" "} 70 + {subscriberQuery.data.pageName}. 71 + </StatusBlankDescription> 72 + <StatusBlankLink href="../">Go back</StatusBlankLink> 73 + </StatusBlankContent> 74 + </StatusBlankContainer> 75 + ); 76 + } 77 + 78 + // Error state 79 + if (unsubscribeMutation.isError) { 80 + return ( 81 + <StatusBlankContainer> 82 + <StatusBlankContent> 83 + <StatusBlankTitle className="text-destructive"> 84 + {unsubscribeMutation.error?.message || "Something went wrong"} 85 + </StatusBlankTitle> 86 + <StatusBlankDescription> 87 + Please try again or contact support if the issue persists. 88 + </StatusBlankDescription> 89 + <StatusBlankLink href="../">Go back</StatusBlankLink> 90 + </StatusBlankContent> 91 + </StatusBlankContainer> 92 + ); 93 + } 94 + 95 + // Confirmation state (initial view) 96 + return ( 97 + <StatusBlankContainer> 98 + <StatusBlankContent> 99 + <StatusBlankTitle>Unsubscribe from notifications</StatusBlankTitle> 100 + <StatusBlankDescription> 101 + You are about to unsubscribe{" "} 102 + <span className="font-semibold"> 103 + {subscriberQuery.data.maskedEmail} 104 + </span>{" "} 105 + from{" "} 106 + <span className="font-semibold">{subscriberQuery.data.pageName}</span>{" "} 107 + status updates. 108 + </StatusBlankDescription> 109 + <div className="flex justify-center gap-2"> 110 + <StatusBlankLink href="../">Cancel</StatusBlankLink> 111 + <Button 112 + variant="destructive" 113 + size="sm" 114 + onClick={handleUnsubscribe} 115 + disabled={unsubscribeMutation.isPending} 116 + > 117 + {unsubscribeMutation.isPending ? "Unsubscribing..." : "Unsubscribe"} 118 + </Button> 119 + </div> 120 + </StatusBlankContent> 121 + </StatusBlankContainer> 122 + ); 123 + }

+27 -9

packages/api/src/router/email/index.ts

··· 61 61 opts.ctx.workspace.id 62 62 ) 63 63 return; 64 - if (!_statusReportUpdate.statusReport.page.pageSubscribers.length) 65 - return; 64 + const validSubscribers = 65 + _statusReportUpdate.statusReport.page.pageSubscribers.filter( 66 + (s): s is typeof s & { token: string } => 67 + s.token !== null && 68 + s.acceptedAt !== null && 69 + s.unsubscribedAt === null, 70 + ); 71 + if (!validSubscribers.length) return; 66 72 67 73 await emailClient.sendStatusReportUpdate({ 68 - to: _statusReportUpdate.statusReport.page.pageSubscribers.map( 69 - (subscriber) => subscriber.email, 70 - ), 74 + subscribers: validSubscribers.map((subscriber) => ({ 75 + email: subscriber.email, 76 + token: subscriber.token, 77 + })), 71 78 pageTitle: _statusReportUpdate.statusReport.page.title, 79 + pageSlug: _statusReportUpdate.statusReport.page.slug, 80 + customDomain: _statusReportUpdate.statusReport.page.customDomain, 72 81 reportTitle: _statusReportUpdate.statusReport.title, 73 82 status: _statusReportUpdate.status, 74 83 message: _statusReportUpdate.message, ··· 109 118 110 119 if (!_maintenance) return; 111 120 if (!_maintenance.page) return; 112 - if (!_maintenance.page.pageSubscribers.length) return; 121 + const validSubscribers = _maintenance.page.pageSubscribers.filter( 122 + (s): s is typeof s & { token: string } => 123 + s.token !== null && 124 + s.acceptedAt !== null && 125 + s.unsubscribedAt === null, 126 + ); 127 + if (!validSubscribers.length) return; 113 128 114 129 await emailClient.sendStatusReportUpdate({ 115 - to: _maintenance.page.pageSubscribers.map( 116 - (subscriber) => subscriber.email, 117 - ), 130 + subscribers: validSubscribers.map((subscriber) => ({ 131 + email: subscriber.email, 132 + token: subscriber.token, 133 + })), 118 134 pageTitle: _maintenance.page.title, 135 + pageSlug: _maintenance.page.slug, 136 + customDomain: _maintenance.page.customDomain, 119 137 reportTitle: _maintenance.title, 120 138 status: "maintenance", 121 139 message: _maintenance.message,

+722

packages/api/src/router/statusPage.e2e.test.ts

··· 1 + import { afterAll, beforeAll, describe, expect, test } from "bun:test"; 2 + import { and, db, eq, isNotNull, isNull } from "@openstatus/db"; 3 + import { page, pageSubscriber, workspace } from "@openstatus/db/src/schema"; 4 + 5 + /** 6 + * End-to-end integration tests for the full unsubscribe flow. 7 + * These tests simulate the complete user journey: 8 + * subscribe -> verify -> receive email -> unsubscribe 9 + */ 10 + 11 + let testPageId: number; 12 + let testWorkspaceId: number; 13 + const testSlug = "e2e-unsubscribe-test-page"; 14 + const testEmail = "e2e-test-user@example.com"; 15 + let subscriberToken: string; 16 + 17 + beforeAll(async () => { 18 + // Clean up any existing test data 19 + await db.delete(pageSubscriber).where(eq(pageSubscriber.email, testEmail)); 20 + await db.delete(page).where(eq(page.slug, testSlug)); 21 + 22 + // Get an existing workspace (use workspace id 1 from seed data) 23 + const existingWorkspace = await db.query.workspace.findFirst({ 24 + where: eq(workspace.id, 1), 25 + }); 26 + 27 + if (!existingWorkspace) { 28 + throw new Error( 29 + "Test workspace not found. Please ensure seed data exists.", 30 + ); 31 + } 32 + 33 + testWorkspaceId = existingWorkspace.id; 34 + 35 + // Create a test page 36 + const testPage = await db 37 + .insert(page) 38 + .values({ 39 + workspaceId: testWorkspaceId, 40 + title: "E2E Test Status Page", 41 + description: "A test page for E2E unsubscribe flow tests", 42 + slug: testSlug, 43 + customDomain: "", 44 + }) 45 + .returning() 46 + .get(); 47 + 48 + testPageId = testPage.id; 49 + }); 50 + 51 + afterAll(async () => { 52 + // Clean up test data 53 + await db.delete(pageSubscriber).where(eq(pageSubscriber.email, testEmail)); 54 + await db.delete(page).where(eq(page.slug, testSlug)); 55 + }); 56 + 57 + describe("Full unsubscribe flow: subscribe -> verify -> unsubscribe", () => { 58 + test("Step 1: User subscribes to status page", async () => { 59 + // Simulate subscription by inserting a subscriber 60 + const subscriber = await db 61 + .insert(pageSubscriber) 62 + .values({ 63 + pageId: testPageId, 64 + email: testEmail, 65 + token: crypto.randomUUID(), 66 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), // 7 days 67 + }) 68 + .returning() 69 + .get(); 70 + 71 + expect(subscriber.id).toBeDefined(); 72 + expect(subscriber.email).toBe(testEmail); 73 + expect(subscriber.token).toBeDefined(); 74 + expect(subscriber.acceptedAt).toBeNull(); 75 + expect(subscriber.unsubscribedAt).toBeNull(); 76 + 77 + if (!subscriber.token) { 78 + throw new Error("Subscriber token is undefined"); 79 + } 80 + 81 + subscriberToken = subscriber.token; 82 + }); 83 + 84 + test("Step 2: User verifies their email subscription", async () => { 85 + // Verify the subscription 86 + await db 87 + .update(pageSubscriber) 88 + .set({ acceptedAt: new Date() }) 89 + .where(eq(pageSubscriber.token, subscriberToken)); 90 + 91 + // Verify the subscription is now active 92 + const subscriber = await db.query.pageSubscriber.findFirst({ 93 + where: eq(pageSubscriber.token, subscriberToken), 94 + }); 95 + 96 + expect(subscriber?.acceptedAt).not.toBeNull(); 97 + expect(subscriber?.unsubscribedAt).toBeNull(); 98 + }); 99 + 100 + test("Step 3: Verified subscriber is included in email recipient list", async () => { 101 + // This query mirrors the exact query used in statusReports/post.ts 102 + const subscribers = await db 103 + .select() 104 + .from(pageSubscriber) 105 + .where( 106 + and( 107 + eq(pageSubscriber.pageId, testPageId), 108 + isNotNull(pageSubscriber.acceptedAt), 109 + isNull(pageSubscriber.unsubscribedAt), 110 + ), 111 + ) 112 + .all(); 113 + 114 + expect(subscribers.length).toBe(1); 115 + expect(subscribers[0].email).toBe(testEmail); 116 + expect(subscribers[0].token).toBe(subscriberToken); 117 + }); 118 + 119 + test("Step 4: User clicks unsubscribe and sets unsubscribedAt", async () => { 120 + // Simulate the unsubscribe action 121 + await db 122 + .update(pageSubscriber) 123 + .set({ unsubscribedAt: new Date() }) 124 + .where(eq(pageSubscriber.token, subscriberToken)); 125 + 126 + // Verify the unsubscription 127 + const subscriber = await db.query.pageSubscriber.findFirst({ 128 + where: eq(pageSubscriber.token, subscriberToken), 129 + }); 130 + 131 + expect(subscriber?.unsubscribedAt).not.toBeNull(); 132 + expect(subscriber?.unsubscribedAt).toBeInstanceOf(Date); 133 + }); 134 + 135 + test("Step 5: Unsubscribed user is excluded from email recipient list", async () => { 136 + // This query mirrors the exact query used in statusReports/post.ts 137 + const subscribers = await db 138 + .select() 139 + .from(pageSubscriber) 140 + .where( 141 + and( 142 + eq(pageSubscriber.pageId, testPageId), 143 + isNotNull(pageSubscriber.acceptedAt), 144 + isNull(pageSubscriber.unsubscribedAt), 145 + ), 146 + ) 147 + .all(); 148 + 149 + expect(subscribers.length).toBe(0); 150 + }); 151 + }); 152 + 153 + describe("Confirmation page displays correct information", () => { 154 + let confirmPageToken: string; 155 + 156 + beforeAll(async () => { 157 + // Create a fresh subscriber for confirmation page tests 158 + await db 159 + .delete(pageSubscriber) 160 + .where(eq(pageSubscriber.email, "confirm-page-test@example.com")); 161 + 162 + const subscriber = await db 163 + .insert(pageSubscriber) 164 + .values({ 165 + pageId: testPageId, 166 + email: "confirm-page-test@example.com", 167 + token: crypto.randomUUID(), 168 + acceptedAt: new Date(), // Already verified 169 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 170 + }) 171 + .returning() 172 + .get(); 173 + 174 + if (!subscriber.token) { 175 + throw new Error("Subscriber token is undefined"); 176 + } 177 + 178 + confirmPageToken = subscriber.token; 179 + }); 180 + 181 + afterAll(async () => { 182 + await db 183 + .delete(pageSubscriber) 184 + .where(eq(pageSubscriber.email, "confirm-page-test@example.com")); 185 + }); 186 + 187 + test("Confirmation page displays correct page name", async () => { 188 + const subscriber = await db.query.pageSubscriber.findFirst({ 189 + where: eq(pageSubscriber.token, confirmPageToken), 190 + with: { 191 + page: true, 192 + }, 193 + }); 194 + 195 + expect(subscriber?.page.title).toBe("E2E Test Status Page"); 196 + }); 197 + 198 + test("Confirmation page displays masked email (first char + *** + @domain)", async () => { 199 + const subscriber = await db.query.pageSubscriber.findFirst({ 200 + where: eq(pageSubscriber.token, confirmPageToken), 201 + }); 202 + 203 + if (!subscriber) { 204 + throw new Error("Subscriber not found"); 205 + } 206 + 207 + const email = subscriber.email; 208 + expect(email).toBe("confirm-page-test@example.com"); 209 + 210 + // Apply the same masking logic as in the API 211 + const [localPart, domain] = email.split("@"); 212 + const maskedEmail = 213 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 214 + 215 + expect(maskedEmail).toBe("c***@example.com"); 216 + }); 217 + 218 + test("Email masking works for single character local part", async () => { 219 + const email = "a@example.com"; 220 + const [localPart, domain] = email.split("@"); 221 + const maskedEmail = 222 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 223 + 224 + expect(maskedEmail).toBe("a***@example.com"); 225 + }); 226 + 227 + test("Email masking works for long local part", async () => { 228 + const email = "verylongemailaddress@example.com"; 229 + const [localPart, domain] = email.split("@"); 230 + const maskedEmail = 231 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 232 + 233 + expect(maskedEmail).toBe("v***@example.com"); 234 + }); 235 + }); 236 + 237 + describe("Clicking confirm sets unsubscribedAt timestamp", () => { 238 + let unsubscribeToken: string; 239 + 240 + beforeAll(async () => { 241 + // Create a fresh subscriber 242 + await db 243 + .delete(pageSubscriber) 244 + .where(eq(pageSubscriber.email, "unsubscribe-click-test@example.com")); 245 + 246 + const subscriber = await db 247 + .insert(pageSubscriber) 248 + .values({ 249 + pageId: testPageId, 250 + email: "unsubscribe-click-test@example.com", 251 + token: crypto.randomUUID(), 252 + acceptedAt: new Date(), // Already verified 253 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 254 + }) 255 + .returning() 256 + .get(); 257 + 258 + if (!subscriber.token) { 259 + throw new Error("Subscriber token is undefined"); 260 + } 261 + 262 + unsubscribeToken = subscriber.token; 263 + }); 264 + 265 + afterAll(async () => { 266 + await db 267 + .delete(pageSubscriber) 268 + .where(eq(pageSubscriber.email, "unsubscribe-click-test@example.com")); 269 + }); 270 + 271 + test("Before clicking confirm, unsubscribedAt is null", async () => { 272 + const subscriber = await db.query.pageSubscriber.findFirst({ 273 + where: eq(pageSubscriber.token, unsubscribeToken), 274 + }); 275 + 276 + expect(subscriber?.unsubscribedAt).toBeNull(); 277 + }); 278 + 279 + test("After clicking confirm, unsubscribedAt is set to current timestamp", async () => { 280 + const beforeUnsubscribe = new Date(); 281 + 282 + // Simulate clicking "Confirm Unsubscribe" 283 + await db 284 + .update(pageSubscriber) 285 + .set({ unsubscribedAt: new Date() }) 286 + .where(eq(pageSubscriber.token, unsubscribeToken)); 287 + 288 + const afterUnsubscribe = new Date(); 289 + 290 + const subscriber = await db.query.pageSubscriber.findFirst({ 291 + where: eq(pageSubscriber.token, unsubscribeToken), 292 + }); 293 + 294 + if (!subscriber) { 295 + throw new Error("Subscriber not found"); 296 + } 297 + 298 + expect(subscriber.unsubscribedAt).not.toBeNull(); 299 + expect(subscriber.unsubscribedAt).toBeInstanceOf(Date); 300 + 301 + // Verify the timestamp is within the expected range 302 + if (!subscriber.unsubscribedAt) { 303 + throw new Error("Subscriber unsubscribedAt is undefined"); 304 + } 305 + 306 + // SQLite stores timestamps in seconds, so we compare at second precision 307 + const unsubscribedTime = Math.floor( 308 + subscriber.unsubscribedAt.getTime() / 1000, 309 + ); 310 + const beforeTime = Math.floor(beforeUnsubscribe.getTime() / 1000); 311 + const afterTime = Math.floor(afterUnsubscribe.getTime() / 1000); 312 + 313 + expect(unsubscribedTime).toBeGreaterThanOrEqual(beforeTime); 314 + expect(unsubscribedTime).toBeLessThanOrEqual(afterTime); 315 + }); 316 + 317 + test("Subscriber state transitions correctly through the flow", async () => { 318 + // Verify the subscriber has completed the full lifecycle 319 + const subscriber = await db.query.pageSubscriber.findFirst({ 320 + where: eq(pageSubscriber.token, unsubscribeToken), 321 + }); 322 + 323 + // Has been verified (acceptedAt is set) 324 + expect(subscriber?.acceptedAt).not.toBeNull(); 325 + 326 + // Has been unsubscribed (unsubscribedAt is set) 327 + expect(subscriber?.unsubscribedAt).not.toBeNull(); 328 + 329 + // Token is still present (for audit purposes) 330 + expect(subscriber?.token).toBe(unsubscribeToken); 331 + }); 332 + }); 333 + 334 + describe("Unsubscribed user does not receive new emails", () => { 335 + let _activeToken: string; 336 + let unsubscribedToken: string; 337 + let pendingToken: string; 338 + 339 + beforeAll(async () => { 340 + // Clean up and create multiple subscribers with different states 341 + await db 342 + .delete(pageSubscriber) 343 + .where(eq(pageSubscriber.email, "active-user@example.com")); 344 + await db 345 + .delete(pageSubscriber) 346 + .where(eq(pageSubscriber.email, "unsubscribed-user@example.com")); 347 + await db 348 + .delete(pageSubscriber) 349 + .where(eq(pageSubscriber.email, "pending-user@example.com")); 350 + 351 + // Active subscriber 352 + const active = await db 353 + .insert(pageSubscriber) 354 + .values({ 355 + pageId: testPageId, 356 + email: "active-user@example.com", 357 + token: crypto.randomUUID(), 358 + acceptedAt: new Date(), 359 + unsubscribedAt: null, 360 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 361 + }) 362 + .returning() 363 + .get(); 364 + 365 + if (!active.token) { 366 + throw new Error("Active subscriber token is undefined"); 367 + } 368 + 369 + _activeToken = active.token; 370 + 371 + // Unsubscribed subscriber 372 + const unsubscribed = await db 373 + .insert(pageSubscriber) 374 + .values({ 375 + pageId: testPageId, 376 + email: "unsubscribed-user@example.com", 377 + token: crypto.randomUUID(), 378 + acceptedAt: new Date(), 379 + unsubscribedAt: new Date(), 380 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 381 + }) 382 + .returning() 383 + .get(); 384 + 385 + if (!unsubscribed.token) { 386 + throw new Error("Unsubscribed subscriber token is undefined"); 387 + } 388 + 389 + unsubscribedToken = unsubscribed.token; 390 + 391 + // Pending (unverified) subscriber 392 + const pending = await db 393 + .insert(pageSubscriber) 394 + .values({ 395 + pageId: testPageId, 396 + email: "pending-user@example.com", 397 + token: crypto.randomUUID(), 398 + acceptedAt: null, 399 + unsubscribedAt: null, 400 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 401 + }) 402 + .returning() 403 + .get(); 404 + 405 + if (!pending.token) { 406 + throw new Error("Pending subscriber token is undefined"); 407 + } 408 + 409 + pendingToken = pending.token; 410 + }); 411 + 412 + afterAll(async () => { 413 + await db 414 + .delete(pageSubscriber) 415 + .where(eq(pageSubscriber.email, "active-user@example.com")); 416 + await db 417 + .delete(pageSubscriber) 418 + .where(eq(pageSubscriber.email, "unsubscribed-user@example.com")); 419 + await db 420 + .delete(pageSubscriber) 421 + .where(eq(pageSubscriber.email, "pending-user@example.com")); 422 + }); 423 + 424 + test("Email query returns only active subscribers with valid tokens", async () => { 425 + // This mirrors the exact query pattern used in email-sending routes 426 + const emailRecipients = await db 427 + .select({ 428 + email: pageSubscriber.email, 429 + token: pageSubscriber.token, 430 + }) 431 + .from(pageSubscriber) 432 + .where( 433 + and( 434 + eq(pageSubscriber.pageId, testPageId), 435 + isNotNull(pageSubscriber.acceptedAt), 436 + isNull(pageSubscriber.unsubscribedAt), 437 + ), 438 + ) 439 + .all(); 440 + 441 + // Should only include active subscriber 442 + expect(emailRecipients.length).toBeGreaterThanOrEqual(1); 443 + 444 + const emails = emailRecipients.map((r) => r.email); 445 + expect(emails).toContain("active-user@example.com"); 446 + expect(emails).not.toContain("unsubscribed-user@example.com"); 447 + expect(emails).not.toContain("pending-user@example.com"); 448 + }); 449 + 450 + test("Unsubscribed users are filtered out even with acceptedAt set", async () => { 451 + // Verify the unsubscribed user has acceptedAt set 452 + const unsubscribedUser = await db.query.pageSubscriber.findFirst({ 453 + where: eq(pageSubscriber.token, unsubscribedToken), 454 + }); 455 + 456 + expect(unsubscribedUser?.acceptedAt).not.toBeNull(); 457 + expect(unsubscribedUser?.unsubscribedAt).not.toBeNull(); 458 + 459 + // Query with proper filters 460 + const subscribers = await db 461 + .select() 462 + .from(pageSubscriber) 463 + .where( 464 + and( 465 + eq(pageSubscriber.pageId, testPageId), 466 + isNotNull(pageSubscriber.acceptedAt), 467 + isNull(pageSubscriber.unsubscribedAt), 468 + ), 469 + ) 470 + .all(); 471 + 472 + const foundUnsubscribed = subscribers.find( 473 + (s) => s.email === "unsubscribed-user@example.com", 474 + ); 475 + expect(foundUnsubscribed).toBeUndefined(); 476 + }); 477 + 478 + test("Pending users are filtered out (not verified)", async () => { 479 + // Verify the pending user has no acceptedAt 480 + const pendingUser = await db.query.pageSubscriber.findFirst({ 481 + where: eq(pageSubscriber.token, pendingToken), 482 + }); 483 + 484 + expect(pendingUser?.acceptedAt).toBeNull(); 485 + 486 + // Query with proper filters 487 + const subscribers = await db 488 + .select() 489 + .from(pageSubscriber) 490 + .where( 491 + and( 492 + eq(pageSubscriber.pageId, testPageId), 493 + isNotNull(pageSubscriber.acceptedAt), 494 + isNull(pageSubscriber.unsubscribedAt), 495 + ), 496 + ) 497 + .all(); 498 + 499 + const foundPending = subscribers.find( 500 + (s) => s.email === "pending-user@example.com", 501 + ); 502 + expect(foundPending).toBeUndefined(); 503 + }); 504 + 505 + test("Email recipients list includes token for unsubscribe URL generation", async () => { 506 + const emailRecipients = await db 507 + .select({ 508 + email: pageSubscriber.email, 509 + token: pageSubscriber.token, 510 + }) 511 + .from(pageSubscriber) 512 + .where( 513 + and( 514 + eq(pageSubscriber.pageId, testPageId), 515 + isNotNull(pageSubscriber.acceptedAt), 516 + isNull(pageSubscriber.unsubscribedAt), 517 + ), 518 + ) 519 + .all(); 520 + 521 + // Filter for valid tokens (as done in email sending routes) 522 + const validRecipients = emailRecipients.filter( 523 + (r): r is { email: string; token: string } => r.token !== null, 524 + ); 525 + 526 + expect(validRecipients.length).toBeGreaterThanOrEqual(1); 527 + 528 + // Each valid recipient should have a UUID token 529 + for (const recipient of validRecipients) { 530 + expect(recipient.token).toMatch( 531 + /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, 532 + ); 533 + } 534 + }); 535 + }); 536 + 537 + describe("Re-subscription after unsubscribe flow", () => { 538 + let resubscribeToken: string; 539 + 540 + beforeAll(async () => { 541 + // Clean up 542 + await db 543 + .delete(pageSubscriber) 544 + .where(eq(pageSubscriber.email, "resubscribe-test@example.com")); 545 + 546 + // Create an initially subscribed and verified user 547 + const subscriber = await db 548 + .insert(pageSubscriber) 549 + .values({ 550 + pageId: testPageId, 551 + email: "resubscribe-test@example.com", 552 + token: crypto.randomUUID(), 553 + acceptedAt: new Date(), 554 + unsubscribedAt: null, 555 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 556 + }) 557 + .returning() 558 + .get(); 559 + 560 + if (!subscriber.token) { 561 + throw new Error("Subscriber token is undefined"); 562 + } 563 + 564 + resubscribeToken = subscriber.token; 565 + }); 566 + 567 + afterAll(async () => { 568 + await db 569 + .delete(pageSubscriber) 570 + .where(eq(pageSubscriber.email, "resubscribe-test@example.com")); 571 + }); 572 + 573 + test("User can complete full subscribe -> unsubscribe -> resubscribe cycle", async () => { 574 + // Step 1: Verify initial subscription state 575 + let subscriber = await db.query.pageSubscriber.findFirst({ 576 + where: eq(pageSubscriber.email, "resubscribe-test@example.com"), 577 + }); 578 + 579 + expect(subscriber?.acceptedAt).not.toBeNull(); 580 + expect(subscriber?.unsubscribedAt).toBeNull(); 581 + 582 + // Step 2: User unsubscribes 583 + await db 584 + .update(pageSubscriber) 585 + .set({ unsubscribedAt: new Date() }) 586 + .where(eq(pageSubscriber.id, subscriber?.id)); 587 + 588 + subscriber = await db.query.pageSubscriber.findFirst({ 589 + where: eq(pageSubscriber.id, subscriber?.id), 590 + }); 591 + 592 + expect(subscriber?.unsubscribedAt).not.toBeNull(); 593 + 594 + // Step 3: User is excluded from emails 595 + const subscribersAfterUnsub = await db 596 + .select() 597 + .from(pageSubscriber) 598 + .where( 599 + and( 600 + eq(pageSubscriber.pageId, testPageId), 601 + eq(pageSubscriber.email, "resubscribe-test@example.com"), 602 + isNotNull(pageSubscriber.acceptedAt), 603 + isNull(pageSubscriber.unsubscribedAt), 604 + ), 605 + ) 606 + .all(); 607 + 608 + expect(subscribersAfterUnsub.length).toBe(0); 609 + 610 + // Step 4: User re-subscribes (simulating the re-subscription flow) 611 + const newToken = crypto.randomUUID(); 612 + await db 613 + .update(pageSubscriber) 614 + .set({ 615 + unsubscribedAt: null, 616 + acceptedAt: null, // Requires re-verification 617 + token: newToken, 618 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 619 + }) 620 + .where(eq(pageSubscriber.id, subscriber?.id)); 621 + 622 + // Step 5: User is still excluded (not yet verified) 623 + const subscribersPendingVerify = await db 624 + .select() 625 + .from(pageSubscriber) 626 + .where( 627 + and( 628 + eq(pageSubscriber.pageId, testPageId), 629 + eq(pageSubscriber.email, "resubscribe-test@example.com"), 630 + isNotNull(pageSubscriber.acceptedAt), 631 + isNull(pageSubscriber.unsubscribedAt), 632 + ), 633 + ) 634 + .all(); 635 + 636 + expect(subscribersPendingVerify.length).toBe(0); 637 + 638 + // Step 6: User verifies their email again 639 + await db 640 + .update(pageSubscriber) 641 + .set({ acceptedAt: new Date() }) 642 + .where(eq(pageSubscriber.token, newToken)); 643 + 644 + // Step 7: User is now included in email list again 645 + const subscribersAfterReverify = await db 646 + .select() 647 + .from(pageSubscriber) 648 + .where( 649 + and( 650 + eq(pageSubscriber.pageId, testPageId), 651 + eq(pageSubscriber.email, "resubscribe-test@example.com"), 652 + isNotNull(pageSubscriber.acceptedAt), 653 + isNull(pageSubscriber.unsubscribedAt), 654 + ), 655 + ) 656 + .all(); 657 + 658 + expect(subscribersAfterReverify.length).toBe(1); 659 + expect(subscribersAfterReverify[0].token).toBe(newToken); 660 + expect(subscribersAfterReverify[0].token).not.toBe(resubscribeToken); 661 + }); 662 + }); 663 + 664 + describe("Invalid token handling", () => { 665 + test("Non-existent token returns no subscriber", async () => { 666 + const fakeToken = crypto.randomUUID(); 667 + 668 + const subscriber = await db.query.pageSubscriber.findFirst({ 669 + where: eq(pageSubscriber.token, fakeToken), 670 + }); 671 + 672 + expect(subscriber).toBeUndefined(); 673 + }); 674 + 675 + test("Invalid UUID format is handled gracefully", async () => { 676 + const invalidToken = "not-a-valid-uuid"; 677 + 678 + // The database query will still work, just return no results 679 + const subscriber = await db.query.pageSubscriber.findFirst({ 680 + where: eq(pageSubscriber.token, invalidToken), 681 + }); 682 + 683 + expect(subscriber).toBeUndefined(); 684 + }); 685 + 686 + test("Already unsubscribed token returns subscriber with unsubscribedAt set", async () => { 687 + // Create an unsubscribed subscriber 688 + await db 689 + .delete(pageSubscriber) 690 + .where(eq(pageSubscriber.email, "already-unsub@example.com")); 691 + 692 + const subscriber = await db 693 + .insert(pageSubscriber) 694 + .values({ 695 + pageId: testPageId, 696 + email: "already-unsub@example.com", 697 + token: crypto.randomUUID(), 698 + acceptedAt: new Date(), 699 + unsubscribedAt: new Date(), 700 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 701 + }) 702 + .returning() 703 + .get(); 704 + 705 + if (!subscriber.token) { 706 + throw new Error("Subscriber token is undefined"); 707 + } 708 + 709 + // Query the subscriber 710 + const found = await db.query.pageSubscriber.findFirst({ 711 + where: eq(pageSubscriber.token, subscriber.token), 712 + }); 713 + 714 + expect(found).toBeDefined(); 715 + expect(found?.unsubscribedAt).not.toBeNull(); 716 + 717 + // Clean up 718 + await db 719 + .delete(pageSubscriber) 720 + .where(eq(pageSubscriber.email, "already-unsub@example.com")); 721 + }); 722 + });

+133 -4

packages/api/src/router/statusPage.ts

··· 1 1 import { z } from "zod"; 2 2 3 - import { and, eq, inArray, isNotNull, sql } from "@openstatus/db"; 3 + import { and, eq, inArray, sql } from "@openstatus/db"; 4 4 import { 5 5 maintenance, 6 6 monitorsToPages, ··· 873 873 }); 874 874 } 875 875 876 - const _alreadySubscribed = 876 + // Check for existing subscriber (active or unsubscribed) 877 + const _existingSubscriber = 877 878 await opts.ctx.db.query.pageSubscriber.findFirst({ 878 879 where: and( 879 880 eq(pageSubscriber.pageId, _page.id), 880 881 eq(pageSubscriber.email, opts.input.email), 881 - isNotNull(pageSubscriber.acceptedAt), 882 882 ), 883 883 }); 884 884 885 - if (_alreadySubscribed) { 885 + // If already subscribed and verified (not unsubscribed), reject 886 + if ( 887 + _existingSubscriber?.acceptedAt && 888 + !_existingSubscriber.unsubscribedAt 889 + ) { 886 890 throw new TRPCError({ 887 891 code: "BAD_REQUEST", 888 892 message: "Email already subscribed", 889 893 }); 890 894 } 891 895 896 + // Handle re-subscription: clear unsubscribedAt, regenerate token, reset acceptedAt 897 + if (_existingSubscriber?.unsubscribedAt) { 898 + const updatedSubscriber = await opts.ctx.db 899 + .update(pageSubscriber) 900 + .set({ 901 + unsubscribedAt: null, 902 + acceptedAt: null, 903 + token: crypto.randomUUID(), 904 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 905 + }) 906 + .where(eq(pageSubscriber.id, _existingSubscriber.id)) 907 + .returning() 908 + .get(); 909 + 910 + return updatedSubscriber.id; 911 + } 912 + 913 + // Handle pending re-subscription (not yet verified): regenerate token 914 + if (_existingSubscriber && !_existingSubscriber.acceptedAt) { 915 + const updatedSubscriber = await opts.ctx.db 916 + .update(pageSubscriber) 917 + .set({ 918 + token: crypto.randomUUID(), 919 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 920 + }) 921 + .where(eq(pageSubscriber.id, _existingSubscriber.id)) 922 + .returning() 923 + .get(); 924 + 925 + return updatedSubscriber.id; 926 + } 927 + 928 + // New subscription 892 929 const _pageSubscriber = await opts.ctx.db 893 930 .insert(pageSubscriber) 894 931 .values({ ··· 1019 1056 } 1020 1057 1021 1058 return true; 1059 + }), 1060 + 1061 + getSubscriberByToken: publicProcedure 1062 + .input( 1063 + z.object({ token: z.string().uuid(), domain: z.string().toLowerCase() }), 1064 + ) 1065 + .query(async (opts) => { 1066 + const _page = await opts.ctx.db.query.page.findFirst({ 1067 + where: sql`lower(${page.slug}) = ${opts.input.domain} OR lower(${page.customDomain}) = ${opts.input.domain}`, 1068 + }); 1069 + 1070 + if (!_page) return null; 1071 + 1072 + const _pageSubscriber = await opts.ctx.db.query.pageSubscriber.findFirst({ 1073 + where: and( 1074 + eq(pageSubscriber.token, opts.input.token), 1075 + eq(pageSubscriber.pageId, _page.id), 1076 + ), 1077 + }); 1078 + 1079 + // Return null if not found or already unsubscribed 1080 + if (!_pageSubscriber) { 1081 + return null; 1082 + } 1083 + 1084 + if (_pageSubscriber.unsubscribedAt) { 1085 + return null; 1086 + } 1087 + 1088 + // Mask email: show first character, then ***, then @domain 1089 + const email = _pageSubscriber.email; 1090 + const [localPart, domain] = email.split("@"); 1091 + const maskedEmail = 1092 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 1093 + 1094 + return { 1095 + pageName: _page.title, 1096 + maskedEmail, 1097 + }; 1098 + }), 1099 + 1100 + unsubscribe: publicProcedure 1101 + .input( 1102 + z.object({ token: z.string().uuid(), domain: z.string().toLowerCase() }), 1103 + ) 1104 + .mutation(async (opts) => { 1105 + const _page = await opts.ctx.db.query.page.findFirst({ 1106 + where: sql`lower(${page.slug}) = ${opts.input.domain} OR lower(${page.customDomain}) = ${opts.input.domain}`, 1107 + }); 1108 + 1109 + if (!_page) return null; 1110 + 1111 + const _pageSubscriber = await opts.ctx.db.query.pageSubscriber.findFirst({ 1112 + where: and( 1113 + eq(pageSubscriber.token, opts.input.token), 1114 + eq(pageSubscriber.pageId, _page.id), 1115 + ), 1116 + }); 1117 + 1118 + if (!_pageSubscriber) { 1119 + throw new TRPCError({ 1120 + code: "NOT_FOUND", 1121 + message: "Subscription not found", 1122 + }); 1123 + } 1124 + 1125 + if (!_pageSubscriber.acceptedAt) { 1126 + throw new TRPCError({ 1127 + code: "BAD_REQUEST", 1128 + message: "Subscription not yet verified", 1129 + }); 1130 + } 1131 + 1132 + if (_pageSubscriber.unsubscribedAt) { 1133 + throw new TRPCError({ 1134 + code: "BAD_REQUEST", 1135 + message: "Already unsubscribed", 1136 + }); 1137 + } 1138 + 1139 + await opts.ctx.db 1140 + .update(pageSubscriber) 1141 + .set({ 1142 + unsubscribedAt: new Date(), 1143 + }) 1144 + .where(eq(pageSubscriber.id, _pageSubscriber.id)) 1145 + .execute(); 1146 + 1147 + return { 1148 + success: true, 1149 + pageName: _page.title, 1150 + }; 1022 1151 }), 1023 1152 });

+298

packages/api/src/router/statusPage.unsubscribe.test.ts

··· 1 + import { afterAll, beforeAll, describe, expect, test } from "bun:test"; 2 + 3 + import { db, eq } from "@openstatus/db"; 4 + import { page, pageSubscriber } from "@openstatus/db/src/schema"; 5 + 6 + // Test data setup 7 + let testPageId: number; 8 + let _testSubscriberId: number; 9 + let testToken: string; 10 + const testWorkspaceId = 1; // Use existing test workspace from seed data 11 + 12 + beforeAll(async () => { 13 + // Clean up any existing test data 14 + await db 15 + .delete(pageSubscriber) 16 + .where(eq(pageSubscriber.email, "test-unsubscribe@example.com")); 17 + await db 18 + .delete(pageSubscriber) 19 + .where(eq(pageSubscriber.email, "test-unsubscribe-2@example.com")); 20 + await db 21 + .delete(pageSubscriber) 22 + .where(eq(pageSubscriber.email, "test-unsubscribe-3@example.com")); 23 + await db 24 + .delete(pageSubscriber) 25 + .where(eq(pageSubscriber.email, "test-unsubscribe-4@example.com")); 26 + await db.delete(page).where(eq(page.slug, "test-unsubscribe-page")); 27 + 28 + // Create a test page 29 + const testPage = await db 30 + .insert(page) 31 + .values({ 32 + workspaceId: testWorkspaceId, 33 + title: "Test Unsubscribe Page", 34 + description: "A test page for unsubscribe tests", 35 + slug: "test-unsubscribe-page", 36 + customDomain: "", 37 + }) 38 + .returning() 39 + .get(); 40 + 41 + testPageId = testPage.id; 42 + 43 + // Create a verified subscriber for testing 44 + testToken = crypto.randomUUID(); 45 + const subscriber = await db 46 + .insert(pageSubscriber) 47 + .values({ 48 + pageId: testPageId, 49 + email: "test-unsubscribe@example.com", 50 + token: testToken, 51 + acceptedAt: new Date(), 52 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 53 + }) 54 + .returning() 55 + .get(); 56 + 57 + _testSubscriberId = subscriber.id; 58 + }); 59 + 60 + afterAll(async () => { 61 + // Clean up test data 62 + await db 63 + .delete(pageSubscriber) 64 + .where(eq(pageSubscriber.email, "test-unsubscribe@example.com")); 65 + await db 66 + .delete(pageSubscriber) 67 + .where(eq(pageSubscriber.email, "test-unsubscribe-2@example.com")); 68 + await db 69 + .delete(pageSubscriber) 70 + .where(eq(pageSubscriber.email, "test-unsubscribe-3@example.com")); 71 + await db 72 + .delete(pageSubscriber) 73 + .where(eq(pageSubscriber.email, "test-unsubscribe-4@example.com")); 74 + await db.delete(page).where(eq(page.slug, "test-unsubscribe-page")); 75 + }); 76 + 77 + describe("getSubscriberByToken", () => { 78 + test("should return subscriber info with masked email for valid token", async () => { 79 + const subscriber = await db.query.pageSubscriber.findFirst({ 80 + where: eq(pageSubscriber.token, testToken), 81 + with: { page: true }, 82 + }); 83 + 84 + expect(subscriber).toBeDefined(); 85 + expect(subscriber?.page.title).toBe("Test Unsubscribe Page"); 86 + 87 + // Manually mask the email to test the masking logic 88 + const email = subscriber?.email; 89 + const [localPart, domain] = email.split("@"); 90 + const maskedEmail = 91 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 92 + 93 + expect(maskedEmail).toBe("t***@example.com"); 94 + }); 95 + 96 + test("should return null for non-existent token", async () => { 97 + const nonExistentToken = crypto.randomUUID(); 98 + const subscriber = await db.query.pageSubscriber.findFirst({ 99 + where: eq(pageSubscriber.token, nonExistentToken), 100 + }); 101 + 102 + expect(subscriber).toBeUndefined(); 103 + }); 104 + 105 + test("should return null for already unsubscribed user", async () => { 106 + // Create an unsubscribed subscriber 107 + const unsubscribedToken = crypto.randomUUID(); 108 + await db.insert(pageSubscriber).values({ 109 + pageId: testPageId, 110 + email: "test-unsubscribe-2@example.com", 111 + token: unsubscribedToken, 112 + acceptedAt: new Date(), 113 + unsubscribedAt: new Date(), 114 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 115 + }); 116 + 117 + const subscriber = await db.query.pageSubscriber.findFirst({ 118 + where: eq(pageSubscriber.token, unsubscribedToken), 119 + }); 120 + 121 + expect(subscriber).toBeDefined(); 122 + expect(subscriber?.unsubscribedAt).not.toBeNull(); 123 + }); 124 + 125 + test("should properly mask emails with single character local part", async () => { 126 + const email = "a@example.com"; 127 + const [localPart, domain] = email.split("@"); 128 + const maskedEmail = 129 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 130 + 131 + expect(maskedEmail).toBe("a***@example.com"); 132 + }); 133 + 134 + test("should properly mask emails with long local part", async () => { 135 + const email = "verylongemail@example.com"; 136 + const [localPart, domain] = email.split("@"); 137 + const maskedEmail = 138 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 139 + 140 + expect(maskedEmail).toBe("v***@example.com"); 141 + }); 142 + }); 143 + 144 + describe("unsubscribe mutation", () => { 145 + test("should unsubscribe a verified subscriber successfully", async () => { 146 + // Create a fresh subscriber for this test 147 + const newToken = crypto.randomUUID(); 148 + const newSubscriber = await db 149 + .insert(pageSubscriber) 150 + .values({ 151 + pageId: testPageId, 152 + email: "test-unsubscribe-3@example.com", 153 + token: newToken, 154 + acceptedAt: new Date(), 155 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 156 + }) 157 + .returning() 158 + .get(); 159 + 160 + // Simulate unsubscribe operation 161 + await db 162 + .update(pageSubscriber) 163 + .set({ unsubscribedAt: new Date() }) 164 + .where(eq(pageSubscriber.id, newSubscriber.id)); 165 + 166 + // Verify unsubscribed 167 + const updatedSubscriber = await db.query.pageSubscriber.findFirst({ 168 + where: eq(pageSubscriber.id, newSubscriber.id), 169 + }); 170 + 171 + expect(updatedSubscriber?.unsubscribedAt).not.toBeNull(); 172 + expect(updatedSubscriber?.unsubscribedAt).toBeInstanceOf(Date); 173 + }); 174 + 175 + test("should fail for non-existent token", async () => { 176 + const nonExistentToken = crypto.randomUUID(); 177 + const subscriber = await db.query.pageSubscriber.findFirst({ 178 + where: eq(pageSubscriber.token, nonExistentToken), 179 + }); 180 + 181 + expect(subscriber).toBeUndefined(); 182 + }); 183 + 184 + test("should fail for unverified subscriber", async () => { 185 + // Create an unverified subscriber 186 + const unverifiedToken = crypto.randomUUID(); 187 + const unverifiedSubscriber = await db 188 + .insert(pageSubscriber) 189 + .values({ 190 + pageId: testPageId, 191 + email: "test-unsubscribe-4@example.com", 192 + token: unverifiedToken, 193 + acceptedAt: null, // Not verified 194 + expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), 195 + }) 196 + .returning() 197 + .get(); 198 + 199 + expect(unverifiedSubscriber.acceptedAt).toBeNull(); 200 + }); 201 + 202 + test("should fail for already unsubscribed user", async () => { 203 + // Get the unsubscribed subscriber from earlier test 204 + const unsubscribedSubscriber = await db.query.pageSubscriber.findFirst({ 205 + where: eq(pageSubscriber.email, "test-unsubscribe-2@example.com"), 206 + }); 207 + 208 + expect(unsubscribedSubscriber).toBeDefined(); 209 + expect(unsubscribedSubscriber?.unsubscribedAt).not.toBeNull(); 210 + }); 211 + 212 + test("should set unsubscribedAt to current timestamp", async () => { 213 + const beforeUnsubscribe = new Date(); 214 + 215 + // Get subscriber and unsubscribe 216 + const subscriber = await db.query.pageSubscriber.findFirst({ 217 + where: eq(pageSubscriber.email, "test-unsubscribe-3@example.com"), 218 + }); 219 + 220 + if (subscriber) { 221 + await db 222 + .update(pageSubscriber) 223 + .set({ unsubscribedAt: new Date() }) 224 + .where(eq(pageSubscriber.id, subscriber.id)); 225 + 226 + const updatedSubscriber = await db.query.pageSubscriber.findFirst({ 227 + where: eq(pageSubscriber.id, subscriber.id), 228 + }); 229 + 230 + const afterUnsubscribe = new Date(); 231 + 232 + expect(updatedSubscriber?.unsubscribedAt).toBeDefined(); 233 + expect( 234 + updatedSubscriber?.unsubscribedAt?.getTime(), 235 + ).toBeGreaterThanOrEqual(beforeUnsubscribe.getTime() - 1000); 236 + expect(updatedSubscriber?.unsubscribedAt?.getTime()).toBeLessThanOrEqual( 237 + afterUnsubscribe.getTime() + 1000, 238 + ); 239 + } 240 + }); 241 + }); 242 + 243 + describe("email masking logic", () => { 244 + test("should mask email j***@example.com correctly", () => { 245 + const email = "john@example.com"; 246 + const [localPart, domain] = email.split("@"); 247 + const maskedEmail = 248 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 249 + 250 + expect(maskedEmail).toBe("j***@example.com"); 251 + }); 252 + 253 + test("should handle empty local part gracefully", () => { 254 + // Edge case: if somehow we have @domain only 255 + const email = "@example.com"; 256 + const [localPart, domain] = email.split("@"); 257 + const maskedEmail = 258 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 259 + 260 + expect(maskedEmail).toBe("***@example.com"); 261 + }); 262 + 263 + test("should preserve domain in masked email", () => { 264 + const email = "user@custom-domain.io"; 265 + const [localPart, domain] = email.split("@"); 266 + const maskedEmail = 267 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 268 + 269 + expect(maskedEmail).toBe("u***@custom-domain.io"); 270 + }); 271 + 272 + test("should handle complex domain", () => { 273 + const email = "test@subdomain.example.co.uk"; 274 + const [localPart, domain] = email.split("@"); 275 + const maskedEmail = 276 + localPart.length > 0 ? `${localPart[0]}***@${domain}` : `***@${domain}`; 277 + 278 + expect(maskedEmail).toBe("t***@subdomain.example.co.uk"); 279 + }); 280 + }); 281 + 282 + describe("token validation", () => { 283 + test("should validate UUID format for token", () => { 284 + const validToken = crypto.randomUUID(); 285 + const uuidRegex = 286 + /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; 287 + 288 + expect(validToken).toMatch(uuidRegex); 289 + }); 290 + 291 + test("should reject invalid UUID format", () => { 292 + const invalidToken = "not-a-valid-uuid"; 293 + const uuidRegex = 294 + /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; 295 + 296 + expect(invalidToken).not.toMatch(uuidRegex); 297 + }); 298 + });

+1

packages/db/drizzle/0053_groovy_doctor_strange.sql

··· 1 + ALTER TABLE `page_subscriber` ADD `unsubscribed_at` integer;

+3078

packages/db/drizzle/meta/0053_snapshot.json

··· 1 + { 2 + "version": "6", 3 + "dialect": "sqlite", 4 + "id": "cf9ebf5a-5a27-455a-8542-1441972faa63", 5 + "prevId": "cc596587-5474-42a7-b638-1b7c771fbc5e", 6 + "tables": { 7 + "workspace": { 8 + "name": "workspace", 9 + "columns": { 10 + "id": { 11 + "name": "id", 12 + "type": "integer", 13 + "primaryKey": true, 14 + "notNull": true, 15 + "autoincrement": false 16 + }, 17 + "slug": { 18 + "name": "slug", 19 + "type": "text", 20 + "primaryKey": false, 21 + "notNull": true, 22 + "autoincrement": false 23 + }, 24 + "name": { 25 + "name": "name", 26 + "type": "text", 27 + "primaryKey": false, 28 + "notNull": false, 29 + "autoincrement": false 30 + }, 31 + "stripe_id": { 32 + "name": "stripe_id", 33 + "type": "text(256)", 34 + "primaryKey": false, 35 + "notNull": false, 36 + "autoincrement": false 37 + }, 38 + "subscription_id": { 39 + "name": "subscription_id", 40 + "type": "text", 41 + "primaryKey": false, 42 + "notNull": false, 43 + "autoincrement": false 44 + }, 45 + "plan": { 46 + "name": "plan", 47 + "type": "text", 48 + "primaryKey": false, 49 + "notNull": false, 50 + "autoincrement": false 51 + }, 52 + "ends_at": { 53 + "name": "ends_at", 54 + "type": "integer", 55 + "primaryKey": false, 56 + "notNull": false, 57 + "autoincrement": false 58 + }, 59 + "paid_until": { 60 + "name": "paid_until", 61 + "type": "integer", 62 + "primaryKey": false, 63 + "notNull": false, 64 + "autoincrement": false 65 + }, 66 + "limits": { 67 + "name": "limits", 68 + "type": "text", 69 + "primaryKey": false, 70 + "notNull": true, 71 + "autoincrement": false, 72 + "default": "'{}'" 73 + }, 74 + "created_at": { 75 + "name": "created_at", 76 + "type": "integer", 77 + "primaryKey": false, 78 + "notNull": false, 79 + "autoincrement": false, 80 + "default": "(strftime('%s', 'now'))" 81 + }, 82 + "updated_at": { 83 + "name": "updated_at", 84 + "type": "integer", 85 + "primaryKey": false, 86 + "notNull": false, 87 + "autoincrement": false, 88 + "default": "(strftime('%s', 'now'))" 89 + }, 90 + "dsn": { 91 + "name": "dsn", 92 + "type": "text", 93 + "primaryKey": false, 94 + "notNull": false, 95 + "autoincrement": false 96 + } 97 + }, 98 + "indexes": { 99 + "workspace_slug_unique": { 100 + "name": "workspace_slug_unique", 101 + "columns": [ 102 + "slug" 103 + ], 104 + "isUnique": true 105 + }, 106 + "workspace_stripe_id_unique": { 107 + "name": "workspace_stripe_id_unique", 108 + "columns": [ 109 + "stripe_id" 110 + ], 111 + "isUnique": true 112 + }, 113 + "workspace_id_dsn_unique": { 114 + "name": "workspace_id_dsn_unique", 115 + "columns": [ 116 + "id", 117 + "dsn" 118 + ], 119 + "isUnique": true 120 + } 121 + }, 122 + "foreignKeys": {}, 123 + "compositePrimaryKeys": {}, 124 + "uniqueConstraints": {}, 125 + "checkConstraints": {} 126 + }, 127 + "account": { 128 + "name": "account", 129 + "columns": { 130 + "user_id": { 131 + "name": "user_id", 132 + "type": "integer", 133 + "primaryKey": false, 134 + "notNull": true, 135 + "autoincrement": false 136 + }, 137 + "type": { 138 + "name": "type", 139 + "type": "text", 140 + "primaryKey": false, 141 + "notNull": true, 142 + "autoincrement": false 143 + }, 144 + "provider": { 145 + "name": "provider", 146 + "type": "text", 147 + "primaryKey": false, 148 + "notNull": true, 149 + "autoincrement": false 150 + }, 151 + "provider_account_id": { 152 + "name": "provider_account_id", 153 + "type": "text", 154 + "primaryKey": false, 155 + "notNull": true, 156 + "autoincrement": false 157 + }, 158 + "refresh_token": { 159 + "name": "refresh_token", 160 + "type": "text", 161 + "primaryKey": false, 162 + "notNull": false, 163 + "autoincrement": false 164 + }, 165 + "access_token": { 166 + "name": "access_token", 167 + "type": "text", 168 + "primaryKey": false, 169 + "notNull": false, 170 + "autoincrement": false 171 + }, 172 + "expires_at": { 173 + "name": "expires_at", 174 + "type": "integer", 175 + "primaryKey": false, 176 + "notNull": false, 177 + "autoincrement": false 178 + }, 179 + "token_type": { 180 + "name": "token_type", 181 + "type": "text", 182 + "primaryKey": false, 183 + "notNull": false, 184 + "autoincrement": false 185 + }, 186 + "scope": { 187 + "name": "scope", 188 + "type": "text", 189 + "primaryKey": false, 190 + "notNull": false, 191 + "autoincrement": false 192 + }, 193 + "id_token": { 194 + "name": "id_token", 195 + "type": "text", 196 + "primaryKey": false, 197 + "notNull": false, 198 + "autoincrement": false 199 + }, 200 + "session_state": { 201 + "name": "session_state", 202 + "type": "text", 203 + "primaryKey": false, 204 + "notNull": false, 205 + "autoincrement": false 206 + } 207 + }, 208 + "indexes": {}, 209 + "foreignKeys": { 210 + "account_user_id_user_id_fk": { 211 + "name": "account_user_id_user_id_fk", 212 + "tableFrom": "account", 213 + "tableTo": "user", 214 + "columnsFrom": [ 215 + "user_id" 216 + ], 217 + "columnsTo": [ 218 + "id" 219 + ], 220 + "onDelete": "cascade", 221 + "onUpdate": "no action" 222 + } 223 + }, 224 + "compositePrimaryKeys": { 225 + "account_provider_provider_account_id_pk": { 226 + "columns": [ 227 + "provider", 228 + "provider_account_id" 229 + ], 230 + "name": "account_provider_provider_account_id_pk" 231 + } 232 + }, 233 + "uniqueConstraints": {}, 234 + "checkConstraints": {} 235 + }, 236 + "session": { 237 + "name": "session", 238 + "columns": { 239 + "session_token": { 240 + "name": "session_token", 241 + "type": "text", 242 + "primaryKey": true, 243 + "notNull": true, 244 + "autoincrement": false 245 + }, 246 + "user_id": { 247 + "name": "user_id", 248 + "type": "integer", 249 + "primaryKey": false, 250 + "notNull": true, 251 + "autoincrement": false 252 + }, 253 + "expires": { 254 + "name": "expires", 255 + "type": "integer", 256 + "primaryKey": false, 257 + "notNull": true, 258 + "autoincrement": false 259 + } 260 + }, 261 + "indexes": {}, 262 + "foreignKeys": { 263 + "session_user_id_user_id_fk": { 264 + "name": "session_user_id_user_id_fk", 265 + "tableFrom": "session", 266 + "tableTo": "user", 267 + "columnsFrom": [ 268 + "user_id" 269 + ], 270 + "columnsTo": [ 271 + "id" 272 + ], 273 + "onDelete": "cascade", 274 + "onUpdate": "no action" 275 + } 276 + }, 277 + "compositePrimaryKeys": {}, 278 + "uniqueConstraints": {}, 279 + "checkConstraints": {} 280 + }, 281 + "user": { 282 + "name": "user", 283 + "columns": { 284 + "id": { 285 + "name": "id", 286 + "type": "integer", 287 + "primaryKey": true, 288 + "notNull": true, 289 + "autoincrement": false 290 + }, 291 + "tenant_id": { 292 + "name": "tenant_id", 293 + "type": "text(256)", 294 + "primaryKey": false, 295 + "notNull": false, 296 + "autoincrement": false 297 + }, 298 + "first_name": { 299 + "name": "first_name", 300 + "type": "text", 301 + "primaryKey": false, 302 + "notNull": false, 303 + "autoincrement": false, 304 + "default": "''" 305 + }, 306 + "last_name": { 307 + "name": "last_name", 308 + "type": "text", 309 + "primaryKey": false, 310 + "notNull": false, 311 + "autoincrement": false, 312 + "default": "''" 313 + }, 314 + "photo_url": { 315 + "name": "photo_url", 316 + "type": "text", 317 + "primaryKey": false, 318 + "notNull": false, 319 + "autoincrement": false, 320 + "default": "''" 321 + }, 322 + "name": { 323 + "name": "name", 324 + "type": "text", 325 + "primaryKey": false, 326 + "notNull": false, 327 + "autoincrement": false 328 + }, 329 + "email": { 330 + "name": "email", 331 + "type": "text", 332 + "primaryKey": false, 333 + "notNull": false, 334 + "autoincrement": false, 335 + "default": "''" 336 + }, 337 + "emailVerified": { 338 + "name": "emailVerified", 339 + "type": "integer", 340 + "primaryKey": false, 341 + "notNull": false, 342 + "autoincrement": false 343 + }, 344 + "created_at": { 345 + "name": "created_at", 346 + "type": "integer", 347 + "primaryKey": false, 348 + "notNull": false, 349 + "autoincrement": false, 350 + "default": "(strftime('%s', 'now'))" 351 + }, 352 + "updated_at": { 353 + "name": "updated_at", 354 + "type": "integer", 355 + "primaryKey": false, 356 + "notNull": false, 357 + "autoincrement": false, 358 + "default": "(strftime('%s', 'now'))" 359 + } 360 + }, 361 + "indexes": { 362 + "user_tenant_id_unique": { 363 + "name": "user_tenant_id_unique", 364 + "columns": [ 365 + "tenant_id" 366 + ], 367 + "isUnique": true 368 + } 369 + }, 370 + "foreignKeys": {}, 371 + "compositePrimaryKeys": {}, 372 + "uniqueConstraints": {}, 373 + "checkConstraints": {} 374 + }, 375 + "users_to_workspaces": { 376 + "name": "users_to_workspaces", 377 + "columns": { 378 + "user_id": { 379 + "name": "user_id", 380 + "type": "integer", 381 + "primaryKey": false, 382 + "notNull": true, 383 + "autoincrement": false 384 + }, 385 + "workspace_id": { 386 + "name": "workspace_id", 387 + "type": "integer", 388 + "primaryKey": false, 389 + "notNull": true, 390 + "autoincrement": false 391 + }, 392 + "role": { 393 + "name": "role", 394 + "type": "text", 395 + "primaryKey": false, 396 + "notNull": true, 397 + "autoincrement": false, 398 + "default": "'member'" 399 + }, 400 + "created_at": { 401 + "name": "created_at", 402 + "type": "integer", 403 + "primaryKey": false, 404 + "notNull": false, 405 + "autoincrement": false, 406 + "default": "(strftime('%s', 'now'))" 407 + } 408 + }, 409 + "indexes": {}, 410 + "foreignKeys": { 411 + "users_to_workspaces_user_id_user_id_fk": { 412 + "name": "users_to_workspaces_user_id_user_id_fk", 413 + "tableFrom": "users_to_workspaces", 414 + "tableTo": "user", 415 + "columnsFrom": [ 416 + "user_id" 417 + ], 418 + "columnsTo": [ 419 + "id" 420 + ], 421 + "onDelete": "no action", 422 + "onUpdate": "no action" 423 + }, 424 + "users_to_workspaces_workspace_id_workspace_id_fk": { 425 + "name": "users_to_workspaces_workspace_id_workspace_id_fk", 426 + "tableFrom": "users_to_workspaces", 427 + "tableTo": "workspace", 428 + "columnsFrom": [ 429 + "workspace_id" 430 + ], 431 + "columnsTo": [ 432 + "id" 433 + ], 434 + "onDelete": "no action", 435 + "onUpdate": "no action" 436 + } 437 + }, 438 + "compositePrimaryKeys": { 439 + "users_to_workspaces_user_id_workspace_id_pk": { 440 + "columns": [ 441 + "user_id", 442 + "workspace_id" 443 + ], 444 + "name": "users_to_workspaces_user_id_workspace_id_pk" 445 + } 446 + }, 447 + "uniqueConstraints": {}, 448 + "checkConstraints": {} 449 + }, 450 + "verification_token": { 451 + "name": "verification_token", 452 + "columns": { 453 + "identifier": { 454 + "name": "identifier", 455 + "type": "text", 456 + "primaryKey": false, 457 + "notNull": true, 458 + "autoincrement": false 459 + }, 460 + "token": { 461 + "name": "token", 462 + "type": "text", 463 + "primaryKey": false, 464 + "notNull": true, 465 + "autoincrement": false 466 + }, 467 + "expires": { 468 + "name": "expires", 469 + "type": "integer", 470 + "primaryKey": false, 471 + "notNull": true, 472 + "autoincrement": false 473 + } 474 + }, 475 + "indexes": {}, 476 + "foreignKeys": {}, 477 + "compositePrimaryKeys": { 478 + "verification_token_identifier_token_pk": { 479 + "columns": [ 480 + "identifier", 481 + "token" 482 + ], 483 + "name": "verification_token_identifier_token_pk" 484 + } 485 + }, 486 + "uniqueConstraints": {}, 487 + "checkConstraints": {} 488 + }, 489 + "status_report_to_monitors": { 490 + "name": "status_report_to_monitors", 491 + "columns": { 492 + "monitor_id": { 493 + "name": "monitor_id", 494 + "type": "integer", 495 + "primaryKey": false, 496 + "notNull": true, 497 + "autoincrement": false 498 + }, 499 + "status_report_id": { 500 + "name": "status_report_id", 501 + "type": "integer", 502 + "primaryKey": false, 503 + "notNull": true, 504 + "autoincrement": false 505 + }, 506 + "created_at": { 507 + "name": "created_at", 508 + "type": "integer", 509 + "primaryKey": false, 510 + "notNull": false, 511 + "autoincrement": false, 512 + "default": "(strftime('%s', 'now'))" 513 + } 514 + }, 515 + "indexes": {}, 516 + "foreignKeys": { 517 + "status_report_to_monitors_monitor_id_monitor_id_fk": { 518 + "name": "status_report_to_monitors_monitor_id_monitor_id_fk", 519 + "tableFrom": "status_report_to_monitors", 520 + "tableTo": "monitor", 521 + "columnsFrom": [ 522 + "monitor_id" 523 + ], 524 + "columnsTo": [ 525 + "id" 526 + ], 527 + "onDelete": "cascade", 528 + "onUpdate": "no action" 529 + }, 530 + "status_report_to_monitors_status_report_id_status_report_id_fk": { 531 + "name": "status_report_to_monitors_status_report_id_status_report_id_fk", 532 + "tableFrom": "status_report_to_monitors", 533 + "tableTo": "status_report", 534 + "columnsFrom": [ 535 + "status_report_id" 536 + ], 537 + "columnsTo": [ 538 + "id" 539 + ], 540 + "onDelete": "cascade", 541 + "onUpdate": "no action" 542 + } 543 + }, 544 + "compositePrimaryKeys": { 545 + "status_report_to_monitors_monitor_id_status_report_id_pk": { 546 + "columns": [ 547 + "monitor_id", 548 + "status_report_id" 549 + ], 550 + "name": "status_report_to_monitors_monitor_id_status_report_id_pk" 551 + } 552 + }, 553 + "uniqueConstraints": {}, 554 + "checkConstraints": {} 555 + }, 556 + "status_report": { 557 + "name": "status_report", 558 + "columns": { 559 + "id": { 560 + "name": "id", 561 + "type": "integer", 562 + "primaryKey": true, 563 + "notNull": true, 564 + "autoincrement": false 565 + }, 566 + "status": { 567 + "name": "status", 568 + "type": "text", 569 + "primaryKey": false, 570 + "notNull": true, 571 + "autoincrement": false 572 + }, 573 + "title": { 574 + "name": "title", 575 + "type": "text(256)", 576 + "primaryKey": false, 577 + "notNull": true, 578 + "autoincrement": false 579 + }, 580 + "workspace_id": { 581 + "name": "workspace_id", 582 + "type": "integer", 583 + "primaryKey": false, 584 + "notNull": false, 585 + "autoincrement": false 586 + }, 587 + "page_id": { 588 + "name": "page_id", 589 + "type": "integer", 590 + "primaryKey": false, 591 + "notNull": false, 592 + "autoincrement": false 593 + }, 594 + "created_at": { 595 + "name": "created_at", 596 + "type": "integer", 597 + "primaryKey": false, 598 + "notNull": false, 599 + "autoincrement": false, 600 + "default": "(strftime('%s', 'now'))" 601 + }, 602 + "updated_at": { 603 + "name": "updated_at", 604 + "type": "integer", 605 + "primaryKey": false, 606 + "notNull": false, 607 + "autoincrement": false, 608 + "default": "(strftime('%s', 'now'))" 609 + } 610 + }, 611 + "indexes": {}, 612 + "foreignKeys": { 613 + "status_report_workspace_id_workspace_id_fk": { 614 + "name": "status_report_workspace_id_workspace_id_fk", 615 + "tableFrom": "status_report", 616 + "tableTo": "workspace", 617 + "columnsFrom": [ 618 + "workspace_id" 619 + ], 620 + "columnsTo": [ 621 + "id" 622 + ], 623 + "onDelete": "no action", 624 + "onUpdate": "no action" 625 + }, 626 + "status_report_page_id_page_id_fk": { 627 + "name": "status_report_page_id_page_id_fk", 628 + "tableFrom": "status_report", 629 + "tableTo": "page", 630 + "columnsFrom": [ 631 + "page_id" 632 + ], 633 + "columnsTo": [ 634 + "id" 635 + ], 636 + "onDelete": "cascade", 637 + "onUpdate": "no action" 638 + } 639 + }, 640 + "compositePrimaryKeys": {}, 641 + "uniqueConstraints": {}, 642 + "checkConstraints": {} 643 + }, 644 + "status_report_update": { 645 + "name": "status_report_update", 646 + "columns": { 647 + "id": { 648 + "name": "id", 649 + "type": "integer", 650 + "primaryKey": true, 651 + "notNull": true, 652 + "autoincrement": false 653 + }, 654 + "status": { 655 + "name": "status", 656 + "type": "text", 657 + "primaryKey": false, 658 + "notNull": true, 659 + "autoincrement": false 660 + }, 661 + "date": { 662 + "name": "date", 663 + "type": "integer", 664 + "primaryKey": false, 665 + "notNull": true, 666 + "autoincrement": false 667 + }, 668 + "message": { 669 + "name": "message", 670 + "type": "text", 671 + "primaryKey": false, 672 + "notNull": true, 673 + "autoincrement": false 674 + }, 675 + "status_report_id": { 676 + "name": "status_report_id", 677 + "type": "integer", 678 + "primaryKey": false, 679 + "notNull": true, 680 + "autoincrement": false 681 + }, 682 + "created_at": { 683 + "name": "created_at", 684 + "type": "integer", 685 + "primaryKey": false, 686 + "notNull": false, 687 + "autoincrement": false, 688 + "default": "(strftime('%s', 'now'))" 689 + }, 690 + "updated_at": { 691 + "name": "updated_at", 692 + "type": "integer", 693 + "primaryKey": false, 694 + "notNull": false, 695 + "autoincrement": false, 696 + "default": "(strftime('%s', 'now'))" 697 + } 698 + }, 699 + "indexes": {}, 700 + "foreignKeys": { 701 + "status_report_update_status_report_id_status_report_id_fk": { 702 + "name": "status_report_update_status_report_id_status_report_id_fk", 703 + "tableFrom": "status_report_update", 704 + "tableTo": "status_report", 705 + "columnsFrom": [ 706 + "status_report_id" 707 + ], 708 + "columnsTo": [ 709 + "id" 710 + ], 711 + "onDelete": "cascade", 712 + "onUpdate": "no action" 713 + } 714 + }, 715 + "compositePrimaryKeys": {}, 716 + "uniqueConstraints": {}, 717 + "checkConstraints": {} 718 + }, 719 + "integration": { 720 + "name": "integration", 721 + "columns": { 722 + "id": { 723 + "name": "id", 724 + "type": "integer", 725 + "primaryKey": true, 726 + "notNull": true, 727 + "autoincrement": false 728 + }, 729 + "name": { 730 + "name": "name", 731 + "type": "text(256)", 732 + "primaryKey": false, 733 + "notNull": true, 734 + "autoincrement": false 735 + }, 736 + "workspace_id": { 737 + "name": "workspace_id", 738 + "type": "integer", 739 + "primaryKey": false, 740 + "notNull": false, 741 + "autoincrement": false 742 + }, 743 + "credential": { 744 + "name": "credential", 745 + "type": "text", 746 + "primaryKey": false, 747 + "notNull": false, 748 + "autoincrement": false 749 + }, 750 + "external_id": { 751 + "name": "external_id", 752 + "type": "text", 753 + "primaryKey": false, 754 + "notNull": true, 755 + "autoincrement": false 756 + }, 757 + "created_at": { 758 + "name": "created_at", 759 + "type": "integer", 760 + "primaryKey": false, 761 + "notNull": false, 762 + "autoincrement": false, 763 + "default": "(strftime('%s', 'now'))" 764 + }, 765 + "updated_at": { 766 + "name": "updated_at", 767 + "type": "integer", 768 + "primaryKey": false, 769 + "notNull": false, 770 + "autoincrement": false, 771 + "default": "(strftime('%s', 'now'))" 772 + }, 773 + "data": { 774 + "name": "data", 775 + "type": "text", 776 + "primaryKey": false, 777 + "notNull": true, 778 + "autoincrement": false 779 + } 780 + }, 781 + "indexes": {}, 782 + "foreignKeys": { 783 + "integration_workspace_id_workspace_id_fk": { 784 + "name": "integration_workspace_id_workspace_id_fk", 785 + "tableFrom": "integration", 786 + "tableTo": "workspace", 787 + "columnsFrom": [ 788 + "workspace_id" 789 + ], 790 + "columnsTo": [ 791 + "id" 792 + ], 793 + "onDelete": "no action", 794 + "onUpdate": "no action" 795 + } 796 + }, 797 + "compositePrimaryKeys": {}, 798 + "uniqueConstraints": {}, 799 + "checkConstraints": {} 800 + }, 801 + "page": { 802 + "name": "page", 803 + "columns": { 804 + "id": { 805 + "name": "id", 806 + "type": "integer", 807 + "primaryKey": true, 808 + "notNull": true, 809 + "autoincrement": false 810 + }, 811 + "workspace_id": { 812 + "name": "workspace_id", 813 + "type": "integer", 814 + "primaryKey": false, 815 + "notNull": true, 816 + "autoincrement": false 817 + }, 818 + "title": { 819 + "name": "title", 820 + "type": "text", 821 + "primaryKey": false, 822 + "notNull": true, 823 + "autoincrement": false 824 + }, 825 + "description": { 826 + "name": "description", 827 + "type": "text", 828 + "primaryKey": false, 829 + "notNull": true, 830 + "autoincrement": false 831 + }, 832 + "icon": { 833 + "name": "icon", 834 + "type": "text(256)", 835 + "primaryKey": false, 836 + "notNull": false, 837 + "autoincrement": false, 838 + "default": "''" 839 + }, 840 + "slug": { 841 + "name": "slug", 842 + "type": "text(256)", 843 + "primaryKey": false, 844 + "notNull": true, 845 + "autoincrement": false 846 + }, 847 + "custom_domain": { 848 + "name": "custom_domain", 849 + "type": "text(256)", 850 + "primaryKey": false, 851 + "notNull": true, 852 + "autoincrement": false 853 + }, 854 + "published": { 855 + "name": "published", 856 + "type": "integer", 857 + "primaryKey": false, 858 + "notNull": false, 859 + "autoincrement": false, 860 + "default": false 861 + }, 862 + "force_theme": { 863 + "name": "force_theme", 864 + "type": "text", 865 + "primaryKey": false, 866 + "notNull": true, 867 + "autoincrement": false, 868 + "default": "'system'" 869 + }, 870 + "password": { 871 + "name": "password", 872 + "type": "text(256)", 873 + "primaryKey": false, 874 + "notNull": false, 875 + "autoincrement": false 876 + }, 877 + "password_protected": { 878 + "name": "password_protected", 879 + "type": "integer", 880 + "primaryKey": false, 881 + "notNull": false, 882 + "autoincrement": false, 883 + "default": false 884 + }, 885 + "access_type": { 886 + "name": "access_type", 887 + "type": "text", 888 + "primaryKey": false, 889 + "notNull": false, 890 + "autoincrement": false, 891 + "default": "'public'" 892 + }, 893 + "auth_email_domains": { 894 + "name": "auth_email_domains", 895 + "type": "text", 896 + "primaryKey": false, 897 + "notNull": false, 898 + "autoincrement": false 899 + }, 900 + "homepage_url": { 901 + "name": "homepage_url", 902 + "type": "text(256)", 903 + "primaryKey": false, 904 + "notNull": false, 905 + "autoincrement": false 906 + }, 907 + "contact_url": { 908 + "name": "contact_url", 909 + "type": "text(256)", 910 + "primaryKey": false, 911 + "notNull": false, 912 + "autoincrement": false 913 + }, 914 + "legacy_page": { 915 + "name": "legacy_page", 916 + "type": "integer", 917 + "primaryKey": false, 918 + "notNull": true, 919 + "autoincrement": false, 920 + "default": true 921 + }, 922 + "configuration": { 923 + "name": "configuration", 924 + "type": "text", 925 + "primaryKey": false, 926 + "notNull": false, 927 + "autoincrement": false 928 + }, 929 + "show_monitor_values": { 930 + "name": "show_monitor_values", 931 + "type": "integer", 932 + "primaryKey": false, 933 + "notNull": false, 934 + "autoincrement": false, 935 + "default": true 936 + }, 937 + "created_at": { 938 + "name": "created_at", 939 + "type": "integer", 940 + "primaryKey": false, 941 + "notNull": false, 942 + "autoincrement": false, 943 + "default": "(strftime('%s', 'now'))" 944 + }, 945 + "updated_at": { 946 + "name": "updated_at", 947 + "type": "integer", 948 + "primaryKey": false, 949 + "notNull": false, 950 + "autoincrement": false, 951 + "default": "(strftime('%s', 'now'))" 952 + } 953 + }, 954 + "indexes": { 955 + "page_slug_unique": { 956 + "name": "page_slug_unique", 957 + "columns": [ 958 + "slug" 959 + ], 960 + "isUnique": true 961 + } 962 + }, 963 + "foreignKeys": { 964 + "page_workspace_id_workspace_id_fk": { 965 + "name": "page_workspace_id_workspace_id_fk", 966 + "tableFrom": "page", 967 + "tableTo": "workspace", 968 + "columnsFrom": [ 969 + "workspace_id" 970 + ], 971 + "columnsTo": [ 972 + "id" 973 + ], 974 + "onDelete": "cascade", 975 + "onUpdate": "no action" 976 + } 977 + }, 978 + "compositePrimaryKeys": {}, 979 + "uniqueConstraints": {}, 980 + "checkConstraints": {} 981 + }, 982 + "monitor": { 983 + "name": "monitor", 984 + "columns": { 985 + "id": { 986 + "name": "id", 987 + "type": "integer", 988 + "primaryKey": true, 989 + "notNull": true, 990 + "autoincrement": false 991 + }, 992 + "job_type": { 993 + "name": "job_type", 994 + "type": "text", 995 + "primaryKey": false, 996 + "notNull": true, 997 + "autoincrement": false, 998 + "default": "'http'" 999 + }, 1000 + "periodicity": { 1001 + "name": "periodicity", 1002 + "type": "text", 1003 + "primaryKey": false, 1004 + "notNull": true, 1005 + "autoincrement": false, 1006 + "default": "'other'" 1007 + }, 1008 + "status": { 1009 + "name": "status", 1010 + "type": "text", 1011 + "primaryKey": false, 1012 + "notNull": true, 1013 + "autoincrement": false, 1014 + "default": "'active'" 1015 + }, 1016 + "active": { 1017 + "name": "active", 1018 + "type": "integer", 1019 + "primaryKey": false, 1020 + "notNull": false, 1021 + "autoincrement": false, 1022 + "default": false 1023 + }, 1024 + "regions": { 1025 + "name": "regions", 1026 + "type": "text", 1027 + "primaryKey": false, 1028 + "notNull": true, 1029 + "autoincrement": false, 1030 + "default": "''" 1031 + }, 1032 + "url": { 1033 + "name": "url", 1034 + "type": "text(2048)", 1035 + "primaryKey": false, 1036 + "notNull": true, 1037 + "autoincrement": false 1038 + }, 1039 + "name": { 1040 + "name": "name", 1041 + "type": "text(256)", 1042 + "primaryKey": false, 1043 + "notNull": true, 1044 + "autoincrement": false, 1045 + "default": "''" 1046 + }, 1047 + "external_name": { 1048 + "name": "external_name", 1049 + "type": "text", 1050 + "primaryKey": false, 1051 + "notNull": false, 1052 + "autoincrement": false 1053 + }, 1054 + "description": { 1055 + "name": "description", 1056 + "type": "text", 1057 + "primaryKey": false, 1058 + "notNull": true, 1059 + "autoincrement": false, 1060 + "default": "''" 1061 + }, 1062 + "headers": { 1063 + "name": "headers", 1064 + "type": "text", 1065 + "primaryKey": false, 1066 + "notNull": false, 1067 + "autoincrement": false, 1068 + "default": "''" 1069 + }, 1070 + "body": { 1071 + "name": "body", 1072 + "type": "text", 1073 + "primaryKey": false, 1074 + "notNull": false, 1075 + "autoincrement": false, 1076 + "default": "''" 1077 + }, 1078 + "method": { 1079 + "name": "method", 1080 + "type": "text", 1081 + "primaryKey": false, 1082 + "notNull": false, 1083 + "autoincrement": false, 1084 + "default": "'GET'" 1085 + }, 1086 + "workspace_id": { 1087 + "name": "workspace_id", 1088 + "type": "integer", 1089 + "primaryKey": false, 1090 + "notNull": false, 1091 + "autoincrement": false 1092 + }, 1093 + "timeout": { 1094 + "name": "timeout", 1095 + "type": "integer", 1096 + "primaryKey": false, 1097 + "notNull": true, 1098 + "autoincrement": false, 1099 + "default": 45000 1100 + }, 1101 + "degraded_after": { 1102 + "name": "degraded_after", 1103 + "type": "integer", 1104 + "primaryKey": false, 1105 + "notNull": false, 1106 + "autoincrement": false 1107 + }, 1108 + "assertions": { 1109 + "name": "assertions", 1110 + "type": "text", 1111 + "primaryKey": false, 1112 + "notNull": false, 1113 + "autoincrement": false 1114 + }, 1115 + "otel_endpoint": { 1116 + "name": "otel_endpoint", 1117 + "type": "text", 1118 + "primaryKey": false, 1119 + "notNull": false, 1120 + "autoincrement": false 1121 + }, 1122 + "otel_headers": { 1123 + "name": "otel_headers", 1124 + "type": "text", 1125 + "primaryKey": false, 1126 + "notNull": false, 1127 + "autoincrement": false 1128 + }, 1129 + "public": { 1130 + "name": "public", 1131 + "type": "integer", 1132 + "primaryKey": false, 1133 + "notNull": false, 1134 + "autoincrement": false, 1135 + "default": false 1136 + }, 1137 + "retry": { 1138 + "name": "retry", 1139 + "type": "integer", 1140 + "primaryKey": false, 1141 + "notNull": false, 1142 + "autoincrement": false, 1143 + "default": 3 1144 + }, 1145 + "follow_redirects": { 1146 + "name": "follow_redirects", 1147 + "type": "integer", 1148 + "primaryKey": false, 1149 + "notNull": false, 1150 + "autoincrement": false, 1151 + "default": true 1152 + }, 1153 + "created_at": { 1154 + "name": "created_at", 1155 + "type": "integer", 1156 + "primaryKey": false, 1157 + "notNull": false, 1158 + "autoincrement": false, 1159 + "default": "(strftime('%s', 'now'))" 1160 + }, 1161 + "updated_at": { 1162 + "name": "updated_at", 1163 + "type": "integer", 1164 + "primaryKey": false, 1165 + "notNull": false, 1166 + "autoincrement": false, 1167 + "default": "(strftime('%s', 'now'))" 1168 + }, 1169 + "deleted_at": { 1170 + "name": "deleted_at", 1171 + "type": "integer", 1172 + "primaryKey": false, 1173 + "notNull": false, 1174 + "autoincrement": false 1175 + } 1176 + }, 1177 + "indexes": {}, 1178 + "foreignKeys": { 1179 + "monitor_workspace_id_workspace_id_fk": { 1180 + "name": "monitor_workspace_id_workspace_id_fk", 1181 + "tableFrom": "monitor", 1182 + "tableTo": "workspace", 1183 + "columnsFrom": [ 1184 + "workspace_id" 1185 + ], 1186 + "columnsTo": [ 1187 + "id" 1188 + ], 1189 + "onDelete": "no action", 1190 + "onUpdate": "no action" 1191 + } 1192 + }, 1193 + "compositePrimaryKeys": {}, 1194 + "uniqueConstraints": {}, 1195 + "checkConstraints": {} 1196 + }, 1197 + "monitors_to_pages": { 1198 + "name": "monitors_to_pages", 1199 + "columns": { 1200 + "monitor_id": { 1201 + "name": "monitor_id", 1202 + "type": "integer", 1203 + "primaryKey": false, 1204 + "notNull": true, 1205 + "autoincrement": false 1206 + }, 1207 + "page_id": { 1208 + "name": "page_id", 1209 + "type": "integer", 1210 + "primaryKey": false, 1211 + "notNull": true, 1212 + "autoincrement": false 1213 + }, 1214 + "created_at": { 1215 + "name": "created_at", 1216 + "type": "integer", 1217 + "primaryKey": false, 1218 + "notNull": false, 1219 + "autoincrement": false, 1220 + "default": "(strftime('%s', 'now'))" 1221 + }, 1222 + "order": { 1223 + "name": "order", 1224 + "type": "integer", 1225 + "primaryKey": false, 1226 + "notNull": false, 1227 + "autoincrement": false, 1228 + "default": 0 1229 + }, 1230 + "monitor_group_id": { 1231 + "name": "monitor_group_id", 1232 + "type": "integer", 1233 + "primaryKey": false, 1234 + "notNull": false, 1235 + "autoincrement": false 1236 + }, 1237 + "group_order": { 1238 + "name": "group_order", 1239 + "type": "integer", 1240 + "primaryKey": false, 1241 + "notNull": false, 1242 + "autoincrement": false, 1243 + "default": 0 1244 + } 1245 + }, 1246 + "indexes": {}, 1247 + "foreignKeys": { 1248 + "monitors_to_pages_monitor_id_monitor_id_fk": { 1249 + "name": "monitors_to_pages_monitor_id_monitor_id_fk", 1250 + "tableFrom": "monitors_to_pages", 1251 + "tableTo": "monitor", 1252 + "columnsFrom": [ 1253 + "monitor_id" 1254 + ], 1255 + "columnsTo": [ 1256 + "id" 1257 + ], 1258 + "onDelete": "cascade", 1259 + "onUpdate": "no action" 1260 + }, 1261 + "monitors_to_pages_page_id_page_id_fk": { 1262 + "name": "monitors_to_pages_page_id_page_id_fk", 1263 + "tableFrom": "monitors_to_pages", 1264 + "tableTo": "page", 1265 + "columnsFrom": [ 1266 + "page_id" 1267 + ], 1268 + "columnsTo": [ 1269 + "id" 1270 + ], 1271 + "onDelete": "cascade", 1272 + "onUpdate": "no action" 1273 + }, 1274 + "monitors_to_pages_monitor_group_id_monitor_group_id_fk": { 1275 + "name": "monitors_to_pages_monitor_group_id_monitor_group_id_fk", 1276 + "tableFrom": "monitors_to_pages", 1277 + "tableTo": "monitor_group", 1278 + "columnsFrom": [ 1279 + "monitor_group_id" 1280 + ], 1281 + "columnsTo": [ 1282 + "id" 1283 + ], 1284 + "onDelete": "cascade", 1285 + "onUpdate": "no action" 1286 + } 1287 + }, 1288 + "compositePrimaryKeys": { 1289 + "monitors_to_pages_monitor_id_page_id_pk": { 1290 + "columns": [ 1291 + "monitor_id", 1292 + "page_id" 1293 + ], 1294 + "name": "monitors_to_pages_monitor_id_page_id_pk" 1295 + } 1296 + }, 1297 + "uniqueConstraints": {}, 1298 + "checkConstraints": {} 1299 + }, 1300 + "page_subscriber": { 1301 + "name": "page_subscriber", 1302 + "columns": { 1303 + "id": { 1304 + "name": "id", 1305 + "type": "integer", 1306 + "primaryKey": true, 1307 + "notNull": true, 1308 + "autoincrement": false 1309 + }, 1310 + "email": { 1311 + "name": "email", 1312 + "type": "text", 1313 + "primaryKey": false, 1314 + "notNull": true, 1315 + "autoincrement": false 1316 + }, 1317 + "page_id": { 1318 + "name": "page_id", 1319 + "type": "integer", 1320 + "primaryKey": false, 1321 + "notNull": true, 1322 + "autoincrement": false 1323 + }, 1324 + "token": { 1325 + "name": "token", 1326 + "type": "text", 1327 + "primaryKey": false, 1328 + "notNull": false, 1329 + "autoincrement": false 1330 + }, 1331 + "accepted_at": { 1332 + "name": "accepted_at", 1333 + "type": "integer", 1334 + "primaryKey": false, 1335 + "notNull": false, 1336 + "autoincrement": false 1337 + }, 1338 + "expires_at": { 1339 + "name": "expires_at", 1340 + "type": "integer", 1341 + "primaryKey": false, 1342 + "notNull": false, 1343 + "autoincrement": false 1344 + }, 1345 + "unsubscribed_at": { 1346 + "name": "unsubscribed_at", 1347 + "type": "integer", 1348 + "primaryKey": false, 1349 + "notNull": false, 1350 + "autoincrement": false 1351 + }, 1352 + "created_at": { 1353 + "name": "created_at", 1354 + "type": "integer", 1355 + "primaryKey": false, 1356 + "notNull": false, 1357 + "autoincrement": false, 1358 + "default": "(strftime('%s', 'now'))" 1359 + }, 1360 + "updated_at": { 1361 + "name": "updated_at", 1362 + "type": "integer", 1363 + "primaryKey": false, 1364 + "notNull": false, 1365 + "autoincrement": false, 1366 + "default": "(strftime('%s', 'now'))" 1367 + } 1368 + }, 1369 + "indexes": {}, 1370 + "foreignKeys": { 1371 + "page_subscriber_page_id_page_id_fk": { 1372 + "name": "page_subscriber_page_id_page_id_fk", 1373 + "tableFrom": "page_subscriber", 1374 + "tableTo": "page", 1375 + "columnsFrom": [ 1376 + "page_id" 1377 + ], 1378 + "columnsTo": [ 1379 + "id" 1380 + ], 1381 + "onDelete": "cascade", 1382 + "onUpdate": "no action" 1383 + } 1384 + }, 1385 + "compositePrimaryKeys": {}, 1386 + "uniqueConstraints": {}, 1387 + "checkConstraints": {} 1388 + }, 1389 + "notification": { 1390 + "name": "notification", 1391 + "columns": { 1392 + "id": { 1393 + "name": "id", 1394 + "type": "integer", 1395 + "primaryKey": true, 1396 + "notNull": true, 1397 + "autoincrement": false 1398 + }, 1399 + "name": { 1400 + "name": "name", 1401 + "type": "text", 1402 + "primaryKey": false, 1403 + "notNull": true, 1404 + "autoincrement": false 1405 + }, 1406 + "provider": { 1407 + "name": "provider", 1408 + "type": "text", 1409 + "primaryKey": false, 1410 + "notNull": true, 1411 + "autoincrement": false 1412 + }, 1413 + "data": { 1414 + "name": "data", 1415 + "type": "text", 1416 + "primaryKey": false, 1417 + "notNull": false, 1418 + "autoincrement": false, 1419 + "default": "'{}'" 1420 + }, 1421 + "workspace_id": { 1422 + "name": "workspace_id", 1423 + "type": "integer", 1424 + "primaryKey": false, 1425 + "notNull": false, 1426 + "autoincrement": false 1427 + }, 1428 + "created_at": { 1429 + "name": "created_at", 1430 + "type": "integer", 1431 + "primaryKey": false, 1432 + "notNull": false, 1433 + "autoincrement": false, 1434 + "default": "(strftime('%s', 'now'))" 1435 + }, 1436 + "updated_at": { 1437 + "name": "updated_at", 1438 + "type": "integer", 1439 + "primaryKey": false, 1440 + "notNull": false, 1441 + "autoincrement": false, 1442 + "default": "(strftime('%s', 'now'))" 1443 + } 1444 + }, 1445 + "indexes": {}, 1446 + "foreignKeys": { 1447 + "notification_workspace_id_workspace_id_fk": { 1448 + "name": "notification_workspace_id_workspace_id_fk", 1449 + "tableFrom": "notification", 1450 + "tableTo": "workspace", 1451 + "columnsFrom": [ 1452 + "workspace_id" 1453 + ], 1454 + "columnsTo": [ 1455 + "id" 1456 + ], 1457 + "onDelete": "no action", 1458 + "onUpdate": "no action" 1459 + } 1460 + }, 1461 + "compositePrimaryKeys": {}, 1462 + "uniqueConstraints": {}, 1463 + "checkConstraints": {} 1464 + }, 1465 + "notification_trigger": { 1466 + "name": "notification_trigger", 1467 + "columns": { 1468 + "id": { 1469 + "name": "id", 1470 + "type": "integer", 1471 + "primaryKey": true, 1472 + "notNull": true, 1473 + "autoincrement": false 1474 + }, 1475 + "monitor_id": { 1476 + "name": "monitor_id", 1477 + "type": "integer", 1478 + "primaryKey": false, 1479 + "notNull": false, 1480 + "autoincrement": false 1481 + }, 1482 + "notification_id": { 1483 + "name": "notification_id", 1484 + "type": "integer", 1485 + "primaryKey": false, 1486 + "notNull": false, 1487 + "autoincrement": false 1488 + }, 1489 + "cron_timestamp": { 1490 + "name": "cron_timestamp", 1491 + "type": "integer", 1492 + "primaryKey": false, 1493 + "notNull": true, 1494 + "autoincrement": false 1495 + } 1496 + }, 1497 + "indexes": { 1498 + "notification_id_monitor_id_crontimestampe": { 1499 + "name": "notification_id_monitor_id_crontimestampe", 1500 + "columns": [ 1501 + "notification_id", 1502 + "monitor_id", 1503 + "cron_timestamp" 1504 + ], 1505 + "isUnique": true 1506 + } 1507 + }, 1508 + "foreignKeys": { 1509 + "notification_trigger_monitor_id_monitor_id_fk": { 1510 + "name": "notification_trigger_monitor_id_monitor_id_fk", 1511 + "tableFrom": "notification_trigger", 1512 + "tableTo": "monitor", 1513 + "columnsFrom": [ 1514 + "monitor_id" 1515 + ], 1516 + "columnsTo": [ 1517 + "id" 1518 + ], 1519 + "onDelete": "cascade", 1520 + "onUpdate": "no action" 1521 + }, 1522 + "notification_trigger_notification_id_notification_id_fk": { 1523 + "name": "notification_trigger_notification_id_notification_id_fk", 1524 + "tableFrom": "notification_trigger", 1525 + "tableTo": "notification", 1526 + "columnsFrom": [ 1527 + "notification_id" 1528 + ], 1529 + "columnsTo": [ 1530 + "id" 1531 + ], 1532 + "onDelete": "cascade", 1533 + "onUpdate": "no action" 1534 + } 1535 + }, 1536 + "compositePrimaryKeys": {}, 1537 + "uniqueConstraints": {}, 1538 + "checkConstraints": {} 1539 + }, 1540 + "notifications_to_monitors": { 1541 + "name": "notifications_to_monitors", 1542 + "columns": { 1543 + "monitor_id": { 1544 + "name": "monitor_id", 1545 + "type": "integer", 1546 + "primaryKey": false, 1547 + "notNull": true, 1548 + "autoincrement": false 1549 + }, 1550 + "notification_id": { 1551 + "name": "notification_id", 1552 + "type": "integer", 1553 + "primaryKey": false, 1554 + "notNull": true, 1555 + "autoincrement": false 1556 + }, 1557 + "created_at": { 1558 + "name": "created_at", 1559 + "type": "integer", 1560 + "primaryKey": false, 1561 + "notNull": false, 1562 + "autoincrement": false, 1563 + "default": "(strftime('%s', 'now'))" 1564 + } 1565 + }, 1566 + "indexes": {}, 1567 + "foreignKeys": { 1568 + "notifications_to_monitors_monitor_id_monitor_id_fk": { 1569 + "name": "notifications_to_monitors_monitor_id_monitor_id_fk", 1570 + "tableFrom": "notifications_to_monitors", 1571 + "tableTo": "monitor", 1572 + "columnsFrom": [ 1573 + "monitor_id" 1574 + ], 1575 + "columnsTo": [ 1576 + "id" 1577 + ], 1578 + "onDelete": "cascade", 1579 + "onUpdate": "no action" 1580 + }, 1581 + "notifications_to_monitors_notification_id_notification_id_fk": { 1582 + "name": "notifications_to_monitors_notification_id_notification_id_fk", 1583 + "tableFrom": "notifications_to_monitors", 1584 + "tableTo": "notification", 1585 + "columnsFrom": [ 1586 + "notification_id" 1587 + ], 1588 + "columnsTo": [ 1589 + "id" 1590 + ], 1591 + "onDelete": "cascade", 1592 + "onUpdate": "no action" 1593 + } 1594 + }, 1595 + "compositePrimaryKeys": { 1596 + "notifications_to_monitors_monitor_id_notification_id_pk": { 1597 + "columns": [ 1598 + "monitor_id", 1599 + "notification_id" 1600 + ], 1601 + "name": "notifications_to_monitors_monitor_id_notification_id_pk" 1602 + } 1603 + }, 1604 + "uniqueConstraints": {}, 1605 + "checkConstraints": {} 1606 + }, 1607 + "monitor_status": { 1608 + "name": "monitor_status", 1609 + "columns": { 1610 + "monitor_id": { 1611 + "name": "monitor_id", 1612 + "type": "integer", 1613 + "primaryKey": false, 1614 + "notNull": true, 1615 + "autoincrement": false 1616 + }, 1617 + "region": { 1618 + "name": "region", 1619 + "type": "text", 1620 + "primaryKey": false, 1621 + "notNull": true, 1622 + "autoincrement": false, 1623 + "default": "''" 1624 + }, 1625 + "status": { 1626 + "name": "status", 1627 + "type": "text", 1628 + "primaryKey": false, 1629 + "notNull": true, 1630 + "autoincrement": false, 1631 + "default": "'active'" 1632 + }, 1633 + "created_at": { 1634 + "name": "created_at", 1635 + "type": "integer", 1636 + "primaryKey": false, 1637 + "notNull": false, 1638 + "autoincrement": false, 1639 + "default": "(strftime('%s', 'now'))" 1640 + }, 1641 + "updated_at": { 1642 + "name": "updated_at", 1643 + "type": "integer", 1644 + "primaryKey": false, 1645 + "notNull": false, 1646 + "autoincrement": false, 1647 + "default": "(strftime('%s', 'now'))" 1648 + } 1649 + }, 1650 + "indexes": { 1651 + "monitor_status_idx": { 1652 + "name": "monitor_status_idx", 1653 + "columns": [ 1654 + "monitor_id", 1655 + "region" 1656 + ], 1657 + "isUnique": false 1658 + } 1659 + }, 1660 + "foreignKeys": { 1661 + "monitor_status_monitor_id_monitor_id_fk": { 1662 + "name": "monitor_status_monitor_id_monitor_id_fk", 1663 + "tableFrom": "monitor_status", 1664 + "tableTo": "monitor", 1665 + "columnsFrom": [ 1666 + "monitor_id" 1667 + ], 1668 + "columnsTo": [ 1669 + "id" 1670 + ], 1671 + "onDelete": "cascade", 1672 + "onUpdate": "no action" 1673 + } 1674 + }, 1675 + "compositePrimaryKeys": { 1676 + "monitor_status_monitor_id_region_pk": { 1677 + "columns": [ 1678 + "monitor_id", 1679 + "region" 1680 + ], 1681 + "name": "monitor_status_monitor_id_region_pk" 1682 + } 1683 + }, 1684 + "uniqueConstraints": {}, 1685 + "checkConstraints": {} 1686 + }, 1687 + "invitation": { 1688 + "name": "invitation", 1689 + "columns": { 1690 + "id": { 1691 + "name": "id", 1692 + "type": "integer", 1693 + "primaryKey": true, 1694 + "notNull": true, 1695 + "autoincrement": false 1696 + }, 1697 + "email": { 1698 + "name": "email", 1699 + "type": "text", 1700 + "primaryKey": false, 1701 + "notNull": true, 1702 + "autoincrement": false 1703 + }, 1704 + "role": { 1705 + "name": "role", 1706 + "type": "text", 1707 + "primaryKey": false, 1708 + "notNull": true, 1709 + "autoincrement": false, 1710 + "default": "'member'" 1711 + }, 1712 + "workspace_id": { 1713 + "name": "workspace_id", 1714 + "type": "integer", 1715 + "primaryKey": false, 1716 + "notNull": true, 1717 + "autoincrement": false 1718 + }, 1719 + "token": { 1720 + "name": "token", 1721 + "type": "text", 1722 + "primaryKey": false, 1723 + "notNull": true, 1724 + "autoincrement": false 1725 + }, 1726 + "expires_at": { 1727 + "name": "expires_at", 1728 + "type": "integer", 1729 + "primaryKey": false, 1730 + "notNull": true, 1731 + "autoincrement": false 1732 + }, 1733 + "created_at": { 1734 + "name": "created_at", 1735 + "type": "integer", 1736 + "primaryKey": false, 1737 + "notNull": false, 1738 + "autoincrement": false, 1739 + "default": "(strftime('%s', 'now'))" 1740 + }, 1741 + "accepted_at": { 1742 + "name": "accepted_at", 1743 + "type": "integer", 1744 + "primaryKey": false, 1745 + "notNull": false, 1746 + "autoincrement": false 1747 + } 1748 + }, 1749 + "indexes": {}, 1750 + "foreignKeys": {}, 1751 + "compositePrimaryKeys": {}, 1752 + "uniqueConstraints": {}, 1753 + "checkConstraints": {} 1754 + }, 1755 + "incident": { 1756 + "name": "incident", 1757 + "columns": { 1758 + "id": { 1759 + "name": "id", 1760 + "type": "integer", 1761 + "primaryKey": true, 1762 + "notNull": true, 1763 + "autoincrement": false 1764 + }, 1765 + "title": { 1766 + "name": "title", 1767 + "type": "text", 1768 + "primaryKey": false, 1769 + "notNull": true, 1770 + "autoincrement": false, 1771 + "default": "''" 1772 + }, 1773 + "summary": { 1774 + "name": "summary", 1775 + "type": "text", 1776 + "primaryKey": false, 1777 + "notNull": true, 1778 + "autoincrement": false, 1779 + "default": "''" 1780 + }, 1781 + "status": { 1782 + "name": "status", 1783 + "type": "text", 1784 + "primaryKey": false, 1785 + "notNull": true, 1786 + "autoincrement": false, 1787 + "default": "'triage'" 1788 + }, 1789 + "monitor_id": { 1790 + "name": "monitor_id", 1791 + "type": "integer", 1792 + "primaryKey": false, 1793 + "notNull": false, 1794 + "autoincrement": false 1795 + }, 1796 + "workspace_id": { 1797 + "name": "workspace_id", 1798 + "type": "integer", 1799 + "primaryKey": false, 1800 + "notNull": false, 1801 + "autoincrement": false 1802 + }, 1803 + "started_at": { 1804 + "name": "started_at", 1805 + "type": "integer", 1806 + "primaryKey": false, 1807 + "notNull": true, 1808 + "autoincrement": false, 1809 + "default": "(strftime('%s', 'now'))" 1810 + }, 1811 + "acknowledged_at": { 1812 + "name": "acknowledged_at", 1813 + "type": "integer", 1814 + "primaryKey": false, 1815 + "notNull": false, 1816 + "autoincrement": false 1817 + }, 1818 + "acknowledged_by": { 1819 + "name": "acknowledged_by", 1820 + "type": "integer", 1821 + "primaryKey": false, 1822 + "notNull": false, 1823 + "autoincrement": false 1824 + }, 1825 + "resolved_at": { 1826 + "name": "resolved_at", 1827 + "type": "integer", 1828 + "primaryKey": false, 1829 + "notNull": false, 1830 + "autoincrement": false 1831 + }, 1832 + "resolved_by": { 1833 + "name": "resolved_by", 1834 + "type": "integer", 1835 + "primaryKey": false, 1836 + "notNull": false, 1837 + "autoincrement": false 1838 + }, 1839 + "incident_screenshot_url": { 1840 + "name": "incident_screenshot_url", 1841 + "type": "text", 1842 + "primaryKey": false, 1843 + "notNull": false, 1844 + "autoincrement": false 1845 + }, 1846 + "recovery_screenshot_url": { 1847 + "name": "recovery_screenshot_url", 1848 + "type": "text", 1849 + "primaryKey": false, 1850 + "notNull": false, 1851 + "autoincrement": false 1852 + }, 1853 + "auto_resolved": { 1854 + "name": "auto_resolved", 1855 + "type": "integer", 1856 + "primaryKey": false, 1857 + "notNull": false, 1858 + "autoincrement": false, 1859 + "default": false 1860 + }, 1861 + "created_at": { 1862 + "name": "created_at", 1863 + "type": "integer", 1864 + "primaryKey": false, 1865 + "notNull": false, 1866 + "autoincrement": false, 1867 + "default": "(strftime('%s', 'now'))" 1868 + }, 1869 + "updated_at": { 1870 + "name": "updated_at", 1871 + "type": "integer", 1872 + "primaryKey": false, 1873 + "notNull": false, 1874 + "autoincrement": false, 1875 + "default": "(strftime('%s', 'now'))" 1876 + } 1877 + }, 1878 + "indexes": { 1879 + "incident_monitor_id_started_at_unique": { 1880 + "name": "incident_monitor_id_started_at_unique", 1881 + "columns": [ 1882 + "monitor_id", 1883 + "started_at" 1884 + ], 1885 + "isUnique": true 1886 + } 1887 + }, 1888 + "foreignKeys": { 1889 + "incident_monitor_id_monitor_id_fk": { 1890 + "name": "incident_monitor_id_monitor_id_fk", 1891 + "tableFrom": "incident", 1892 + "tableTo": "monitor", 1893 + "columnsFrom": [ 1894 + "monitor_id" 1895 + ], 1896 + "columnsTo": [ 1897 + "id" 1898 + ], 1899 + "onDelete": "set default", 1900 + "onUpdate": "no action" 1901 + }, 1902 + "incident_workspace_id_workspace_id_fk": { 1903 + "name": "incident_workspace_id_workspace_id_fk", 1904 + "tableFrom": "incident", 1905 + "tableTo": "workspace", 1906 + "columnsFrom": [ 1907 + "workspace_id" 1908 + ], 1909 + "columnsTo": [ 1910 + "id" 1911 + ], 1912 + "onDelete": "no action", 1913 + "onUpdate": "no action" 1914 + }, 1915 + "incident_acknowledged_by_user_id_fk": { 1916 + "name": "incident_acknowledged_by_user_id_fk", 1917 + "tableFrom": "incident", 1918 + "tableTo": "user", 1919 + "columnsFrom": [ 1920 + "acknowledged_by" 1921 + ], 1922 + "columnsTo": [ 1923 + "id" 1924 + ], 1925 + "onDelete": "no action", 1926 + "onUpdate": "no action" 1927 + }, 1928 + "incident_resolved_by_user_id_fk": { 1929 + "name": "incident_resolved_by_user_id_fk", 1930 + "tableFrom": "incident", 1931 + "tableTo": "user", 1932 + "columnsFrom": [ 1933 + "resolved_by" 1934 + ], 1935 + "columnsTo": [ 1936 + "id" 1937 + ], 1938 + "onDelete": "no action", 1939 + "onUpdate": "no action" 1940 + } 1941 + }, 1942 + "compositePrimaryKeys": {}, 1943 + "uniqueConstraints": {}, 1944 + "checkConstraints": {} 1945 + }, 1946 + "monitor_tag": { 1947 + "name": "monitor_tag", 1948 + "columns": { 1949 + "id": { 1950 + "name": "id", 1951 + "type": "integer", 1952 + "primaryKey": true, 1953 + "notNull": true, 1954 + "autoincrement": false 1955 + }, 1956 + "workspace_id": { 1957 + "name": "workspace_id", 1958 + "type": "integer", 1959 + "primaryKey": false, 1960 + "notNull": true, 1961 + "autoincrement": false 1962 + }, 1963 + "name": { 1964 + "name": "name", 1965 + "type": "text", 1966 + "primaryKey": false, 1967 + "notNull": true, 1968 + "autoincrement": false 1969 + }, 1970 + "color": { 1971 + "name": "color", 1972 + "type": "text", 1973 + "primaryKey": false, 1974 + "notNull": true, 1975 + "autoincrement": false 1976 + }, 1977 + "created_at": { 1978 + "name": "created_at", 1979 + "type": "integer", 1980 + "primaryKey": false, 1981 + "notNull": false, 1982 + "autoincrement": false, 1983 + "default": "(strftime('%s', 'now'))" 1984 + }, 1985 + "updated_at": { 1986 + "name": "updated_at", 1987 + "type": "integer", 1988 + "primaryKey": false, 1989 + "notNull": false, 1990 + "autoincrement": false, 1991 + "default": "(strftime('%s', 'now'))" 1992 + } 1993 + }, 1994 + "indexes": {}, 1995 + "foreignKeys": { 1996 + "monitor_tag_workspace_id_workspace_id_fk": { 1997 + "name": "monitor_tag_workspace_id_workspace_id_fk", 1998 + "tableFrom": "monitor_tag", 1999 + "tableTo": "workspace", 2000 + "columnsFrom": [ 2001 + "workspace_id" 2002 + ], 2003 + "columnsTo": [ 2004 + "id" 2005 + ], 2006 + "onDelete": "cascade", 2007 + "onUpdate": "no action" 2008 + } 2009 + }, 2010 + "compositePrimaryKeys": {}, 2011 + "uniqueConstraints": {}, 2012 + "checkConstraints": {} 2013 + }, 2014 + "monitor_tag_to_monitor": { 2015 + "name": "monitor_tag_to_monitor", 2016 + "columns": { 2017 + "monitor_id": { 2018 + "name": "monitor_id", 2019 + "type": "integer", 2020 + "primaryKey": false, 2021 + "notNull": true, 2022 + "autoincrement": false 2023 + }, 2024 + "monitor_tag_id": { 2025 + "name": "monitor_tag_id", 2026 + "type": "integer", 2027 + "primaryKey": false, 2028 + "notNull": true, 2029 + "autoincrement": false 2030 + }, 2031 + "created_at": { 2032 + "name": "created_at", 2033 + "type": "integer", 2034 + "primaryKey": false, 2035 + "notNull": false, 2036 + "autoincrement": false, 2037 + "default": "(strftime('%s', 'now'))" 2038 + } 2039 + }, 2040 + "indexes": {}, 2041 + "foreignKeys": { 2042 + "monitor_tag_to_monitor_monitor_id_monitor_id_fk": { 2043 + "name": "monitor_tag_to_monitor_monitor_id_monitor_id_fk", 2044 + "tableFrom": "monitor_tag_to_monitor", 2045 + "tableTo": "monitor", 2046 + "columnsFrom": [ 2047 + "monitor_id" 2048 + ], 2049 + "columnsTo": [ 2050 + "id" 2051 + ], 2052 + "onDelete": "cascade", 2053 + "onUpdate": "no action" 2054 + }, 2055 + "monitor_tag_to_monitor_monitor_tag_id_monitor_tag_id_fk": { 2056 + "name": "monitor_tag_to_monitor_monitor_tag_id_monitor_tag_id_fk", 2057 + "tableFrom": "monitor_tag_to_monitor", 2058 + "tableTo": "monitor_tag", 2059 + "columnsFrom": [ 2060 + "monitor_tag_id" 2061 + ], 2062 + "columnsTo": [ 2063 + "id" 2064 + ], 2065 + "onDelete": "cascade", 2066 + "onUpdate": "no action" 2067 + } 2068 + }, 2069 + "compositePrimaryKeys": { 2070 + "monitor_tag_to_monitor_monitor_id_monitor_tag_id_pk": { 2071 + "columns": [ 2072 + "monitor_id", 2073 + "monitor_tag_id" 2074 + ], 2075 + "name": "monitor_tag_to_monitor_monitor_id_monitor_tag_id_pk" 2076 + } 2077 + }, 2078 + "uniqueConstraints": {}, 2079 + "checkConstraints": {} 2080 + }, 2081 + "application": { 2082 + "name": "application", 2083 + "columns": { 2084 + "id": { 2085 + "name": "id", 2086 + "type": "integer", 2087 + "primaryKey": true, 2088 + "notNull": true, 2089 + "autoincrement": false 2090 + }, 2091 + "name": { 2092 + "name": "name", 2093 + "type": "text", 2094 + "primaryKey": false, 2095 + "notNull": false, 2096 + "autoincrement": false 2097 + }, 2098 + "dsn": { 2099 + "name": "dsn", 2100 + "type": "text", 2101 + "primaryKey": false, 2102 + "notNull": false, 2103 + "autoincrement": false 2104 + }, 2105 + "workspace_id": { 2106 + "name": "workspace_id", 2107 + "type": "integer", 2108 + "primaryKey": false, 2109 + "notNull": false, 2110 + "autoincrement": false 2111 + }, 2112 + "created_at": { 2113 + "name": "created_at", 2114 + "type": "integer", 2115 + "primaryKey": false, 2116 + "notNull": false, 2117 + "autoincrement": false, 2118 + "default": "(strftime('%s', 'now'))" 2119 + }, 2120 + "updated_at": { 2121 + "name": "updated_at", 2122 + "type": "integer", 2123 + "primaryKey": false, 2124 + "notNull": false, 2125 + "autoincrement": false, 2126 + "default": "(strftime('%s', 'now'))" 2127 + } 2128 + }, 2129 + "indexes": { 2130 + "application_dsn_unique": { 2131 + "name": "application_dsn_unique", 2132 + "columns": [ 2133 + "dsn" 2134 + ], 2135 + "isUnique": true 2136 + } 2137 + }, 2138 + "foreignKeys": { 2139 + "application_workspace_id_workspace_id_fk": { 2140 + "name": "application_workspace_id_workspace_id_fk", 2141 + "tableFrom": "application", 2142 + "tableTo": "workspace", 2143 + "columnsFrom": [ 2144 + "workspace_id" 2145 + ], 2146 + "columnsTo": [ 2147 + "id" 2148 + ], 2149 + "onDelete": "no action", 2150 + "onUpdate": "no action" 2151 + } 2152 + }, 2153 + "compositePrimaryKeys": {}, 2154 + "uniqueConstraints": {}, 2155 + "checkConstraints": {} 2156 + }, 2157 + "maintenance": { 2158 + "name": "maintenance", 2159 + "columns": { 2160 + "id": { 2161 + "name": "id", 2162 + "type": "integer", 2163 + "primaryKey": true, 2164 + "notNull": true, 2165 + "autoincrement": false 2166 + }, 2167 + "title": { 2168 + "name": "title", 2169 + "type": "text(256)", 2170 + "primaryKey": false, 2171 + "notNull": true, 2172 + "autoincrement": false 2173 + }, 2174 + "message": { 2175 + "name": "message", 2176 + "type": "text", 2177 + "primaryKey": false, 2178 + "notNull": true, 2179 + "autoincrement": false 2180 + }, 2181 + "from": { 2182 + "name": "from", 2183 + "type": "integer", 2184 + "primaryKey": false, 2185 + "notNull": true, 2186 + "autoincrement": false 2187 + }, 2188 + "to": { 2189 + "name": "to", 2190 + "type": "integer", 2191 + "primaryKey": false, 2192 + "notNull": true, 2193 + "autoincrement": false 2194 + }, 2195 + "workspace_id": { 2196 + "name": "workspace_id", 2197 + "type": "integer", 2198 + "primaryKey": false, 2199 + "notNull": false, 2200 + "autoincrement": false 2201 + }, 2202 + "page_id": { 2203 + "name": "page_id", 2204 + "type": "integer", 2205 + "primaryKey": false, 2206 + "notNull": false, 2207 + "autoincrement": false 2208 + }, 2209 + "created_at": { 2210 + "name": "created_at", 2211 + "type": "integer", 2212 + "primaryKey": false, 2213 + "notNull": false, 2214 + "autoincrement": false, 2215 + "default": "(strftime('%s', 'now'))" 2216 + }, 2217 + "updated_at": { 2218 + "name": "updated_at", 2219 + "type": "integer", 2220 + "primaryKey": false, 2221 + "notNull": false, 2222 + "autoincrement": false, 2223 + "default": "(strftime('%s', 'now'))" 2224 + } 2225 + }, 2226 + "indexes": {}, 2227 + "foreignKeys": { 2228 + "maintenance_workspace_id_workspace_id_fk": { 2229 + "name": "maintenance_workspace_id_workspace_id_fk", 2230 + "tableFrom": "maintenance", 2231 + "tableTo": "workspace", 2232 + "columnsFrom": [ 2233 + "workspace_id" 2234 + ], 2235 + "columnsTo": [ 2236 + "id" 2237 + ], 2238 + "onDelete": "no action", 2239 + "onUpdate": "no action" 2240 + }, 2241 + "maintenance_page_id_page_id_fk": { 2242 + "name": "maintenance_page_id_page_id_fk", 2243 + "tableFrom": "maintenance", 2244 + "tableTo": "page", 2245 + "columnsFrom": [ 2246 + "page_id" 2247 + ], 2248 + "columnsTo": [ 2249 + "id" 2250 + ], 2251 + "onDelete": "cascade", 2252 + "onUpdate": "no action" 2253 + } 2254 + }, 2255 + "compositePrimaryKeys": {}, 2256 + "uniqueConstraints": {}, 2257 + "checkConstraints": {} 2258 + }, 2259 + "maintenance_to_monitor": { 2260 + "name": "maintenance_to_monitor", 2261 + "columns": { 2262 + "maintenance_id": { 2263 + "name": "maintenance_id", 2264 + "type": "integer", 2265 + "primaryKey": false, 2266 + "notNull": true, 2267 + "autoincrement": false 2268 + }, 2269 + "monitor_id": { 2270 + "name": "monitor_id", 2271 + "type": "integer", 2272 + "primaryKey": false, 2273 + "notNull": true, 2274 + "autoincrement": false 2275 + }, 2276 + "created_at": { 2277 + "name": "created_at", 2278 + "type": "integer", 2279 + "primaryKey": false, 2280 + "notNull": false, 2281 + "autoincrement": false, 2282 + "default": "(strftime('%s', 'now'))" 2283 + } 2284 + }, 2285 + "indexes": {}, 2286 + "foreignKeys": { 2287 + "maintenance_to_monitor_maintenance_id_maintenance_id_fk": { 2288 + "name": "maintenance_to_monitor_maintenance_id_maintenance_id_fk", 2289 + "tableFrom": "maintenance_to_monitor", 2290 + "tableTo": "maintenance", 2291 + "columnsFrom": [ 2292 + "maintenance_id" 2293 + ], 2294 + "columnsTo": [ 2295 + "id" 2296 + ], 2297 + "onDelete": "cascade", 2298 + "onUpdate": "no action" 2299 + }, 2300 + "maintenance_to_monitor_monitor_id_monitor_id_fk": { 2301 + "name": "maintenance_to_monitor_monitor_id_monitor_id_fk", 2302 + "tableFrom": "maintenance_to_monitor", 2303 + "tableTo": "monitor", 2304 + "columnsFrom": [ 2305 + "monitor_id" 2306 + ], 2307 + "columnsTo": [ 2308 + "id" 2309 + ], 2310 + "onDelete": "cascade", 2311 + "onUpdate": "no action" 2312 + } 2313 + }, 2314 + "compositePrimaryKeys": { 2315 + "maintenance_to_monitor_maintenance_id_monitor_id_pk": { 2316 + "columns": [ 2317 + "maintenance_id", 2318 + "monitor_id" 2319 + ], 2320 + "name": "maintenance_to_monitor_maintenance_id_monitor_id_pk" 2321 + } 2322 + }, 2323 + "uniqueConstraints": {}, 2324 + "checkConstraints": {} 2325 + }, 2326 + "check": { 2327 + "name": "check", 2328 + "columns": { 2329 + "id": { 2330 + "name": "id", 2331 + "type": "integer", 2332 + "primaryKey": true, 2333 + "notNull": true, 2334 + "autoincrement": true 2335 + }, 2336 + "regions": { 2337 + "name": "regions", 2338 + "type": "text", 2339 + "primaryKey": false, 2340 + "notNull": true, 2341 + "autoincrement": false, 2342 + "default": "''" 2343 + }, 2344 + "url": { 2345 + "name": "url", 2346 + "type": "text(4096)", 2347 + "primaryKey": false, 2348 + "notNull": true, 2349 + "autoincrement": false 2350 + }, 2351 + "headers": { 2352 + "name": "headers", 2353 + "type": "text", 2354 + "primaryKey": false, 2355 + "notNull": false, 2356 + "autoincrement": false, 2357 + "default": "''" 2358 + }, 2359 + "body": { 2360 + "name": "body", 2361 + "type": "text", 2362 + "primaryKey": false, 2363 + "notNull": false, 2364 + "autoincrement": false, 2365 + "default": "''" 2366 + }, 2367 + "method": { 2368 + "name": "method", 2369 + "type": "text", 2370 + "primaryKey": false, 2371 + "notNull": false, 2372 + "autoincrement": false, 2373 + "default": "'GET'" 2374 + }, 2375 + "count_requests": { 2376 + "name": "count_requests", 2377 + "type": "integer", 2378 + "primaryKey": false, 2379 + "notNull": false, 2380 + "autoincrement": false, 2381 + "default": 1 2382 + }, 2383 + "workspace_id": { 2384 + "name": "workspace_id", 2385 + "type": "integer", 2386 + "primaryKey": false, 2387 + "notNull": false, 2388 + "autoincrement": false 2389 + }, 2390 + "created_at": { 2391 + "name": "created_at", 2392 + "type": "integer", 2393 + "primaryKey": false, 2394 + "notNull": false, 2395 + "autoincrement": false, 2396 + "default": "(strftime('%s', 'now'))" 2397 + } 2398 + }, 2399 + "indexes": {}, 2400 + "foreignKeys": { 2401 + "check_workspace_id_workspace_id_fk": { 2402 + "name": "check_workspace_id_workspace_id_fk", 2403 + "tableFrom": "check", 2404 + "tableTo": "workspace", 2405 + "columnsFrom": [ 2406 + "workspace_id" 2407 + ], 2408 + "columnsTo": [ 2409 + "id" 2410 + ], 2411 + "onDelete": "no action", 2412 + "onUpdate": "no action" 2413 + } 2414 + }, 2415 + "compositePrimaryKeys": {}, 2416 + "uniqueConstraints": {}, 2417 + "checkConstraints": {} 2418 + }, 2419 + "monitor_run": { 2420 + "name": "monitor_run", 2421 + "columns": { 2422 + "id": { 2423 + "name": "id", 2424 + "type": "integer", 2425 + "primaryKey": true, 2426 + "notNull": true, 2427 + "autoincrement": false 2428 + }, 2429 + "workspace_id": { 2430 + "name": "workspace_id", 2431 + "type": "integer", 2432 + "primaryKey": false, 2433 + "notNull": false, 2434 + "autoincrement": false 2435 + }, 2436 + "monitor_id": { 2437 + "name": "monitor_id", 2438 + "type": "integer", 2439 + "primaryKey": false, 2440 + "notNull": false, 2441 + "autoincrement": false 2442 + }, 2443 + "runned_at": { 2444 + "name": "runned_at", 2445 + "type": "integer", 2446 + "primaryKey": false, 2447 + "notNull": false, 2448 + "autoincrement": false 2449 + }, 2450 + "created_at": { 2451 + "name": "created_at", 2452 + "type": "integer", 2453 + "primaryKey": false, 2454 + "notNull": false, 2455 + "autoincrement": false, 2456 + "default": "(strftime('%s', 'now'))" 2457 + } 2458 + }, 2459 + "indexes": {}, 2460 + "foreignKeys": { 2461 + "monitor_run_workspace_id_workspace_id_fk": { 2462 + "name": "monitor_run_workspace_id_workspace_id_fk", 2463 + "tableFrom": "monitor_run", 2464 + "tableTo": "workspace", 2465 + "columnsFrom": [ 2466 + "workspace_id" 2467 + ], 2468 + "columnsTo": [ 2469 + "id" 2470 + ], 2471 + "onDelete": "no action", 2472 + "onUpdate": "no action" 2473 + }, 2474 + "monitor_run_monitor_id_monitor_id_fk": { 2475 + "name": "monitor_run_monitor_id_monitor_id_fk", 2476 + "tableFrom": "monitor_run", 2477 + "tableTo": "monitor", 2478 + "columnsFrom": [ 2479 + "monitor_id" 2480 + ], 2481 + "columnsTo": [ 2482 + "id" 2483 + ], 2484 + "onDelete": "no action", 2485 + "onUpdate": "no action" 2486 + } 2487 + }, 2488 + "compositePrimaryKeys": {}, 2489 + "uniqueConstraints": {}, 2490 + "checkConstraints": {} 2491 + }, 2492 + "private_location": { 2493 + "name": "private_location", 2494 + "columns": { 2495 + "id": { 2496 + "name": "id", 2497 + "type": "integer", 2498 + "primaryKey": true, 2499 + "notNull": true, 2500 + "autoincrement": false 2501 + }, 2502 + "name": { 2503 + "name": "name", 2504 + "type": "text", 2505 + "primaryKey": false, 2506 + "notNull": true, 2507 + "autoincrement": false 2508 + }, 2509 + "token": { 2510 + "name": "token", 2511 + "type": "text", 2512 + "primaryKey": false, 2513 + "notNull": true, 2514 + "autoincrement": false 2515 + }, 2516 + "last_seen_at": { 2517 + "name": "last_seen_at", 2518 + "type": "integer", 2519 + "primaryKey": false, 2520 + "notNull": false, 2521 + "autoincrement": false 2522 + }, 2523 + "workspace_id": { 2524 + "name": "workspace_id", 2525 + "type": "integer", 2526 + "primaryKey": false, 2527 + "notNull": false, 2528 + "autoincrement": false 2529 + }, 2530 + "created_at": { 2531 + "name": "created_at", 2532 + "type": "integer", 2533 + "primaryKey": false, 2534 + "notNull": false, 2535 + "autoincrement": false, 2536 + "default": "(strftime('%s', 'now'))" 2537 + }, 2538 + "updated_at": { 2539 + "name": "updated_at", 2540 + "type": "integer", 2541 + "primaryKey": false, 2542 + "notNull": false, 2543 + "autoincrement": false, 2544 + "default": "(strftime('%s', 'now'))" 2545 + } 2546 + }, 2547 + "indexes": {}, 2548 + "foreignKeys": { 2549 + "private_location_workspace_id_workspace_id_fk": { 2550 + "name": "private_location_workspace_id_workspace_id_fk", 2551 + "tableFrom": "private_location", 2552 + "tableTo": "workspace", 2553 + "columnsFrom": [ 2554 + "workspace_id" 2555 + ], 2556 + "columnsTo": [ 2557 + "id" 2558 + ], 2559 + "onDelete": "no action", 2560 + "onUpdate": "no action" 2561 + } 2562 + }, 2563 + "compositePrimaryKeys": {}, 2564 + "uniqueConstraints": {}, 2565 + "checkConstraints": {} 2566 + }, 2567 + "private_location_to_monitor": { 2568 + "name": "private_location_to_monitor", 2569 + "columns": { 2570 + "private_location_id": { 2571 + "name": "private_location_id", 2572 + "type": "integer", 2573 + "primaryKey": false, 2574 + "notNull": false, 2575 + "autoincrement": false 2576 + }, 2577 + "monitor_id": { 2578 + "name": "monitor_id", 2579 + "type": "integer", 2580 + "primaryKey": false, 2581 + "notNull": false, 2582 + "autoincrement": false 2583 + }, 2584 + "created_at": { 2585 + "name": "created_at", 2586 + "type": "integer", 2587 + "primaryKey": false, 2588 + "notNull": false, 2589 + "autoincrement": false, 2590 + "default": "(strftime('%s', 'now'))" 2591 + }, 2592 + "deleted_at": { 2593 + "name": "deleted_at", 2594 + "type": "integer", 2595 + "primaryKey": false, 2596 + "notNull": false, 2597 + "autoincrement": false 2598 + } 2599 + }, 2600 + "indexes": {}, 2601 + "foreignKeys": { 2602 + "private_location_to_monitor_private_location_id_private_location_id_fk": { 2603 + "name": "private_location_to_monitor_private_location_id_private_location_id_fk", 2604 + "tableFrom": "private_location_to_monitor", 2605 + "tableTo": "private_location", 2606 + "columnsFrom": [ 2607 + "private_location_id" 2608 + ], 2609 + "columnsTo": [ 2610 + "id" 2611 + ], 2612 + "onDelete": "cascade", 2613 + "onUpdate": "no action" 2614 + }, 2615 + "private_location_to_monitor_monitor_id_monitor_id_fk": { 2616 + "name": "private_location_to_monitor_monitor_id_monitor_id_fk", 2617 + "tableFrom": "private_location_to_monitor", 2618 + "tableTo": "monitor", 2619 + "columnsFrom": [ 2620 + "monitor_id" 2621 + ], 2622 + "columnsTo": [ 2623 + "id" 2624 + ], 2625 + "onDelete": "cascade", 2626 + "onUpdate": "no action" 2627 + } 2628 + }, 2629 + "compositePrimaryKeys": {}, 2630 + "uniqueConstraints": {}, 2631 + "checkConstraints": {} 2632 + }, 2633 + "monitor_group": { 2634 + "name": "monitor_group", 2635 + "columns": { 2636 + "id": { 2637 + "name": "id", 2638 + "type": "integer", 2639 + "primaryKey": true, 2640 + "notNull": true, 2641 + "autoincrement": false 2642 + }, 2643 + "workspace_id": { 2644 + "name": "workspace_id", 2645 + "type": "integer", 2646 + "primaryKey": false, 2647 + "notNull": true, 2648 + "autoincrement": false 2649 + }, 2650 + "page_id": { 2651 + "name": "page_id", 2652 + "type": "integer", 2653 + "primaryKey": false, 2654 + "notNull": true, 2655 + "autoincrement": false 2656 + }, 2657 + "name": { 2658 + "name": "name", 2659 + "type": "text", 2660 + "primaryKey": false, 2661 + "notNull": true, 2662 + "autoincrement": false 2663 + }, 2664 + "created_at": { 2665 + "name": "created_at", 2666 + "type": "integer", 2667 + "primaryKey": false, 2668 + "notNull": false, 2669 + "autoincrement": false, 2670 + "default": "(strftime('%s', 'now'))" 2671 + }, 2672 + "updated_at": { 2673 + "name": "updated_at", 2674 + "type": "integer", 2675 + "primaryKey": false, 2676 + "notNull": false, 2677 + "autoincrement": false, 2678 + "default": "(strftime('%s', 'now'))" 2679 + } 2680 + }, 2681 + "indexes": {}, 2682 + "foreignKeys": { 2683 + "monitor_group_workspace_id_workspace_id_fk": { 2684 + "name": "monitor_group_workspace_id_workspace_id_fk", 2685 + "tableFrom": "monitor_group", 2686 + "tableTo": "workspace", 2687 + "columnsFrom": [ 2688 + "workspace_id" 2689 + ], 2690 + "columnsTo": [ 2691 + "id" 2692 + ], 2693 + "onDelete": "cascade", 2694 + "onUpdate": "no action" 2695 + }, 2696 + "monitor_group_page_id_page_id_fk": { 2697 + "name": "monitor_group_page_id_page_id_fk", 2698 + "tableFrom": "monitor_group", 2699 + "tableTo": "page", 2700 + "columnsFrom": [ 2701 + "page_id" 2702 + ], 2703 + "columnsTo": [ 2704 + "id" 2705 + ], 2706 + "onDelete": "cascade", 2707 + "onUpdate": "no action" 2708 + } 2709 + }, 2710 + "compositePrimaryKeys": {}, 2711 + "uniqueConstraints": {}, 2712 + "checkConstraints": {} 2713 + }, 2714 + "viewer": { 2715 + "name": "viewer", 2716 + "columns": { 2717 + "id": { 2718 + "name": "id", 2719 + "type": "integer", 2720 + "primaryKey": true, 2721 + "notNull": true, 2722 + "autoincrement": false 2723 + }, 2724 + "name": { 2725 + "name": "name", 2726 + "type": "text", 2727 + "primaryKey": false, 2728 + "notNull": false, 2729 + "autoincrement": false 2730 + }, 2731 + "email": { 2732 + "name": "email", 2733 + "type": "text", 2734 + "primaryKey": false, 2735 + "notNull": false, 2736 + "autoincrement": false 2737 + }, 2738 + "emailVerified": { 2739 + "name": "emailVerified", 2740 + "type": "integer", 2741 + "primaryKey": false, 2742 + "notNull": false, 2743 + "autoincrement": false 2744 + }, 2745 + "image": { 2746 + "name": "image", 2747 + "type": "text", 2748 + "primaryKey": false, 2749 + "notNull": false, 2750 + "autoincrement": false 2751 + }, 2752 + "created_at": { 2753 + "name": "created_at", 2754 + "type": "integer", 2755 + "primaryKey": false, 2756 + "notNull": false, 2757 + "autoincrement": false, 2758 + "default": "(strftime('%s', 'now'))" 2759 + }, 2760 + "updated_at": { 2761 + "name": "updated_at", 2762 + "type": "integer", 2763 + "primaryKey": false, 2764 + "notNull": false, 2765 + "autoincrement": false, 2766 + "default": "(strftime('%s', 'now'))" 2767 + } 2768 + }, 2769 + "indexes": { 2770 + "viewer_email_unique": { 2771 + "name": "viewer_email_unique", 2772 + "columns": [ 2773 + "email" 2774 + ], 2775 + "isUnique": true 2776 + } 2777 + }, 2778 + "foreignKeys": {}, 2779 + "compositePrimaryKeys": {}, 2780 + "uniqueConstraints": {}, 2781 + "checkConstraints": {} 2782 + }, 2783 + "viewer_accounts": { 2784 + "name": "viewer_accounts", 2785 + "columns": { 2786 + "user_id": { 2787 + "name": "user_id", 2788 + "type": "text", 2789 + "primaryKey": false, 2790 + "notNull": true, 2791 + "autoincrement": false 2792 + }, 2793 + "type": { 2794 + "name": "type", 2795 + "type": "text", 2796 + "primaryKey": false, 2797 + "notNull": true, 2798 + "autoincrement": false 2799 + }, 2800 + "provider": { 2801 + "name": "provider", 2802 + "type": "text", 2803 + "primaryKey": false, 2804 + "notNull": true, 2805 + "autoincrement": false 2806 + }, 2807 + "providerAccountId": { 2808 + "name": "providerAccountId", 2809 + "type": "text", 2810 + "primaryKey": false, 2811 + "notNull": true, 2812 + "autoincrement": false 2813 + }, 2814 + "refresh_token": { 2815 + "name": "refresh_token", 2816 + "type": "text", 2817 + "primaryKey": false, 2818 + "notNull": false, 2819 + "autoincrement": false 2820 + }, 2821 + "access_token": { 2822 + "name": "access_token", 2823 + "type": "text", 2824 + "primaryKey": false, 2825 + "notNull": false, 2826 + "autoincrement": false 2827 + }, 2828 + "expires_at": { 2829 + "name": "expires_at", 2830 + "type": "integer", 2831 + "primaryKey": false, 2832 + "notNull": false, 2833 + "autoincrement": false 2834 + }, 2835 + "token_type": { 2836 + "name": "token_type", 2837 + "type": "text", 2838 + "primaryKey": false, 2839 + "notNull": false, 2840 + "autoincrement": false 2841 + }, 2842 + "scope": { 2843 + "name": "scope", 2844 + "type": "text", 2845 + "primaryKey": false, 2846 + "notNull": false, 2847 + "autoincrement": false 2848 + }, 2849 + "id_token": { 2850 + "name": "id_token", 2851 + "type": "text", 2852 + "primaryKey": false, 2853 + "notNull": false, 2854 + "autoincrement": false 2855 + }, 2856 + "session_state": { 2857 + "name": "session_state", 2858 + "type": "text", 2859 + "primaryKey": false, 2860 + "notNull": false, 2861 + "autoincrement": false 2862 + } 2863 + }, 2864 + "indexes": {}, 2865 + "foreignKeys": { 2866 + "viewer_accounts_user_id_viewer_id_fk": { 2867 + "name": "viewer_accounts_user_id_viewer_id_fk", 2868 + "tableFrom": "viewer_accounts", 2869 + "tableTo": "viewer", 2870 + "columnsFrom": [ 2871 + "user_id" 2872 + ], 2873 + "columnsTo": [ 2874 + "id" 2875 + ], 2876 + "onDelete": "cascade", 2877 + "onUpdate": "no action" 2878 + } 2879 + }, 2880 + "compositePrimaryKeys": { 2881 + "viewer_accounts_provider_providerAccountId_pk": { 2882 + "columns": [ 2883 + "provider", 2884 + "providerAccountId" 2885 + ], 2886 + "name": "viewer_accounts_provider_providerAccountId_pk" 2887 + } 2888 + }, 2889 + "uniqueConstraints": {}, 2890 + "checkConstraints": {} 2891 + }, 2892 + "viewer_session": { 2893 + "name": "viewer_session", 2894 + "columns": { 2895 + "session_token": { 2896 + "name": "session_token", 2897 + "type": "text", 2898 + "primaryKey": true, 2899 + "notNull": true, 2900 + "autoincrement": false 2901 + }, 2902 + "user_id": { 2903 + "name": "user_id", 2904 + "type": "integer", 2905 + "primaryKey": false, 2906 + "notNull": true, 2907 + "autoincrement": false 2908 + }, 2909 + "expires": { 2910 + "name": "expires", 2911 + "type": "integer", 2912 + "primaryKey": false, 2913 + "notNull": true, 2914 + "autoincrement": false 2915 + } 2916 + }, 2917 + "indexes": {}, 2918 + "foreignKeys": { 2919 + "viewer_session_user_id_viewer_id_fk": { 2920 + "name": "viewer_session_user_id_viewer_id_fk", 2921 + "tableFrom": "viewer_session", 2922 + "tableTo": "viewer", 2923 + "columnsFrom": [ 2924 + "user_id" 2925 + ], 2926 + "columnsTo": [ 2927 + "id" 2928 + ], 2929 + "onDelete": "cascade", 2930 + "onUpdate": "no action" 2931 + } 2932 + }, 2933 + "compositePrimaryKeys": {}, 2934 + "uniqueConstraints": {}, 2935 + "checkConstraints": {} 2936 + }, 2937 + "api_key": { 2938 + "name": "api_key", 2939 + "columns": { 2940 + "id": { 2941 + "name": "id", 2942 + "type": "integer", 2943 + "primaryKey": true, 2944 + "notNull": true, 2945 + "autoincrement": true 2946 + }, 2947 + "name": { 2948 + "name": "name", 2949 + "type": "text", 2950 + "primaryKey": false, 2951 + "notNull": true, 2952 + "autoincrement": false 2953 + }, 2954 + "description": { 2955 + "name": "description", 2956 + "type": "text", 2957 + "primaryKey": false, 2958 + "notNull": false, 2959 + "autoincrement": false 2960 + }, 2961 + "prefix": { 2962 + "name": "prefix", 2963 + "type": "text", 2964 + "primaryKey": false, 2965 + "notNull": true, 2966 + "autoincrement": false 2967 + }, 2968 + "hashed_token": { 2969 + "name": "hashed_token", 2970 + "type": "text", 2971 + "primaryKey": false, 2972 + "notNull": true, 2973 + "autoincrement": false 2974 + }, 2975 + "workspace_id": { 2976 + "name": "workspace_id", 2977 + "type": "integer", 2978 + "primaryKey": false, 2979 + "notNull": true, 2980 + "autoincrement": false 2981 + }, 2982 + "created_by_id": { 2983 + "name": "created_by_id", 2984 + "type": "integer", 2985 + "primaryKey": false, 2986 + "notNull": true, 2987 + "autoincrement": false 2988 + }, 2989 + "created_at": { 2990 + "name": "created_at", 2991 + "type": "integer", 2992 + "primaryKey": false, 2993 + "notNull": false, 2994 + "autoincrement": false, 2995 + "default": "(strftime('%s', 'now'))" 2996 + }, 2997 + "expires_at": { 2998 + "name": "expires_at", 2999 + "type": "integer", 3000 + "primaryKey": false, 3001 + "notNull": false, 3002 + "autoincrement": false 3003 + }, 3004 + "last_used_at": { 3005 + "name": "last_used_at", 3006 + "type": "integer", 3007 + "primaryKey": false, 3008 + "notNull": false, 3009 + "autoincrement": false 3010 + } 3011 + }, 3012 + "indexes": { 3013 + "api_key_prefix_unique": { 3014 + "name": "api_key_prefix_unique", 3015 + "columns": [ 3016 + "prefix" 3017 + ], 3018 + "isUnique": true 3019 + }, 3020 + "api_key_hashed_token_unique": { 3021 + "name": "api_key_hashed_token_unique", 3022 + "columns": [ 3023 + "hashed_token" 3024 + ], 3025 + "isUnique": true 3026 + }, 3027 + "api_key_prefix_idx": { 3028 + "name": "api_key_prefix_idx", 3029 + "columns": [ 3030 + "prefix" 3031 + ], 3032 + "isUnique": false 3033 + } 3034 + }, 3035 + "foreignKeys": { 3036 + "api_key_workspace_id_workspace_id_fk": { 3037 + "name": "api_key_workspace_id_workspace_id_fk", 3038 + "tableFrom": "api_key", 3039 + "tableTo": "workspace", 3040 + "columnsFrom": [ 3041 + "workspace_id" 3042 + ], 3043 + "columnsTo": [ 3044 + "id" 3045 + ], 3046 + "onDelete": "cascade", 3047 + "onUpdate": "no action" 3048 + }, 3049 + "api_key_created_by_id_user_id_fk": { 3050 + "name": "api_key_created_by_id_user_id_fk", 3051 + "tableFrom": "api_key", 3052 + "tableTo": "user", 3053 + "columnsFrom": [ 3054 + "created_by_id" 3055 + ], 3056 + "columnsTo": [ 3057 + "id" 3058 + ], 3059 + "onDelete": "cascade", 3060 + "onUpdate": "no action" 3061 + } 3062 + }, 3063 + "compositePrimaryKeys": {}, 3064 + "uniqueConstraints": {}, 3065 + "checkConstraints": {} 3066 + } 3067 + }, 3068 + "views": {}, 3069 + "enums": {}, 3070 + "_meta": { 3071 + "schemas": {}, 3072 + "tables": {}, 3073 + "columns": {} 3074 + }, 3075 + "internal": { 3076 + "indexes": {} 3077 + } 3078 + }

+7

packages/db/drizzle/meta/_journal.json

··· 372 372 "when": 1767797078062, 373 373 "tag": "0052_illegal_killraven", 374 374 "breakpoints": true 375 + }, 376 + { 377 + "idx": 53, 378 + "version": "6", 379 + "when": 1736935200000, 380 + "tag": "0053_groovy_doctor_strange", 381 + "breakpoints": true 375 382 } 376 383 ] 377 384 }

+1

packages/db/src/schema/page_subscribers/page_subscribers.ts

··· 14 14 token: text("token"), 15 15 acceptedAt: integer("accepted_at", { mode: "timestamp" }), 16 16 expiresAt: integer("expires_at", { mode: "timestamp" }), 17 + unsubscribedAt: integer("unsubscribed_at", { mode: "timestamp" }), 17 18 createdAt: integer("created_at", { mode: "timestamp" }).default( 18 19 sql`(strftime('%s', 'now'))`, 19 20 ),

+21 -4

packages/emails/emails/status-report.tsx

··· 6 6 Head, 7 7 Heading, 8 8 Html, 9 + Link, 9 10 Markdown, 10 11 Preview, 11 12 Row, 13 + Section, 12 14 Text, 13 15 } from "@react-email/components"; 14 16 import { z } from "zod"; ··· 29 31 message: z.string(), 30 32 reportTitle: z.string(), 31 33 monitors: z.array(z.string()), 34 + unsubscribeUrl: z.string().url().optional(), 32 35 }); 33 36 34 37 export type StatusReportProps = z.infer<typeof StatusReportSchema>; ··· 57 60 reportTitle, 58 61 pageTitle, 59 62 monitors, 63 + unsubscribeUrl, 60 64 }: StatusReportProps) { 61 65 return ( 62 66 <Html> ··· 110 114 <Markdown>{message}</Markdown> 111 115 </Column> 112 116 </Row> 117 + {unsubscribeUrl && ( 118 + <Section style={{ marginTop: "24px", textAlign: "center" }}> 119 + <Text style={{ fontSize: "12px", color: "#6b7280" }}> 120 + <Link 121 + href={unsubscribeUrl} 122 + style={{ color: "#6b7280", textDecoration: "underline" }} 123 + > 124 + Unsubscribe 125 + </Link>{" "} 126 + from these notifications. 127 + </Text> 128 + </Section> 129 + )} 113 130 </Layout> 114 131 </Body> 115 132 </Html> 116 133 ); 117 134 } 118 - 119 - // TODO: add unsubscribe link! 120 135 121 136 StatusReportEmail.PreviewProps = { 122 137 pageTitle: "OpenStatus Status", ··· 132 147 133 148 --- 134 149 135 - ### What’s Changed 150 + ### What's Changed 136 151 137 152 - All queued workflows are now being picked up and completed successfully. 138 153 - Jobs are running normally on our GitHub App. ### Current Issue: Cache Action Unavailable Attempts to re-publish our action to GitHub Marketplace are returning 500 Internal Server Errors. This prevents the updated versions from going live. ··· 143 158 144 159 ### Next Update 145 160 146 - We’ll post another update by **19:00 UTC** today or sooner if critical developments occur. We apologize for the inconvenience and appreciate your patience as we restore full cache functionality. 161 + We'll post another update by **19:00 UTC** today or sooner if critical developments occur. We apologize for the inconvenience and appreciate your patience as we restore full cache functionality. 147 162 `, 148 163 monitors: ["OpenStatus API", "OpenStatus Webhook"], 164 + unsubscribeUrl: 165 + "https://status.openstatus.dev/unsubscribe/550e8400-e29b-41d4-a716-446655440000", 149 166 }; 150 167 151 168 export default StatusReportEmail;

+128

packages/emails/src/client.integration.test.tsx

··· 1 + /** @jsxImportSource react */ 2 + 3 + import { describe, expect, test } from "bun:test"; 4 + import { render } from "@react-email/render"; 5 + import StatusReportEmail from "../emails/status-report"; 6 + 7 + describe("Status Report Email - Unsubscribe Link in Body", () => { 8 + const unsubscribeUrl = 9 + "https://openstatus.openstatus.dev/unsubscribe/test-token"; 10 + 11 + test("should include unsubscribe link in email body when URL is provided", async () => { 12 + const html = await render( 13 + <StatusReportEmail 14 + pageTitle="Test Page" 15 + reportTitle="Test Report" 16 + status="investigating" 17 + date={new Date().toISOString()} 18 + message="Test message" 19 + monitors={["Monitor 1"]} 20 + unsubscribeUrl={unsubscribeUrl} 21 + />, 22 + ); 23 + 24 + expect(html).toContain(unsubscribeUrl); 25 + expect(html).toContain("Unsubscribe"); 26 + }); 27 + 28 + test("should not include unsubscribe section when URL is not provided", async () => { 29 + const html = await render( 30 + <StatusReportEmail 31 + pageTitle="Test Page" 32 + reportTitle="Test Report" 33 + status="investigating" 34 + date={new Date().toISOString()} 35 + message="Test message" 36 + monitors={["Monitor 1"]} 37 + />, 38 + ); 39 + 40 + // Should not contain the unsubscribe text when no URL provided 41 + expect(html).not.toContain("from these notifications"); 42 + }); 43 + 44 + test("should render unsubscribe link as clickable", async () => { 45 + const html = await render( 46 + <StatusReportEmail 47 + pageTitle="Test Page" 48 + reportTitle="Test Report" 49 + status="investigating" 50 + date={new Date().toISOString()} 51 + message="Test message" 52 + monitors={["Monitor 1"]} 53 + unsubscribeUrl={unsubscribeUrl} 54 + />, 55 + ); 56 + 57 + // Check that the URL is in an href attribute 58 + expect(html).toContain(`href="${unsubscribeUrl}"`); 59 + }); 60 + 61 + test("should display unsubscribe link with proper styling", async () => { 62 + const html = await render( 63 + <StatusReportEmail 64 + pageTitle="Test Page" 65 + reportTitle="Test Report" 66 + status="investigating" 67 + date={new Date().toISOString()} 68 + message="Test message" 69 + monitors={["Monitor 1"]} 70 + unsubscribeUrl={unsubscribeUrl} 71 + />, 72 + ); 73 + 74 + // Check for muted styling (gray color for footer) 75 + expect(html).toContain("#6b7280"); 76 + }); 77 + }); 78 + 79 + describe("Status Report Email - Email Content Validation", () => { 80 + test("should include all required email fields", async () => { 81 + const props = { 82 + pageTitle: "OpenStatus", 83 + reportTitle: "API Outage", 84 + status: "investigating" as const, 85 + date: "2024-01-15T10:00:00.000Z", 86 + message: "We are investigating the issue", 87 + monitors: ["API", "Web"], 88 + unsubscribeUrl: "https://openstatus.openstatus.dev/unsubscribe/test", 89 + }; 90 + 91 + const html = await render(<StatusReportEmail {...props} />); 92 + 93 + expect(html).toContain(props.pageTitle); 94 + expect(html).toContain(props.reportTitle); 95 + expect(html).toContain(props.message); 96 + expect(html).toContain("API"); 97 + expect(html).toContain("Web"); 98 + expect(html).toContain(props.unsubscribeUrl); 99 + }); 100 + 101 + test("should handle all status types correctly", async () => { 102 + const statuses = [ 103 + "investigating", 104 + "identified", 105 + "monitoring", 106 + "resolved", 107 + "maintenance", 108 + ] as const; 109 + 110 + for (const status of statuses) { 111 + const html = await render( 112 + <StatusReportEmail 113 + pageTitle="Test" 114 + reportTitle="Test Report" 115 + status={status} 116 + date={new Date().toISOString()} 117 + message="Test" 118 + monitors={[]} 119 + unsubscribeUrl="https://example.com/unsubscribe" 120 + />, 121 + ); 122 + 123 + // Should render without errors and contain the status 124 + // Note: status is rendered lowercase in HTML with text-transform: uppercase CSS 125 + expect(html).toContain(status); 126 + } 127 + }); 128 + });

+28 -14

packages/emails/src/client.tsx

··· 90 90 } 91 91 92 92 public async sendStatusReportUpdate( 93 - req: StatusReportProps & { to: string[] }, 93 + req: StatusReportProps & { 94 + subscribers: Array<{ email: string; token: string }>; 95 + pageSlug: string; 96 + customDomain?: string | null; 97 + }, 94 98 ) { 99 + const statusPageBaseUrl = req.customDomain 100 + ? `https://${req.customDomain}` 101 + : `https://${req.pageSlug}.openstatus.dev`; 102 + 95 103 if (process.env.NODE_ENV === "development") { 96 104 console.log( 97 - `Sending status report update emails to ${req.to.join(", ")}`, 105 + `Sending status report update emails to ${req.subscribers 106 + .map((s) => s.email) 107 + .join(", ")}`, 98 108 ); 99 109 return; 100 110 } 101 111 102 - // const html = await render(<StatusReportEmail {...req} />); 103 - 104 - for (const recipients of chunk(req.to, 100)) { 112 + for (const recipients of chunk(req.subscribers, 100)) { 105 113 const sendEmail = Effect.tryPromise({ 106 114 try: () => 107 115 this.client.batch.send( 108 - recipients.map((subscriber) => ({ 109 - from: `${req.pageTitle} <notifications@notifications.openstatus.dev>`, 110 - subject: req.reportTitle, 111 - to: subscriber, 112 - // html, 113 - react: <StatusReportEmail {...req} />, 114 - })), 116 + recipients.map((subscriber) => { 117 + const unsubscribeUrl = `${statusPageBaseUrl}/unsubscribe/${subscriber.token}`; 118 + return { 119 + from: `${req.pageTitle} <notifications@notifications.openstatus.dev>`, 120 + subject: req.reportTitle, 121 + to: subscriber.email, 122 + react: ( 123 + <StatusReportEmail {...req} unsubscribeUrl={unsubscribeUrl} /> 124 + ), 125 + }; 126 + }), 115 127 ), 116 128 catch: (_unknown) => 117 129 new Error( 118 - `Error sending status report update batch to ${recipients}`, 130 + `Error sending status report update batch to ${recipients.map( 131 + (r) => r.email, 132 + )}`, 119 133 ), 120 134 }).pipe( 121 135 Effect.andThen((result) => ··· 130 144 } 131 145 132 146 console.log( 133 - `Sent status report update email to ${req.to.length} subscribers`, 147 + `Sent status report update email to ${req.subscribers.length} subscribers`, 134 148 ); 135 149 } 136 150

+4

ralph/.gitignore

··· 1 + # Ignore PRD and progress files as they are specific to local development 2 + prd.json 3 + progress.txt 4 +

ralph/afk-ralph.sh

-8

ralph/prd.json

··· 1 - [ 2 - { 3 - "category": "functional", 4 - "description": "When a user is on wrong dashboard /status-pages/[id] redirect him to /status-pages", 5 - "steps": ["Redirect user no access for page id", "Avoid throwing an error"], 6 - "passes": false 7 - } 8 - ]

-13

ralph/progress.txt

··· 1 - ## Completed Tasks 2 - 3 - ### Task 1: Redirect user with no access for status-pages/[id] 4 - - **PRD Item**: "When a user is on wrong dashboard /status-pages/[id] redirect him to /status-pages" 5 - - **Status**: COMPLETED 6 - - **Commit**: b72b1bf5 7 - - **Changes Made**: 8 - - Modified `apps/dashboard/src/app/(dashboard)/status-pages/[id]/layout.tsx` 9 - - Changed from `prefetchQuery` to `fetchQuery` to properly check page access 10 - - Added try-catch block to handle errors when user doesn't have access to the page 11 - - Redirects to `/status-pages` instead of throwing an error when: 12 - - Page doesn't exist 13 - - User doesn't have access to the page (wrong workspace)