@checkstack/maintenance-backend 0.2.5 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @checkstack/maintenance-backend
 
+## 0.4.0
+
+### Minor Changes
+
+- 65aa47e: Add automatic maintenance status transitions
+
+  Maintenances now automatically transition from `scheduled` to `in_progress` when their `startAt` time is reached, and from `in_progress` to `completed` when their `endAt` time is reached. A recurring queue job runs every minute to check and transition statuses. Integration hooks and real-time signals are emitted upon each transition.
+
+### Patch Changes
+
+- Updated dependencies [8a87cd4]
+- Updated dependencies [8a87cd4]
+- Updated dependencies [8a87cd4]
+- Updated dependencies [8a87cd4]
+  - @checkstack/backend-api@0.4.1
+  - @checkstack/catalog-common@1.2.3
+  - @checkstack/common@0.5.0
+  - @checkstack/maintenance-common@0.4.1
+  - @checkstack/command-backend@0.1.5
+  - @checkstack/integration-backend@0.1.5
+  - @checkstack/integration-common@0.2.2
+  - @checkstack/notification-common@0.2.2
+  - @checkstack/signal-common@0.1.3
+
+## 0.3.0
+
+### Minor Changes
+
+- 18fa8e3: Add notification suppression toggle for maintenance windows
+
+  **New Feature:** When creating or editing a maintenance window, you can now enable "Suppress health notifications" to prevent health status change notifications from being sent for affected systems while the maintenance is active (in_progress status). This is useful for planned downtime where health alerts are expected and would otherwise create noise.
+
+  **Changes:**
+
+  - Added `suppressNotifications` field to maintenance schema
+  - Added new service-to-service API `hasActiveMaintenanceWithSuppression`
+  - Healthcheck queue executor now checks for suppression before sending notifications
+  - MaintenanceEditor UI includes new toggle checkbox
+
+  **Bug Fix:** Fixed migration system to correctly set PostgreSQL search_path when running plugin migrations. Previously, migrations could fail with "relation does not exist" errors because the schema context wasn't properly set.
+
+### Patch Changes
+
+- Updated dependencies [18fa8e3]
+  - @checkstack/maintenance-common@0.4.0
+
 ## 0.2.5
 
 ### Patch Changes

package/drizzle/0001_tough_star_brand.sql

@@ -0,0 +1 @@
+ALTER TABLE "maintenances" ADD COLUMN "suppress_notifications" boolean DEFAULT false NOT NULL;

package/drizzle/meta/0001_snapshot.json

