@oneuptime/common 11.7.1 → 11.7.2

package/Tests/Server/Services/AddHotQueryIndexesSecondPassMigration.test.ts

@@ -0,0 +1,258 @@
+import DashboardDomain from "../../../Models/DatabaseModels/DashboardDomain";
+import NetworkSite from "../../../Models/DatabaseModels/NetworkSite";
+import OnCallDutyPolicySchedule from "../../../Models/DatabaseModels/OnCallDutyPolicySchedule";
+import ScheduledMaintenanceTemplate from "../../../Models/DatabaseModels/ScheduledMaintenanceTemplate";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import StatusPageDomain from "../../../Models/DatabaseModels/StatusPageDomain";
+import WorkspaceNotificationSummary from "../../../Models/DatabaseModels/WorkspaceNotificationSummary";
+import { AddHotQueryIndexesSecondPass1785148065137 } from "../../../Server/Infrastructure/Postgres/SchemaMigrations/1785148065137-AddHotQueryIndexesSecondPass";
+import SchemaMigrations from "../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import { createHash } from "node:crypto";
+import { QueryRunner, getMetadataArgsStorage } from "typeorm";
+import type { IndexMetadataArgs } from "typeorm/metadata-args/IndexMetadataArgs";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The 8 columns below are the filter columns of hot recurring lookups that were
+ * full-table seq scans before AddHotQueryIndexesSecondPass1785148065137:
+ *   - StatusPageDomain.fullDomain / DashboardDomain.fullDomain: resolved on
+ *     EVERY public request to a custom-domain status page or dashboard (the
+ *     Host header is looked up by fullDomain to find the page to serve),
+ *   - StatusPage.sendNextReportBy: the EVERY_MINUTE status-page report cron
+ *     sweeps for pages whose next report is due,
+ *   - OnCallDutyPolicySchedule.rosterHandoffAt / rosterNextStartAt: the
+ *     EVERY_MINUTE on-call roster crons sweep for schedules due a handoff or
+ *     a roster start,
+ *   - WorkspaceNotificationSummary.nextSendAt: the workspace notification
+ *     digest cron sweeps for summaries due to send,
+ *   - ScheduledMaintenanceTemplate.scheduleNextEventAt: the recurring
+ *     scheduled-maintenance cron sweeps for templates due to spawn an event,
+ *   - NetworkSite.lastRollupAt: the network-site rollup cron sweeps for sites
+ *     due a metrics rollup.
+ *
+ * These tests pin the pieces that must all hold for the scans to stay gone —
+ * a regression in ANY one silently reintroduces them:
+ *   1. the @Index() decorator on each entity property (keeps future
+ *      schema:generate runs from emitting a DROP INDEX as "drift"),
+ *   2. the migration's SQL contract: up() creates exactly these 8 indexes
+ *      and nothing else (no ALTER TABLE drift statements from a regenerated
+ *      migration), down() drops exactly the indexes up() created,
+ *   3. each index NAME equals TypeORM's deterministic derivation
+ *      "IDX_" + sha1(tableName + "_" + columnName) truncated to 26 hex chars,
+ *      so the hand-written migration creates the SAME index a schema:generate
+ *      run would derive from the decorators (a name mismatch would make a
+ *      future generated migration drop and recreate the index as drift),
+ *   4. the migration's registration in SchemaMigrations/Index.ts (an
+ *      unregistered migration is dead code and never runs on boot).
+ *
+ * Pure metadata/mocks — no Postgres connection anywhere.
+ */
+
+type ModelClass = { new (): unknown };
+
+// [entity class, table name (=== class name for all of these), indexed column]
+const HOT_INDEX_PAIRS: Array<[ModelClass, string, string]> = [
+  [StatusPageDomain, "StatusPageDomain", "fullDomain"],
+  [DashboardDomain, "DashboardDomain", "fullDomain"],
+  [StatusPage, "StatusPage", "sendNextReportBy"],
+  [OnCallDutyPolicySchedule, "OnCallDutyPolicySchedule", "rosterHandoffAt"],
+  [OnCallDutyPolicySchedule, "OnCallDutyPolicySchedule", "rosterNextStartAt"],
+  [WorkspaceNotificationSummary, "WorkspaceNotificationSummary", "nextSendAt"],
+  [
+    ScheduledMaintenanceTemplate,
+    "ScheduledMaintenanceTemplate",
+    "scheduleNextEventAt",
+  ],
+  [NetworkSite, "NetworkSite", "lastRollupAt"],
+];
+
+/*
+ * IndexMetadataArgs.columns is either an array of property names (property-
+ * level @Index()) or a function over the entity's properties map (class-level
+ * @Index((o) => [o.a, o.b])). Resolve both to plain property-name arrays; the
+ * function form is fed a proxy whose every property reads as its own name,
+ * which is exactly how TypeORM's propertiesMap behaves for flat columns.
+ */
+function resolveIndexColumns(
+  columns: IndexMetadataArgs["columns"],
+): Array<string> {
+  if (!columns) {
+    return [];
+  }
+  if (Array.isArray(columns)) {
+    return columns.map(String);
+  }
+  const propertiesMap: Record<string, string> = new Proxy(
+    {} as Record<string, string>,
+    {
+      get: (_target: Record<string, string>, property: string | symbol) => {
+        return String(property);
+      },
+    },
+  );
+  const resolved: Array<unknown> | { [key: string]: number } =
+    columns(propertiesMap);
+  if (Array.isArray(resolved)) {
+    return resolved.map(String);
+  }
+  return Object.keys(resolved);
+}
+
+/*
+ * TypeORM's DefaultNamingStrategy.indexName: "IDX_" + the first 26 hex chars
+ * of sha1(`${tableName}_${columnName}`) for a single-column index.
+ */
+function typeormIndexName(tableName: string, columnName: string): string {
+  const hash: string = createHash("sha1")
+    .update(`${tableName}_${columnName}`)
+    .digest("hex");
+  return `IDX_${hash.substring(0, 26)}`;
+}
+
+interface CreateIndexStatement {
+  indexName: string;
+  tableName: string;
+  columnName: string;
+}
+
+const CREATE_INDEX_REGEX: RegExp =
+  /^CREATE INDEX "([^"]+)" ON "([^"]+)" \("([^"]+)"\)\s*$/;
+const DROP_INDEX_REGEX: RegExp = /^DROP INDEX "public"\."([^"]+)"$/;
+
+function makeQueryRunner(): { runner: QueryRunner; query: jest.Mock } {
+  const query: jest.Mock = jest.fn().mockResolvedValue(undefined);
+  return { runner: { query } as unknown as QueryRunner, query };
+}
+
+function executedSql(query: jest.Mock): Array<string> {
+  return query.mock.calls.map((call: Array<unknown>) => {
+    return String(call[0]);
+  });
+}
+
+describe("AddHotQueryIndexesSecondPass: entity @Index() decorators", () => {
+  test.each(
+    HOT_INDEX_PAIRS.map(
+      ([model, table, column]: [ModelClass, string, string]) => {
+        return [table, column, model] as [string, string, ModelClass];
+      },
+    ),
+  )(
+    "%s.%s has a single-column index decorator",
+    (_table: string, column: string, model: ModelClass) => {
+      const singleColumnIndexes: Array<string> = getMetadataArgsStorage()
+        .indices.filter((index: IndexMetadataArgs) => {
+          return index.target === model;
+        })
+        .map((index: IndexMetadataArgs) => {
+          return resolveIndexColumns(index.columns);
+        })
+        .filter((columns: Array<string>) => {
+          return columns.length === 1;
+        })
+        .map((columns: Array<string>) => {
+          return columns[0] as string;
+        });
+
+      expect(singleColumnIndexes).toContain(column);
+    },
+  );
+});
+
+describe("AddHotQueryIndexesSecondPass1785148065137 migration SQL contract", () => {
+  const migration: AddHotQueryIndexesSecondPass1785148065137 =
+    new AddHotQueryIndexesSecondPass1785148065137();
+
+  test("up() issues exactly 8 CREATE INDEX statements covering exactly the 8 hot columns — and nothing else", async () => {
+    const { runner, query } = makeQueryRunner();
+    await migration.up(runner);
+
+    const statements: Array<string> = executedSql(query);
+    expect(statements).toHaveLength(8);
+
+    /*
+     * A regenerated migration on a drifted schema would interleave ALTER
+     * TABLE / DROP statements with the index creates; none may sneak in.
+     */
+    for (const sql of statements) {
+      expect(sql).not.toContain("ALTER TABLE");
+      expect(sql).not.toContain("DROP");
+      expect(sql).toMatch(CREATE_INDEX_REGEX);
+    }
+
+    const created: Array<CreateIndexStatement> = statements.map(
+      (sql: string) => {
+        const match: RegExpMatchArray = sql.match(
+          CREATE_INDEX_REGEX,
+        ) as RegExpMatchArray;
+        return {
+          indexName: match[1] as string,
+          tableName: match[2] as string,
+          columnName: match[3] as string,
+        };
+      },
+    );
+
+    const createdPairs: Array<string> = created
+      .map((statement: CreateIndexStatement) => {
+        return `"${statement.tableName}"."${statement.columnName}"`;
+      })
+      .sort();
+    const expectedPairs: Array<string> = HOT_INDEX_PAIRS.map(
+      ([, table, column]: [ModelClass, string, string]) => {
+        return `"${table}"."${column}"`;
+      },
+    ).sort();
+
+    expect(createdPairs).toEqual(expectedPairs);
+  });
+
+  test("every index name matches TypeORM's deterministic sha1 derivation from (table, column)", async () => {
+    const { runner, query } = makeQueryRunner();
+    await migration.up(runner);
+
+    const statements: Array<string> = executedSql(query);
+    for (const sql of statements) {
+      const match: RegExpMatchArray = sql.match(
+        CREATE_INDEX_REGEX,
+      ) as RegExpMatchArray;
+      const indexName: string = match[1] as string;
+      const tableName: string = match[2] as string;
+      const columnName: string = match[3] as string;
+
+      expect(indexName).toBe(typeormIndexName(tableName, columnName));
+    }
+  });
+
+  test("down() drops exactly the 8 indexes up() created", async () => {
+    const upRunner: { runner: QueryRunner; query: jest.Mock } =
+      makeQueryRunner();
+    await migration.up(upRunner.runner);
+    const createdNames: Array<string> = executedSql(upRunner.query).map(
+      (sql: string) => {
+        return (sql.match(CREATE_INDEX_REGEX) as RegExpMatchArray)[1] as string;
+      },
+    );
+
+    const downRunner: { runner: QueryRunner; query: jest.Mock } =
+      makeQueryRunner();
+    await migration.down(downRunner.runner);
+    const statements: Array<string> = executedSql(downRunner.query);
+    expect(statements).toHaveLength(8);
+
+    const droppedNames: Array<string> = statements.map((sql: string) => {
+      expect(sql).toMatch(DROP_INDEX_REGEX);
+      return (sql.match(DROP_INDEX_REGEX) as RegExpMatchArray)[1] as string;
+    });
+
+    expect([...droppedNames].sort()).toEqual([...createdNames].sort());
+  });
+});
+
+describe("AddHotQueryIndexesSecondPass1785148065137 registration", () => {
+  test("is registered in SchemaMigrations/Index.ts so it actually runs on boot", () => {
+    expect(SchemaMigrations).toContain(
+      AddHotQueryIndexesSecondPass1785148065137,
+    );
+  });
+});

