Skip to content

Open-source status page, incident response and uptime monitoring

add maintenance resource routes

Thomas Mola4f8a3bff490
diff --git a/apps/server/src/routes/v1/index.ts b/apps/server/src/routes/v1/index.ts
index 632fd29da..12cd2f218 100644
--- a/apps/server/src/routes/v1/index.ts
+++ b/apps/server/src/routes/v1/index.ts
@@ -10,6 +10,7 @@ import { checkApi } from "./check";
import { incidentsApi } from "./incidents";
import { monitorsApi } from "./monitors";
import { notificationsApi } from "./notifications";
+import { maintenanceApi } from "./maintenance";
import { pageSubscribersApi } from "./pageSubscribers";
import { pagesApi } from "./pages";
import { statusReportUpdatesApi } from "./statusReportUpdates";
@@ -71,6 +72,11 @@ api.doc("/openapi", {
description: "Incident related endpoints",
"x-displayName": "Incident",
},
+ {
+ name: "maintenance",
+ description: "Maintenance related endpoints",
+ "x-displayName": "Maintenance",
+ },
{
name: "notification",
description: "Notification related endpoints",
@@ -115,7 +121,7 @@ api.get(
"https://openstatus.dev/api/og?title=OpenStatus%20API&description=API%20Reference",
twitterCard: "summary_large_image",
},
- }),
+ })
);
/**
* Middlewares
@@ -130,6 +136,7 @@ api.route("/page", pagesApi);
api.route("/status_report", statusReportsApi);
api.route("/status_report_update", statusReportUpdatesApi);
api.route("/incident", incidentsApi);
+api.route("/maintenance", maintenanceApi);
api.route("/notification", notificationsApi);
api.route("/page_subscriber", pageSubscribersApi);
api.route("/check", checkApi);
diff --git a/apps/server/src/routes/v1/maintenance/get.test.ts b/apps/server/src/routes/v1/maintenance/get.test.ts
new file mode 100644
index 000000000..1222a1f01
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/get.test.ts
@@ -0,0 +1,31 @@
+import { expect, test } from "bun:test";
+import { app } from "@/index";
+import { MaintenanceSchema } from "./schema";
+
+test("return the maintenance", async () => {
+ const res = await app.request("/v1/maintenance/1", {
+ headers: {
+ "x-openstatus-key": "1",
+ },
+ });
+ const result = MaintenanceSchema.safeParse(await res.json());
+
+ expect(res.status).toBe(200);
+ expect(result.success).toBe(true);
+});
+
+test("no auth key should return 401", async () => {
+ const res = await app.request("/v1/maintenance/1");
+
+ expect(res.status).toBe(401);
+});
+
+test("invalid maintenance id should return 404", async () => {
+ const res = await app.request("/v1/maintenance/999", {
+ headers: {
+ "x-openstatus-key": "1",
+ },
+ });
+
+ expect(res.status).toBe(404);
+});
diff --git a/apps/server/src/routes/v1/maintenance/get.ts b/apps/server/src/routes/v1/maintenance/get.ts
new file mode 100644
index 000000000..4886f5fbe
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/get.ts
@@ -0,0 +1,58 @@
+import { createRoute } from "@hono/zod-openapi";
+import { and, db, eq } from "@openstatus/db";
+import { maintenance } from "@openstatus/db/src/schema/maintenances";
+import { OpenStatusApiError, openApiErrorResponses } from "@/libs/errors";
+import type { maintenanceApi } from "./index";
+import { MaintenanceSchema, ParamsSchema } from "./schema";
+
+const getRoute = createRoute({
+ method: "get",
+ tags: ["maintenance"],
+ summary: "Get a maintenance",
+ path: "/:id",
+ request: {
+ params: ParamsSchema,
+ },
+ responses: {
+ 200: {
+ content: {
+ "application/json": {
+ schema: MaintenanceSchema,
+ },
+ },
+ description: "Get a maintenance",
+ },
+ ...openApiErrorResponses,
+ },
+});
+
+export function registerGetMaintenance(api: typeof maintenanceApi) {
+ return api.openapi(getRoute, async (c) => {
+ const workspaceId = c.get("workspace").id;
+ const { id } = c.req.valid("param");
+
+ const _maintenance = await db.query.maintenance.findFirst({
+ with: {
+ maintenancesToMonitors: true,
+ },
+ where: and(
+ eq(maintenance.id, Number(id)),
+ eq(maintenance.workspaceId, workspaceId)
+ ),
+ });
+
+ if (!_maintenance) {
+ throw new OpenStatusApiError({
+ code: "NOT_FOUND",
+ message: `Maintenance ${id} not found`,
+ });
+ }
+
+ const data = MaintenanceSchema.parse({
+ ..._maintenance,
+ monitorIds: _maintenance.maintenancesToMonitors.map((m) => m.monitorId),
+ });
+
+ return c.json(data, 200);
+ });
+}
diff --git a/apps/server/src/routes/v1/maintenance/get_all.test.ts b/apps/server/src/routes/v1/maintenance/get_all.test.ts
new file mode 100644
index 000000000..e957b2d75
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/get_all.test.ts
@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test";
+import { app } from "@/index";
+import { MaintenanceSchema } from "./schema";
+
+test("return all maintenances", async () => {
+ const res = await app.request("/v1/maintenance", {
+ method: "GET",
+ headers: {
+ "x-openstatus-key": "1",
+ },
+ });
+
+ const result = MaintenanceSchema.array().safeParse(await res.json());
+
+ expect(res.status).toBe(200);
+ expect(result.success).toBe(true);
+ expect(result.data?.length).toBeGreaterThan(0);
+});
+
+test("return empty maintenances", async () => {
+ const res = await app.request("/v1/maintenance", {
+ method: "GET",
+ headers: {
+ "x-openstatus-key": "2",
+ },
+ });
+
+ const result = MaintenanceSchema.array().safeParse(await res.json());
+
+ expect(result.success).toBe(true);
+ expect(res.status).toBe(200);
+ expect(result.data?.length).toBe(0);
+});
+
+test("no auth key should return 401", async () => {
+ const res = await app.request("/v1/maintenance", {
+ method: "GET",
+ });
+
+ expect(res.status).toBe(401);
+});
diff --git a/apps/server/src/routes/v1/maintenance/get_all.ts b/apps/server/src/routes/v1/maintenance/get_all.ts
new file mode 100644
index 000000000..857bb8d58
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/get_all.ts
@@ -0,0 +1,48 @@
+import { createRoute } from "@hono/zod-openapi";
+import { db, eq, desc } from "@openstatus/db";
+import { maintenance } from "@openstatus/db/src/schema/maintenances";
+import { openApiErrorResponses } from "@/libs/errors";
+import type { maintenanceApi } from "./index";
+import { MaintenanceSchema } from "./schema";
+
+const getAllRoute = createRoute({
+ method: "get",
+ tags: ["maintenance"],
+ summary: "List all maintenances",
+ path: "/",
+ request: {},
+ responses: {
+ 200: {
+ content: {
+ "application/json": {
+ schema: MaintenanceSchema.array(),
+ },
+ },
+ description: "Get all maintenances",
+ },
+ ...openApiErrorResponses,
+ },
+});
+
+export function registerGetAllMaintenances(api: typeof maintenanceApi) {
+ return api.openapi(getAllRoute, async (c) => {
+ const workspaceId = c.get("workspace").id;
+
+ const _maintenances = await db.query.maintenance.findMany({
+ with: {
+ maintenancesToMonitors: true,
+ },
+ where: eq(maintenance.workspaceId, workspaceId),
+ orderBy: desc(maintenance.createdAt)
+ });
+
+ const data = MaintenanceSchema.array().parse(
+ _maintenances.map((m) => ({
+ ...m,
+ monitorIds: m.maintenancesToMonitors.map((mtm) => mtm.monitorId),
+ }))
+ );
+
+ return c.json(data, 200);
+ });
+}
diff --git a/apps/server/src/routes/v1/maintenance/index.ts b/apps/server/src/routes/v1/maintenance/index.ts
new file mode 100644
index 000000000..fd41c42e0
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/index.ts
@@ -0,0 +1,18 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { handleZodError } from "@/libs/errors";
+import type { Variables } from "../index";
+import { registerGetMaintenance } from "./get";
+import { registerGetAllMaintenances } from "./get_all";
+import { registerPostMaintenance } from "./post";
+import { registerPutMaintenance } from "./put";
+
+const maintenanceApi = new OpenAPIHono<{ Variables: Variables }>({
+ defaultHook: handleZodError,
+});
+
+registerGetAllMaintenances(maintenanceApi);
+registerGetMaintenance(maintenanceApi);
+registerPostMaintenance(maintenanceApi);
+registerPutMaintenance(maintenanceApi);
+
+export { maintenanceApi };
diff --git a/apps/server/src/routes/v1/maintenance/post.test.ts b/apps/server/src/routes/v1/maintenance/post.test.ts
new file mode 100644
index 000000000..677bd446a
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/post.test.ts
@@ -0,0 +1,60 @@
+import { expect, test } from "bun:test";
+import { app } from "@/index";
+import { MaintenanceSchema } from "./schema";
+
+test("create a valid maintenance", async () => {
+ const from = new Date();
+ const to = new Date(from.getTime() + 3600000); // 1 hour later
+
+ const res = await app.request("/v1/maintenance", {
+ method: "POST",
+ headers: {
+ "x-openstatus-key": "1",
+ "content-type": "application/json",
+ },
+ body: JSON.stringify({
+ title: "Database Upgrade",
+ message: "Scheduled database maintenance",
+ from: from.toISOString(),
+ to: to.toISOString(),
+ monitorIds: [1],
+ pageId: 1,
+ }),
+ });
+
+ const result = MaintenanceSchema.safeParse(await res.json());
+
+ expect(res.status).toBe(200);
+ expect(result.success).toBe(true);
+ expect(result.data?.monitorIds?.length).toBe(1);
+});
+
+test("create a maintenance with invalid dates should return 400", async () => {
+ const res = await app.request("/v1/maintenance", {
+ method: "POST",
+ headers: {
+ "x-openstatus-key": "1",
+ "content-type": "application/json",
+ },
+ body: JSON.stringify({
+ title: "Invalid Maintenance",
+ message: "Test message",
+ from: "invalid-date",
+ to: "invalid-date",
+ pageId: 1,
+ }),
+ });
+
+ expect(res.status).toBe(400);
+});
+
+test("no auth key should return 401", async () => {
+ const res = await app.request("/v1/maintenance", {
+ method: "POST",
+ headers: {
+ "content-type": "application/json",
+ },
+ });
+
+ expect(res.status).toBe(401);
+});
diff --git a/apps/server/src/routes/v1/maintenance/post.ts b/apps/server/src/routes/v1/maintenance/post.ts
new file mode 100644
index 000000000..8721996e6
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/post.ts
@@ -0,0 +1,78 @@
+import { createRoute } from "@hono/zod-openapi";
+import { db } from "@openstatus/db";
+import {
+ maintenance,
+ maintenancesToMonitors,
+} from "@openstatus/db/src/schema/maintenances";
+import { OpenStatusApiError, openApiErrorResponses } from "@/libs/errors";
+import { trackMiddleware } from "@/libs/middlewares";
+import { Events } from "@openstatus/analytics";
+import type { maintenanceApi } from "./index";
+import { MaintenanceSchema } from "./schema";
+
+const postRoute = createRoute({
+ method: "post",
+ tags: ["maintenance"],
+ summary: "Create a maintenance",
+ path: "/",
+ middleware: [trackMiddleware(Events.CreateMaintenance)],
+ request: {
+ body: {
+ content: {
+ "application/json": {
+ schema: MaintenanceSchema.omit({ id: true }),
+ },
+ },
+ },
+ },
+ responses: {
+ 200: {
+ content: {
+ "application/json": {
+ schema: MaintenanceSchema,
+ },
+ },
+ description: "Create a maintenance",
+ },
+ ...openApiErrorResponses,
+ },
+});
+
+export function registerPostMaintenance(api: typeof maintenanceApi) {
+ return api.openapi(postRoute, async (c) => {
+ const workspaceId = c.get("workspace").id;
+ const input = c.req.valid("json");
+
+ const _maintenance = await db.transaction(async (tx) => {
+ const newMaintenance = await tx
+ .insert(maintenance)
+ .values({
+ ...input,
+ workspaceId,
+ })
+ .returning()
+ .get();
+
+ if (input.monitorIds?.length) {
+ await tx
+ .insert(maintenancesToMonitors)
+ .values(
+ input.monitorIds.map((monitorId) => ({
+ maintenanceId: newMaintenance.id,
+ monitorId,
+ }))
+ )
+ .run();
+ }
+
+ return newMaintenance;
+ });
+
+ const data = MaintenanceSchema.parse({
+ ..._maintenance,
+ monitorIds: input.monitorIds,
+ });
+
+ return c.json(data, 200);
+ });
+}
diff --git a/apps/server/src/routes/v1/maintenance/put.test.ts b/apps/server/src/routes/v1/maintenance/put.test.ts
new file mode 100644
index 000000000..72e5e488b
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/put.test.ts
@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test";
+import { app } from "@/index";
+import { MaintenanceSchema } from "./schema";
+
+test("update the maintenance", async () => {
+ const res = await app.request("/v1/maintenance/1", {
+ method: "PUT",
+ headers: {
+ "x-openstatus-key": "1",
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ title: "Updated Maintenance",
+ message: "Updated message",
+ }),
+ });
+
+ const result = MaintenanceSchema.safeParse(await res.json());
+
+ expect(res.status).toBe(200);
+ expect(result.success).toBe(true);
+ expect(result.data?.title).toBe("Updated Maintenance");
+});
+
+test("update maintenance monitors", async () => {
+ const res = await app.request("/v1/maintenance/1", {
+ method: "PUT",
+ headers: {
+ "x-openstatus-key": "1",
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ monitorIds: [1, 2],
+ }),
+ });
+
+ const result = MaintenanceSchema.safeParse(await res.json());
+
+ expect(res.status).toBe(200);
+ expect(result.success).toBe(true);
+ expect(result.data?.monitorIds?.length).toBe(2);
+});
+
+test("invalid maintenance id should return 404", async () => {
+ const res = await app.request("/v1/maintenance/999", {
+ method: "PUT",
+ headers: {
+ "x-openstatus-key": "1",
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ title: "Not Found",
+ }),
+ });
+
+ expect(res.status).toBe(404);
+});
+
+test("no auth key should return 401", async () => {
+ const res = await app.request("/v1/maintenance/1", {
+ method: "PUT",
+ headers: {
+ "content-type": "application/json",
+ },
+ body: JSON.stringify({}),
+ });
+
+ expect(res.status).toBe(401);
+});
diff --git a/apps/server/src/routes/v1/maintenance/put.ts b/apps/server/src/routes/v1/maintenance/put.ts
new file mode 100644
index 000000000..f01f890c5
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/put.ts
@@ -0,0 +1,109 @@
+import { createRoute } from "@hono/zod-openapi";
+import { and, db, eq } from "@openstatus/db";
+import {
+ maintenance,
+ maintenancesToMonitors,
+} from "@openstatus/db/src/schema/maintenances";
+import { OpenStatusApiError, openApiErrorResponses } from "@/libs/errors";
+import { trackMiddleware } from "@/libs/middlewares";
+import { Events } from "@openstatus/analytics";
+import type { maintenanceApi } from "./index";
+import { MaintenanceSchema, ParamsSchema } from "./schema";
+
+const putRoute = createRoute({
+ method: "put",
+ tags: ["maintenance"],
+ summary: "Update a maintenance",
+ path: "/:id",
+ middleware: [trackMiddleware(Events.UpdateMaintenance)],
+ request: {
+ params: ParamsSchema,
+ body: {
+ content: {
+ "application/json": {
+ schema: MaintenanceSchema.omit({ id: true }).partial(),
+ },
+ },
+ },
+ },
+ responses: {
+ 200: {
+ content: {
+ "application/json": {
+ schema: MaintenanceSchema,
+ },
+ },
+ description: "Update a maintenance",
+ },
+ ...openApiErrorResponses,
+ },
+});
+
+export function registerPutMaintenance(api: typeof maintenanceApi) {
+ return api.openapi(putRoute, async (c) => {
+ const workspaceId = c.get("workspace").id;
+ const { id } = c.req.valid("param");
+ const input = c.req.valid("json");
+
+ const _maintenance = await db.query.maintenance.findFirst({
+ with: {
+ maintenancesToMonitors: true,
+ },
+ where: and(
+ eq(maintenance.id, Number(id)),
+ eq(maintenance.workspaceId, workspaceId)
+ ),
+ });
+
+ if (!_maintenance) {
+ throw new OpenStatusApiError({
+ code: "NOT_FOUND",
+ message: `Maintenance ${id} not found`,
+ });
+ }
+
+ const updatedMaintenance = await db.transaction(async (tx) => {
+ const updated = await tx
+ .update(maintenance)
+ .set({
+ ...input,
+ updatedAt: new Date(),
+ })
+ .where(eq(maintenance.id, Number(id)))
+ .returning()
+ .get();
+
+ if (input.monitorIds) {
+ // Delete existing monitor associations
+ await tx
+ .delete(maintenancesToMonitors)
+ .where(eq(maintenancesToMonitors.maintenanceId, Number(id)))
+ .run();
+
+ // Add new monitor associations
+ if (input.monitorIds.length > 0) {
+ await tx
+ .insert(maintenancesToMonitors)
+ .values(
+ input.monitorIds.map((monitorId) => ({
+ maintenanceId: Number(id),
+ monitorId,
+ }))
+ )
+ .run();
+ }
+ }
+
+ return updated;
+ });
+
+ const data = MaintenanceSchema.parse({
+ ...updatedMaintenance,
+ monitorIds:
+ input.monitorIds ??
+ _maintenance.maintenancesToMonitors.map((m) => m.monitorId),
+ });
+
+ return c.json(data, 200);
+ });
+}
diff --git a/apps/server/src/routes/v1/maintenance/schema.ts b/apps/server/src/routes/v1/maintenance/schema.ts
new file mode 100644
index 000000000..ee3782aff
--- /dev/null
+++ b/apps/server/src/routes/v1/maintenance/schema.ts
@@ -0,0 +1,48 @@
+import { z } from "@hono/zod-openapi";
+
+export const ParamsSchema = z.object({
+ id: z
+ .string()
+ .min(1)
+ .openapi({
+ param: {
+ name: "id",
+ in: "path",
+ },
+ description: "The id of the maintenance",
+ example: "1",
+ }),
+});
+
+export const MaintenanceSchema = z
+ .object({
+ id: z.number().openapi({
+ description: "The id of the maintenance",
+ example: 1,
+ }),
+ title: z.string().openapi({
+ description: "The title of the maintenance",
+ example: "Database Upgrade",
+ }),
+ message: z.string().openapi({
+ description: "The message describing the maintenance",
+ example: "Upgrading database to improve performance",
+ }),
+ from: z.coerce.date().openapi({
+ description: "When the maintenance starts",
+ }),
+ to: z.coerce.date().openapi({
+ description: "When the maintenance ends",
+ }),
+ monitorIds: z
+ .array(z.number())
+ .optional()
+ .default([])
+ .openapi({ description: "IDs of affected monitors" }),
+ pageId: z.number().openapi({
+ description: "The id of the status page this maintenance belongs to",
+ }),
+ })
+ .openapi("Maintenance");
+
+export type MaintenanceSchema = z.infer<typeof MaintenanceSchema>;