@@ -0,0 +1,214 @@
+{
+  "id": "d0a42a3a-4685-408b-8ad9-e2c0ac19e8a2",
+  "prevId": "2722e752-6079-4992-b4d1-da0a4bc0e01b",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.maintenance_systems": {
+      "name": "maintenance_systems",
+      "schema": "",
+      "columns": {
+        "maintenance_id": {
+          "name": "maintenance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "system_id": {
+          "name": "system_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "maintenance_systems_maintenance_id_maintenances_id_fk": {
+          "name": "maintenance_systems_maintenance_id_maintenances_id_fk",
+          "tableFrom": "maintenance_systems",
+          "tableTo": "maintenances",
+          "columnsFrom": [
+            "maintenance_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "maintenance_systems_maintenance_id_system_id_pk": {
+          "name": "maintenance_systems_maintenance_id_system_id_pk",
+          "columns": [
+            "maintenance_id",
+            "system_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.maintenance_updates": {
+      "name": "maintenance_updates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "maintenance_id": {
+          "name": "maintenance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message": {
+          "name": "message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status_change": {
+          "name": "status_change",
+          "type": "maintenance_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "maintenance_updates_maintenance_id_maintenances_id_fk": {
+          "name": "maintenance_updates_maintenance_id_maintenances_id_fk",
+          "tableFrom": "maintenance_updates",
+          "tableTo": "maintenances",
+          "columnsFrom": [
+            "maintenance_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.maintenances": {
+      "name": "maintenances",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "suppress_notifications": {
+          "name": "suppress_notifications",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "status": {
+          "name": "status",
+          "type": "maintenance_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'scheduled'"
+        },
+        "start_at": {
+          "name": "start_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "end_at": {
+          "name": "end_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.maintenance_status": {
+      "name": "maintenance_status",
+      "schema": "public",
+      "values": [
+        "scheduled",
+        "in_progress",
+        "completed",
+        "cancelled"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1767319104427,
       "tag": "0000_numerous_shadow_king",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1768688736163,
+      "tag": "0001_tough_star_brand",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/maintenance-backend",
-  "version": "0.2.5",
+  "version": "0.4.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {

package/src/index.ts

@@ -7,7 +7,9 @@ import {
   pluginMetadata,
   maintenanceContract,
   maintenanceRoutes,
+  MAINTENANCE_UPDATED,
 } from "@checkstack/maintenance-common";
+
 import { createBackendPlugin, coreServices } from "@checkstack/backend-api";
 import { integrationEventExtensionPoint } from "@checkstack/integration-backend";
 import { MaintenanceService } from "./service";
@@ -42,6 +44,11 @@ const maintenanceUpdatedPayloadSchema = z.object({
   action: z.enum(["updated", "closed"]),
 });
 
+// Queue and job constants
+const STATUS_TRANSITION_QUEUE = "maintenance-status-transitions";
+const STATUS_TRANSITION_JOB_ID = "maintenance-status-transition-check";
+const WORKER_GROUP = "maintenance-status-worker";
+
 // =============================================================================
 // Plugin Definition
 // =============================================================================
@@ -53,7 +60,7 @@ export default createBackendPlugin({
 
     // Register hooks as integration events
     const integrationEvents = env.getExtensionPoint(
-      integrationEventExtensionPoint
+      integrationEventExtensionPoint,
     );
 
     integrationEvents.registerEvent(
@@ -64,7 +71,7 @@ export default createBackendPlugin({
         category: "Maintenance",
         payloadSchema: maintenanceCreatedPayloadSchema,
       },
-      pluginMetadata
+      pluginMetadata,
     );
 
     integrationEvents.registerEvent(
@@ -75,9 +82,12 @@ export default createBackendPlugin({
         category: "Maintenance",
         payloadSchema: maintenanceUpdatedPayloadSchema,
       },
-      pluginMetadata
+      pluginMetadata,
     );
 
+    // Store service reference for afterPluginsReady
+    let maintenanceService: MaintenanceService;
+
     env.registerInit({
       schema,
       deps: {
@@ -85,20 +95,21 @@ export default createBackendPlugin({
         rpc: coreServices.rpc,
         rpcClient: coreServices.rpcClient,
         signalService: coreServices.signalService,
+        queueManager: coreServices.queueManager,
       },
       init: async ({ logger, database, rpc, rpcClient, signalService }) => {
         logger.debug("🔧 Initializing Maintenance Backend...");
 
         const catalogClient = rpcClient.forPlugin(CatalogApi);
 
-        const service = new MaintenanceService(
-          database as NodePgDatabase<typeof schema>
+        maintenanceService = new MaintenanceService(
+          database as NodePgDatabase<typeof schema>,
         );
         const router = createRouter(
-          service,
+          maintenanceService,
           signalService,
           catalogClient,
-          logger
+          logger,
         );
         rpc.registerRouter(router, maintenanceContract);
 
@@ -130,6 +141,116 @@ export default createBackendPlugin({
 
         logger.debug("✅ Maintenance Backend initialized.");
       },
+      afterPluginsReady: async ({
+        queueManager,
+        emitHook,
+        logger,
+        signalService,
+      }) => {
+        // Schedule the recurring status transition check job
+        const queue = queueManager.getQueue<Record<string, never>>(
+          STATUS_TRANSITION_QUEUE,
+        );
+
+        // Subscribe to process status transition check jobs
+        await queue.consume(
+          async () => {
+            logger.debug("⏰ Checking maintenance status transitions...");
+
+            // Get maintenances that need to start
+            const toStart = await maintenanceService.getMaintenancesToStart();
+            for (const maintenance of toStart) {
+              const updated = await maintenanceService.transitionStatus(
+                maintenance.id,
+                "in_progress",
+                "Maintenance started automatically",
+              );
+
+              if (updated) {
+                logger.info(
+                  `Maintenance "${updated.title}" transitioned to in_progress`,
+                );
+
+                // Emit hook for integrations
+                await emitHook(maintenanceHooks.maintenanceUpdated, {
+                  maintenanceId: updated.id,
+                  systemIds: updated.systemIds,
+                  title: updated.title,
+                  description: updated.description,
+                  status: updated.status,
+                  startAt: updated.startAt.toISOString(),
+                  endAt: updated.endAt.toISOString(),
+                  action: "updated" as const,
+                });
+
+                // Send signal for real-time UI updates
+                await signalService.broadcast(MAINTENANCE_UPDATED, {
+                  maintenanceId: updated.id,
+                  systemIds: updated.systemIds,
+                  action: "updated",
+                });
+              }
+            }
+
+            // Get maintenances that need to complete
+            const toComplete =
+              await maintenanceService.getMaintenancesToComplete();
+            for (const maintenance of toComplete) {
+              const updated = await maintenanceService.transitionStatus(
+                maintenance.id,
+                "completed",
+                "Maintenance completed automatically",
+              );
+
+              if (updated) {
+                logger.info(
+                  `Maintenance "${updated.title}" transitioned to completed`,
+                );
+
+                // Emit hook for integrations
+                await emitHook(maintenanceHooks.maintenanceUpdated, {
+                  maintenanceId: updated.id,
+                  systemIds: updated.systemIds,
+                  title: updated.title,
+                  description: updated.description,
+                  status: updated.status,
+                  startAt: updated.startAt.toISOString(),
+                  endAt: updated.endAt.toISOString(),
+                  action: "closed" as const,
+                });
+
+                // Send signal for real-time UI updates
+                await signalService.broadcast(MAINTENANCE_UPDATED, {
+                  maintenanceId: updated.id,
+                  systemIds: updated.systemIds,
+                  action: "closed",
+                });
+              }
+            }
+
+            if (toStart.length > 0 || toComplete.length > 0) {
+              logger.debug(
+                `Status transitions: ${toStart.length} started, ${toComplete.length} completed`,
+              );
+            }
+          },
+          {
+            consumerGroup: WORKER_GROUP,
+            maxRetries: 0, // Status checks should not retry
+          },
+        );
+
+        // Schedule to run every minute (60 seconds)
+        await queue.scheduleRecurring(
+          {}, // Empty payload - the job just triggers a check
+          {
+            jobId: STATUS_TRANSITION_JOB_ID,
+            intervalSeconds: 60,
+          },
+        );
+
+        logger.debug("✅ Maintenance status transition job scheduled.");
+      },
     });
   },
 });

package/src/router.ts

@@ -20,7 +20,7 @@ export function createRouter(
   service: MaintenanceService,
   signalService: SignalService,
   catalogClient: InferClient<typeof CatalogApi>,
-  logger: Logger
+  logger: Logger,
 ) {
   const os = implement(maintenanceContract)
     .$context<RpcContext>()
@@ -44,7 +44,7 @@ export function createRouter(
       maintenanceRoutes.routes.detail,
       {
         maintenanceId,
-      }
+      },
     );
 
     for (const systemId of systemIds) {
@@ -61,7 +61,7 @@ export function createRouter(
         // Log but don't fail the operation - notifications are best-effort
         logger.warn(
           `Failed to notify subscribers for system ${systemId}:`,
-          error
+          error,
         );
       }
     }
@@ -81,7 +81,7 @@ export function createRouter(
     getMaintenancesForSystem: os.getMaintenancesForSystem.handler(
       async ({ input }) => {
         return service.getMaintenancesForSystem(input.systemId);
-      }
+      },
     ),
 
     getBulkMaintenancesForSystems: os.getBulkMaintenancesForSystems.handler(
@@ -94,14 +94,13 @@ export function createRouter(
         // Fetch maintenances for each system in parallel
         await Promise.all(
           input.systemIds.map(async (systemId) => {
-            maintenances[systemId] = await service.getMaintenancesForSystem(
-              systemId
-            );
-          })
+            maintenances[systemId] =
+              await service.getMaintenancesForSystem(systemId);
+          }),
         );
 
         return { maintenances };
-      }
+      },
     ),
 
     createMaintenance: os.createMaintenance.handler(
@@ -135,7 +134,7 @@ export function createRouter(
         });
 
         return result;
-      }
+      },
     ),
 
     updateMaintenance: os.updateMaintenance.handler(
@@ -175,7 +174,7 @@ export function createRouter(
         });
 
         return result;
-      }
+      },
     ),
 
     addUpdate: os.addUpdate.handler(async ({ input, context }) => {
@@ -213,7 +212,7 @@ export function createRouter(
         const result = await service.closeMaintenance(
           input.id,
           input.message,
-          userId
+          userId,
         );
         if (!result) {
           throw new ORPCError("NOT_FOUND", {
@@ -240,7 +239,7 @@ export function createRouter(
         });
 
         return result;
-      }
+      },
     ),
 
     deleteMaintenance: os.deleteMaintenance.handler(async ({ input }) => {
@@ -256,5 +255,13 @@ export function createRouter(
       }
       return { success };
     }),
+
+    hasActiveMaintenanceWithSuppression:
+      os.hasActiveMaintenanceWithSuppression.handler(async ({ input }) => {
+        const suppressed = await service.hasActiveMaintenanceWithSuppression(
+          input.systemId,
+        );
+        return { suppressed };
+      }),
   });
 }

package/src/schema.ts

@@ -4,6 +4,7 @@ import {
   text,
   timestamp,
   primaryKey,
+  boolean,
 } from "drizzle-orm/pg-core";
 
 /**
@@ -23,6 +24,9 @@ export const maintenances = pgTable("maintenances", {
   id: text("id").primaryKey(),
   title: text("title").notNull(),
   description: text("description"),
+  suppressNotifications: boolean("suppress_notifications")
+    .notNull()
+    .default(false),
   status: maintenanceStatusEnum("status").notNull().default("scheduled"),
   startAt: timestamp("start_at").notNull(),
   endAt: timestamp("end_at").notNull(),
@@ -43,7 +47,7 @@ export const maintenanceSystems = pgTable(
   },
   (t) => ({
     pk: primaryKey(t.maintenanceId, t.systemId),
-  })
+  }),
 );
 
 /**

package/src/service.ts

@@ -46,15 +46,17 @@ export class MaintenanceService {
         .where(
           and(
             inArray(maintenances.id, ids),
-            filters.status ? eq(maintenances.status, filters.status) : undefined
-          )
+            filters.status
+              ? eq(maintenances.status, filters.status)
+              : undefined,
+          ),
         );
     } else {
       maintenanceRows = await this.db
         .select()
         .from(maintenances)
         .where(
-          filters?.status ? eq(maintenances.status, filters.status) : undefined
+          filters?.status ? eq(maintenances.status, filters.status) : undefined,
         );
     }
 
@@ -113,7 +115,7 @@ export class MaintenanceService {
    * Get active/upcoming maintenances for a system
    */
   async getMaintenancesForSystem(
-    systemId: string
+    systemId: string,
   ): Promise<MaintenanceWithSystems[]> {
     const _now = new Date();
 
@@ -135,9 +137,9 @@ export class MaintenanceService {
           inArray(maintenances.id, ids),
           or(
             eq(maintenances.status, "scheduled"),
-            eq(maintenances.status, "in_progress")
-          )
-        )
+            eq(maintenances.status, "in_progress"),
+          ),
+        ),
       );
 
     // Fetch system IDs for each
@@ -162,7 +164,7 @@ export class MaintenanceService {
    * Create a new maintenance
    */
   async createMaintenance(
-    input: CreateMaintenanceInput
+    input: CreateMaintenanceInput,
   ): Promise<MaintenanceWithSystems> {
     const id = generateId();
 
@@ -170,6 +172,7 @@ export class MaintenanceService {
       id,
       title: input.title,
       description: input.description,
+      suppressNotifications: input.suppressNotifications ?? false,
       status: "scheduled",
       startAt: input.startAt,
       endAt: input.endAt,
@@ -190,7 +193,7 @@ export class MaintenanceService {
    * Update an existing maintenance
    */
   async updateMaintenance(
-    input: UpdateMaintenanceInput
+    input: UpdateMaintenanceInput,
   ): Promise<MaintenanceWithSystems | undefined> {
     const [existing] = await this.db
       .select()
@@ -206,6 +209,8 @@ export class MaintenanceService {
     if (input.title !== undefined) updateData.title = input.title;
     if (input.description !== undefined)
       updateData.description = input.description;
+    if (input.suppressNotifications !== undefined)
+      updateData.suppressNotifications = input.suppressNotifications;
     if (input.startAt !== undefined) updateData.startAt = input.startAt;
     if (input.endAt !== undefined) updateData.endAt = input.endAt;
 
@@ -236,7 +241,7 @@ export class MaintenanceService {
    */
   async addUpdate(
     input: AddMaintenanceUpdateInput,
-    userId?: string
+    userId?: string,
   ): Promise<MaintenanceUpdate> {
     const id = generateId();
 
@@ -274,7 +279,7 @@ export class MaintenanceService {
   async closeMaintenance(
     id: string,
     message?: string,
-    userId?: string
+    userId?: string,
   ): Promise<MaintenanceWithSystems | undefined> {
     const [existing] = await this.db
       .select()
@@ -325,4 +330,142 @@ export class MaintenanceService {
     // For now, return empty set
     return new Set();
   }
+
+  /**
+   * Check if a system has an active maintenance with notification suppression enabled.
+   * A maintenance is considered "active" if its status is "in_progress".
+   */
+  async hasActiveMaintenanceWithSuppression(
+    systemId: string,
+  ): Promise<boolean> {
+    // Get maintenance IDs for this system
+    const systemMaintenances = await this.db
+      .select({ maintenanceId: maintenanceSystems.maintenanceId })
+      .from(maintenanceSystems)
+      .where(eq(maintenanceSystems.systemId, systemId));
+
+    const ids = systemMaintenances.map((r) => r.maintenanceId);
+    if (ids.length === 0) return false;
+
+    // Check if any of these maintenances are in_progress with suppressNotifications enabled
+    const [match] = await this.db
+      .select({ id: maintenances.id })
+      .from(maintenances)
+      .where(
+        and(
+          inArray(maintenances.id, ids),
+          eq(maintenances.status, "in_progress"),
+          eq(maintenances.suppressNotifications, true),
+        ),
+      )
+      .limit(1);
+
+    return !!match;
+  }
+
+  /**
+   * Get maintenances that should transition from 'scheduled' to 'in_progress'.
+   * These are maintenances where status = 'scheduled' AND startAt <= now.
+   */
+  async getMaintenancesToStart(): Promise<MaintenanceWithSystems[]> {
+    const now = new Date();
+
+    const rows = await this.db
+      .select()
+      .from(maintenances)
+      .where(
+        and(
+          eq(maintenances.status, "scheduled"),
+          // startAt is in the past or now
+          // Using SQL comparison - startAt <= now
+        ),
+      );
+
+    // Filter in JS since Drizzle SQL comparison can be tricky with dates
+    const startable = rows.filter((m) => m.startAt <= now);
+
+    // Fetch system IDs for each
+    const result: MaintenanceWithSystems[] = [];
+    for (const m of startable) {
+      const systems = await this.db
+        .select({ systemId: maintenanceSystems.systemId })
+        .from(maintenanceSystems)
+        .where(eq(maintenanceSystems.maintenanceId, m.id));
+
+      result.push({
+        ...m,
+        description: m.description ?? undefined,
+        systemIds: systems.map((s) => s.systemId),
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Get maintenances that should transition from 'in_progress' to 'completed'.
+   * These are maintenances where status = 'in_progress' AND endAt <= now.
+   */
+  async getMaintenancesToComplete(): Promise<MaintenanceWithSystems[]> {
+    const now = new Date();
+
+    const rows = await this.db
+      .select()
+      .from(maintenances)
+      .where(eq(maintenances.status, "in_progress"));
+
+    // Filter in JS for those that have ended
+    const completable = rows.filter((m) => m.endAt <= now);
+
+    // Fetch system IDs for each
+    const result: MaintenanceWithSystems[] = [];
+    for (const m of completable) {
+      const systems = await this.db
+        .select({ systemId: maintenanceSystems.systemId })
+        .from(maintenanceSystems)
+        .where(eq(maintenanceSystems.maintenanceId, m.id));
+
+      result.push({
+        ...m,
+        description: m.description ?? undefined,
+        systemIds: systems.map((s) => s.systemId),
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Transition a maintenance to a new status with an automatic update entry.
+   * Used by the scheduled job for automatic status transitions.
+   */
+  async transitionStatus(
+    id: string,
+    newStatus: MaintenanceStatus,
+    message: string,
+  ): Promise<MaintenanceWithSystems | undefined> {
+    const [existing] = await this.db
+      .select()
+      .from(maintenances)
+      .where(eq(maintenances.id, id));
+
+    if (!existing) return undefined;
+
+    // Update the maintenance status
+    await this.db
+      .update(maintenances)
+      .set({ status: newStatus, updatedAt: new Date() })
+      .where(eq(maintenances.id, id));
+
+    // Add update entry (no user - system-generated)
+    await this.db.insert(maintenanceUpdates).values({
+      id: generateId(),
+      maintenanceId: id,
+      message,
+      statusChange: newStatus,
+      createdBy: undefined, // System-generated, no user
+    });
+
+    return (await this.getMaintenance(id))!;
+  }
 }