Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import {
type SQL,
and,
asc,
db as defaultDb,
desc,
eq,
inArray,
isNull,
} from "@openstatus/db";
import {
maintenance,
maintenancesToPageComponents,
monitor,
pageComponent,
pageComponentGroup,
selectMaintenanceSchema,
selectMonitorSchema,
selectPageComponentGroupSchema,
selectPageComponentSchema,
selectStatusReportSchema,
statusReport,
statusReportsToPageComponents,
} from "@openstatus/db/src/schema";
import type { DB, ServiceContext } from "../context";
import type {
Maintenance,
Monitor,
PageComponent,
StatusReport,
} from "../types";
import { ListPageComponentsInput } from "./schemas";
type PageComponentGroupRow = typeof pageComponentGroup.$inferSelect;
export type PageComponentWithRelations = PageComponent & {
monitor?: Monitor | null;
group?: PageComponentGroupRow | null;
statusReports: StatusReport[];
maintenances: Maintenance[];
};
/**
* Batched enrichment for a list of page components. Four IN queries total
* (monitors / groups / status reports via join / maintenances via join);
* no per-row fan-out.
*/
async function enrichPageComponentsBatch(
db: DB,
rows: Array<typeof pageComponent.$inferSelect>,
workspaceId: number,
): Promise<PageComponentWithRelations[]> {
if (rows.length === 0) return [];
const ids = rows.map((r) => r.id);
const monitorIds = Array.from(
new Set(rows.map((r) => r.monitorId).filter((m): m is number => m != null)),
);
const groupIds = Array.from(
new Set(rows.map((r) => r.groupId).filter((g): g is number => g != null)),
);
const [monitorRows, groupRows, statusReportRows, maintenanceRows] =
await Promise.all([
monitorIds.length > 0
? db
.select()
.from(monitor)
.where(
and(
inArray(monitor.id, monitorIds),
eq(monitor.workspaceId, workspaceId),
// Skip soft-deleted monitors so the enrichment map
// doesn't resurrect tombstoned rows as `component.monitor`.
isNull(monitor.deletedAt),
),
)
.all()
: Promise.resolve([] as never[]),
groupIds.length > 0
? db
.select()
.from(pageComponentGroup)
.where(
and(
inArray(pageComponentGroup.id, groupIds),
eq(pageComponentGroup.workspaceId, workspaceId),
),
)
.all()
: Promise.resolve([] as never[]),
// Explicit column selection on join queries — keeps the row shape
// in our hands instead of relying on drizzle's auto-derived
// `row.<table_name>` keys (named after the JS variable, fragile to
// schema renames).
db
.select({
pageComponentId: statusReportsToPageComponents.pageComponentId,
report: statusReport,
})
.from(statusReport)
.innerJoin(
statusReportsToPageComponents,
eq(statusReportsToPageComponents.statusReportId, statusReport.id),
)
.where(
and(
inArray(statusReportsToPageComponents.pageComponentId, ids),
eq(statusReport.workspaceId, workspaceId),
),
)
.all(),
db
.select({
pageComponentId: maintenancesToPageComponents.pageComponentId,
maintenance,
})
.from(maintenance)
.innerJoin(
maintenancesToPageComponents,
eq(maintenancesToPageComponents.maintenanceId, maintenance.id),
)
.where(
and(
inArray(maintenancesToPageComponents.pageComponentId, ids),
eq(maintenance.workspaceId, workspaceId),
),
)
.all(),
]);
const monitorById = new Map<number, Monitor>();
for (const m of monitorRows) {
monitorById.set(m.id, selectMonitorSchema.parse(m));
}
const groupById = new Map<number, PageComponentGroupRow>();
for (const g of groupRows) {
groupById.set(g.id, selectPageComponentGroupSchema.parse(g));
}
const statusReportsByComponent = new Map<number, StatusReport[]>();
for (const row of statusReportRows) {
const parsed = selectStatusReportSchema.parse(row.report);
const arr = statusReportsByComponent.get(row.pageComponentId);
if (arr) arr.push(parsed);
else statusReportsByComponent.set(row.pageComponentId, [parsed]);
}
const maintenancesByComponent = new Map<number, Maintenance[]>();
for (const row of maintenanceRows) {
const parsed = selectMaintenanceSchema.parse(row.maintenance);
const arr = maintenancesByComponent.get(row.pageComponentId);
if (arr) arr.push(parsed);
else maintenancesByComponent.set(row.pageComponentId, [parsed]);
}
return rows.map((r) => ({
...selectPageComponentSchema.parse(r),
monitor:
r.monitorId != null ? (monitorById.get(r.monitorId) ?? null) : null,
group: r.groupId != null ? (groupById.get(r.groupId) ?? null) : null,
statusReports: statusReportsByComponent.get(r.id) ?? [],
maintenances: maintenancesByComponent.get(r.id) ?? [],
}));
}
export async function listPageComponents(args: {
ctx: ServiceContext;
input: ListPageComponentsInput;
}): Promise<PageComponentWithRelations[]> {
const { ctx } = args;
const input = ListPageComponentsInput.parse(args.input);
const db = ctx.db ?? defaultDb;
const conditions: SQL[] = [eq(pageComponent.workspaceId, ctx.workspace.id)];
if (input.pageId !== undefined) {
conditions.push(eq(pageComponent.pageId, input.pageId));
}
const rows = await db
.select()
.from(pageComponent)
.where(and(...conditions))
.orderBy(
input.order === "desc"
? desc(pageComponent.order)
: asc(pageComponent.order),
)
.all();
return enrichPageComponentsBatch(db, rows, ctx.workspace.id);
}