+576

apps/server/src/routes/v1/__test__/sync.test.ts

··· 1 1 + import { afterAll, beforeAll, describe, expect, test } from "bun:test"; 2 2 + import { and, db, eq, inArray } from "@openstatus/db"; 3 3 + import { 4 4 + maintenance, 5 5 + maintenancesToMonitors, 6 6 + maintenancesToPageComponents, 7 7 + monitor, 8 8 + monitorsToPages, 9 9 + monitorsToStatusReport, 10 10 + page, 11 11 + pageComponent, 12 12 + statusReport, 13 13 + statusReportUpdate, 14 14 + statusReportsToPageComponents, 15 15 + } from "@openstatus/db/src/schema"; 16 16 + 17 17 + import { app } from "@/index"; 18 18 + 19 19 + /** 20 20 + * Sync Tests for REST API: Verify that mutations to legacy tables also sync to new page_component tables 21 21 + * 22 22 + * These tests use the REST API endpoints and verify that the sync operations 23 23 + * correctly update the new page_component related tables. 24 24 + */ 25 25 + 26 26 + const TEST_PREFIX = "api-sync-test"; 27 27 + let testPageId: number; 28 28 + let testMonitorId: number; 29 29 + 30 30 + beforeAll(async () => { 31 31 + // Clean up any existing test data 32 32 + await db 33 33 + .delete(pageComponent) 34 34 + .where(eq(pageComponent.name, `${TEST_PREFIX}-monitor`)); 35 35 + await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-page`)); 36 36 + await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-monitor`)); 37 37 + 38 38 + // Create test page 39 39 + const testPage = await db 40 40 + .insert(page) 41 41 + .values({ 42 42 + workspaceId: 1, 43 43 + title: "API Sync Test Page", 44 44 + description: "A test page for API sync tests", 45 45 + slug: `${TEST_PREFIX}-page`, 46 46 + customDomain: "", 47 47 + }) 48 48 + .returning() 49 49 + .get(); 50 50 + testPageId = testPage.id; 51 51 + 52 52 + // Create test monitor 53 53 + const testMonitor = await db 54 54 + .insert(monitor) 55 55 + .values({ 56 56 + workspaceId: 1, 57 57 + name: `${TEST_PREFIX}-monitor`, 58 58 + url: "https://api-sync-test.example.com", 59 59 + periodicity: "1m", 60 60 + active: true, 61 61 + regions: "ams", 62 62 + jobType: "http", 63 63 + }) 64 64 + .returning() 65 65 + .get(); 66 66 + testMonitorId = testMonitor.id; 67 67 + 68 68 + // Add monitor to page (creates monitors_to_pages entry) 69 69 + await db.insert(monitorsToPages).values({ 70 70 + monitorId: testMonitorId, 71 71 + pageId: testPageId, 72 72 + }); 73 73 + 74 74 + // Create page_component for the monitor (simulating initial sync) 75 75 + await db 76 76 + .insert(pageComponent) 77 77 + .values({ 78 78 + workspaceId: 1, 79 79 + pageId: testPageId, 80 80 + monitorId: testMonitorId, 81 81 + type: "monitor", 82 82 + name: `${TEST_PREFIX}-monitor`, 83 83 + }) 84 84 + .onConflictDoNothing(); 85 85 + }); 86 86 + 87 87 + afterAll(async () => { 88 88 + // Clean up test data in correct order 89 89 + await db 90 90 + .delete(maintenancesToPageComponents) 91 91 + .where( 92 92 + inArray( 93 93 + maintenancesToPageComponents.pageComponentId, 94 94 + db 95 95 + .select({ id: pageComponent.id }) 96 96 + .from(pageComponent) 97 97 + .where(eq(pageComponent.pageId, testPageId)), 98 98 + ), 99 99 + ); 100 100 + await db 101 101 + .delete(statusReportsToPageComponents) 102 102 + .where( 103 103 + inArray( 104 104 + statusReportsToPageComponents.pageComponentId, 105 105 + db 106 106 + .select({ id: pageComponent.id }) 107 107 + .from(pageComponent) 108 108 + .where(eq(pageComponent.pageId, testPageId)), 109 109 + ), 110 110 + ); 111 111 + await db.delete(pageComponent).where(eq(pageComponent.pageId, testPageId)); 112 112 + await db 113 113 + .delete(monitorsToPages) 114 114 + .where(eq(monitorsToPages.pageId, testPageId)); 115 115 + await db 116 116 + .delete(maintenancesToMonitors) 117 117 + .where(eq(maintenancesToMonitors.monitorId, testMonitorId)); 118 118 + await db 119 119 + .delete(monitorsToStatusReport) 120 120 + .where(eq(monitorsToStatusReport.monitorId, testMonitorId)); 121 121 + await db 122 122 + .delete(statusReportUpdate) 123 123 + .where( 124 124 + inArray( 125 125 + statusReportUpdate.statusReportId, 126 126 + db 127 127 + .select({ id: statusReport.id }) 128 128 + .from(statusReport) 129 129 + .where(eq(statusReport.pageId, testPageId)), 130 130 + ), 131 131 + ); 132 132 + await db.delete(statusReport).where(eq(statusReport.pageId, testPageId)); 133 133 + await db.delete(maintenance).where(eq(maintenance.pageId, testPageId)); 134 134 + await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-page`)); 135 135 + await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-monitor`)); 136 136 + }); 137 137 + 138 138 + describe("API Sync: POST /v1/maintenance - maintenance_to_page_component", () => { 139 139 + let createdMaintenanceId: number; 140 140 + 141 141 + afterAll(async () => { 142 142 + if (createdMaintenanceId) { 143 143 + await db 144 144 + .delete(maintenancesToPageComponents) 145 145 + .where( 146 146 + eq(maintenancesToPageComponents.maintenanceId, createdMaintenanceId), 147 147 + ); 148 148 + await db 149 149 + .delete(maintenancesToMonitors) 150 150 + .where(eq(maintenancesToMonitors.maintenanceId, createdMaintenanceId)); 151 151 + await db 152 152 + .delete(maintenance) 153 153 + .where(eq(maintenance.id, createdMaintenanceId)); 154 154 + } 155 155 + }); 156 156 + 157 157 + test("creating maintenance with monitors syncs to maintenance_to_page_component", async () => { 158 158 + const from = new Date(); 159 159 + const to = new Date(from.getTime() + 3600000); 160 160 + 161 161 + const res = await app.request("/v1/maintenance", { 162 162 + method: "POST", 163 163 + headers: { 164 164 + "x-openstatus-key": "1", 165 165 + "content-type": "application/json", 166 166 + }, 167 167 + body: JSON.stringify({ 168 168 + title: `${TEST_PREFIX} Maintenance`, 169 169 + message: "Test maintenance for sync", 170 170 + from: from.toISOString(), 171 171 + to: to.toISOString(), 172 172 + monitorIds: [testMonitorId], 173 173 + pageId: testPageId, 174 174 + }), 175 175 + }); 176 176 + 177 177 + expect(res.status).toBe(200); 178 178 + 179 179 + const data = await res.json(); 180 180 + createdMaintenanceId = data.id; 181 181 + 182 182 + // Verify maintenance_to_monitor was created 183 183 + const maintenanceToMonitor = 184 184 + await db.query.maintenancesToMonitors.findFirst({ 185 185 + where: and( 186 186 + eq(maintenancesToMonitors.maintenanceId, createdMaintenanceId), 187 187 + eq(maintenancesToMonitors.monitorId, testMonitorId), 188 188 + ), 189 189 + }); 190 190 + expect(maintenanceToMonitor).toBeDefined(); 191 191 + 192 192 + // Verify maintenance_to_page_component was synced 193 193 + const component = await db.query.pageComponent.findFirst({ 194 194 + where: and( 195 195 + eq(pageComponent.monitorId, testMonitorId), 196 196 + eq(pageComponent.pageId, testPageId), 197 197 + ), 198 198 + }); 199 199 + 200 200 + if (component) { 201 201 + const maintenanceToComponent = 202 202 + await db.query.maintenancesToPageComponents.findFirst({ 203 203 + where: and( 204 204 + eq( 205 205 + maintenancesToPageComponents.maintenanceId, 206 206 + createdMaintenanceId, 207 207 + ), 208 208 + eq(maintenancesToPageComponents.pageComponentId, component.id), 209 209 + ), 210 210 + }); 211 211 + expect(maintenanceToComponent).toBeDefined(); 212 212 + } 213 213 + }); 214 214 + }); 215 215 + 216 216 + describe("API Sync: PUT /v1/maintenance - maintenance_to_page_component updates", () => { 217 217 + let testMaintenanceId: number; 218 218 + 219 219 + beforeAll(async () => { 220 220 + // Create a maintenance for update tests 221 221 + const from = new Date(); 222 222 + const to = new Date(from.getTime() + 3600000); 223 223 + 224 224 + const newMaintenance = await db 225 225 + .insert(maintenance) 226 226 + .values({ 227 227 + workspaceId: 1, 228 228 + pageId: testPageId, 229 229 + title: `${TEST_PREFIX} Update Test Maintenance`, 230 230 + message: "For update tests", 231 231 + from, 232 232 + to, 233 233 + }) 234 234 + .returning() 235 235 + .get(); 236 236 + testMaintenanceId = newMaintenance.id; 237 237 + 238 238 + // Add monitor to maintenance 239 239 + await db.insert(maintenancesToMonitors).values({ 240 240 + maintenanceId: testMaintenanceId, 241 241 + monitorId: testMonitorId, 242 242 + }); 243 243 + 244 244 + // Sync to page component 245 245 + const component = await db.query.pageComponent.findFirst({ 246 246 + where: and( 247 247 + eq(pageComponent.monitorId, testMonitorId), 248 248 + eq(pageComponent.pageId, testPageId), 249 249 + ), 250 250 + }); 251 251 + 252 252 + if (component) { 253 253 + await db 254 254 + .insert(maintenancesToPageComponents) 255 255 + .values({ 256 256 + maintenanceId: testMaintenanceId, 257 257 + pageComponentId: component.id, 258 258 + }) 259 259 + .onConflictDoNothing(); 260 260 + } 261 261 + }); 262 262 + 263 263 + afterAll(async () => { 264 264 + if (testMaintenanceId) { 265 265 + await db 266 266 + .delete(maintenancesToPageComponents) 267 267 + .where( 268 268 + eq(maintenancesToPageComponents.maintenanceId, testMaintenanceId), 269 269 + ); 270 270 + await db 271 271 + .delete(maintenancesToMonitors) 272 272 + .where(eq(maintenancesToMonitors.maintenanceId, testMaintenanceId)); 273 273 + await db.delete(maintenance).where(eq(maintenance.id, testMaintenanceId)); 274 274 + } 275 275 + }); 276 276 + 277 277 + test("removing monitors from maintenance syncs delete to maintenance_to_page_component", async () => { 278 278 + const res = await app.request(`/v1/maintenance/${testMaintenanceId}`, { 279 279 + method: "PUT", 280 280 + headers: { 281 281 + "x-openstatus-key": "1", 282 282 + "content-type": "application/json", 283 283 + }, 284 284 + body: JSON.stringify({ 285 285 + monitorIds: [], 286 286 + }), 287 287 + }); 288 288 + 289 289 + expect(res.status).toBe(200); 290 290 + 291 291 + // Verify maintenance_to_monitor was deleted 292 292 + const maintenanceToMonitor = 293 293 + await db.query.maintenancesToMonitors.findFirst({ 294 294 + where: and( 295 295 + eq(maintenancesToMonitors.maintenanceId, testMaintenanceId), 296 296 + eq(maintenancesToMonitors.monitorId, testMonitorId), 297 297 + ), 298 298 + }); 299 299 + expect(maintenanceToMonitor).toBeUndefined(); 300 300 + 301 301 + // Verify maintenance_to_page_component was also deleted 302 302 + const maintenanceToComponent = 303 303 + await db.query.maintenancesToPageComponents.findFirst({ 304 304 + where: eq( 305 305 + maintenancesToPageComponents.maintenanceId, 306 306 + testMaintenanceId, 307 307 + ), 308 308 + }); 309 309 + expect(maintenanceToComponent).toBeUndefined(); 310 310 + }); 311 311 + }); 312 312 + 313 313 + describe("API Sync: POST /v1/status_report - status_report_to_page_component", () => { 314 314 + let createdStatusReportId: number; 315 315 + 316 316 + afterAll(async () => { 317 317 + if (createdStatusReportId) { 318 318 + await db 319 319 + .delete(statusReportsToPageComponents) 320 320 + .where( 321 321 + eq( 322 322 + statusReportsToPageComponents.statusReportId, 323 323 + createdStatusReportId, 324 324 + ), 325 325 + ); 326 326 + await db 327 327 + .delete(monitorsToStatusReport) 328 328 + .where( 329 329 + eq(monitorsToStatusReport.statusReportId, createdStatusReportId), 330 330 + ); 331 331 + await db 332 332 + .delete(statusReportUpdate) 333 333 + .where(eq(statusReportUpdate.statusReportId, createdStatusReportId)); 334 334 + await db 335 335 + .delete(statusReport) 336 336 + .where(eq(statusReport.id, createdStatusReportId)); 337 337 + } 338 338 + }); 339 339 + 340 340 + test("creating status report with monitors syncs to status_report_to_page_component", async () => { 341 341 + const res = await app.request("/v1/status_report", { 342 342 + method: "POST", 343 343 + headers: { 344 344 + "x-openstatus-key": "1", 345 345 + "content-type": "application/json", 346 346 + }, 347 347 + body: JSON.stringify({ 348 348 + title: `${TEST_PREFIX} Status Report`, 349 349 + status: "investigating", 350 350 + message: "Test status report for sync", 351 351 + monitorIds: [testMonitorId], 352 352 + pageId: testPageId, 353 353 + }), 354 354 + }); 355 355 + 356 356 + expect(res.status).toBe(200); 357 357 + 358 358 + const data = await res.json(); 359 359 + createdStatusReportId = data.id; 360 360 + 361 361 + // Verify status_report_to_monitors was created 362 362 + const reportToMonitor = await db.query.monitorsToStatusReport.findFirst({ 363 363 + where: and( 364 364 + eq(monitorsToStatusReport.statusReportId, createdStatusReportId), 365 365 + eq(monitorsToStatusReport.monitorId, testMonitorId), 366 366 + ), 367 367 + }); 368 368 + expect(reportToMonitor).toBeDefined(); 369 369 + 370 370 + // Verify status_report_to_page_component was synced 371 371 + const component = await db.query.pageComponent.findFirst({ 372 372 + where: and( 373 373 + eq(pageComponent.monitorId, testMonitorId), 374 374 + eq(pageComponent.pageId, testPageId), 375 375 + ), 376 376 + }); 377 377 + 378 378 + if (component) { 379 379 + const reportToComponent = 380 380 + await db.query.statusReportsToPageComponents.findFirst({ 381 381 + where: and( 382 382 + eq( 383 383 + statusReportsToPageComponents.statusReportId, 384 384 + createdStatusReportId, 385 385 + ), 386 386 + eq(statusReportsToPageComponents.pageComponentId, component.id), 387 387 + ), 388 388 + }); 389 389 + expect(reportToComponent).toBeDefined(); 390 390 + } 391 391 + }); 392 392 + }); 393 393 + 394 394 + describe("API Sync: POST /v1/page - monitors_to_pages -> page_component", () => { 395 395 + let createdPageId: number; 396 396 + 397 397 + afterAll(async () => { 398 398 + if (createdPageId) { 399 399 + await db 400 400 + .delete(pageComponent) 401 401 + .where(eq(pageComponent.pageId, createdPageId)); 402 402 + await db 403 403 + .delete(monitorsToPages) 404 404 + .where(eq(monitorsToPages.pageId, createdPageId)); 405 405 + await db.delete(page).where(eq(page.id, createdPageId)); 406 406 + } 407 407 + }); 408 408 + 409 409 + test("creating page with monitors syncs to page_component", async () => { 410 410 + const res = await app.request("/v1/page", { 411 411 + method: "POST", 412 412 + headers: { 413 413 + "x-openstatus-key": "1", 414 414 + "content-type": "application/json", 415 415 + }, 416 416 + body: JSON.stringify({ 417 417 + title: `${TEST_PREFIX} New Page`, 418 418 + description: "Test page for sync", 419 419 + slug: `${TEST_PREFIX}-new-page`, 420 420 + monitors: [testMonitorId], 421 421 + }), 422 422 + }); 423 423 + 424 424 + expect(res.status).toBe(200); 425 425 + 426 426 + const data = await res.json(); 427 427 + createdPageId = data.id; 428 428 + 429 429 + // Verify monitors_to_pages was created 430 430 + const monitorToPage = await db.query.monitorsToPages.findFirst({ 431 431 + where: and( 432 432 + eq(monitorsToPages.monitorId, testMonitorId), 433 433 + eq(monitorsToPages.pageId, createdPageId), 434 434 + ), 435 435 + }); 436 436 + expect(monitorToPage).toBeDefined(); 437 437 + 438 438 + // Verify page_component was synced 439 439 + const component = await db.query.pageComponent.findFirst({ 440 440 + where: and( 441 441 + eq(pageComponent.monitorId, testMonitorId), 442 442 + eq(pageComponent.pageId, createdPageId), 443 443 + ), 444 444 + }); 445 445 + expect(component).toBeDefined(); 446 446 + expect(component?.type).toBe("monitor"); 447 447 + }); 448 448 + }); 449 449 + 450 450 + describe("API Sync: PUT /v1/page - monitors_to_pages -> page_component updates", () => { 451 451 + let updateTestPageId: number; 452 452 + 453 453 + beforeAll(async () => { 454 454 + // Create a page for update tests 455 455 + const updateTestPage = await db 456 456 + .insert(page) 457 457 + .values({ 458 458 + workspaceId: 1, 459 459 + title: `${TEST_PREFIX} Update Test Page`, 460 460 + description: "For update tests", 461 461 + slug: `${TEST_PREFIX}-update-page`, 462 462 + customDomain: "", 463 463 + }) 464 464 + .returning() 465 465 + .get(); 466 466 + updateTestPageId = updateTestPage.id; 467 467 + }); 468 468 + 469 469 + afterAll(async () => { 470 470 + if (updateTestPageId) { 471 471 + await db 472 472 + .delete(pageComponent) 473 473 + .where(eq(pageComponent.pageId, updateTestPageId)); 474 474 + await db 475 475 + .delete(monitorsToPages) 476 476 + .where(eq(monitorsToPages.pageId, updateTestPageId)); 477 477 + await db.delete(page).where(eq(page.id, updateTestPageId)); 478 478 + } 479 479 + }); 480 480 + 481 481 + test("adding monitors to page syncs to page_component", async () => { 482 482 + const res = await app.request(`/v1/page/${updateTestPageId}`, { 483 483 + method: "PUT", 484 484 + headers: { 485 485 + "x-openstatus-key": "1", 486 486 + "content-type": "application/json", 487 487 + }, 488 488 + body: JSON.stringify({ 489 489 + monitors: [testMonitorId], 490 490 + }), 491 491 + }); 492 492 + 493 493 + expect(res.status).toBe(200); 494 494 + 495 495 + // Verify monitors_to_pages was created 496 496 + const monitorToPage = await db.query.monitorsToPages.findFirst({ 497 497 + where: and( 498 498 + eq(monitorsToPages.monitorId, testMonitorId), 499 499 + eq(monitorsToPages.pageId, updateTestPageId), 500 500 + ), 501 501 + }); 502 502 + expect(monitorToPage).toBeDefined(); 503 503 + 504 504 + // Verify page_component was synced 505 505 + const component = await db.query.pageComponent.findFirst({ 506 506 + where: and( 507 507 + eq(pageComponent.monitorId, testMonitorId), 508 508 + eq(pageComponent.pageId, updateTestPageId), 509 509 + ), 510 510 + }); 511 511 + expect(component).toBeDefined(); 512 512 + }); 513 513 + 514 514 + test("removing monitors from page syncs delete to page_component", async () => { 515 515 + // First ensure monitor is on the page 516 516 + await db 517 517 + .insert(monitorsToPages) 518 518 + .values({ 519 519 + monitorId: testMonitorId, 520 520 + pageId: updateTestPageId, 521 521 + }) 522 522 + .onConflictDoNothing(); 523 523 + 524 524 + await db 525 525 + .insert(pageComponent) 526 526 + .values({ 527 527 + workspaceId: 1, 528 528 + pageId: updateTestPageId, 529 529 + monitorId: testMonitorId, 530 530 + type: "monitor", 531 531 + name: `${TEST_PREFIX}-monitor`, 532 532 + }) 533 533 + .onConflictDoNothing(); 534 534 + 535 535 + // Verify page_component exists before removal 536 536 + let component = await db.query.pageComponent.findFirst({ 537 537 + where: and( 538 538 + eq(pageComponent.monitorId, testMonitorId), 539 539 + eq(pageComponent.pageId, updateTestPageId), 540 540 + ), 541 541 + }); 542 542 + expect(component).toBeDefined(); 543 543 + 544 544 + // Remove all monitors 545 545 + const res = await app.request(`/v1/page/${updateTestPageId}`, { 546 546 + method: "PUT", 547 547 + headers: { 548 548 + "x-openstatus-key": "1", 549 549 + "content-type": "application/json", 550 550 + }, 551 551 + body: JSON.stringify({ 552 552 + monitors: [], 553 553 + }), 554 554 + }); 555 555 + 556 556 + expect(res.status).toBe(200); 557 557 + 558 558 + // Verify monitors_to_pages was deleted 559 559 + const monitorToPage = await db.query.monitorsToPages.findFirst({ 560 560 + where: and( 561 561 + eq(monitorsToPages.monitorId, testMonitorId), 562 562 + eq(monitorsToPages.pageId, updateTestPageId), 563 563 + ), 564 564 + }); 565 565 + expect(monitorToPage).toBeUndefined(); 566 566 + 567 567 + // Verify page_component was deleted 568 568 + component = await db.query.pageComponent.findFirst({ 569 569 + where: and( 570 570 + eq(pageComponent.monitorId, testMonitorId), 571 571 + eq(pageComponent.pageId, updateTestPageId), 572 572 + ), 573 573 + }); 574 574 + expect(component).toBeUndefined(); 575 575 + }); 576 576 + });

+15 -1

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

··· 3 3 import { trackMiddleware } from "@/libs/middlewares"; 4 4 import { createRoute } from "@hono/zod-openapi"; 5 5 import { Events } from "@openstatus/analytics"; 6 6 - import { and, db, eq, inArray, isNotNull, isNull } from "@openstatus/db"; 6 6 + import { 7 7 + and, 8 8 + db, 9 9 + eq, 10 10 + inArray, 11 11 + isNotNull, 12 12 + isNull, 13 13 + syncMaintenanceToMonitorInsertMany, 14 14 + } from "@openstatus/db"; 7 15 import { monitor, page, pageSubscriber } from "@openstatus/db/src/schema"; 8 16 import { 9 17 maintenance, ··· 110 118 })), 111 119 ) 112 120 .run(); 121 121 + // Sync to page components 122 122 + await syncMaintenanceToMonitorInsertMany( 123 123 + tx, 124 124 + newMaintenance.id, 125 125 + input.monitorIds, 126 126 + ); 113 127 } 114 128 115 129 return newMaintenance;

