Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { desc, eq } from "@openstatus/db";
import { maintenance, maintenanceUpdate } from "@openstatus/db/src/schema";
import { emitAudit } from "../audit";
import { requireScope } from "../auth";
import {
type DB,
type ServiceContext,
tryGetActorUserId,
withTransaction,
} from "../context";
import { ConflictError, InternalServiceError } from "../errors";
import type { Maintenance } from "../types";
import {
getMaintenanceInWorkspace,
updatePageComponentAssociations,
validatePageComponentIds,
} from "./internal";
import { UpdateMaintenanceInput } from "./schemas";
export async function updateMaintenance(args: {
ctx: ServiceContext;
input: UpdateMaintenanceInput;
}): Promise<Maintenance> {
const { ctx } = args;
requireScope(ctx, "write");
const input = UpdateMaintenanceInput.parse(args.input);
const actorUserId = tryGetActorUserId(ctx.actor);
return withTransaction(ctx, async (tx) => {
const existing = await getMaintenanceInWorkspace({
tx,
id: input.id,
workspaceId: ctx.workspace.id,
});
// Effective from/to for the range check — either the incoming value or
// whatever was persisted before.
const effectiveFrom = input.from ?? existing.from;
const effectiveTo = input.to ?? existing.to;
if (effectiveFrom >= effectiveTo) {
throw new ConflictError("End date must be after start date.");
}
const updateValues: Record<string, unknown> = {
updatedAt: new Date(),
updatedBy: actorUserId,
};
if (input.title !== undefined) updateValues.title = input.title;
if (input.from !== undefined) updateValues.from = input.from;
if (input.to !== undefined) updateValues.to = input.to;
if (input.pageComponentIds !== undefined) {
const validated = await validatePageComponentIds({
tx,
workspaceId: ctx.workspace.id,
pageComponentIds: input.pageComponentIds,
});
// A non-empty set moves the maintenance to that page; an empty set
// only clears associations and keeps `pageId` (same as status-report).
// The dashboard edit sheet always sends the array, so nulling here
// orphaned every maintenance edited without components.
if (validated.pageId !== null) {
updateValues.pageId = validated.pageId;
}
await updatePageComponentAssociations({
tx,
maintenanceId: existing.id,
componentIds: validated.componentIds,
});
}
if (input.message !== undefined) {
await rewriteLatestUpdate(tx, ctx, existing.id, input.message);
}
const updated = await tx
.update(maintenance)
.set(updateValues)
.where(eq(maintenance.id, existing.id))
.returning()
.get();
if (!updated) {
throw new InternalServiceError(
`failed to update maintenance ${existing.id}`,
);
}
await emitAudit(tx, ctx, {
action: "maintenance.update",
entityType: "maintenance",
entityId: updated.id,
before: existing,
after: updated,
});
return updated;
});
}
/**
* `message` is the newest update's text, so editing it rewrites that row.
* A maintenance without updates (pre-backfill) gets one dated now instead.
*/
async function rewriteLatestUpdate(
tx: DB,
ctx: ServiceContext,
maintenanceId: number,
message: string,
): Promise<void> {
const actorUserId = tryGetActorUserId(ctx.actor);
const latest = await tx
.select()
.from(maintenanceUpdate)
.where(eq(maintenanceUpdate.maintenanceId, maintenanceId))
.orderBy(desc(maintenanceUpdate.date), desc(maintenanceUpdate.id))
.limit(1)
.get();
if (!latest) {
const created = await tx
.insert(maintenanceUpdate)
.values({
maintenanceId,
message,
date: new Date(),
createdBy: actorUserId,
updatedBy: actorUserId,
})
.returning()
.get();
await emitAudit(tx, ctx, {
action: "maintenance_update.create",
entityType: "maintenance_update",
entityId: created.id,
after: created,
metadata: { maintenanceId },
});
return;
}
if (latest.message === message) return;
const updated = await tx
.update(maintenanceUpdate)
.set({ message, updatedAt: new Date(), updatedBy: actorUserId })
.where(eq(maintenanceUpdate.id, latest.id))
.returning()
.get();
if (!updated) {
throw new InternalServiceError(
`failed to update maintenance update ${latest.id}`,
);
}
await emitAudit(tx, ctx, {
action: "maintenance_update.update",
entityType: "maintenance_update",
entityId: updated.id,
before: latest,
after: updated,
metadata: { maintenanceId },
});
}