Skip to content

Open-source status page, incident response and uptime monitoring

fix: reset status report affected monitors on reorder (#1781)

Maximilian Kaske5d972bc6b279
diff --git a/packages/api/src/router/page.ts b/packages/api/src/router/page.ts
index f2de0d831..74f5f66a9 100644
--- a/packages/api/src/router/page.ts
+++ b/packages/api/src/router/page.ts
@@ -14,8 +14,8 @@ import {
syncMonitorGroupDeleteMany,
syncMonitorGroupInsert,
syncMonitorsToPageDelete,
- syncMonitorsToPageDeleteByPage,
syncMonitorsToPageInsertMany,
+ syncMonitorsToPageUpsertMany,
} from "@openstatus/db";
import {
incidentTable,
@@ -967,28 +967,76 @@ export const pageRouter = createTRPCRouter({
}
await opts.ctx.db.transaction(async (tx) => {
- // Get existing monitor groups to delete from page components
+ // Get existing state
+ const existingMonitorsToPages = await tx
+ .select()
+ .from(monitorsToPages)
+ .where(eq(monitorsToPages.pageId, opts.input.id))
+ .all();
+
const existingGroups = await tx.query.monitorGroup.findMany({
where: eq(monitorGroup.pageId, opts.input.id),
});
const existingGroupIds = existingGroups.map((g) => g.id);
- // Delete child records first to avoid foreign key constraint violation
- await tx
- .delete(monitorsToPages)
- .where(eq(monitorsToPages.pageId, opts.input.id));
- await tx
- .delete(monitorGroup)
- .where(eq(monitorGroup.pageId, opts.input.id));
+ // Calculate what monitors are in the new input vs existing
+ const existingMonitorIds = existingMonitorsToPages.map(
+ (m) => m.monitorId,
+ );
+
+ // Find monitors that are being removed (in DB but not in input)
+ const removedMonitorIds = existingMonitorIds.filter(
+ (id) => !allMonitorIds.includes(id),
+ );
+
+ // Delete removed monitors from monitorsToPages and page components
+ if (removedMonitorIds.length > 0) {
+ await tx
+ .delete(monitorsToPages)
+ .where(
+ and(
+ eq(monitorsToPages.pageId, opts.input.id),
+ inArray(monitorsToPages.monitorId, removedMonitorIds),
+ ),
+ );
+
+ // Sync delete to page components
+ for (const monitorId of removedMonitorIds) {
+ await syncMonitorsToPageDelete(tx, {
+ monitorId,
+ pageId: opts.input.id,
+ });
+ }
+ }
+
+ // Clear monitorGroupId from all monitorsToPages before deleting groups
+ // This prevents foreign key constraint errors
+ if (existingGroupIds.length > 0) {
+ await tx
+ .update(monitorsToPages)
+ .set({ monitorGroupId: null })
+ .where(
+ and(
+ eq(monitorsToPages.pageId, opts.input.id),
+ inArray(monitorsToPages.monitorGroupId, existingGroupIds),
+ ),
+ );
+ }
- // Sync deletes to page components
- await syncMonitorsToPageDeleteByPage(tx, opts.input.id);
+ // Handle groups: delete old groups and create new ones
if (existingGroupIds.length > 0) {
+ await tx
+ .delete(monitorGroup)
+ .where(eq(monitorGroup.pageId, opts.input.id));
+
+ // Sync delete page component groups
await syncMonitorGroupDeleteMany(tx, existingGroupIds);
}
+ // Create new monitor groups
+ let monitorGroups: Array<{ id: number; name: string }> = [];
if (opts.input.groups.length > 0) {
- const monitorGroups = await tx
+ monitorGroups = await tx
.insert(monitorGroup)
.values(
opts.input.groups.map((g) => ({
@@ -1008,32 +1056,45 @@ export const pageRouter = createTRPCRouter({
name: group.name,
});
}
-
- const groupMonitorValues = opts.input.groups.flatMap((g, i) =>
- g.monitors.map((m) => ({
- pageId: opts.input.id,
- monitorId: m.id,
- order: g.order,
- monitorGroupId: monitorGroups[i].id,
- groupOrder: m.order,
- })),
- );
-
- await tx.insert(monitorsToPages).values(groupMonitorValues);
- // Sync to page components
- await syncMonitorsToPageInsertMany(tx, groupMonitorValues);
}
- if (opts.input.monitors.length > 0) {
- const monitorValues = opts.input.monitors.map((m) => ({
+ // Prepare values for upsert - both grouped and ungrouped monitors
+ const groupMonitorValues = opts.input.groups.flatMap((g, i) =>
+ g.monitors.map((m) => ({
pageId: opts.input.id,
monitorId: m.id,
- order: m.order,
- }));
+ order: g.order,
+ monitorGroupId: monitorGroups[i].id,
+ groupOrder: m.order,
+ })),
+ );
+
+ const monitorValues = opts.input.monitors.map((m) => ({
+ pageId: opts.input.id,
+ monitorId: m.id,
+ order: m.order,
+ monitorGroupId: null as number | null,
+ groupOrder: 0,
+ }));
+
+ const allValues = [...groupMonitorValues, ...monitorValues];
+
+ // Upsert all monitors (update existing, insert new)
+ if (allValues.length > 0) {
+ await tx
+ .insert(monitorsToPages)
+ .values(allValues)
+ .onConflictDoUpdate({
+ target: [monitorsToPages.monitorId, monitorsToPages.pageId],
+ set: {
+ order: sql.raw("excluded.`order`"),
+ monitorGroupId: sql.raw("excluded.`monitor_group_id`"),
+ groupOrder: sql.raw("excluded.`group_order`"),
+ },
+ });
- await tx.insert(monitorsToPages).values(monitorValues);
- // Sync to page components
- await syncMonitorsToPageInsertMany(tx, monitorValues);
+ // Sync upsert to page components (updates existing, inserts new)
+ await syncMonitorsToPageUpsertMany(tx, allValues);
}
});
}),
diff --git a/packages/db/src/sync.ts b/packages/db/src/sync.ts
index b15df405d..b60a83e72 100644
--- a/packages/db/src/sync.ts
+++ b/packages/db/src/sync.ts
@@ -1,4 +1,4 @@
-import { and, eq, inArray } from "drizzle-orm";
+import { and, eq, inArray, sql } from "drizzle-orm";
import type { db } from "./db";
import {
@@ -170,6 +170,70 @@ export async function syncMonitorsToPageInsertMany(
await db.insert(pageComponent).values(values).onConflictDoNothing();
}
+/**
+ * Syncs multiple monitors_to_pages upserts to page_component
+ * Updates order, groupId, groupOrder for existing components, inserts new ones
+ */
+export async function syncMonitorsToPageUpsertMany(
+ db: DB | Transaction,
+ items: Array<{
+ monitorId: number;
+ pageId: number;
+ order?: number;
+ monitorGroupId?: number | null;
+ groupOrder?: number;
+ }>,
+) {
+ if (items.length === 0) return;
+
+ // Get all monitor data in one query
+ const monitorIds = [...new Set(items.map((item) => item.monitorId))];
+ const monitors = await db
+ .select({
+ id: monitor.id,
+ name: monitor.name,
+ externalName: monitor.externalName,
+ workspaceId: monitor.workspaceId,
+ })
+ .from(monitor)
+ .where(inArray(monitor.id, monitorIds));
+
+ const monitorMap = new Map(monitors.map((m) => [m.id, m]));
+
+ const values = items
+ .map((item) => {
+ const m = monitorMap.get(item.monitorId);
+ if (!m || !m.workspaceId) return null;
+ return {
+ workspaceId: m.workspaceId,
+ pageId: item.pageId,
+ type: "monitor" as const,
+ monitorId: item.monitorId,
+ name: m.externalName || m.name,
+ order: item.order ?? 0,
+ groupId: item.monitorGroupId ?? null,
+ groupOrder: item.groupOrder ?? 0,
+ };
+ })
+ .filter((v): v is NonNullable<typeof v> => v !== null);
+
+ if (values.length === 0) return;
+
+ // Use onConflictDoUpdate to update existing page components
+ // The unique constraint is on (pageId, monitorId)
+ await db
+ .insert(pageComponent)
+ .values(values)
+ .onConflictDoUpdate({
+ target: [pageComponent.pageId, pageComponent.monitorId],
+ set: {
+ order: sql.raw("excluded.`order`"),
+ groupId: sql.raw("excluded.`group_id`"),
+ groupOrder: sql.raw("excluded.`group_order`"),
+ },
+ });
+}
+
/**
* Syncs a monitors_to_pages delete to page_component
*/