+13 -1

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

··· 2 2 import { trackMiddleware } from "@/libs/middlewares"; 3 3 import { createRoute } from "@hono/zod-openapi"; 4 4 import { Events } from "@openstatus/analytics"; 5 5 - import { and, db, eq, inArray, isNull } from "@openstatus/db"; 5 5 + import { 6 6 + and, 7 7 + db, 8 8 + eq, 9 9 + inArray, 10 10 + isNull, 11 11 + syncMaintenanceToMonitorDeleteByMaintenance, 12 12 + syncMaintenanceToMonitorInsertMany, 13 13 + } from "@openstatus/db"; 6 14 import { monitor, page } from "@openstatus/db/src/schema"; 7 15 import { 8 16 maintenance, ··· 128 136 .delete(maintenancesToMonitors) 129 137 .where(eq(maintenancesToMonitors.maintenanceId, Number(id))) 130 138 .run(); 139 139 + // Sync delete to page components 140 140 + await syncMaintenanceToMonitorDeleteByMaintenance(tx, Number(id)); 131 141 132 142 // Add new monitor associations 133 143 if (monitorIds.length > 0) { ··· 140 150 })), 141 151 ) 142 152 .run(); 153 153 + // Sync to page components 154 154 + await syncMaintenanceToMonitorInsertMany(tx, Number(id), monitorIds); 143 155 } 144 156 } 145 157

+14 -1

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

··· 1 1 import { createRoute } from "@hono/zod-openapi"; 2 2 3 3 - import { and, eq, inArray, isNull, sql } from "@openstatus/db"; 3 3 + import { 4 4 + and, 5 5 + eq, 6 6 + inArray, 7 7 + isNull, 8 8 + sql, 9 9 + syncMonitorsToPageInsert, 10 10 + } from "@openstatus/db"; 4 11 import { db } from "@openstatus/db/src/db"; 5 12 import { 6 13 monitor, ··· 182 189 .insert(monitorsToPages) 183 190 .values({ pageId: _page.id, ...values }) 184 191 .run(); 192 192 + // Sync to page components 193 193 + await syncMonitorsToPageInsert(db, { 194 194 + monitorId: values.monitorId, 195 195 + pageId: _page.id, 196 196 + order: "order" in values ? values.order : undefined, 197 197 + }); 185 198 } 186 199 } 187 200 const data = transformPageData(PageSchema.parse(_page));

+19 -1

apps/server/src/routes/v1/pages/put.ts

··· 3 3 import { OpenStatusApiError, openApiErrorResponses } from "@/libs/errors"; 4 4 import { trackMiddleware } from "@/libs/middlewares"; 5 5 import { Events } from "@openstatus/analytics"; 6 6 - import { and, eq, inArray, isNull, sql } from "@openstatus/db"; 6 6 + import { 7 7 + and, 8 8 + eq, 9 9 + inArray, 10 10 + isNull, 11 11 + sql, 12 12 + syncMonitorsToPageDelete, 13 13 + syncMonitorsToPageInsert, 14 14 + } from "@openstatus/db"; 7 15 import { db } from "@openstatus/db/src/db"; 8 16 import { 9 17 monitor, ··· 194 202 eq(monitorsToPages.pageId, newPage.id), 195 203 ), 196 204 ); 205 205 + // Sync delete to page components 206 206 + for (const monitorId of removedMonitors) { 207 207 + await syncMonitorsToPageDelete(db, { monitorId, pageId: newPage.id }); 208 208 + } 197 209 } 198 210 199 211 if (monitors) { ··· 208 220 target: [monitorsToPages.monitorId, monitorsToPages.pageId], 209 221 set: { order: sql.raw("excluded.`order`") }, 210 222 }); 223 223 + // Sync to page components (existing ones will be ignored due to onConflictDoNothing in sync) 224 224 + await syncMonitorsToPageInsert(db, { 225 225 + monitorId: values.monitorId, 226 226 + pageId: newPage.id, 227 227 + order: "order" in values ? values.order : undefined, 228 228 + }); 211 229 } 212 230 } 213 231

+15 -1

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

··· 1 1 import { createRoute, z } from "@hono/zod-openapi"; 2 2 3 3 - import { and, db, eq, inArray, isNotNull, isNull } from "@openstatus/db"; 3 3 + import { 4 4 + and, 5 5 + db, 6 6 + eq, 7 7 + inArray, 8 8 + isNotNull, 9 9 + isNull, 10 10 + syncStatusReportToMonitorInsertMany, 11 11 + } from "@openstatus/db"; 4 12 import { 5 13 monitor, 6 14 monitorsToStatusReport, ··· 133 141 }), 134 142 ) 135 143 .returning(); 144 144 + // Sync to page components 145 145 + await syncStatusReportToMonitorInsertMany( 146 146 + db, 147 147 + _newStatusReport.id, 148 148 + input.monitorIds, 149 149 + ); 136 150 } 137 151 138 152 if (limits["status-subscribers"] && _newStatusReport.pageId) {

