@oneuptime/common 11.7.3 → 12.0.0

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

@@ -0,0 +1,269 @@
+import DatabaseService from "../../../Server/Services/DatabaseService";
+import LogDropFilter from "../../../Models/DatabaseModels/LogDropFilter";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import { getJestSpyOn } from "../../Spy";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+
+/*
+ * Contract under test — `atomicAddToColumnsByIdWithoutHooks`, the primitive
+ * the drop-filter counter flush is built on.
+ *
+ * Neither existing helper could express this write:
+ *
+ *   - `updateColumnsByIdWithoutHooks` sets literals, so a counter bump would
+ *     have to be a read-modify-write, which loses concurrent writers'
+ *     increments (several ingest replicas flush the same filter row).
+ *   - `getRepository().increment()` goes through TypeORM's
+ *     UpdateQueryBuilder, which always appends `version = version + 1`. An
+ *     ingest-driven bump would then fight the optimistic lock on a row a
+ *     human may be editing in the dashboard — and it cannot set a second
+ *     column (`lastDroppedAt`) in the same statement anyway.
+ *
+ * So this issues one raw parameterized UPDATE. The tests below pin the three
+ * properties that make it safe to run from the ingest path: it adds rather
+ * than assigns, it does not touch `version`, and identifiers come from entity
+ * metadata rather than from the caller.
+ */
+
+const FILTER_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+
+interface CapturedQuery {
+  sql: string;
+  params: Array<unknown>;
+}
+
+describe("DatabaseService.atomicAddToColumnsByIdWithoutHooks", () => {
+  let service: DatabaseService<LogDropFilter>;
+  let captured: Array<CapturedQuery>;
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    captured = [];
+
+    service = new DatabaseService<LogDropFilter>(LogDropFilter);
+
+    /*
+     * `getRepository()` needs a live Postgres connection, so the whole
+     * repository is stood in for — the same approach the other
+     * DatabaseService unit tests take.
+     *
+     * The stand-in models the two things this method actually reads from
+     * TypeORM: metadata (to resolve property names to real column names, and
+     * to find the primary key and updatedAt columns) and the driver's
+     * persist-value hook. Column names are deliberately spelled out here
+     * rather than derived, so if a model rename ever silently changed the
+     * generated SQL, these assertions would still be checking the names the
+     * migration actually created.
+     */
+    const columns: Record<string, string> = {
+      droppedCount: "droppedCount",
+      lastDroppedAt: "lastDroppedAt",
+      sortOrder: "sortOrder",
+      _id: "_id",
+      updatedAt: "updatedAt",
+    };
+
+    getJestSpyOn(service, "getRepository").mockReturnValue({
+      metadata: {
+        tableName: "LogDropFilter",
+        findColumnWithPropertyName: (
+          propertyName: string,
+        ): { databaseName: string } | undefined => {
+          return columns[propertyName]
+            ? { databaseName: columns[propertyName]! }
+            : undefined;
+        },
+        updateDateColumn: { databaseName: "updatedAt" },
+        primaryColumns: [{ databaseName: "_id" }],
+      },
+      manager: {
+        connection: {
+          driver: {
+            // Identity persist: these tests are about the SQL, not coercion.
+            preparePersistentValue: (value: unknown): unknown => {
+              return value;
+            },
+          },
+        },
+        query: async (
+          sql: string,
+          params: Array<unknown>,
+        ): Promise<Array<unknown>> => {
+          captured.push({ sql, params });
+          return [];
+        },
+      },
+    } as any);
+  });
+
+  it("adds to the column instead of assigning it", async () => {
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 42 },
+    });
+
+    expect(captured).toHaveLength(1);
+    expect(captured[0]!.sql).toContain(
+      `"droppedCount" = COALESCE("droppedCount", 0) +`,
+    );
+  });
+
+  /*
+   * COALESCE matters for rows that predate the column, or any future nullable
+   * counter: `NULL + 1` is NULL, so without it a counter could stay null
+   * forever no matter how many drops happened.
+   */
+  it("treats a NULL counter as zero rather than propagating NULL", async () => {
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 1 },
+    });
+
+    expect(captured[0]!.sql).toContain("COALESCE");
+  });
+
+  it("binds the delta as a parameter, not as inline SQL", async () => {
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 7 },
+    });
+
+    expect(captured[0]!.params).toContain(7);
+    expect(captured[0]!.sql).not.toContain("7");
+  });
+
+  it("sets literal columns in the same statement as the add", async () => {
+    const when: Date = new Date("2026-07-29T05:14:03.000Z");
+
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 3 },
+      set: { lastDroppedAt: when } as any,
+    });
+
+    expect(captured).toHaveLength(1);
+    expect(captured[0]!.sql).toContain(`"droppedCount" = COALESCE(`);
+    expect(captured[0]!.sql).toContain(`"lastDroppedAt" =`);
+    expect(captured[0]!.params).toContain(when);
+  });
+
+  /*
+   * The reason this helper exists rather than using increment(). A bumped
+   * `version` on an ingest write would make the next dashboard save fail its
+   * optimistic-lock check for no reason the user could understand.
+   */
+  it("never bumps the optimistic-lock version column", async () => {
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 1 },
+      set: { lastDroppedAt: new Date() } as any,
+    });
+
+    expect(captured[0]!.sql).not.toContain("version");
+  });
+
+  it("refreshes updatedAt so the row does not look stale", async () => {
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 1 },
+    });
+
+    expect(captured[0]!.sql).toContain(`"updatedAt" = CURRENT_TIMESTAMP`);
+  });
+
+  it("scopes the update to the one row by primary key", async () => {
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 1 },
+    });
+
+    expect(captured[0]!.sql).toMatch(/WHERE "_id" = \$\d+$/);
+    expect(captured[0]!.params[captured[0]!.params.length - 1]).toBe(
+      FILTER_ID.toString(),
+    );
+  });
+
+  it("targets the model's real table", async () => {
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 1 },
+    });
+
+    expect(captured[0]!.sql).toContain(`UPDATE "LogDropFilter"`);
+  });
+
+  it("adds to several columns in one statement", async () => {
+    await service.atomicAddToColumnsByIdWithoutHooks({
+      id: FILTER_ID,
+      add: { droppedCount: 2, sortOrder: 1 } as any,
+    });
+
+    expect(captured).toHaveLength(1);
+    expect(captured[0]!.sql).toContain(`"droppedCount" = COALESCE(`);
+    expect(captured[0]!.sql).toContain(`"sortOrder" = COALESCE(`);
+  });
+
+  describe("rejects inputs it cannot execute safely", () => {
+    it("requires an id", async () => {
+      await expect(
+        service.atomicAddToColumnsByIdWithoutHooks({
+          id: undefined as unknown as ObjectID,
+          add: { droppedCount: 1 },
+        }),
+      ).rejects.toThrow(BadDataException);
+    });
+
+    /*
+     * Identifiers come from entity metadata, never from the caller, so an
+     * unknown property is a programming error rather than an injection
+     * vector — but it must fail loudly instead of silently writing nothing.
+     */
+    it("rejects a column that does not exist on the model", async () => {
+      await expect(
+        service.atomicAddToColumnsByIdWithoutHooks({
+          id: FILTER_ID,
+          add: { notAColumn: 1 } as any,
+        }),
+      ).rejects.toThrow(/unknown column/);
+      expect(captured).toHaveLength(0);
+    });
+
+    it("rejects a non-numeric delta", async () => {
+      for (const bad of ["5", null, undefined, {}, NaN, Infinity]) {
+        await expect(
+          service.atomicAddToColumnsByIdWithoutHooks({
+            id: FILTER_ID,
+            add: { droppedCount: bad } as any,
+          }),
+        ).rejects.toThrow(/finite number/);
+      }
+      expect(captured).toHaveLength(0);
+    });
+
+    it("rejects a SQL-expression value in the literal set", async () => {
+      await expect(
+        service.atomicAddToColumnsByIdWithoutHooks({
+          id: FILTER_ID,
+          add: { droppedCount: 1 },
+          set: {
+            lastDroppedAt: () => {
+              return "NOW()";
+            },
+          } as any,
+        }),
+      ).rejects.toThrow(/SQL-expression values are not supported/);
+    });
+
+    it("issues no statement at all when there is nothing to write", async () => {
+      await service.atomicAddToColumnsByIdWithoutHooks({
+        id: FILTER_ID,
+        add: {},
+      });
+
+      expect(captured).toHaveLength(0);
+    });
+  });
+});

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

