Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { relations, sql } from "drizzle-orm";
import {
check,
index,
integer,
primaryKey,
sqliteTable,
text,
unique,
} from "drizzle-orm/sqlite-core";
import { maintenance } from "../maintenances";
import { monitor } from "../monitors";
import { pageComponentGroup } from "../page_component_groups";
import { page } from "../pages";
import { statusReport, statusReportUpdate } from "../status_reports";
import { workspace } from "../workspaces";
import { pageComponentImpact, pageComponentTypes } from "./constants";
export const pageComponent = sqliteTable(
"page_component",
{
id: integer("id").primaryKey(),
workspaceId: integer("workspace_id")
.notNull()
.references(() => workspace.id, { onDelete: "cascade" }),
pageId: integer("page_id")
.notNull()
.references(() => page.id, { onDelete: "cascade" }),
type: text("type", { enum: pageComponentTypes })
.notNull()
.default("monitor"),
monitorId: integer("monitor_id").references(() => monitor.id, {
onDelete: "cascade",
}),
name: text("name").notNull(),
description: text("description"),
order: integer("order").default(0),
groupId: integer("group_id").references(() => pageComponentGroup.id, {
onDelete: "set null",
}),
groupOrder: integer("group_order").default(0),
createdAt: integer("created_at", { mode: "timestamp" }).default(
sql`(strftime('%s', 'now'))`,
),
updatedAt: integer("updated_at", { mode: "timestamp" }).default(
sql`(strftime('%s', 'now'))`,
),
},
(t) => [
unique("page_component_page_id_monitor_id_unique").on(
t.pageId,
t.monitorId,
),
index("page_component_workspace_id_idx").on(t.workspaceId),
check(
"page_component_type_check",
// NOTE: This check ensures that either the component is a monitor or a static component, but not both.
sql`${t.type} = 'monitor' AND ${t.monitorId} IS NOT NULL OR ${t.type} = 'static' AND ${t.monitorId} IS NULL`,
),
],
);
export const pageComponentRelations = relations(
pageComponent,
({ one, many }) => ({
workspace: one(workspace, {
fields: [pageComponent.workspaceId],
references: [workspace.id],
}),
page: one(page, {
fields: [pageComponent.pageId],
references: [page.id],
}),
monitor: one(monitor, {
fields: [pageComponent.monitorId],
references: [monitor.id],
}),
group: one(pageComponentGroup, {
fields: [pageComponent.groupId],
references: [pageComponentGroup.id],
}),
statusReportsToPageComponents: many(statusReportsToPageComponents),
statusReportUpdateToPageComponents: many(
statusReportUpdateToPageComponents,
),
maintenancesToPageComponents: many(maintenancesToPageComponents),
}),
);
export const maintenancesToPageComponents = sqliteTable(
"maintenance_to_page_component",
{
maintenanceId: integer("maintenance_id")
.notNull()
.references(() => maintenance.id, { onDelete: "cascade" }),
pageComponentId: integer("page_component_id")
.notNull()
.references(() => pageComponent.id, { onDelete: "cascade" }),
createdAt: integer("created_at", { mode: "timestamp" }).default(
sql`(strftime('%s', 'now'))`,
),
},
(t) => [
primaryKey({ columns: [t.maintenanceId, t.pageComponentId] }),
index("maintenance_to_page_component_page_component_id_idx").on(
t.pageComponentId,
),
],
);
export const maintenancesToPageComponentsRelations = relations(
maintenancesToPageComponents,
({ one }) => ({
maintenance: one(maintenance, {
fields: [maintenancesToPageComponents.maintenanceId],
references: [maintenance.id],
}),
pageComponent: one(pageComponent, {
fields: [maintenancesToPageComponents.pageComponentId],
references: [pageComponent.id],
}),
}),
);
export const statusReportsToPageComponents = sqliteTable(
"status_report_to_page_component",
{
statusReportId: integer("status_report_id")
.notNull()
.references(() => statusReport.id, { onDelete: "cascade" }),
pageComponentId: integer("page_component_id")
.notNull()
.references(() => pageComponent.id, { onDelete: "cascade" }),
createdAt: integer("created_at", { mode: "timestamp" }).default(
sql`(strftime('%s', 'now'))`,
),
},
(t) => [
primaryKey({ columns: [t.statusReportId, t.pageComponentId] }),
index("status_report_to_page_component_page_component_id_idx").on(
t.pageComponentId,
),
],
);
export const statusReportsToPageComponentsRelations = relations(
statusReportsToPageComponents,
({ one }) => ({
statusReport: one(statusReport, {
fields: [statusReportsToPageComponents.statusReportId],
references: [statusReport.id],
}),
pageComponent: one(pageComponent, {
fields: [statusReportsToPageComponents.pageComponentId],
references: [pageComponent.id],
}),
}),
);
// timeline: the impact each update set per component — the only place impact
// is stored. `status_report_to_page_component` stays the membership source.
export const statusReportUpdateToPageComponents = sqliteTable(
"status_report_update_to_page_component",
{
statusReportUpdateId: integer("status_report_update_id")
.notNull()
.references(() => statusReportUpdate.id, { onDelete: "cascade" }),
pageComponentId: integer("page_component_id")
.notNull()
.references(() => pageComponent.id, { onDelete: "cascade" }),
impact: text("impact", { enum: pageComponentImpact }).notNull(),
createdAt: integer("created_at", { mode: "timestamp" }).default(
sql`(strftime('%s', 'now'))`,
),
},
(t) => [
primaryKey({ columns: [t.statusReportUpdateId, t.pageComponentId] }),
index("status_report_update_to_page_component_page_component_id_idx").on(
t.pageComponentId,
),
],
);
export const statusReportUpdateToPageComponentsRelations = relations(
statusReportUpdateToPageComponents,
({ one }) => ({
statusReportUpdate: one(statusReportUpdate, {
fields: [statusReportUpdateToPageComponents.statusReportUpdateId],
references: [statusReportUpdate.id],
}),
pageComponent: one(pageComponent, {
fields: [statusReportUpdateToPageComponents.pageComponentId],
references: [pageComponent.id],
}),
}),
);