+16

packages/api/src/router/maintenance.ts

··· 9 9 gte, 10 10 inArray, 11 11 lte, 12 12 + syncMaintenanceToMonitorDeleteByMaintenance, 13 13 + syncMaintenanceToMonitorInsertMany, 12 14 } from "@openstatus/db"; 13 15 import { 14 16 maintenance, ··· 217 219 monitorId, 218 220 })), 219 221 ); 222 222 + // Sync to page components 223 223 + await syncMaintenanceToMonitorInsertMany( 224 224 + tx, 225 225 + newMaintenance.id, 226 226 + opts.input.monitors, 227 227 + ); 220 228 } 221 229 222 230 return newMaintenance; ··· 287 295 .delete(maintenancesToMonitors) 288 296 .where(eq(maintenancesToMonitors.maintenanceId, _maintenance.id)) 289 297 .run(); 298 298 + // Sync delete to page components 299 299 + await syncMaintenanceToMonitorDeleteByMaintenance(tx, _maintenance.id); 290 300 291 301 // Create new relations if monitors are provided 292 302 if (opts.input.monitors?.length) { ··· 295 305 maintenanceId: _maintenance.id, 296 306 monitorId, 297 307 })), 308 308 + ); 309 309 + // Sync to page components 310 310 + await syncMaintenanceToMonitorInsertMany( 311 311 + tx, 312 312 + _maintenance.id, 313 313 + opts.input.monitors, 298 314 ); 299 315 } 300 316

+48 -7

packages/api/src/router/monitor.ts

··· 14 14 statusAssertion, 15 15 textBodyAssertion, 16 16 } from "@openstatus/assertions"; 17 17 - import { type SQL, and, count, eq, inArray, isNull, sql } from "@openstatus/db"; 17 17 + import { 18 18 + type SQL, 19 19 + and, 20 20 + count, 21 21 + eq, 22 22 + inArray, 23 23 + isNull, 24 24 + sql, 25 25 + syncMaintenanceToMonitorDeleteByMonitors, 26 26 + syncMonitorsToPageDelete, 27 27 + syncMonitorsToPageDeleteByMonitors, 28 28 + syncMonitorsToPageInsertMany, 29 29 + syncStatusReportToMonitorDeleteByMonitors, 30 30 + } from "@openstatus/db"; 18 31 import { 19 32 insertMonitorSchema, 20 33 maintenancesToMonitors, ··· 187 200 })); 188 201 189 202 await opts.ctx.db.insert(monitorsToPages).values(values).run(); 203 203 + // Sync to page components 204 204 + await syncMonitorsToPageInsertMany(opts.ctx.db, values); 190 205 } 191 206 192 207 return selectMonitorSchema.parse(newMonitor); ··· 460 475 })); 461 476 462 477 await opts.ctx.db.insert(monitorsToPages).values(values).run(); 478 478 + // Sync to page components 479 479 + await syncMonitorsToPageInsertMany(opts.ctx.db, values); 463 480 } 464 481 465 482 const removedPages = currentMonitorPages ··· 476 493 ), 477 494 ) 478 495 .run(); 496 496 + // Sync delete to page components 497 497 + for (const pageId of removedPages) { 498 498 + await syncMonitorsToPageDelete(opts.ctx.db, { 499 499 + monitorId: currentMonitor.id, 500 500 + pageId, 501 501 + }); 502 502 + } 479 503 } 480 504 }), 481 505 ··· 593 617 await tx 594 618 .delete(maintenancesToMonitors) 595 619 .where(eq(maintenancesToMonitors.monitorId, monitorToDelete.id)); 620 620 + // Sync deletes to page components 621 621 + await syncMonitorsToPageDeleteByMonitors(tx, [monitorToDelete.id]); 622 622 + await syncStatusReportToMonitorDeleteByMonitors(tx, [ 623 623 + monitorToDelete.id, 624 624 + ]); 625 625 + await syncMaintenanceToMonitorDeleteByMonitors(tx, [ 626 626 + monitorToDelete.id, 627 627 + ]); 596 628 }); 597 629 }), 598 630 ··· 639 671 await tx 640 672 .delete(maintenancesToMonitors) 641 673 .where(inArray(maintenancesToMonitors.monitorId, opts.input.ids)); 674 674 + // Sync deletes to page components 675 675 + await syncMonitorsToPageDeleteByMonitors(tx, opts.input.ids); 676 676 + await syncStatusReportToMonitorDeleteByMonitors(tx, opts.input.ids); 677 677 + await syncMaintenanceToMonitorDeleteByMonitors(tx, opts.input.ids); 642 678 }); 643 679 }), 644 680 ··· 1250 1286 inArray(monitorsToPages.pageId, pageIdsToDelete), 1251 1287 ), 1252 1288 ); 1289 1289 + // Sync delete to page components 1290 1290 + for (const pageId of pageIdsToDelete) { 1291 1291 + await syncMonitorsToPageDelete(tx, { monitorId: input.id, pageId }); 1292 1292 + } 1253 1293 } 1254 1294 1255 1295 if (pageIdsToInsert.length > 0) { 1256 1256 - await tx.insert(monitorsToPages).values( 1257 1257 - pageIdsToInsert.map((pageId) => ({ 1258 1258 - monitorId: input.id, 1259 1259 - pageId, 1260 1260 - })), 1261 1261 - ); 1296 1296 + const values = pageIdsToInsert.map((pageId) => ({ 1297 1297 + monitorId: input.id, 1298 1298 + pageId, 1299 1299 + })); 1300 1300 + await tx.insert(monitorsToPages).values(values); 1301 1301 + // Sync to page components 1302 1302 + await syncMonitorsToPageInsertMany(tx, values); 1262 1303 } 1263 1304 1264 1305 await tx

+58 -16

packages/api/src/router/page.ts

··· 11 11 isNull, 12 12 lte, 13 13 sql, 14 14 + syncMonitorGroupDeleteMany, 15 15 + syncMonitorGroupInsert, 16 16 + syncMonitorsToPageDelete, 17 17 + syncMonitorsToPageDeleteByPage, 18 18 + syncMonitorsToPageInsertMany, 14 19 } from "@openstatus/db"; 15 20 import { 16 21 incidentTable, ··· 142 147 })); 143 148 144 149 await opts.ctx.db.insert(monitorsToPages).values(values).run(); 150 150 + // Sync to page components 151 151 + await syncMonitorsToPageInsertMany(opts.ctx.db, values); 145 152 } 146 153 147 154 return newPage; ··· 241 248 eq(monitorsToPages.pageId, currentPage.id), 242 249 ), 243 250 ); 251 251 + // Sync delete to page components 252 252 + for (const monitorId of removedMonitors) { 253 253 + await syncMonitorsToPageDelete(opts.ctx.db, { 254 254 + monitorId, 255 255 + pageId: currentPage.id, 256 256 + }); 257 257 + } 244 258 } 245 259 246 260 const values = monitors.map(({ monitorId }, index) => ({ ··· 257 271 target: [monitorsToPages.monitorId, monitorsToPages.pageId], 258 272 set: { order: sql.raw("excluded.`order`") }, 259 273 }); 274 274 + // Sync new monitors to page components (existing ones will be ignored due to onConflictDoNothing) 275 275 + await syncMonitorsToPageInsertMany(opts.ctx.db, values); 260 276 } 261 277 }), 262 278 delete: protectedProcedure ··· 947 963 } 948 964 949 965 await opts.ctx.db.transaction(async (tx) => { 966 966 + // Get existing monitor groups to delete from page components 967 967 + const existingGroups = await tx.query.monitorGroup.findMany({ 968 968 + where: eq(monitorGroup.pageId, opts.input.id), 969 969 + }); 970 970 + const existingGroupIds = existingGroups.map((g) => g.id); 971 971 + 950 972 // Delete child records first to avoid foreign key constraint violation 951 973 await tx 952 974 .delete(monitorsToPages) ··· 955 977 .delete(monitorGroup) 956 978 .where(eq(monitorGroup.pageId, opts.input.id)); 957 979 980 980 + // Sync deletes to page components 981 981 + await syncMonitorsToPageDeleteByPage(tx, opts.input.id); 982 982 + if (existingGroupIds.length > 0) { 983 983 + await syncMonitorGroupDeleteMany(tx, existingGroupIds); 984 984 + } 985 985 + 958 986 if (opts.input.groups.length > 0) { 959 987 const monitorGroups = await tx 960 988 .insert(monitorGroup) ··· 967 995 ) 968 996 .returning(); 969 997 970 970 - await tx.insert(monitorsToPages).values( 971 971 - opts.input.groups.flatMap((g, i) => 972 972 - g.monitors.map((m) => ({ 973 973 - pageId: opts.input.id, 974 974 - monitorId: m.id, 975 975 - order: g.order, 976 976 - monitorGroupId: monitorGroups[i].id, 977 977 - groupOrder: m.order, 978 978 - })), 979 979 - ), 980 980 - ); 981 981 - } 998 998 + // Sync new monitor groups to page component groups 999 999 + for (const group of monitorGroups) { 1000 1000 + await syncMonitorGroupInsert(tx, { 1001 1001 + id: group.id, 1002 1002 + workspaceId: opts.ctx.workspace.id, 1003 1003 + pageId: opts.input.id, 1004 1004 + name: group.name, 1005 1005 + }); 1006 1006 + } 982 1007 983 983 - if (opts.input.monitors.length > 0) { 984 984 - await tx.insert(monitorsToPages).values( 985 985 - opts.input.monitors.map((m) => ({ 1008 1008 + const groupMonitorValues = opts.input.groups.flatMap((g, i) => 1009 1009 + g.monitors.map((m) => ({ 986 1010 pageId: opts.input.id, 987 1011 monitorId: m.id, 988 988 - order: m.order, 1012 1012 + order: g.order, 1013 1013 + monitorGroupId: monitorGroups[i].id, 1014 1014 + groupOrder: m.order, 989 1015 })), 990 1016 ); 1017 1017 + 1018 1018 + await tx.insert(monitorsToPages).values(groupMonitorValues); 1019 1019 + // Sync to page components 1020 1020 + await syncMonitorsToPageInsertMany(tx, groupMonitorValues); 1021 1021 + } 1022 1022 + 1023 1023 + if (opts.input.monitors.length > 0) { 1024 1024 + const monitorValues = opts.input.monitors.map((m) => ({ 1025 1025 + pageId: opts.input.id, 1026 1026 + monitorId: m.id, 1027 1027 + order: m.order, 1028 1028 + })); 1029 1029 + 1030 1030 + await tx.insert(monitorsToPages).values(monitorValues); 1031 1031 + // Sync to page components 1032 1032 + await syncMonitorsToPageInsertMany(tx, monitorValues); 991 1033 } 992 1034 }); 993 1035 }),

+29

packages/api/src/router/statusReport.ts