@@ -0,0 +1,299 @@
+import DatabaseService from "../../../Server/Services/DatabaseService";
+import ModelPermission from "../../../Server/Types/Database/Permissions/Index";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import Probe from "../../../Models/DatabaseModels/Probe";
+import ObjectID from "../../../Types/ObjectID";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import { getJestSpyOn } from "../../Spy";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+} from "@jest/globals";
+
+/*
+ * A customer's workflow PUT a flat body to /api/workflow-variable/<id>, so
+ * BaseAPI read `body["data"]` as undefined and handed DatabaseService an empty
+ * update payload. _updateBy still ran its internal find, matched the row, wrote
+ * no columns at all, and returned the MATCHED count (1). Every caller - the API
+ * included - reads that number as "rows written", so the request answered 200
+ * while the database was untouched, and the guard that exists precisely for
+ * this ("numberOfDocsAffected === 0") could never fire.
+ *
+ * The fix: when the sanitized update data carries no columns, _updateBy skips
+ * the find entirely and reports 0. These tests pin that down, and pin down that
+ * it did not change anything about updates that DO carry columns.
+ */
+
+type ProbeUpdateData = UpdateBy<Probe>["data"];
+
+const EMPTY_DATA: ProbeUpdateData = {} as ProbeUpdateData;
+
+const TEST_ID: string = "550e8400-e29b-41d4-a716-446655440021";
+const OTHER_ID: string = "550e8400-e29b-41d4-a716-446655440022";
+
+const matchedRow: (id: string) => Probe = (id: string): Probe => {
+  const probe: Probe = new Probe();
+  probe._id = id;
+  return probe;
+};
+
+describe("DatabaseService._updateBy when the update carries no columns", () => {
+  let service: DatabaseService<Probe>;
+  let findBySpy: jest.SpyInstance;
+  let saveMock: MockFunction;
+  let updateMock: MockFunction;
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+
+    service = new DatabaseService<Probe>(Probe);
+
+    /*
+     * Only the two surfaces that need a live Postgres are stubbed - the
+     * internal find (`_findBy`) and the repository behind the write. Mocking
+     * the TypeORM repository itself is impractical here because `_findBy`
+     * builds real query metadata against a DataSource that does not exist in
+     * a unit test; stubbing `_findBy` keeps the mock at the exact boundary the
+     * fix is about (was the find run at all?) while leaving every line of
+     * _updateBy under test - sanitizing, the hooks and the return arithmetic.
+     * Both write surfaces are stubbed (`save()` for relation updates,
+     * `update()` for scalar-only ones) so a stray write of either kind is
+     * caught rather than throwing "not a function".
+     *
+     * The stub deliberately returns a MATCHING row, because that is what a
+     * real database does here: the row exists and the query finds it, there is
+     * simply nothing to write to it. That is the whole trap - so if _updateBy
+     * ever runs this find again for an empty payload, every expectation below
+     * reports the old, wrong answer (1 row "changed") instead of 0.
+     */
+    findBySpy = getJestSpyOn(service as any, "_findBy").mockResolvedValue([
+      matchedRow(TEST_ID),
+    ]);
+
+    saveMock = getJestMockFunction();
+    saveMock.mockImplementation((item: unknown) => {
+      return Promise.resolve(item);
+    });
+    updateMock = getJestMockFunction();
+    updateMock.mockImplementation(() => {
+      return Promise.resolve({ affected: 1 });
+    });
+    getJestSpyOn(service, "getRepository").mockReturnValue({
+      save: saveMock,
+      update: updateMock,
+    });
+
+    // The permission layer is not what these tests are about, and needs a DB.
+    getJestSpyOn(
+      ModelPermission,
+      "checkUpdateQueryPermissions",
+    ).mockImplementation((_modelType: unknown, query: unknown) => {
+      return Promise.resolve(query);
+    });
+    getJestSpyOn(
+      ModelPermission,
+      "checkUpdatePermissionByModel",
+    ).mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("reports zero rows changed when updateOneBy is handed an empty payload", async () => {
+    const numberOfDocsAffected: number = await service.updateOneBy({
+      query: { _id: TEST_ID } as any,
+      data: EMPTY_DATA,
+      props: { isRoot: true },
+    });
+
+    expect(numberOfDocsAffected).toBe(0);
+  });
+
+  it("reports zero rows changed when updateBy is handed an empty payload", async () => {
+    const numberOfDocsAffected: number = await service.updateBy({
+      query: {} as any,
+      data: EMPTY_DATA,
+      props: { isRoot: true },
+      limit: 10,
+      skip: 0,
+    });
+
+    expect(numberOfDocsAffected).toBe(0);
+  });
+
+  it("reports zero rows changed when the empty payload arrives through updateOneById, which is the path the API takes", async () => {
+    const numberOfDocsAffected: number = await service.updateOneById({
+      id: new ObjectID(TEST_ID),
+      data: EMPTY_DATA,
+      props: { isRoot: true },
+    });
+
+    /*
+     * This is the exact number BaseAPI.updateItem checks before answering
+     * 200, so a no-column update can no longer be reported as a save.
+     */
+    expect(numberOfDocsAffected).toBe(0);
+  });
+
+  it("never runs the find, because a payload with no columns cannot change any row", async () => {
+    await service.updateOneBy({
+      query: { _id: TEST_ID } as any,
+      data: EMPTY_DATA,
+      props: { isRoot: true },
+    });
+
+    expect(findBySpy).not.toHaveBeenCalled();
+  });
+
+  it("never writes anything, so the count it reports and the rows it touched agree", async () => {
+    /*
+     * The semantic in prose: an update that writes no columns must not be
+     * reported as a successful write. Nothing is saved AND the caller is told
+     * zero - previously the second half of that sentence was a lie, because
+     * `items.length` counted rows the query MATCHED, not rows it changed, and
+     * the row matched here (see the `_findBy` stub above).
+     */
+    const numberOfDocsAffected: number = await service.updateOneBy({
+      query: { _id: TEST_ID } as any,
+      data: EMPTY_DATA,
+      props: { isRoot: true },
+    });
+
+    expect(saveMock).not.toHaveBeenCalled();
+    expect(updateMock).not.toHaveBeenCalled();
+    expect(numberOfDocsAffected).toBe(0);
+  });
+
+  it("still calls onUpdateSuccess, with an empty list of ids, so hooks behave exactly as they do when the query matches nothing", async () => {
+    const onUpdateSuccessSpy: jest.SpyInstance = getJestSpyOn(
+      service as any,
+      "onUpdateSuccess",
+    );
+
+    await service.updateOneBy({
+      query: { _id: TEST_ID } as any,
+      data: EMPTY_DATA,
+      props: { isRoot: true, ignoreHooks: false },
+    });
+
+    /*
+     * Skipping the find must not quietly skip the hooks too: subclasses
+     * override onUpdateSuccess and some of them rely on being told about
+     * every update attempt. The id list is empty because nothing was written -
+     * before the fix this hook was handed the id of the row that merely
+     * matched, telling every subclass a write had happened.
+     */
+    expect(onUpdateSuccessSpy).toHaveBeenCalledTimes(1);
+    expect(onUpdateSuccessSpy.mock.calls[0]![1]).toEqual([]);
+  });
+});
+
+describe("DatabaseService._updateBy when the update does carry columns", () => {
+  let service: DatabaseService<Probe>;
+  let findBySpy: jest.SpyInstance;
+  let saveMock: MockFunction;
+  let updateMock: MockFunction;
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+
+    service = new DatabaseService<Probe>(Probe);
+
+    findBySpy = getJestSpyOn(service as any, "_findBy").mockResolvedValue([
+      matchedRow(TEST_ID),
+      matchedRow(OTHER_ID),
+    ]);
+
+    saveMock = getJestMockFunction();
+    saveMock.mockImplementation((item: unknown) => {
+      return Promise.resolve(item);
+    });
+    updateMock = getJestMockFunction();
+    updateMock.mockImplementation(() => {
+      return Promise.resolve({ affected: 1 });
+    });
+    getJestSpyOn(service, "getRepository").mockReturnValue({
+      save: saveMock,
+      update: updateMock,
+    });
+
+    getJestSpyOn(
+      ModelPermission,
+      "checkUpdateQueryPermissions",
+    ).mockImplementation((_modelType: unknown, query: unknown) => {
+      return Promise.resolve(query);
+    });
+    getJestSpyOn(
+      ModelPermission,
+      "checkUpdatePermissionByModel",
+    ).mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("still runs the find and still reports the number of rows it matched", async () => {
+    const numberOfDocsAffected: number = await service.updateBy({
+      query: {} as any,
+      data: { name: "renamed-probe" } as ProbeUpdateData,
+      props: { isRoot: true },
+      limit: 10,
+      skip: 0,
+    });
+
+    /*
+     * This assertion is also what proves the `_findBy` spy in the sibling
+     * describe is wired to the method _updateBy really calls: the same spy,
+     * on the same private method, IS exercised as soon as the payload has a
+     * column. "not.toHaveBeenCalled()" over there is therefore meaningful.
+     */
+    expect(findBySpy).toHaveBeenCalledTimes(1);
+    expect(numberOfDocsAffected).toBe(2);
+  });
+
+  it("still writes every row the find returned", async () => {
+    await service.updateOneBy({
+      query: { _id: TEST_ID } as any,
+      data: { name: "renamed-probe" } as ProbeUpdateData,
+      props: { isRoot: true },
+    });
+
+    /*
+     * `name` is a scalar column, so the write goes through update() (which
+     * never inserts) rather than save() — one update() per row the find
+     * returned, and save() is left untouched.
+     */
+    expect(updateMock).toHaveBeenCalledTimes(2);
+    expect(saveMock).not.toHaveBeenCalled();
+  });
+
+  it("still calls onUpdateSuccess with the ids of the rows it updated", async () => {
+    const onUpdateSuccessSpy: jest.SpyInstance = getJestSpyOn(
+      service as any,
+      "onUpdateSuccess",
+    );
+
+    await service.updateOneBy({
+      query: { _id: TEST_ID } as any,
+      data: { name: "renamed-probe" } as ProbeUpdateData,
+      props: { isRoot: true, ignoreHooks: false },
+    });
+
+    const updatedIds: Array<ObjectID> = onUpdateSuccessSpy.mock
+      .calls[0]![1] as Array<ObjectID>;
+
+    expect(
+      updatedIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([TEST_ID, OTHER_ID]);
+  });
+});

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

@@ -168,12 +168,12 @@ describe("DatabaseService._updateBy — updateOneById with a model instance no l
       .mockResolvedValue([foundItem] as never);
 
     // eslint-disable-next-line @typescript-eslint/typedef
-    const saveMock = jest.fn((item: unknown) => {
-      return Promise.resolve(item);
+    const updateMock = jest.fn((_where: unknown, _data: unknown) => {
+      return Promise.resolve({ affected: 1 });
     });
     jest
       .spyOn(NetworkDeviceDiscoveryScanService, "getRepository")
-      .mockReturnValue({ save: saveMock } as never);
+      .mockReturnValue({ update: updateMock } as never);
 
     // Permission layer is not under test here and needs no DB.
     jest
@@ -220,13 +220,20 @@ describe("DatabaseService._updateBy — updateOneById with a model instance no l
     );
     expect(selectedColumns).not.toContain("isPermissionIf");
 
-    // The persisted payload is the plain data plus the located row's _id.
-    expect(saveMock).toHaveBeenCalledTimes(1);
-    const savedItem: JSONObject = saveMock.mock.calls[0]![0] as JSONObject;
-    expect(Object.keys(savedItem).sort()).toEqual(
-      ["_id", "startedAt", "status"].sort(),
+    /*
+     * Scalar-only updates go through repository.update(): the located row's
+     * _id becomes the WHERE clause and the sanitized columns the SET payload.
+     * _id must stay out of the SET, and the version bump is emulated there
+     * because update() (unlike save()) does not touch @VersionColumn.
+     */
+    expect(updateMock).toHaveBeenCalledTimes(1);
+    const whereClause: JSONObject = updateMock.mock.calls[0]![0] as JSONObject;
+    const setPayload: JSONObject = updateMock.mock.calls[0]![1] as JSONObject;
+    expect(whereClause["_id"]).toBe(scanId.toString());
+    expect(Object.keys(setPayload).sort()).toEqual(
+      ["startedAt", "status", "version"].sort(),
     );
-    expect(savedItem["status"]).toBe("In Progress");
-    expect(savedItem["_id"]).toBe(scanId.toString());
+    expect(setPayload["status"]).toBe("In Progress");
+    expect(setPayload["_id"]).toBeUndefined();
   });
 });