package/Tests/Server/Services/DatabaseServiceSanitizeUpdateData.test.ts

@@ -206,7 +206,7 @@ describe("DatabaseService._updateBy — updateOneById with a model instance no l
           isRoot: true,
         },
       }),
-    ).resolves.toBeUndefined();
+    ).resolves.toBe(1);
 
     expect(findBySpy).toHaveBeenCalledTimes(1);
     const findArgs: { select: Select<NetworkDeviceDiscoveryScan> } = (

package/Tests/Server/Services/DiscoveryScanClaimHookFreeSafety.test.ts

@@ -0,0 +1,121 @@
+import NetworkDeviceDiscoveryScanService, {
+  Service as NetworkDeviceDiscoveryScanServiceClass,
+} from "../../../Server/Services/NetworkDeviceDiscoveryScanService";
+import DatabaseService from "../../../Server/Services/DatabaseService";
+import NetworkDeviceDiscoveryScan from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The /probe-ingest/probe/discovery-scan/list route hands the requesting
+ * probe its pending subnet scans and claims them (status "In Progress" +
+ * startedAt) via DatabaseService.updateColumnsByIdWithoutHooks — one raw
+ * parameterized UPDATE that skips ALL on-update hooks: workflow HTTP
+ * triggers, audit-log inserts, realtime events, service
+ * onBeforeUpdate/onUpdateSuccess. The probe synchronously waits on this
+ * route's response, and it sits behind the same probe-auth middleware whose
+ * hang got healthy probes flagged Disconnected — so the claim write must
+ * stay a single statement, not the full updateOneById pipeline (permission
+ * pre-fetch SELECT + row re-fetch + save() transaction).
+ *
+ *   - App/FeatureSet/Telemetry/API/ProbeIngest/DiscoveryScan.ts
+ *       NetworkDeviceDiscoveryScan.status/startedAt when a probe claims a
+ *       Pending scan
+ *
+ * The conversion dropped NOTHING: the model declares no update workflow, no
+ * audit logging and no realtime events, and the service overrides neither
+ * update hook — so the old pipeline's hook stages were inert for this
+ * write. But the fast path skips hooks UNCONDITIONALLY: if someone later
+ * adds a decorator to NetworkDeviceDiscoveryScan or an update-hook override
+ * to its service, nothing at the call site fails — the new hook is just
+ * silently never fired for the claim write. This suite turns that silent
+ * drift into a loud test failure: if any assertion here starts failing, the
+ * hookless claim writes in DiscoveryScan.ts silently skip that new hook —
+ * revisit the call site before changing the assertion.
+ *
+ * Pure model-metadata + class-shape tests — no Postgres, no Redis.
+ */
+
+describe("discovery-scan claim hookless write safety preconditions", () => {
+  describe("NetworkDeviceDiscoveryScan model (claim write in DiscoveryScan.ts)", () => {
+    /*
+     * No @EnableWorkflow decorator AT ALL — the accessor is entirely unset,
+     * which resolves to "no update workflow". If this becomes defined,
+     * someone added @EnableWorkflow to NetworkDeviceDiscoveryScan and must
+     * decide whether the claim write should keep skipping it.
+     */
+    test("has no @EnableWorkflow metadata at all", () => {
+      const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+      expect(scan.enableWorkflowOn).toBeFalsy();
+      expect(scan.enableWorkflowOn?.update).toBeFalsy();
+    });
+
+    test("has no on-update audit log", () => {
+      const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+      expect(scan.enableAuditLogOn?.update).toBeFalsy();
+    });
+
+    test("has no realtime events", () => {
+      const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+      expect(scan.enableRealtimeEventsOn).toBeFalsy();
+    });
+  });
+
+  describe("fast-path columns exist on the entity", () => {
+    /*
+     * updateColumnsByIdWithoutHooks validates column names against entity
+     * metadata at runtime and throws BadDataException on an unknown column.
+     * Pinning column existence here means a rename breaks this suite at CI
+     * time instead of leaving every claimed scan stuck in Pending at
+     * runtime.
+     */
+    test("NetworkDeviceDiscoveryScan has every column the claim write stamps", () => {
+      const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+      const fastPathColumns: Array<string> = ["status", "startedAt"];
+      for (const column of fastPathColumns) {
+        expect(scan.isTableColumn(column)).toBe(true);
+      }
+      // Negative control: isTableColumn actually discriminates.
+      expect(scan.isTableColumn("notARealColumn")).toBe(false);
+    });
+  });
+
+  describe("service defines no update hooks of its own", () => {
+    /*
+     * DatabaseService's base onBeforeUpdate/onUpdateSuccess are no-op
+     * pass-throughs; a service only gets update behavior by OVERRIDING
+     * them. Own-property checks on the concrete service prototype pin that
+     * NetworkDeviceDiscoveryScanService does not — so the fast path skips
+     * nothing. If an override appears, these fail loudly and the claim
+     * write in DiscoveryScan.ts must be re-evaluated.
+     */
+    const updateHooks: Array<string> = ["onBeforeUpdate", "onUpdateSuccess"];
+
+    test("NetworkDeviceDiscoveryScanService does not override onBeforeUpdate/onUpdateSuccess", () => {
+      for (const hook of updateHooks) {
+        expect(
+          Object.prototype.hasOwnProperty.call(
+            NetworkDeviceDiscoveryScanServiceClass.prototype,
+            hook,
+          ),
+        ).toBe(false);
+      }
+      // The default export is an instance of the class checked above.
+      expect(NetworkDeviceDiscoveryScanService).toBeInstanceOf(
+        NetworkDeviceDiscoveryScanServiceClass,
+      );
+    });
+
+    /*
+     * Positive control: the hooks DO exist on the DatabaseService base
+     * prototype, so the own-property checks above cannot pass vacuously
+     * (e.g. after a rename of the hook methods themselves).
+     */
+    test("the base DatabaseService prototype defines both hooks", () => {
+      for (const hook of updateHooks) {
+        expect(
+          Object.prototype.hasOwnProperty.call(DatabaseService.prototype, hook),
+        ).toBe(true);
+      }
+    });
+  });
+});

package/Tests/Server/Services/HeartbeatWriteFastPathSafety.test.ts

@@ -0,0 +1,200 @@
+import MonitorProbeService from "../../../Server/Services/MonitorProbeService";
+import MonitorService from "../../../Server/Services/MonitorService";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorProbe from "../../../Models/DatabaseModels/MonitorProbe";
+import ObjectID from "../../../Types/ObjectID";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import { OnUpdate } from "../../../Server/Types/Database/Hooks";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * Four hot bookkeeping writes were moved off the full updateOneById/
+ * updateOneBy pipeline onto DatabaseService.updateColumnsByIdWithoutHooks
+ * (one raw parameterized UPDATE; skips ALL on-update hooks — workflow HTTP
+ * triggers, audit-log inserts, realtime events, service onUpdateSuccess):
+ *
+ *   - Common/Server/Utils/Monitor/MonitorResource.ts
+ *       MonitorProbe.lastMonitoringLog, on every probe check result
+ *   - App/FeatureSet/Workers/Jobs/IncomingRequestMonitor/CheckHeartbeat.ts
+ *       Monitor.incomingRequestMonitorHeartbeatCheckedAt
+ *   - App/FeatureSet/Workers/Jobs/IncomingEmailMonitor/CheckOnlineStatus.ts
+ *       Monitor.incomingEmailMonitorHeartbeatCheckedAt
+ *   - App/FeatureSet/Workers/Jobs/TelemetryMonitor/MonitorTelemetryMonitor.ts
+ *       Monitor.telemetryMonitorLastMonitorAt + telemetryMonitorNextMonitorAt
+ *
+ * Those conversions are behavior-preserving only under the model-decorator
+ * preconditions pinned below. The fast path skips hooks UNCONDITIONALLY, so
+ * if someone later adds a decorator (or a column rename breaks a fast-path
+ * write), nothing at the call sites fails — the new hook is just silently
+ * never fired for these writes. This suite turns that silent drift into a
+ * loud test failure: when one of these assertions starts failing, revisit
+ * the corresponding fast-path call site before changing the assertion.
+ *
+ * Pure model-metadata + mocked-service tests — no Postgres, no Redis.
+ */
+
+describe("heartbeat write fast-path safety preconditions", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("MonitorProbe (lastMonitoringLog write in MonitorResource.ts)", () => {
+    /*
+     * The MonitorProbe conversion dropped NOTHING: the model has no
+     * @EnableWorkflow, no @EnableAuditLog and no realtime events, so the
+     * old updateOneBy pipeline's hooks were inert for this row anyway.
+     * If any assertion here starts failing, a decorator was added to
+     * MonitorProbe and the fast-path write in MonitorResource.ts now
+     * silently skips it — revisit that call site.
+     */
+    test("has no on-update workflow trigger", () => {
+      const probe: MonitorProbe = new MonitorProbe();
+      expect(probe.enableWorkflowOn?.update).toBeFalsy();
+    });
+
+    test("has no on-update audit log", () => {
+      const probe: MonitorProbe = new MonitorProbe();
+      expect(probe.enableAuditLogOn?.update).toBeFalsy();
+    });
+
+    test("has no realtime events", () => {
+      const probe: MonitorProbe = new MonitorProbe();
+      expect(probe.enableRealtimeEventsOn).toBeFalsy();
+    });
+  });
+
+  describe("Monitor (heartbeat/scheduler timestamp writes in worker jobs)", () => {
+    /*
+     * Monitor DOES have @EnableWorkflow({ update: true }) and
+     * @EnableAuditLog(). The heartbeat/scheduler conversions DELIBERATELY
+     * skip both for these machine-stamped bookkeeping columns — firing a
+     * workflow HTTP trigger plus an audit-log insert per monitor per 30s/60s
+     * tick is exactly the load the fast path removes (documented precedent:
+     * the lastMonitoringLog write in MonitorResource.ts). These assertions
+     * pin that tradeoff so it stays a documented decision: if Monitor's
+     * decorators change shape, re-evaluate the worker-job call sites rather
+     * than assuming the skip is still the intended behavior.
+     */
+    test("still has on-update workflow enabled (the skip is deliberate)", () => {
+      const monitor: Monitor = new Monitor();
+      expect(monitor.enableWorkflowOn?.update).toBe(true);
+    });
+
+    test("still has on-update audit log enabled (the skip is deliberate)", () => {
+      const monitor: Monitor = new Monitor();
+      expect(monitor.enableAuditLogOn?.update).toBe(true);
+    });
+
+    /*
+     * Nothing ELSE was dropped: Monitor has no realtime events, so
+     * workflow + audit are the only hooks the fast path bypasses. If this
+     * starts failing, realtime updates on Monitor rows would silently never
+     * fire for the heartbeat writes — revisit the worker-job call sites.
+     */
+    test("has no realtime events (so only workflow+audit are skipped)", () => {
+      const monitor: Monitor = new Monitor();
+      expect(monitor.enableRealtimeEventsOn).toBeFalsy();
+    });
+  });
+
+  describe("fast-path columns exist on their entities", () => {
+    /*
+     * updateColumnsByIdWithoutHooks validates column names against entity
+     * metadata at runtime and throws BadDataException on an unknown column.
+     * Pinning column existence here means a rename breaks this suite at CI
+     * time instead of breaking every heartbeat write at runtime.
+     */
+    test("Monitor has every column the worker jobs stamp", () => {
+      const monitor: Monitor = new Monitor();
+      const fastPathColumns: Array<string> = [
+        "incomingRequestMonitorHeartbeatCheckedAt",
+        "incomingEmailMonitorHeartbeatCheckedAt",
+        "telemetryMonitorLastMonitorAt",
+        "telemetryMonitorNextMonitorAt",
+      ];
+      for (const column of fastPathColumns) {
+        expect(monitor.isTableColumn(column)).toBe(true);
+      }
+      // Negative control: isTableColumn actually discriminates.
+      expect(monitor.isTableColumn("notARealColumn")).toBe(false);
+    });
+
+    test("MonitorProbe has the lastMonitoringLog column", () => {
+      const probe: MonitorProbe = new MonitorProbe();
+      expect(probe.isTableColumn("lastMonitoringLog")).toBe(true);
+      expect(probe.isTableColumn("notARealColumn")).toBe(false);
+    });
+  });
+
+  describe("MonitorProbeService.onUpdateSuccess early-exit", () => {
+    /*
+     * The old updateOneBy path for lastMonitoringLog also ran
+     * MonitorProbeService.onUpdateSuccess, but that hook early-exits unless
+     * updateBy.data.isEnabled is set — so skipping it for a
+     * lastMonitoringLog-only write changes nothing. If the early-exit
+     * condition ever widens (e.g. the hook starts reacting to other
+     * columns), the no-op test below fails and the MonitorResource.ts
+     * fast-path write must be revisited.
+     */
+    test("is a no-op when data lacks isEnabled (the fast-path case)", async () => {
+      const findBySpy: jest.SpyInstance = jest
+        .spyOn(MonitorProbeService, "findBy")
+        .mockResolvedValue([]);
+      const refreshSpy: jest.SpyInstance = jest
+        .spyOn(MonitorService, "refreshMonitorProbeStatus")
+        .mockResolvedValue(undefined as never);
+
+      const onUpdate: OnUpdate<MonitorProbe> = {
+        updateBy: {
+          query: {},
+          // What the old pipeline would have passed for the converted write.
+          data: { lastMonitoringLog: {} },
+          props: { isRoot: true },
+        } as UpdateBy<MonitorProbe>,
+        carryForward: null,
+      };
+
+      const result: OnUpdate<MonitorProbe> = await (MonitorProbeService as any)[
+        "onUpdateSuccess"
+      ](onUpdate, [ObjectID.generate()]);
+
+      expect(result).toBe(onUpdate);
+      expect(findBySpy).not.toHaveBeenCalled();
+      expect(refreshSpy).not.toHaveBeenCalled();
+    });
+
+    /*
+     * Positive control: proves the spies above would have observed the hook
+     * doing work, so the no-op test cannot pass vacuously.
+     */
+    test("does refresh monitor status when isEnabled IS in data", async () => {
+      const monitorId: ObjectID = ObjectID.generate();
+      const probeRow: MonitorProbe = new MonitorProbe();
+      probeRow.monitorId = monitorId;
+
+      const findBySpy: jest.SpyInstance = jest
+        .spyOn(MonitorProbeService, "findBy")
+        .mockResolvedValue([probeRow]);
+      const refreshSpy: jest.SpyInstance = jest
+        .spyOn(MonitorService, "refreshMonitorProbeStatus")
+        .mockResolvedValue(undefined as never);
+
+      const onUpdate: OnUpdate<MonitorProbe> = {
+        updateBy: {
+          query: {},
+          data: { isEnabled: false },
+          props: { isRoot: true },
+        } as UpdateBy<MonitorProbe>,
+        carryForward: null,
+      };
+
+      await (MonitorProbeService as any)["onUpdateSuccess"](onUpdate, [
+        ObjectID.generate(),
+      ]);
+
+      expect(findBySpy).toHaveBeenCalledTimes(1);
+      expect(refreshSpy).toHaveBeenCalledTimes(1);
+      expect(refreshSpy).toHaveBeenCalledWith(monitorId);
+    });
+  });
+});