··· 9 9 gte, 10 10 inArray, 11 11 sql, 12 12 + syncStatusReportToMonitorDeleteByStatusReport, 13 13 + syncStatusReportToMonitorInsertMany, 12 14 } from "@openstatus/db"; 13 15 import { 14 16 insertStatusReportSchema, ··· 57 59 ) 58 60 .returning() 59 61 .get(); 62 62 + // Sync to page components 63 63 + await syncStatusReportToMonitorInsertMany( 64 64 + opts.ctx.db, 65 65 + newStatusReport.id, 66 66 + monitors, 67 67 + ); 60 68 } 61 69 62 70 return newStatusReport; ··· 143 151 })); 144 152 145 153 await opts.ctx.db.insert(monitorsToStatusReport).values(values).run(); 154 154 + // Sync to page components 155 155 + await syncStatusReportToMonitorInsertMany( 156 156 + opts.ctx.db, 157 157 + currentStatusReport.id, 158 158 + addedMonitors, 159 159 + ); 146 160 } 147 161 148 162 const removedMonitors = currentMonitorsToStatusReport ··· 159 173 ), 160 174 ) 161 175 .run(); 176 176 + // Sync delete is handled by cascade on page_component deletion 162 177 } 163 178 164 179 return currentStatusReport; ··· 476 491 ) 477 492 .returning() 478 493 .get(); 494 494 + // Sync to page components 495 495 + await syncStatusReportToMonitorInsertMany( 496 496 + tx, 497 497 + newStatusReport.id, 498 498 + opts.input.monitors, 499 499 + ); 479 500 } 480 501 481 502 return { ··· 516 537 .delete(monitorsToStatusReport) 517 538 .where(eq(monitorsToStatusReport.statusReportId, opts.input.id)) 518 539 .run(); 540 540 + // Sync delete to page components 541 541 + await syncStatusReportToMonitorDeleteByStatusReport(tx, opts.input.id); 519 542 520 543 if (opts.input.monitors.length > 0) { 521 544 await tx ··· 527 550 })), 528 551 ) 529 552 .run(); 553 553 + // Sync to page components 554 554 + await syncStatusReportToMonitorInsertMany( 555 555 + tx, 556 556 + opts.input.id, 557 557 + opts.input.monitors, 558 558 + ); 530 559 } 531 560 }); 532 561 }),

+608

packages/api/src/router/sync.test.ts

··· 1 1 + import { afterAll, beforeAll, describe, expect, test } from "bun:test"; 2 2 + import { and, db, eq, inArray } from "@openstatus/db"; 3 3 + import { 4 4 + maintenance, 5 5 + maintenancesToMonitors, 6 6 + maintenancesToPageComponents, 7 7 + monitor, 8 8 + monitorGroup, 9 9 + monitorsToPages, 10 10 + monitorsToStatusReport, 11 11 + page, 12 12 + pageComponent, 13 13 + pageComponentGroup, 14 14 + statusReport, 15 15 + statusReportUpdate, 16 16 + statusReportsToPageComponents, 17 17 + } from "@openstatus/db/src/schema"; 18 18 + import { flyRegions } from "@openstatus/db/src/schema/constants"; 19 19 + 20 20 + import { appRouter } from "../root"; 21 21 + import { createInnerTRPCContext } from "../trpc"; 22 22 + 23 23 + /** 24 24 + * Sync Tests: Verify that mutations to legacy tables also sync to new page_component tables 25 25 + * 26 26 + * Table mappings: 27 27 + * - monitor_group -> page_component_groups 28 28 + * - monitors_to_pages -> page_component 29 29 + * - status_report_to_monitors -> status_report_to_page_component 30 30 + * - maintenance_to_monitor -> maintenance_to_page_component 31 31 + */ 32 32 + 33 33 + function getTestContext(limits?: unknown) { 34 34 + return createInnerTRPCContext({ 35 35 + req: undefined, 36 36 + session: { 37 37 + user: { 38 38 + id: "1", 39 39 + }, 40 40 + }, 41 41 + workspace: { 42 42 + id: 1, 43 43 + // @ts-expect-error - test context with partial limits 44 44 + limits: limits || { 45 45 + monitors: 100, 46 46 + periodicity: ["30s", "1m", "5m", "10m", "30m", "1h"], 47 47 + regions: flyRegions, 48 48 + "status-pages": 10, 49 49 + maintenance: true, 50 50 + notifications: 10, 51 51 + "status-subscribers": true, 52 52 + sms: false, 53 53 + pagerduty: true, 54 54 + "password-protection": true, 55 55 + "email-domain-protection": true, 56 56 + "custom-domain": true, 57 57 + }, 58 58 + }, 59 59 + }); 60 60 + } 61 61 + 62 62 + // Test data identifiers 63 63 + const TEST_PREFIX = "sync-test"; 64 64 + let testPageId: number; 65 65 + let testMonitorId: number; 66 66 + 67 67 + const monitorData = { 68 68 + name: `${TEST_PREFIX}-monitor`, 69 69 + url: "https://sync-test.example.com", 70 70 + jobType: "http" as const, 71 71 + method: "GET" as const, 72 72 + periodicity: "1m" as const, 73 73 + regions: [flyRegions[0]], 74 74 + statusAssertions: [], 75 75 + headerAssertions: [], 76 76 + textBodyAssertions: [], 77 77 + notifications: [], 78 78 + pages: [] as number[], 79 79 + tags: [], 80 80 + }; 81 81 + 82 82 + beforeAll(async () => { 83 83 + // Clean up any existing test data 84 84 + await db 85 85 + .delete(pageComponent) 86 86 + .where(eq(pageComponent.name, `${TEST_PREFIX}-monitor`)); 87 87 + await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-page`)); 88 88 + await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-monitor`)); 89 89 + await db 90 90 + .delete(monitor) 91 91 + .where(eq(monitor.name, `${TEST_PREFIX}-deletable-monitor`)); 92 92 + 93 93 + // Create test page first 94 94 + const testPage = await db 95 95 + .insert(page) 96 96 + .values({ 97 97 + workspaceId: 1, 98 98 + title: "Sync Test Page", 99 99 + description: "A test page for sync tests", 100 100 + slug: `${TEST_PREFIX}-page`, 101 101 + customDomain: "", 102 102 + }) 103 103 + .returning() 104 104 + .get(); 105 105 + testPageId = testPage.id; 106 106 + 107 107 + // Create test monitor using tRPC 108 108 + const ctx = getTestContext(); 109 109 + const caller = appRouter.createCaller(ctx); 110 110 + const createdMonitor = await caller.monitor.create(monitorData); 111 111 + testMonitorId = createdMonitor.id; 112 112 + }); 113 113 + 114 114 + afterAll(async () => { 115 115 + // Clean up test data in correct order (dependencies first) 116 116 + await db 117 117 + .delete(maintenancesToPageComponents) 118 118 + .where( 119 119 + inArray( 120 120 + maintenancesToPageComponents.pageComponentId, 121 121 + db 122 122 + .select({ id: pageComponent.id }) 123 123 + .from(pageComponent) 124 124 + .where(eq(pageComponent.pageId, testPageId)), 125 125 + ), 126 126 + ); 127 127 + await db 128 128 + .delete(statusReportsToPageComponents) 129 129 + .where( 130 130 + inArray( 131 131 + statusReportsToPageComponents.pageComponentId, 132 132 + db 133 133 + .select({ id: pageComponent.id }) 134 134 + .from(pageComponent) 135 135 + .where(eq(pageComponent.pageId, testPageId)), 136 136 + ), 137 137 + ); 138 138 + await db.delete(pageComponent).where(eq(pageComponent.pageId, testPageId)); 139 139 + await db 140 140 + .delete(pageComponentGroup) 141 141 + .where(eq(pageComponentGroup.pageId, testPageId)); 142 142 + await db.delete(monitorGroup).where(eq(monitorGroup.pageId, testPageId)); 143 143 + await db 144 144 + .delete(monitorsToPages) 145 145 + .where(eq(monitorsToPages.pageId, testPageId)); 146 146 + await db 147 147 + .delete(maintenancesToMonitors) 148 148 + .where(eq(maintenancesToMonitors.monitorId, testMonitorId)); 149 149 + await db 150 150 + .delete(monitorsToStatusReport) 151 151 + .where(eq(monitorsToStatusReport.monitorId, testMonitorId)); 152 152 + await db 153 153 + .delete(statusReportUpdate) 154 154 + .where( 155 155 + inArray( 156 156 + statusReportUpdate.statusReportId, 157 157 + db 158 158 + .select({ id: statusReport.id }) 159 159 + .from(statusReport) 160 160 + .where(eq(statusReport.pageId, testPageId)), 161 161 + ), 162 162 + ); 163 163 + await db.delete(statusReport).where(eq(statusReport.pageId, testPageId)); 164 164 + await db.delete(maintenance).where(eq(maintenance.pageId, testPageId)); 165 165 + await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-page`)); 166 166 + await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-monitor`)); 167 167 + await db 168 168 + .delete(monitor) 169 169 + .where(eq(monitor.name, `${TEST_PREFIX}-deletable-monitor`)); 170 170 + }); 171 171 + 172 172 + describe("Sync: monitors_to_pages -> page_component", () => { 173 173 + test("Creating monitor-to-page relation syncs to page_component", async () => { 174 174 + const ctx = getTestContext(); 175 175 + const caller = appRouter.createCaller(ctx); 176 176 + 177 177 + // Update monitor to add it to the test page 178 178 + await caller.monitor.update({ 179 179 + ...monitorData, 180 180 + id: testMonitorId, 181 181 + pages: [testPageId], 182 182 + }); 183 183 + 184 184 + // Verify monitors_to_pages was created 185 185 + const monitorToPage = await db.query.monitorsToPages.findFirst({ 186 186 + where: and( 187 187 + eq(monitorsToPages.monitorId, testMonitorId), 188 188 + eq(monitorsToPages.pageId, testPageId), 189 189 + ), 190 190 + }); 191 191 + expect(monitorToPage).toBeDefined(); 192 192 + 193 193 + // Verify page_component was synced 194 194 + const component = await db.query.pageComponent.findFirst({ 195 195 + where: and( 196 196 + eq(pageComponent.monitorId, testMonitorId), 197 197 + eq(pageComponent.pageId, testPageId), 198 198 + ), 199 199 + }); 200 200 + expect(component).toBeDefined(); 201 201 + expect(component?.type).toBe("monitor"); 202 202 + expect(component?.workspaceId).toBe(1); 203 203 + }); 204 204 + 205 205 + test("Removing monitor-to-page relation syncs delete to page_component", async () => { 206 206 + const ctx = getTestContext(); 207 207 + const caller = appRouter.createCaller(ctx); 208 208 + 209 209 + // First add the monitor to page if not already 210 210 + await caller.monitor.update({ 211 211 + ...monitorData, 212 212 + id: testMonitorId, 213 213 + pages: [testPageId], 214 214 + }); 215 215 + 216 216 + // Verify page_component exists 217 217 + let component = await db.query.pageComponent.findFirst({ 218 218 + where: and( 219 219 + eq(pageComponent.monitorId, testMonitorId), 220 220 + eq(pageComponent.pageId, testPageId), 221 221 + ), 222 222 + }); 223 223 + expect(component).toBeDefined(); 224 224 + 225 225 + // Remove monitor from page 226 226 + await caller.monitor.update({ 227 227 + ...monitorData, 228 228 + id: testMonitorId, 229 229 + pages: [], 230 230 + }); 231 231 + 232 232 + // Verify page_component was deleted 233 233 + component = await db.query.pageComponent.findFirst({ 234 234 + where: and( 235 235 + eq(pageComponent.monitorId, testMonitorId), 236 236 + eq(pageComponent.pageId, testPageId), 237 237 + ), 238 238 + }); 239 239 + expect(component).toBeUndefined(); 240 240 + }); 241 241 + }); 242 242 + 243 243 + describe("Sync: page.updateMonitors -> page_component and page_component_groups", () => { 244 244 + test("Adding monitors with groups syncs to page_component and page_component_groups", async () => { 245 245 + const ctx = getTestContext(); 246 246 + const caller = appRouter.createCaller(ctx); 247 247 + 248 248 + // Update page with monitor in a group 249 249 + await caller.page.updateMonitors({ 250 250 + id: testPageId, 251 251 + monitors: [], 252 252 + groups: [ 253 253 + { 254 254 + name: `${TEST_PREFIX}-group`, 255 255 + order: 0, 256 256 + monitors: [{ id: testMonitorId, order: 0 }], 257 257 + }, 258 258 + ], 259 259 + }); 260 260 + 261 261 + // Verify monitor_group was created 262 262 + const group = await db.query.monitorGroup.findFirst({ 263 263 + where: and( 264 264 + eq(monitorGroup.pageId, testPageId), 265 265 + eq(monitorGroup.name, `${TEST_PREFIX}-group`), 266 266 + ), 267 267 + }); 268 268 + expect(group).toBeDefined(); 269 269 + 270 270 + if (!group) { 271 271 + throw new Error("Group not found"); 272 272 + } 273 273 + 274 274 + // Verify page_component_groups was synced 275 275 + const componentGroup = await db.query.pageComponentGroup.findFirst({ 276 276 + where: eq(pageComponentGroup.id, group.id), 277 277 + }); 278 278 + expect(componentGroup).toBeDefined(); 279 279 + expect(componentGroup?.name).toBe(`${TEST_PREFIX}-group`); 280 280 + expect(componentGroup?.pageId).toBe(testPageId); 281 281 + 282 282 + // Verify page_component was synced with group reference 283 283 + const component = await db.query.pageComponent.findFirst({ 284 284 + where: and( 285 285 + eq(pageComponent.monitorId, testMonitorId), 286 286 + eq(pageComponent.pageId, testPageId), 287 287 + ), 288 288 + }); 289 289 + expect(component).toBeDefined(); 290 290 + expect(component?.groupId).toBe(group.id); 291 291 + }); 292 292 + 293 293 + test("Updating page monitors syncs changes to page_component", async () => { 294 294 + const ctx = getTestContext(); 295 295 + const caller = appRouter.createCaller(ctx); 296 296 + 297 297 + // First, set up with a group 298 298 + await caller.page.updateMonitors({ 299 299 + id: testPageId, 300 300 + monitors: [], 301 301 + groups: [ 302 302 + { 303 303 + name: `${TEST_PREFIX}-group`, 304 304 + order: 0, 305 305 + monitors: [{ id: testMonitorId, order: 0 }], 306 306 + }, 307 307 + ], 308 308 + }); 309 309 + 310 310 + // Now update to remove the group and add monitor directly 311 311 + await caller.page.updateMonitors({ 312 312 + id: testPageId, 313 313 + monitors: [{ id: testMonitorId, order: 0 }], 314 314 + groups: [], 315 315 + }); 316 316 + 317 317 + // Verify monitor_group was deleted 318 318 + const group = await db.query.monitorGroup.findFirst({ 319 319 + where: and( 320 320 + eq(monitorGroup.pageId, testPageId), 321 321 + eq(monitorGroup.name, `${TEST_PREFIX}-group`), 322 322 + ), 323 323 + }); 324 324 + expect(group).toBeUndefined(); 325 325 + 326 326 + // Verify page_component still exists but without group 327 327 + const component = await db.query.pageComponent.findFirst({ 328 328 + where: and( 329 329 + eq(pageComponent.monitorId, testMonitorId), 330 330 + eq(pageComponent.pageId, testPageId), 331 331 + ), 332 332 + }); 333 333 + expect(component).toBeDefined(); 334 334 + expect(component?.groupId).toBeNull(); 335 335 + }); 336 336 + }); 337 337 + 338 338 + describe("Sync: maintenance_to_monitor -> maintenance_to_page_component", () => { 339 339 + let testMaintenanceId: number; 340 340 + 341 341 + beforeAll(async () => { 342 342 + const ctx = getTestContext(); 343 343 + const caller = appRouter.createCaller(ctx); 344 344 + 345 345 + // Ensure monitor is on the page first 346 346 + await caller.monitor.update({ 347 347 + ...monitorData, 348 348 + id: testMonitorId, 349 349 + pages: [testPageId], 350 350 + }); 351 351 + }); 352 352 + 353 353 + afterAll(async () => { 354 354 + if (testMaintenanceId) { 355 355 + await db 356 356 + .delete(maintenancesToPageComponents) 357 357 + .where( 358 358 + eq(maintenancesToPageComponents.maintenanceId, testMaintenanceId), 359 359 + ); 360 360 + await db 361 361 + .delete(maintenancesToMonitors) 362 362 + .where(eq(maintenancesToMonitors.maintenanceId, testMaintenanceId)); 363 363 + await db.delete(maintenance).where(eq(maintenance.id, testMaintenanceId)); 364 364 + } 365 365 + }); 366 366 + 367 367 + test("Creating maintenance with monitors syncs to maintenance_to_page_component", async () => { 368 368 + const ctx = getTestContext(); 369 369 + const caller = appRouter.createCaller(ctx); 370 370 + 371 371 + const from = new Date(); 372 372 + const to = new Date(from.getTime() + 1000 * 60 * 60); 373 373 + 374 374 + const createdMaintenance = await caller.maintenance.new({ 375 375 + title: `${TEST_PREFIX} Maintenance`, 376 376 + message: "Test maintenance for sync", 377 377 + startDate: from, 378 378 + endDate: to, 379 379 + pageId: testPageId, 380 380 + monitors: [testMonitorId], 381 381 + }); 382 382 + testMaintenanceId = createdMaintenance.id; 383 383 + 384 384 + // Verify maintenance_to_monitor was created 385 385 + const maintenanceToMonitor = 386 386 + await db.query.maintenancesToMonitors.findFirst({ 387 387 + where: and( 388 388 + eq(maintenancesToMonitors.maintenanceId, testMaintenanceId), 389 389 + eq(maintenancesToMonitors.monitorId, testMonitorId), 390 390 + ), 391 391 + }); 392 392 + expect(maintenanceToMonitor).toBeDefined(); 393 393 + 394 394 + // Verify maintenance_to_page_component was synced 395 395 + const component = await db.query.pageComponent.findFirst({ 396 396 + where: and( 397 397 + eq(pageComponent.monitorId, testMonitorId), 398 398 + eq(pageComponent.pageId, testPageId), 399 399 + ), 400 400 + }); 401 401 + 402 402 + if (component) { 403 403 + const maintenanceToComponent = 404 404 + await db.query.maintenancesToPageComponents.findFirst({ 405 405 + where: and( 406 406 + eq(maintenancesToPageComponents.maintenanceId, testMaintenanceId), 407 407 + eq(maintenancesToPageComponents.pageComponentId, component.id), 408 408 + ), 409 409 + }); 410 410 + expect(maintenanceToComponent).toBeDefined(); 411 411 + } 412 412 + }); 413 413 + 414 414 + test("Updating maintenance monitors syncs to maintenance_to_page_component", async () => { 415 415 + const ctx = getTestContext(); 416 416 + const caller = appRouter.createCaller(ctx); 417 417 + 418 418 + // Skip if no maintenance was created 419 419 + if (!testMaintenanceId) return; 420 420 + 421 421 + const from = new Date(); 422 422 + const to = new Date(from.getTime() + 1000 * 60 * 60); 423 423 + 424 424 + // Update maintenance to remove monitors 425 425 + await caller.maintenance.update({ 426 426 + id: testMaintenanceId, 427 427 + title: `${TEST_PREFIX} Maintenance`, 428 428 + message: "Updated maintenance", 429 429 + startDate: from, 430 430 + endDate: to, 431 431 + monitors: [], 432 432 + }); 433 433 + 434 434 + // Verify maintenance_to_monitor was deleted 435 435 + const maintenanceToMonitor = 436 436 + await db.query.maintenancesToMonitors.findFirst({ 437 437 + where: and( 438 438 + eq(maintenancesToMonitors.maintenanceId, testMaintenanceId), 439 439 + eq(maintenancesToMonitors.monitorId, testMonitorId), 440 440 + ), 441 441 + }); 442 442 + expect(maintenanceToMonitor).toBeUndefined(); 443 443 + 444 444 + // Verify maintenance_to_page_component was also deleted 445 445 + const maintenanceToComponent = 446 446 + await db.query.maintenancesToPageComponents.findFirst({ 447 447 + where: eq( 448 448 + maintenancesToPageComponents.maintenanceId, 449 449 + testMaintenanceId, 450 450 + ), 451 451 + }); 452 452 + expect(maintenanceToComponent).toBeUndefined(); 453 453 + }); 454 454 + }); 455 455 + 456 456 + describe("Sync: status_report_to_monitors -> status_report_to_page_component", () => { 457 457 + let testStatusReportId: number; 458 458 + 459 459 + beforeAll(async () => { 460 460 + const ctx = getTestContext(); 461 461 + const caller = appRouter.createCaller(ctx); 462 462 + 463 463 + // Ensure monitor is on the page first 464 464 + await caller.monitor.update({ 465 465 + ...monitorData, 466 466 + id: testMonitorId, 467 467 + pages: [testPageId], 468 468 + }); 469 469 + }); 470 470 + 471 471 + afterAll(async () => { 472 472 + if (testStatusReportId) { 473 473 + await db 474 474 + .delete(statusReportsToPageComponents) 475 475 + .where( 476 476 + eq(statusReportsToPageComponents.statusReportId, testStatusReportId), 477 477 + ); 478 478 + await db 479 479 + .delete(monitorsToStatusReport) 480 480 + .where(eq(monitorsToStatusReport.statusReportId, testStatusReportId)); 481 481 + await db 482 482 + .delete(statusReportUpdate) 483 483 + .where(eq(statusReportUpdate.statusReportId, testStatusReportId)); 484 484 + await db 485 485 + .delete(statusReport) 486 486 + .where(eq(statusReport.id, testStatusReportId)); 487 487 + } 488 488 + }); 489 489 + 490 490 + test("Creating status report with monitors syncs to status_report_to_page_component", async () => { 491 491 + const ctx = getTestContext(); 492 492 + const caller = appRouter.createCaller(ctx); 493 493 + 494 494 + const createdReport = await caller.statusReport.create({ 495 495 + title: `${TEST_PREFIX} Status Report`, 496 496 + status: "investigating", 497 497 + message: "Test status report for sync", 498 498 + pageId: testPageId, 499 499 + monitors: [testMonitorId], 500 500 + date: new Date(), 501 501 + }); 502 502 + testStatusReportId = createdReport.statusReportId; 503 503 + 504 504 + // Verify status_report_to_monitors was created 505 505 + const reportToMonitor = await db.query.monitorsToStatusReport.findFirst({ 506 506 + where: and( 507 507 + eq(monitorsToStatusReport.statusReportId, testStatusReportId), 508 508 + eq(monitorsToStatusReport.monitorId, testMonitorId), 509 509 + ), 510 510 + }); 511 511 + expect(reportToMonitor).toBeDefined(); 512 512 + 513 513 + // Verify status_report_to_page_component was synced 514 514 + const component = await db.query.pageComponent.findFirst({ 515 515 + where: and( 516 516 + eq(pageComponent.monitorId, testMonitorId), 517 517 + eq(pageComponent.pageId, testPageId), 518 518 + ), 519 519 + }); 520 520 + 521 521 + if (component) { 522 522 + const reportToComponent = 523 523 + await db.query.statusReportsToPageComponents.findFirst({ 524 524 + where: and( 525 525 + eq( 526 526 + statusReportsToPageComponents.statusReportId, 527 527 + testStatusReportId, 528 528 + ), 529 529 + eq(statusReportsToPageComponents.pageComponentId, component.id), 530 530 + ), 531 531 + }); 532 532 + expect(reportToComponent).toBeDefined(); 533 533 + } 534 534 + }); 535 535 + 536 536 + test("Updating status report monitors syncs to status_report_to_page_component", async () => { 537 537 + const ctx = getTestContext(); 538 538 + const caller = appRouter.createCaller(ctx); 539 539 + 540 540 + // Skip if no status report was created 541 541 + if (!testStatusReportId) return; 542 542 + 543 543 + // Update status to remove monitors (using updateStatus procedure) 544 544 + await caller.statusReport.updateStatus({ 545 545 + id: testStatusReportId, 546 546 + status: "resolved", 547 547 + monitors: [], 548 548 + title: `${TEST_PREFIX} Status Report`, 549 549 + }); 550 550 + 551 551 + // Verify status_report_to_monitors was deleted 552 552 + const reportToMonitor = await db.query.monitorsToStatusReport.findFirst({ 553 553 + where: and( 554 554 + eq(monitorsToStatusReport.statusReportId, testStatusReportId), 555 555 + eq(monitorsToStatusReport.monitorId, testMonitorId), 556 556 + ), 557 557 + }); 558 558 + expect(reportToMonitor).toBeUndefined(); 559 559 + 560 560 + // Verify status_report_to_page_component was also deleted 561 561 + const reportToComponent = 562 562 + await db.query.statusReportsToPageComponents.findFirst({ 563 563 + where: eq( 564 564 + statusReportsToPageComponents.statusReportId, 565 565 + testStatusReportId, 566 566 + ), 567 567 + }); 568 568 + expect(reportToComponent).toBeUndefined(); 569 569 + }); 570 570 + }); 571 571 + 572 572 + describe("Sync: monitor deletion cascades to page_component tables", () => { 573 573 + let deletableMonitorId: number; 574 574 + 575 575 + beforeAll(async () => { 576 576 + const ctx = getTestContext(); 577 577 + const caller = appRouter.createCaller(ctx); 578 578 + 579 579 + // Create a monitor specifically for deletion tests 580 580 + const deletableMonitor = await caller.monitor.create({ 581 581 + ...monitorData, 582 582 + name: `${TEST_PREFIX}-deletable-monitor`, 583 583 + url: "https://delete-test.example.com", 584 584 + pages: [testPageId], 585 585 + }); 586 586 + deletableMonitorId = deletableMonitor.id; 587 587 + }); 588 588 + 589 589 + test("Deleting monitor removes related page_component entries", async () => { 590 590 + const ctx = getTestContext(); 591 591 + const caller = appRouter.createCaller(ctx); 592 592 + 593 593 + // Verify page_component exists before deletion 594 594 + let component = await db.query.pageComponent.findFirst({ 595 595 + where: eq(pageComponent.monitorId, deletableMonitorId), 596 596 + }); 597 597 + expect(component).toBeDefined(); 598 598 + 599 599 + // Delete the monitor 600 600 + await caller.monitor.delete({ id: deletableMonitorId }); 601 601 + 602 602 + // Verify page_component was removed 603 603 + component = await db.query.pageComponent.findFirst({ 604 604 + where: eq(pageComponent.monitorId, deletableMonitorId), 605 605 + }); 606 606 + expect(component).toBeUndefined(); 607 607 + }); 608 608 + });

+127

packages/db/drizzle/0054_bitter_lilandra.sql

··· 1 1 + CREATE TABLE `maintenance_to_page_component` ( 2 2 + `maintenance_id` integer NOT NULL, 3 3 + `page_component_id` integer NOT NULL, 4 4 + `created_at` integer DEFAULT (strftime('%s', 'now')), 5 5 + PRIMARY KEY(`maintenance_id`, `page_component_id`), 6 6 + FOREIGN KEY (`maintenance_id`) REFERENCES `maintenance`(`id`) ON UPDATE no action ON DELETE cascade, 7 7 + FOREIGN KEY (`page_component_id`) REFERENCES `page_component`(`id`) ON UPDATE no action ON DELETE cascade 8 8 + ); 9 9 + --> statement-breakpoint 10 10 + CREATE TABLE `page_component` ( 11 11 + `id` integer PRIMARY KEY NOT NULL, 12 12 + `workspace_id` integer NOT NULL, 13 13 + `page_id` integer NOT NULL, 14 14 + `type` text DEFAULT 'monitor' NOT NULL, 15 15 + `monitor_id` integer, 16 16 + `name` text NOT NULL, 17 17 + `description` text, 18 18 + `order` integer DEFAULT 0, 19 19 + `group_id` integer, 20 20 + `group_order` integer DEFAULT 0, 21 21 + `created_at` integer DEFAULT (strftime('%s', 'now')), 22 22 + `updated_at` integer DEFAULT (strftime('%s', 'now')), 23 23 + FOREIGN KEY (`workspace_id`) REFERENCES `workspace`(`id`) ON UPDATE no action ON DELETE cascade, 24 24 + FOREIGN KEY (`page_id`) REFERENCES `page`(`id`) ON UPDATE no action ON DELETE cascade, 25 25 + FOREIGN KEY (`monitor_id`) REFERENCES `monitor`(`id`) ON UPDATE no action ON DELETE cascade, 26 26 + FOREIGN KEY (`group_id`) REFERENCES `page_component_groups`(`id`) ON UPDATE no action ON DELETE set null, 27 27 + CONSTRAINT "page_component_type_check" CHECK("page_component"."type" = 'monitor' AND "page_component"."monitor_id" IS NOT NULL OR "page_component"."type" = 'external' AND "page_component"."monitor_id" IS NULL) 28 28 + ); 29 29 + --> statement-breakpoint 30 30 + CREATE UNIQUE INDEX `page_component_page_id_monitor_id_unique` ON `page_component` (`page_id`,`monitor_id`);--> statement-breakpoint 31 31 + CREATE TABLE `status_report_to_page_component` ( 32 32 + `status_report_id` integer NOT NULL, 33 33 + `page_component_id` integer NOT NULL, 34 34 + `created_at` integer DEFAULT (strftime('%s', 'now')), 35 35 + PRIMARY KEY(`status_report_id`, `page_component_id`), 36 36 + FOREIGN KEY (`status_report_id`) REFERENCES `status_report`(`id`) ON UPDATE no action ON DELETE cascade, 37 37 + FOREIGN KEY (`page_component_id`) REFERENCES `page_component`(`id`) ON UPDATE no action ON DELETE cascade 38 38 + ); 39 39 + --> statement-breakpoint 40 40 + CREATE TABLE `page_component_groups` ( 41 41 + `id` integer PRIMARY KEY NOT NULL, 42 42 + `workspace_id` integer NOT NULL, 43 43 + `page_id` integer NOT NULL, 44 44 + `name` text NOT NULL, 45 45 + `created_at` integer DEFAULT (strftime('%s', 'now')), 46 46 + `updated_at` integer DEFAULT (strftime('%s', 'now')), 47 47 + FOREIGN KEY (`workspace_id`) REFERENCES `workspace`(`id`) ON UPDATE no action ON DELETE cascade, 48 48 + FOREIGN KEY (`page_id`) REFERENCES `page`(`id`) ON UPDATE no action ON DELETE cascade 49 49 + ); 50 50 + --> statement-breakpoint 51 51 + -- Data Migration: monitors_to_pages → page_component 52 52 + -- This section migrates data from the old structure to the new page_component structure 53 53 + -- Step 0: Migrate monitor_group to page_component_groups 54 54 + INSERT OR IGNORE INTO `page_component_groups` ( 55 55 + `id`, 56 56 + `workspace_id`, 57 57 + `page_id`, 58 58 + `name`, 59 59 + `created_at`, 60 60 + `updated_at` 61 61 + ) 62 62 + SELECT 63 63 + mg.id, 64 64 + mg.workspace_id, 65 65 + mg.page_id, 66 66 + mg.name, 67 67 + mg.created_at, 68 68 + mg.updated_at 69 69 + FROM `monitor_group` mg; 70 70 + --> statement-breakpoint 71 71 + -- Step 1: Migrate monitors_to_pages to page_component 72 72 + INSERT OR IGNORE INTO `page_component` ( 73 73 + `workspace_id`, 74 74 + `page_id`, 75 75 + `type`, 76 76 + `monitor_id`, 77 77 + `name`, 78 78 + `order`, 79 79 + `group_id`, 80 80 + `group_order`, 81 81 + `created_at`, 82 82 + `updated_at` 83 83 + ) 84 84 + SELECT 85 85 + m.workspace_id, 86 86 + mtp.page_id, 87 87 + 'monitor' as type, 88 88 + mtp.monitor_id, 89 89 + COALESCE(m.external_name, m.name, 'Unnamed Monitor') as name, 90 90 + COALESCE(mtp.`order`, 0), 91 91 + mtp.monitor_group_id as group_id, 92 92 + COALESCE(mtp.group_order, 0) as group_order, 93 93 + mtp.created_at, 94 94 + strftime('%s', 'now') as updated_at 95 95 + FROM `monitors_to_pages` mtp 96 96 + INNER JOIN `monitor` m ON mtp.monitor_id = m.id 97 97 + WHERE m.workspace_id IS NOT NULL; 98 98 + --> statement-breakpoint 99 99 + -- Step 2: Migrate status_report_to_monitors to status_report_to_page_component 100 100 + INSERT OR IGNORE INTO `status_report_to_page_component` ( 101 101 + `status_report_id`, 102 102 + `page_component_id`, 103 103 + `created_at` 104 104 + ) 105 105 + SELECT DISTINCT 106 106 + srtm.status_report_id, 107 107 + pc.id as page_component_id, 108 108 + srtm.created_at 109 109 + FROM `status_report_to_monitors` srtm 110 110 + INNER JOIN `status_report` sr ON srtm.status_report_id = sr.id 111 111 + INNER JOIN `page_component` pc ON srtm.monitor_id = pc.monitor_id 112 112 + WHERE (sr.page_id = pc.page_id OR sr.page_id IS NULL); 113 113 + --> statement-breakpoint 114 114 + -- Step 3: Migrate maintenance_to_monitor to maintenance_to_page_component 115 115 + INSERT OR IGNORE INTO `maintenance_to_page_component` ( 116 116 + `maintenance_id`, 117 117 + `page_component_id`, 118 118 + `created_at` 119 119 + ) 120 120 + SELECT DISTINCT 121 121 + mtm.maintenance_id, 122 122 + pc.id as page_component_id, 123 123 + mtm.created_at 124 124 + FROM `maintenance_to_monitor` mtm 125 125 + INNER JOIN `maintenance` m ON mtm.maintenance_id = m.id 126 126 + INNER JOIN `page_component` pc ON mtm.monitor_id = pc.monitor_id 127 127 + WHERE (m.page_id = pc.page_id OR m.page_id IS NULL);

+3459

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

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

+7

packages/db/drizzle/meta/_journal.json

··· 379 379 "when": 1768490525276, 380 380 "tag": "0053_dark_orphan", 381 381 "breakpoints": true 382 382 + }, 383 383 + { 384 384 + "idx": 54, 385 385 + "version": "6", 386 386 + "when": 1768564852930, 387 387 + "tag": "0054_bitter_lilandra", 388 388 + "breakpoints": true 382 389 } 383 390 ] 384 391 }

+1

packages/db/src/index.ts

··· 1 1 export * as schema from "./schema"; 2 2 export * from "drizzle-orm"; 3 3 export * from "./db"; 4 4 + export * from "./sync"; 4 5 // doing this because the external module not working see : https://github.com/vercel/next.js/issues/43433 5 6 // export * from "./sync-db";

+2

packages/db/src/schema/index.ts

··· 19 19 export * from "./monitor_groups"; 20 20 export * from "./viewers"; 21 21 export * from "./api-keys"; 22 22 + export * from "./page_components"; 23 23 + export * from "./page_component_groups";

+2

packages/db/src/schema/page_component_groups/index.ts

··· 1 1 + export * from "./page_component_groups"; 2 2 + export * from "./validation";

+39

packages/db/src/schema/page_component_groups/page_component_groups.ts

··· 1 1 + import { relations, sql } from "drizzle-orm"; 2 2 + import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core"; 3 3 + 4 4 + import { pageComponent } from "../page_components"; 5 5 + import { page } from "../pages"; 6 6 + import { workspace } from "../workspaces"; 7 7 + 8 8 + export const pageComponentGroup = sqliteTable("page_component_groups", { 9 9 + id: integer("id").primaryKey(), 10 10 + workspaceId: integer("workspace_id") 11 11 + .references(() => workspace.id, { onDelete: "cascade" }) 12 12 + .notNull(), 13 13 + pageId: integer("page_id") 14 14 + .references(() => page.id, { onDelete: "cascade" }) 15 15 + .notNull(), 16 16 + name: text("name").notNull(), 17 17 + 18 18 + createdAt: integer("created_at", { mode: "timestamp" }).default( 19 19 + sql`(strftime('%s', 'now'))`, 20 20 + ), 21 21 + updatedAt: integer("updated_at", { mode: "timestamp" }).default( 22 22 + sql`(strftime('%s', 'now'))`, 23 23 + ), 24 24 + }); 25 25 + 26 26 + export const pageComponentGroupRelations = relations( 27 27 + pageComponentGroup, 28 28 + ({ one, many }) => ({ 29 29 + workspace: one(workspace, { 30 30 + fields: [pageComponentGroup.workspaceId], 31 31 + references: [workspace.id], 32 32 + }), 33 33 + page: one(page, { 34 34 + fields: [pageComponentGroup.pageId], 35 35 + references: [page.id], 36 36 + }), 37 37 + pageComponents: many(pageComponent), 38 38 + }), 39 39 + );

+15

packages/db/src/schema/page_component_groups/validation.ts

··· 1 1 + import { createInsertSchema, createSelectSchema } from "drizzle-zod"; 2 2 + import type { z } from "zod"; 3 3 + 4 4 + import { pageComponentGroup } from "./page_component_groups"; 5 5 + 6 6 + export const selectPageComponentGroupSchema = 7 7 + createSelectSchema(pageComponentGroup); 8 8 + 9 9 + export const insertPageComponentGroupSchema = 10 10 + createInsertSchema(pageComponentGroup); 11 11 + 12 12 + export type InsertPageComponentGroup = z.infer< 13 13 + typeof insertPageComponentGroupSchema 14 14 + >; 15 15 + export type PageComponentGroup = z.infer<typeof selectPageComponentGroupSchema>;

+2

packages/db/src/schema/page_components/index.ts

··· 1 1 + export * from "./page_components"; 2 2 + export * from "./validation";

+150

packages/db/src/schema/page_components/page_components.ts

··· 1 1 + import { relations, sql } from "drizzle-orm"; 2 2 + import { 3 3 + check, 4 4 + integer, 5 5 + primaryKey, 6 6 + sqliteTable, 7 7 + text, 8 8 + unique, 9 9 + } from "drizzle-orm/sqlite-core"; 10 10 + 11 11 + import { maintenance } from "../maintenances"; 12 12 + import { monitor } from "../monitors"; 13 13 + import { pageComponentGroup } from "../page_component_groups"; 14 14 + import { page } from "../pages"; 15 15 + import { statusReport } from "../status_reports"; 16 16 + import { workspace } from "../workspaces"; 17 17 + 18 18 + export const pageComponentTypes = ["external", "monitor"] as const; 19 19 + 20 20 + export const pageComponent = sqliteTable( 21 21 + "page_component", 22 22 + { 23 23 + id: integer("id").primaryKey(), 24 24 + workspaceId: integer("workspace_id") 25 25 + .notNull() 26 26 + .references(() => workspace.id, { onDelete: "cascade" }), 27 27 + pageId: integer("page_id") 28 28 + .notNull() 29 29 + .references(() => page.id, { onDelete: "cascade" }), 30 30 + type: text("type", { enum: pageComponentTypes }) 31 31 + .notNull() 32 32 + .default("monitor"), 33 33 + monitorId: integer("monitor_id").references(() => monitor.id, { 34 34 + onDelete: "cascade", 35 35 + }), 36 36 + name: text("name").notNull(), 37 37 + description: text("description"), 38 38 + order: integer("order").default(0), 39 39 + groupId: integer("group_id").references(() => pageComponentGroup.id, { 40 40 + onDelete: "set null", 41 41 + }), 42 42 + groupOrder: integer("group_order").default(0), 43 43 + 44 44 + createdAt: integer("created_at", { mode: "timestamp" }).default( 45 45 + sql`(strftime('%s', 'now'))`, 46 46 + ), 47 47 + updatedAt: integer("updated_at", { mode: "timestamp" }).default( 48 48 + sql`(strftime('%s', 'now'))`, 49 49 + ), 50 50 + }, 51 51 + (t) => [ 52 52 + unique("page_component_page_id_monitor_id_unique").on( 53 53 + t.pageId, 54 54 + t.monitorId, 55 55 + ), 56 56 + check( 57 57 + "page_component_type_check", 58 58 + // NOTE: This check ensures that either the component is a monitor or an external component, but not both. 59 59 + sql`${t.type} = 'monitor' AND ${t.monitorId} IS NOT NULL OR ${t.type} = 'external' AND ${t.monitorId} IS NULL`, 60 60 + ), 61 61 + ], 62 62 + ); 63 63 + 64 64 + export const pageComponentRelations = relations( 65 65 + pageComponent, 66 66 + ({ one, many }) => ({ 67 67 + workspace: one(workspace, { 68 68 + fields: [pageComponent.workspaceId], 69 69 + references: [workspace.id], 70 70 + }), 71 71 + page: one(page, { 72 72 + fields: [pageComponent.pageId], 73 73 + references: [page.id], 74 74 + }), 75 75 + monitor: one(monitor, { 76 76 + fields: [pageComponent.monitorId], 77 77 + references: [monitor.id], 78 78 + }), 79 79 + group: one(pageComponentGroup, { 80 80 + fields: [pageComponent.groupId], 81 81 + references: [pageComponentGroup.id], 82 82 + }), 83 83 + statusReportsToPageComponents: many(statusReportsToPageComponents), 84 84 + maintenancesToPageComponents: many(maintenancesToPageComponents), 85 85 + }), 86 86 + ); 87 87 + 88 88 + export const maintenancesToPageComponents = sqliteTable( 89 89 + "maintenance_to_page_component", 90 90 + { 91 91 + maintenanceId: integer("maintenance_id") 92 92 + .notNull() 93 93 + .references(() => maintenance.id, { onDelete: "cascade" }), 94 94 + pageComponentId: integer("page_component_id") 95 95 + .notNull() 96 96 + .references(() => pageComponent.id, { onDelete: "cascade" }), 97 97 + createdAt: integer("created_at", { mode: "timestamp" }).default( 98 98 + sql`(strftime('%s', 'now'))`, 99 99 + ), 100 100 + }, 101 101 + (t) => ({ 102 102 + pk: primaryKey({ columns: [t.maintenanceId, t.pageComponentId] }), 103 103 + }), 104 104 + ); 105 105 + 106 106 + export const maintenancesToPageComponentsRelations = relations( 107 107 + maintenancesToPageComponents, 108 108 + ({ one }) => ({ 109 109 + maintenance: one(maintenance, { 110 110 + fields: [maintenancesToPageComponents.maintenanceId], 111 111 + references: [maintenance.id], 112 112 + }), 113 113 + pageComponent: one(pageComponent, { 114 114 + fields: [maintenancesToPageComponents.pageComponentId], 115 115 + references: [pageComponent.id], 116 116 + }), 117 117 + }), 118 118 + ); 119 119 + 120 120 + export const statusReportsToPageComponents = sqliteTable( 121 121 + "status_report_to_page_component", 122 122 + { 123 123 + statusReportId: integer("status_report_id") 124 124 + .notNull() 125 125 + .references(() => statusReport.id, { onDelete: "cascade" }), 126 126 + pageComponentId: integer("page_component_id") 127 127 + .notNull() 128 128 + .references(() => pageComponent.id, { onDelete: "cascade" }), 129 129 + createdAt: integer("created_at", { mode: "timestamp" }).default( 130 130 + sql`(strftime('%s', 'now'))`, 131 131 + ), 132 132 + }, 133 133 + (t) => ({ 134 134 + pk: primaryKey({ columns: [t.statusReportId, t.pageComponentId] }), 135 135 + }), 136 136 + ); 137 137 + 138 138 + export const statusReportsToPageComponentsRelations = relations( 139 139 + statusReportsToPageComponents, 140 140 + ({ one }) => ({ 141 141 + statusReport: one(statusReport, { 142 142 + fields: [statusReportsToPageComponents.statusReportId], 143 143 + references: [statusReport.id], 144 144 + }), 145 145 + pageComponent: one(pageComponent, { 146 146 + fields: [statusReportsToPageComponents.pageComponentId], 147 147 + references: [pageComponent.id], 148 148 + }), 149 149 + }), 150 150 + );

+29

packages/db/src/schema/page_components/validation.ts

··· 1 1 + import { createInsertSchema, createSelectSchema } from "drizzle-zod"; 2 2 + import type { z } from "zod"; 3 3 + 4 4 + import { pageComponent } from "./page_components"; 5 5 + 6 6 + export const selectPageComponentSchema = createSelectSchema(pageComponent); 7 7 + 8 8 + export const insertPageComponentSchema = createInsertSchema(pageComponent, { 9 9 + name: (schema) => schema.min(1), 10 10 + }).refine( 11 11 + (data) => { 12 12 + // monitorId must be set when type='monitor' 13 13 + if (data.type === "monitor" && !data.monitorId) { 14 14 + return false; 15 15 + } 16 16 + // monitorId must be null when type='external' 17 17 + if (data.type === "external" && data.monitorId) { 18 18 + return false; 19 19 + } 20 20 + return true; 21 21 + }, 22 22 + { 23 23 + message: 24 24 + "monitorId must be set when type is 'monitor' and must be null when type is 'external'", 25 25 + }, 26 26 + ); 27 27 + 28 28 + export type InsertPageComponent = z.infer<typeof insertPageComponentSchema>; 29 29 + export type PageComponent = z.infer<typeof selectPageComponentSchema>;

+515

packages/db/src/sync.ts

··· 1 1 + import { and, eq, inArray } from "drizzle-orm"; 2 2 + 3 3 + import type { db } from "./db"; 4 4 + import { 5 5 + maintenance, 6 6 + maintenancesToPageComponents, 7 7 + monitor, 8 8 + pageComponent, 9 9 + pageComponentGroup, 10 10 + statusReport, 11 11 + statusReportsToPageComponents, 12 12 + } from "./schema"; 13 13 + 14 14 + // Type that works with both LibSQLDatabase and SQLiteTransaction 15 15 + // Using any to allow both db instance and transaction to be passed 16 16 + // biome-ignore lint/suspicious/noExplicitAny: Compatible with both db and transaction 17 17 + type DB = typeof db; 18 18 + // Extract transaction type from the callback parameter of db.transaction() 19 19 + type Transaction = Parameters<Parameters<DB["transaction"]>[0]>[0]; 20 20 + 21 21 + // ============================================================================ 22 22 + // Monitor Group <-> Page Component Group Sync 23 23 + // ============================================================================ 24 24 + 25 25 + /** 26 26 + * Syncs a monitor group insert to page_component_groups 27 27 + */ 28 28 + export async function syncMonitorGroupInsert( 29 29 + db: DB | Transaction, 30 30 + data: { 31 31 + id: number; 32 32 + workspaceId: number; 33 33 + pageId: number; 34 34 + name: string; 35 35 + }, 36 36 + ) { 37 37 + await db 38 38 + .insert(pageComponentGroup) 39 39 + .values({ 40 40 + id: data.id, 41 41 + workspaceId: data.workspaceId, 42 42 + pageId: data.pageId, 43 43 + name: data.name, 44 44 + }) 45 45 + .onConflictDoNothing(); 46 46 + } 47 47 + 48 48 + /** 49 49 + * Syncs a monitor group delete to page_component_groups 50 50 + */ 51 51 + export async function syncMonitorGroupDelete( 52 52 + db: DB | Transaction, 53 53 + monitorGroupId: number, 54 54 + ) { 55 55 + await db 56 56 + .delete(pageComponentGroup) 57 57 + .where(eq(pageComponentGroup.id, monitorGroupId)); 58 58 + } 59 59 + 60 60 + /** 61 61 + * Syncs multiple monitor group deletes to page_component_groups 62 62 + */ 63 63 + export async function syncMonitorGroupDeleteMany( 64 64 + db: DB | Transaction, 65 65 + monitorGroupIds: number[], 66 66 + ) { 67 67 + if (monitorGroupIds.length === 0) return; 68 68 + await db 69 69 + .delete(pageComponentGroup) 70 70 + .where(inArray(pageComponentGroup.id, monitorGroupIds)); 71 71 + } 72 72 + 73 73 + // ============================================================================ 74 74 + // Monitors to Pages <-> Page Component Sync 75 75 + // ============================================================================ 76 76 + 77 77 + /** 78 78 + * Syncs a monitors_to_pages insert to page_component 79 79 + * Requires monitor data to get name and workspace_id 80 80 + */ 81 81 + export async function syncMonitorsToPageInsert( 82 82 + db: DB | Transaction, 83 83 + data: { 84 84 + monitorId: number; 85 85 + pageId: number; 86 86 + order?: number; 87 87 + monitorGroupId?: number | null; 88 88 + groupOrder?: number; 89 89 + }, 90 90 + ) { 91 91 + // Get monitor data for name and workspace_id 92 92 + const monitorData = await db 93 93 + .select({ 94 94 + id: monitor.id, 95 95 + name: monitor.name, 96 96 + externalName: monitor.externalName, 97 97 + workspaceId: monitor.workspaceId, 98 98 + }) 99 99 + .from(monitor) 100 100 + .where(eq(monitor.id, data.monitorId)) 101 101 + .get(); 102 102 + 103 103 + if (!monitorData || !monitorData.workspaceId) return; 104 104 + 105 105 + await db 106 106 + .insert(pageComponent) 107 107 + .values({ 108 108 + workspaceId: monitorData.workspaceId, 109 109 + pageId: data.pageId, 110 110 + type: "monitor", 111 111 + monitorId: data.monitorId, 112 112 + name: monitorData.externalName || monitorData.name, 113 113 + order: data.order ?? 0, 114 114 + groupId: data.monitorGroupId ?? null, 115 115 + groupOrder: data.groupOrder ?? 0, 116 116 + }) 117 117 + .onConflictDoNothing(); 118 118 + } 119 119 + 120 120 + /** 121 121 + * Syncs multiple monitors_to_pages inserts to page_component 122 122 + */ 123 123 + export async function syncMonitorsToPageInsertMany( 124 124 + db: DB | Transaction, 125 125 + items: Array<{ 126 126 + monitorId: number; 127 127 + pageId: number; 128 128 + order?: number; 129 129 + monitorGroupId?: number | null; 130 130 + groupOrder?: number; 131 131 + }>, 132 132 + ) { 133 133 + if (items.length === 0) return; 134 134 + 135 135 + // Get all monitor data in one query 136 136 + const monitorIds = [...new Set(items.map((item) => item.monitorId))]; 137 137 + const monitors = await db 138 138 + .select({ 139 139 + id: monitor.id, 140 140 + name: monitor.name, 141 141 + externalName: monitor.externalName, 142 142 + workspaceId: monitor.workspaceId, 143 143 + }) 144 144 + .from(monitor) 145 145 + .where(inArray(monitor.id, monitorIds)); 146 146 + 147 147 + const monitorMap = new Map(monitors.map((m) => [m.id, m])); 148 148 + 149 149 + const values = items 150 150 + .map((item) => { 151 151 + const m = monitorMap.get(item.monitorId); 152 152 + if (!m || !m.workspaceId) return null; 153 153 + return { 154 154 + workspaceId: m.workspaceId, 155 155 + pageId: item.pageId, 156 156 + type: "monitor" as const, 157 157 + monitorId: item.monitorId, 158 158 + name: m.externalName || m.name, 159 159 + order: item.order ?? 0, 160 160 + groupId: item.monitorGroupId ?? null, 161 161 + groupOrder: item.groupOrder ?? 0, 162 162 + }; 163 163 + }) 164 164 + .filter((v): v is NonNullable<typeof v> => v !== null); 165 165 + 166 166 + if (values.length === 0) return; 167 167 + 168 168 + await db.insert(pageComponent).values(values).onConflictDoNothing(); 169 169 + } 170 170 + 171 171 + /** 172 172 + * Syncs a monitors_to_pages delete to page_component 173 173 + */ 174 174 + export async function syncMonitorsToPageDelete( 175 175 + db: DB | Transaction, 176 176 + data: { monitorId: number; pageId: number }, 177 177 + ) { 178 178 + await db 179 179 + .delete(pageComponent) 180 180 + .where( 181 181 + and( 182 182 + eq(pageComponent.monitorId, data.monitorId), 183 183 + eq(pageComponent.pageId, data.pageId), 184 184 + ), 185 185 + ); 186 186 + } 187 187 + 188 188 + /** 189 189 + * Syncs monitors_to_pages deletes for a specific page to page_component 190 190 + */ 191 191 + export async function syncMonitorsToPageDeleteByPage( 192 192 + db: DB | Transaction, 193 193 + pageId: number, 194 194 + ) { 195 195 + await db 196 196 + .delete(pageComponent) 197 197 + .where( 198 198 + and(eq(pageComponent.pageId, pageId), eq(pageComponent.type, "monitor")), 199 199 + ); 200 200 + } 201 201 + 202 202 + /** 203 203 + * Syncs monitors_to_pages deletes for specific monitors to page_component 204 204 + */ 205 205 + export async function syncMonitorsToPageDeleteByMonitors( 206 206 + db: DB | Transaction, 207 207 + monitorIds: number[], 208 208 + ) { 209 209 + if (monitorIds.length === 0) return; 210 210 + await db 211 211 + .delete(pageComponent) 212 212 + .where(inArray(pageComponent.monitorId, monitorIds)); 213 213 + } 214 214 + 215 215 + // ============================================================================ 216 216 + // Status Report to Monitors <-> Status Report to Page Components Sync 217 217 + // ============================================================================ 218 218 + 219 219 + /** 220 220 + * Syncs a status_report_to_monitors insert to status_report_to_page_component 221 221 + */ 222 222 + export async function syncStatusReportToMonitorInsert( 223 223 + db: DB | Transaction, 224 224 + data: { statusReportId: number; monitorId: number }, 225 225 + ) { 226 226 + // Get the status report's page_id 227 227 + const report = await db 228 228 + .select({ pageId: statusReport.pageId }) 229 229 + .from(statusReport) 230 230 + .where(eq(statusReport.id, data.statusReportId)) 231 231 + .get(); 232 232 + 233 233 + // Find matching page_components 234 234 + const components = await db 235 235 + .select({ id: pageComponent.id }) 236 236 + .from(pageComponent) 237 237 + .where( 238 238 + and( 239 239 + eq(pageComponent.monitorId, data.monitorId), 240 240 + report?.pageId 241 241 + ? eq(pageComponent.pageId, report.pageId) 242 242 + : // If no page_id on status report, match all page_components with this monitor 243 243 + eq(pageComponent.monitorId, data.monitorId), 244 244 + ), 245 245 + ); 246 246 + 247 247 + if (components.length === 0) return; 248 248 + 249 249 + await db 250 250 + .insert(statusReportsToPageComponents) 251 251 + .values( 252 252 + components.map((c) => ({ 253 253 + statusReportId: data.statusReportId, 254 254 + pageComponentId: c.id, 255 255 + })), 256 256 + ) 257 257 + .onConflictDoNothing(); 258 258 + } 259 259 + 260 260 + /** 261 261 + * Syncs multiple status_report_to_monitors inserts to status_report_to_page_component 262 262 + */ 263 263 + export async function syncStatusReportToMonitorInsertMany( 264 264 + db: DB | Transaction, 265 265 + statusReportId: number, 266 266 + monitorIds: number[], 267 267 + ) { 268 268 + if (monitorIds.length === 0) return; 269 269 + 270 270 + // Get the status report's page_id 271 271 + const report = await db 272 272 + .select({ pageId: statusReport.pageId }) 273 273 + .from(statusReport) 274 274 + .where(eq(statusReport.id, statusReportId)) 275 275 + .get(); 276 276 + 277 277 + // Find matching page_components for all monitors 278 278 + const components = await db 279 279 + .select({ id: pageComponent.id, monitorId: pageComponent.monitorId }) 280 280 + .from(pageComponent) 281 281 + .where( 282 282 + and( 283 283 + inArray(pageComponent.monitorId, monitorIds), 284 284 + report?.pageId 285 285 + ? eq(pageComponent.pageId, report.pageId) 286 286 + : // If no page_id, we need to be careful - get components that match the monitor 287 287 + inArray(pageComponent.monitorId, monitorIds), 288 288 + ), 289 289 + ); 290 290 + 291 291 + if (components.length === 0) return; 292 292 + 293 293 + await db 294 294 + .insert(statusReportsToPageComponents) 295 295 + .values( 296 296 + components.map((c) => ({ 297 297 + statusReportId, 298 298 + pageComponentId: c.id, 299 299 + })), 300 300 + ) 301 301 + .onConflictDoNothing(); 302 302 + } 303 303 + 304 304 + /** 305 305 + * Syncs a status_report_to_monitors delete to status_report_to_page_component 306 306 + */ 307 307 + export async function syncStatusReportToMonitorDelete( 308 308 + db: DB | Transaction, 309 309 + data: { statusReportId: number; monitorId: number }, 310 310 + ) { 311 311 + // Find page_components with this monitor 312 312 + const components = await db 313 313 + .select({ id: pageComponent.id }) 314 314 + .from(pageComponent) 315 315 + .where(eq(pageComponent.monitorId, data.monitorId)); 316 316 + 317 317 + if (components.length === 0) return; 318 318 + 319 319 + await db.delete(statusReportsToPageComponents).where( 320 320 + and( 321 321 + eq(statusReportsToPageComponents.statusReportId, data.statusReportId), 322 322 + inArray( 323 323 + statusReportsToPageComponents.pageComponentId, 324 324 + components.map((c) => c.id), 325 325 + ), 326 326 + ), 327 327 + ); 328 328 + } 329 329 + 330 330 + /** 331 331 + * Syncs status_report_to_monitors deletes for a specific status report 332 332 + */ 333 333 + export async function syncStatusReportToMonitorDeleteByStatusReport( 334 334 + db: DB | Transaction, 335 335 + statusReportId: number, 336 336 + ) { 337 337 + await db 338 338 + .delete(statusReportsToPageComponents) 339 339 + .where(eq(statusReportsToPageComponents.statusReportId, statusReportId)); 340 340 + } 341 341 + 342 342 + /** 343 343 + * Syncs status_report_to_monitors deletes for specific monitors 344 344 + */ 345 345 + export async function syncStatusReportToMonitorDeleteByMonitors( 346 346 + db: DB | Transaction, 347 347 + monitorIds: number[], 348 348 + ) { 349 349 + if (monitorIds.length === 0) return; 350 350 + 351 351 + // Find page_components with these monitors 352 352 + const components = await db 353 353 + .select({ id: pageComponent.id }) 354 354 + .from(pageComponent) 355 355 + .where(inArray(pageComponent.monitorId, monitorIds)); 356 356 + 357 357 + if (components.length === 0) return; 358 358 + 359 359 + await db.delete(statusReportsToPageComponents).where( 360 360 + inArray( 361 361 + statusReportsToPageComponents.pageComponentId, 362 362 + components.map((c) => c.id), 363 363 + ), 364 364 + ); 365 365 + } 366 366 + 367 367 + // ============================================================================ 368 368 + // Maintenance to Monitor <-> Maintenance to Page Component Sync 369 369 + // ============================================================================ 370 370 + 371 371 + /** 372 372 + * Syncs a maintenance_to_monitor insert to maintenance_to_page_component 373 373 + */ 374 374 + export async function syncMaintenanceToMonitorInsert( 375 375 + db: DB | Transaction, 376 376 + data: { maintenanceId: number; monitorId: number }, 377 377 + ) { 378 378 + // Get the maintenance's page_id 379 379 + const maint = await db 380 380 + .select({ pageId: maintenance.pageId }) 381 381 + .from(maintenance) 382 382 + .where(eq(maintenance.id, data.maintenanceId)) 383 383 + .get(); 384 384 + 385 385 + // Find matching page_components 386 386 + const components = await db 387 387 + .select({ id: pageComponent.id }) 388 388 + .from(pageComponent) 389 389 + .where( 390 390 + and( 391 391 + eq(pageComponent.monitorId, data.monitorId), 392 392 + maint?.pageId 393 393 + ? eq(pageComponent.pageId, maint.pageId) 394 394 + : eq(pageComponent.monitorId, data.monitorId), 395 395 + ), 396 396 + ); 397 397 + 398 398 + if (components.length === 0) return; 399 399 + 400 400 + await db 401 401 + .insert(maintenancesToPageComponents) 402 402 + .values( 403 403 + components.map((c) => ({ 404 404 + maintenanceId: data.maintenanceId, 405 405 + pageComponentId: c.id, 406 406 + })), 407 407 + ) 408 408 + .onConflictDoNothing(); 409 409 + } 410 410 + 411 411 + /** 412 412 + * Syncs multiple maintenance_to_monitor inserts to maintenance_to_page_component 413 413 + */ 414 414 + export async function syncMaintenanceToMonitorInsertMany( 415 415 + db: DB | Transaction, 416 416 + maintenanceId: number, 417 417 + monitorIds: number[], 418 418 + ) { 419 419 + if (monitorIds.length === 0) return; 420 420 + 421 421 + // Get the maintenance's page_id 422 422 + const maint = await db 423 423 + .select({ pageId: maintenance.pageId }) 424 424 + .from(maintenance) 425 425 + .where(eq(maintenance.id, maintenanceId)) 426 426 + .get(); 427 427 + 428 428 + // Find matching page_components for all monitors 429 429 + const components = await db 430 430 + .select({ id: pageComponent.id, monitorId: pageComponent.monitorId }) 431 431 + .from(pageComponent) 432 432 + .where( 433 433 + and( 434 434 + inArray(pageComponent.monitorId, monitorIds), 435 435 + maint?.pageId 436 436 + ? eq(pageComponent.pageId, maint.pageId) 437 437 + : inArray(pageComponent.monitorId, monitorIds), 438 438 + ), 439 439 + ); 440 440 + 441 441 + if (components.length === 0) return; 442 442 + 443 443 + await db 444 444 + .insert(maintenancesToPageComponents) 445 445 + .values( 446 446 + components.map((c) => ({ 447 447 + maintenanceId, 448 448 + pageComponentId: c.id, 449 449 + })), 450 450 + ) 451 451 + .onConflictDoNothing(); 452 452 + } 453 453 + 454 454 + /** 455 455 + * Syncs a maintenance_to_monitor delete to maintenance_to_page_component 456 456 + */ 457 457 + export async function syncMaintenanceToMonitorDelete( 458 458 + db: DB | Transaction, 459 459 + data: { maintenanceId: number; monitorId: number }, 460 460 + ) { 461 461 + // Find page_components with this monitor 462 462 + const components = await db 463 463 + .select({ id: pageComponent.id }) 464 464 + .from(pageComponent) 465 465 + .where(eq(pageComponent.monitorId, data.monitorId)); 466 466 + 467 467 + if (components.length === 0) return; 468 468 + 469 469 + await db.delete(maintenancesToPageComponents).where( 470 470 + and( 471 471 + eq(maintenancesToPageComponents.maintenanceId, data.maintenanceId), 472 472 + inArray( 473 473 + maintenancesToPageComponents.pageComponentId, 474 474 + components.map((c) => c.id), 475 475 + ), 476 476 + ), 477 477 + ); 478 478 + } 479 479 + 480 480 + /** 481 481 + * Syncs maintenance_to_monitor deletes for a specific maintenance 482 482 + */ 483 483 + export async function syncMaintenanceToMonitorDeleteByMaintenance( 484 484 + db: DB | Transaction, 485 485 + maintenanceId: number, 486 486 + ) { 487 487 + await db 488 488 + .delete(maintenancesToPageComponents) 489 489 + .where(eq(maintenancesToPageComponents.maintenanceId, maintenanceId)); 490 490 + } 491 491 + 492 492 + /** 493 493 + * Syncs maintenance_to_monitor deletes for specific monitors 494 494 + */ 495 495 + export async function syncMaintenanceToMonitorDeleteByMonitors( 496 496 + db: DB | Transaction, 497 497 + monitorIds: number[], 498 498 + ) { 499 499 + if (monitorIds.length === 0) return; 500 500 + 501 501 + // Find page_components with these monitors 502 502 + const components = await db 503 503 + .select({ id: pageComponent.id }) 504 504 + .from(pageComponent) 505 505 + .where(inArray(pageComponent.monitorId, monitorIds)); 506 506 + 507 507 + if (components.length === 0) return; 508 508 + 509 509 + await db.delete(maintenancesToPageComponents).where( 510 510 + inArray( 511 511 + maintenancesToPageComponents.pageComponentId, 512 512 + components.map((c) => c.id), 513 513 + ), 514 514 + ); 515 515 + }