@oneuptime/common 12.0.34 → 13.0.1

package/Tests/Server/Types/Database/InventoryStatusPostgres.test.ts

@@ -0,0 +1,368 @@
+import Entities from "../../../../Models/DatabaseModels/Index";
+import InventoryItem from "../../../../Models/DatabaseModels/InventoryItem";
+import QueryUtil from "../../../../Server/Types/Database/QueryUtil";
+import Query from "../../../../Types/BaseDatabase/Query";
+import Includes from "../../../../Types/BaseDatabase/Includes";
+import IncludesNone from "../../../../Types/BaseDatabase/IncludesNone";
+import LessThan from "../../../../Types/BaseDatabase/LessThan";
+import { JSONObject } from "../../../../Types/JSON";
+import JSONFunctions from "../../../../Types/JSONFunctions";
+import ObjectID from "../../../../Types/ObjectID";
+import EntitySource from "../../../../Types/Telemetry/EntitySource";
+import EntityType from "../../../../Types/Telemetry/EntityType";
+import {
+  InventoryLiveness,
+  getInventoryLivenessState,
+} from "../../../../Types/Telemetry/InventoryLiveness";
+import { DataSource, FindOptionsWhere, QueryRunner } from "typeorm";
+
+/*
+ * Opt in with RUN_POSTGRES_INVENTORY_FACET_TESTS=true and config.env loaded.
+ * Tables live in a unique temporary schema; production rows are never read
+ * or changed. A transaction freezes CURRENT_TIMESTAMP for exact boundaries.
+ */
+const describePostgres: typeof describe =
+  process.env["RUN_POSTGRES_INVENTORY_FACET_TESTS"] === "true"
+    ? describe
+    : describe.skip;
+
+describePostgres("inventory status facets against Postgres", () => {
+  const schema: string = `inventory_facets_${ObjectID.generate().toString().replace(/-/g, "")}`;
+  const projectId: ObjectID = ObjectID.generate();
+  const otherProjectId: ObjectID = ObjectID.generate();
+  const ids: Record<string, string> = {};
+  let database: DataSource;
+  let runner: QueryRunner;
+  let now: Date;
+
+  beforeAll(async () => {
+    database = new DataSource({
+      type: "postgres",
+      host: process.env["INVENTORY_FACET_TEST_DATABASE_HOST"] || "localhost",
+      port: Number(process.env["INVENTORY_FACET_TEST_DATABASE_PORT"] || "5400"),
+      username: process.env["DATABASE_USERNAME"] || "postgres",
+      password: process.env["DATABASE_PASSWORD"] || "password",
+      database: process.env["DATABASE_NAME"] || "oneuptimedb",
+      entities: Entities,
+      schema,
+      synchronize: false,
+      extra: { options: `-c search_path=${schema},public` },
+    });
+    await database.initialize();
+    await database.query(`CREATE SCHEMA "${schema}"`);
+    /*
+     * A standalone temporary table lets this suite run on an empty Postgres
+     * instance too. Its columns are the physical inventory columns used by
+     * these queries; the status itself must never exist on disk.
+     */
+    await database.query(`CREATE TABLE "${schema}"."InventoryItem" (
+      "_id" uuid PRIMARY KEY,
+      "projectId" uuid NOT NULL,
+      "displayName" varchar NOT NULL,
+      "entityType" varchar NOT NULL,
+      "source" varchar,
+      "lastSeenAt" timestamptz,
+      "isArchived" boolean NOT NULL DEFAULT false,
+      "deletedAt" timestamptz
+    )`);
+    runner = database.createQueryRunner();
+    await runner.connect();
+    await runner.startTransaction();
+    now = (await runner.query("SELECT CURRENT_TIMESTAMP AS now"))[0].now;
+
+    for (const [name, age] of [
+      ["live-future", -60_000],
+      ["live-now", 0],
+      ["live-upper-boundary", 31 * 60_000 - 1],
+      ["recent-lower-boundary", 31 * 60_000],
+      ["recent-upper-boundary", 1441 * 60_000 - 1],
+      ["stale-lower-boundary", 1441 * 60_000],
+      ["stale-old", 3 * 1440 * 60_000],
+    ] as Array<[string, number]>) {
+      await seed(name, EntitySource.Discovered, age);
+    }
+    await seed("never-seen", EntitySource.Discovered, null);
+    await seed("manual-old", EntitySource.Manual, 365 * 1440 * 60_000);
+    await seed("mirrored-no-heartbeat", EntitySource.Inventory, null);
+    await seed("unknown-source", "unknown", 365 * 1440 * 60_000);
+    await seed("missing-source", null, null);
+    await seed("archived-stale", EntitySource.Discovered, 3000 * 60_000, {
+      archived: true,
+    });
+    await seed("foreign-stale", EntitySource.Discovered, 3000 * 60_000, {
+      projectId: otherProjectId,
+    });
+    await seed("host-stale", EntitySource.Discovered, 3000 * 60_000, {
+      entityType: EntityType.Host,
+    });
+  });
+
+  afterAll(async () => {
+    if (runner) {
+      if (runner.isTransactionActive) {
+        await runner.rollbackTransaction();
+      }
+      await runner.release();
+    }
+    if (database?.isInitialized) {
+      await database.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+      await database.destroy();
+    }
+  });
+
+  async function seed(
+    name: string,
+    source: string | null,
+    age: number | null,
+    options: {
+      archived?: boolean;
+      projectId?: ObjectID;
+      entityType?: EntityType;
+    } = {},
+  ): Promise<void> {
+    const id: string = ObjectID.generate().toString();
+    ids[name] = id;
+    await runner.query(
+      `INSERT INTO "${schema}"."InventoryItem" ("_id", "projectId", "displayName", "entityType", "source", "lastSeenAt", "isArchived") VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+      [
+        id,
+        (options.projectId || projectId).toString(),
+        name,
+        options.entityType || EntityType.Service,
+        source,
+        age === null ? null : new Date(now.getTime() - age),
+        Boolean(options.archived),
+      ],
+    );
+  }
+
+  function where(
+    query: Query<InventoryItem> = {},
+  ): FindOptionsWhere<InventoryItem> {
+    return QueryUtil.serializeQuery(InventoryItem, {
+      projectId,
+      isArchived: false,
+      ...query,
+    }) as unknown as FindOptionsWhere<InventoryItem>;
+  }
+
+  async function find(
+    query: Query<InventoryItem> = {},
+  ): Promise<Array<InventoryItem>> {
+    return runner.manager.getRepository(InventoryItem).find({
+      select: {
+        _id: true,
+        displayName: true,
+        source: true,
+        lastSeenAt: true,
+        inventoryStatus: true,
+      },
+      where: where(query),
+      order: { displayName: "ASC" },
+    });
+  }
+
+  async function names(query: Query<InventoryItem>): Promise<Array<string>> {
+    return (await find(query)).map((item: InventoryItem): string => {
+      return item.displayName!;
+    });
+  }
+
+  test("every SQL classification matches the shared badge rule at exact boundaries", async () => {
+    const rows: Array<InventoryItem> = await find();
+    expect(rows).toHaveLength(13);
+    for (const item of rows) {
+      expect({ name: item.displayName, status: item.inventoryStatus }).toEqual({
+        name: item.displayName,
+        status: getInventoryLivenessState({
+          source: item.source,
+          lastSeenAt: item.lastSeenAt,
+          now,
+        }),
+      });
+    }
+  });
+
+  test.each([
+    [
+      InventoryLiveness.Live,
+      ["live-future", "live-now", "live-upper-boundary"],
+    ],
+    [
+      InventoryLiveness.Recent,
+      ["recent-lower-boundary", "recent-upper-boundary"],
+    ],
+    [
+      InventoryLiveness.Stale,
+      ["host-stale", "stale-lower-boundary", "stale-old"],
+    ],
+    [InventoryLiveness.Never, ["never-seen"]],
+    [
+      InventoryLiveness.NotTracked,
+      [
+        "manual-old",
+        "mirrored-no-heartbeat",
+        "missing-source",
+        "unknown-source",
+      ],
+    ],
+  ] as Array<[InventoryLiveness, Array<string>]>)(
+    "%s selects precisely the matching rows",
+    async (status: InventoryLiveness, expected: Array<string>) => {
+      expect(await names({ inventoryStatus: new Includes([status]) })).toEqual(
+        expected,
+      );
+    },
+  );
+
+  test("multiple statuses are a union and negation is its complement including untracked rows", async () => {
+    const selected: Array<string> = await names({
+      inventoryStatus: new Includes([
+        InventoryLiveness.Stale,
+        InventoryLiveness.Never,
+      ]),
+    });
+    expect(selected).toEqual([
+      "host-stale",
+      "never-seen",
+      "stale-lower-boundary",
+      "stale-old",
+    ]);
+    const excluded: Array<string> = await names({
+      inventoryStatus: new IncludesNone([
+        InventoryLiveness.Stale,
+        InventoryLiveness.Never,
+      ]),
+    });
+    expect(excluded).toHaveLength(9);
+    expect(excluded).toEqual(
+      expect.arrayContaining(["manual-old", "missing-source"]),
+    );
+    expect(new Set([...selected, ...excluded])).toEqual(
+      new Set(await names({})),
+    );
+    expect(
+      selected.filter((name: string): boolean => {
+        return excluded.includes(name);
+      }),
+    ).toEqual([]);
+  });
+
+  test("status preserves type and source filters", async () => {
+    expect(
+      await names({
+        inventoryStatus: new Includes([InventoryLiveness.Stale]),
+        entityType: new Includes([EntityType.Host]),
+      }),
+    ).toEqual(["host-stale"]);
+    expect(
+      await names({
+        inventoryStatus: new Includes([InventoryLiveness.Stale]),
+        source: EntitySource.Manual,
+      }),
+    ).toEqual([]);
+    expect(
+      await names({
+        inventoryStatus: new Includes([InventoryLiveness.NotTracked]),
+        source: EntitySource.Manual,
+      }),
+    ).toEqual(["manual-old"]);
+  });
+
+  test("last seen dates intersect status without overwriting it", async () => {
+    expect(
+      await names({
+        inventoryStatus: new Includes([InventoryLiveness.Stale]),
+        lastSeenAt: new LessThan(
+          new Date(now.getTime() - 3500 * 60_000).toISOString(),
+        ),
+      }),
+    ).toEqual(["stale-old"]);
+    expect(
+      await names({
+        inventoryStatus: new Includes([InventoryLiveness.Live]),
+        lastSeenAt: new LessThan(
+          new Date(now.getTime() - 60 * 60_000).toISOString(),
+        ),
+      }),
+    ).toEqual([]);
+  });
+
+  test("status preserves explicit ids, project isolation and archived views", async () => {
+    expect(
+      await names({
+        inventoryStatus: new Includes([InventoryLiveness.Stale]),
+        _id: ids["stale-old"]!,
+      }),
+    ).toEqual(["stale-old"]);
+    expect(
+      await names({
+        inventoryStatus: new Includes([InventoryLiveness.Stale]),
+        _id: ids["foreign-stale"]!,
+      }),
+    ).toEqual([]);
+    expect(
+      await names({
+        inventoryStatus: new Includes([InventoryLiveness.Stale]),
+        isArchived: true,
+      }),
+    ).toEqual(["archived-stale"]);
+  });
+
+  test("count and pagination use the same status predicate", async () => {
+    const [rows, count]: [Array<InventoryItem>, number] = await runner.manager
+      .getRepository(InventoryItem)
+      .findAndCount({
+        select: { _id: true, displayName: true },
+        where: where({
+          inventoryStatus: new Includes([
+            InventoryLiveness.Live,
+            InventoryLiveness.Recent,
+          ]),
+        }),
+        order: { displayName: "ASC" },
+        skip: 2,
+        take: 2,
+      });
+    expect(count).toBe(5);
+    expect(
+      rows.map((item: InventoryItem): string => {
+        return item.displayName!;
+      }),
+    ).toEqual(["live-upper-boundary", "recent-lower-boundary"]);
+  });
+
+  test("a serialized API query applies the same status filter", async () => {
+    const serialized: JSONObject = JSON.parse(
+      JSON.stringify(
+        JSONFunctions.serialize({
+          inventoryStatus: new Includes([
+            InventoryLiveness.Never,
+            InventoryLiveness.Recent,
+          ]),
+          entityType: new Includes([EntityType.Service]),
+        }),
+      ),
+    );
+    expect(
+      await names(
+        JSONFunctions.deserialize(serialized) as Query<InventoryItem>,
+      ),
+    ).toEqual(["never-seen", "recent-lower-boundary", "recent-upper-boundary"]);
+  });
+
+  test("the empty schema needs no physical status column", async () => {
+    const columns: Array<{ column_name: string }> = await runner.query(
+      "SELECT column_name FROM information_schema.columns WHERE table_schema = $1 AND table_name = 'InventoryItem'",
+      [schema],
+    );
+    expect(
+      columns.map((column: { column_name: string }): string => {
+        return column.column_name;
+      }),
+    ).not.toContain("inventoryStatus");
+    expect(
+      await names({ inventoryStatus: new Includes([InventoryLiveness.Never]) }),
+    ).toEqual(["never-seen"]);
+  });
+});

package/Tests/Server/Types/Database/Permissions/ProjectCustomerSupportAccessColumn.test.ts

@@ -0,0 +1,261 @@
+import DatabaseRequestType from "../../../../../Server/Types/BaseDatabase/DatabaseRequestType";
+import ColumnPermissions from "../../../../../Server/Types/Database/Permissions/ColumnPermission";
+import UpdatePermission from "../../../../../Server/Types/Database/Permissions/UpdatePermission";
+import Project from "../../../../../Models/DatabaseModels/Project";
+import DatabaseCommonInteractionProps from "../../../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import Columns from "../../../../../Types/Database/Columns";
+import BadDataException from "../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../Types/ObjectID";
+import Permission, {
+  UserTenantAccessPermission,
+} from "../../../../../Types/Permission";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Project.letCustomerSupportAccessProject is the switch that lets OneUptime
+ * customer support open a customer's project. Two pages write it: the
+ * customer's own Project Settings, and - now - the Admin Dashboard's
+ * Project > Support page, which talks to the same CRUD endpoint through
+ * AdminModelAPI as a master admin.
+ *
+ * That admin page only works because UpdatePermission.checkUpdatePermissions
+ * returns before ColumnPermissions ever sees the data when props.isMasterAdmin
+ * is set - the column's own ColumnAccessControl.update lists ProjectOwner and
+ * ProjectAdmin and nothing else, so a master admin who is not a member of the
+ * project has no listed grant on it at all. Nothing in the page or the model
+ * states that dependency, so these tests pin it from both sides: the bypass
+ * that makes the admin page work, and the narrow customer-side grant it must
+ * not be confused with widening.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const userId: ObjectID = ObjectID.generate();
+
+/*
+ * DatabaseCommonInteractionPropsUtil.getUserPermissions drops every permission
+ * whose isBlockPermission does not match the requested PermissionType, and it
+ * only reads the tenant bucket when props.tenantId is set. Getting either
+ * wrong yields an empty permission set, which would make the "does not throw"
+ * cases below pass for entirely the wrong reason - hence the harness guard
+ * that runs first.
+ */
+function makeProps(
+  permissions: Array<Permission>,
+  overrides: Partial<DatabaseCommonInteractionProps> = {},
+): DatabaseCommonInteractionProps {
+  const tenantPermission: UserTenantAccessPermission = {
+    projectId,
+    _type: "UserTenantAccessPermission",
+    permissions: permissions.map((permission: Permission) => {
+      return {
+        _type: "UserPermission",
+        permission: permission,
+        labelIds: [],
+        isBlockPermission: false,
+      };
+    }),
+  };
+
+  return {
+    userId,
+    tenantId: projectId,
+    userTenantAccessPermission: {
+      [projectId.toString()]: tenantPermission,
+    },
+    ...overrides,
+  };
+}
+
+type CheckFunction = () => void;
+
+function checkColumnUpdate(
+  data: Partial<Project>,
+  permissions: Array<Permission>,
+): CheckFunction {
+  return () => {
+    ColumnPermissions.checkDataColumnPermissions(
+      Project,
+      data as Project,
+      makeProps(permissions),
+      DatabaseRequestType.Update,
+    );
+  };
+}
+
+function updatableColumns(permissions: Array<Permission>): Array<string> {
+  return ColumnPermissions.getModelColumnsByPermissions(
+    Project,
+    makeProps(permissions).userTenantAccessPermission![projectId.toString()]!
+      .permissions,
+    DatabaseRequestType.Update,
+  ).columns;
+}
+
+function readableColumns(permissions: Array<Permission>): Array<string> {
+  return ColumnPermissions.getModelColumnsByPermissions(
+    Project,
+    makeProps(permissions).userTenantAccessPermission![projectId.toString()]!
+      .permissions,
+    DatabaseRequestType.Read,
+  ).columns;
+}
+
+const COLUMN: string = "letCustomerSupportAccessProject";
+
+describe("Project.letCustomerSupportAccessProject column access", () => {
+  describe("harness guard", () => {
+    /*
+     * Runs first on purpose. Several assertions below are "does not throw",
+     * which an empty or mis-shaped permission set would also satisfy -
+     * getModelColumnsByPermissions would return no columns, but so would a
+     * props object the util silently ignored. This case has a caller that
+     * genuinely lacks the grant, so it MUST throw. If it stops throwing, the
+     * props factory above is broken, not the model.
+     */
+    it("refuses a plain member who tries to flip the switch", () => {
+      expect(
+        checkColumnUpdate({ letCustomerSupportAccessProject: true }, [
+          Permission.ProjectMember,
+        ]),
+      ).toThrow(BadDataException);
+    });
+  });
+
+  describe("the customer side of the switch", () => {
+    it("lets a project owner turn support access on", () => {
+      expect(
+        checkColumnUpdate({ letCustomerSupportAccessProject: true }, [
+          Permission.ProjectOwner,
+        ]),
+      ).not.toThrow();
+    });
+
+    it("lets a project admin turn support access off again", () => {
+      expect(
+        checkColumnUpdate({ letCustomerSupportAccessProject: false }, [
+          Permission.ProjectAdmin,
+        ]),
+      ).not.toThrow();
+    });
+
+    it("refuses a viewer", () => {
+      expect(
+        checkColumnUpdate({ letCustomerSupportAccessProject: true }, [
+          Permission.ProjectMember,
+          Permission.Viewer,
+        ]),
+      ).toThrow(BadDataException);
+    });
+
+    it("grants only owners and admins the write, and nobody else", () => {
+      /*
+       * Asserted through the column list rather than one role at a time, so
+       * adding a role to the update array fails here even if no test above
+       * happens to name that role.
+       */
+      for (const permission of [
+        Permission.ProjectOwner,
+        Permission.ProjectAdmin,
+      ]) {
+        expect(updatableColumns([permission])).toContain(COLUMN);
+      }
+
+      for (const permission of [
+        Permission.ProjectMember,
+        Permission.Viewer,
+        Permission.ReadProject,
+        Permission.UnAuthorizedSsoUser,
+      ]) {
+        expect(updatableColumns([permission])).not.toContain(COLUMN);
+      }
+    });
+
+    it("is readable by everyone in the project, so the toggle renders its current state", () => {
+      /*
+       * Read and update are independent arrays on ColumnAccessControl. A
+       * member who could not read the column would see an empty card rather
+       * than "No".
+       */
+      for (const permission of [
+        Permission.ProjectOwner,
+        Permission.ProjectAdmin,
+        Permission.ProjectMember,
+        Permission.Viewer,
+        Permission.ReadProject,
+      ]) {
+        expect(readableColumns([permission])).toContain(COLUMN);
+      }
+    });
+
+    it("is never creatable, so a project cannot be created with support already let in", () => {
+      const createColumns: Columns =
+        ColumnPermissions.getModelColumnsByPermissions(
+          Project,
+          makeProps([
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.User,
+          ]).userTenantAccessPermission![projectId.toString()]!.permissions,
+          DatabaseRequestType.Create,
+        );
+
+      expect(createColumns.columns).not.toContain(COLUMN);
+    });
+  });
+
+  describe("the admin dashboard side of the switch", () => {
+    /*
+     * The Admin Dashboard sends no project headers (AdminModelAPI clears
+     * them), so a master admin acting on somebody else's project arrives with
+     * no tenant permissions for it at all. checkUpdatePermissions has to let
+     * that through on isMasterAdmin alone, or the Project > Support page 400s
+     * on every save.
+     */
+    const query: Record<string, unknown> = { _id: projectId.toString() };
+
+    async function checkUpdate(
+      props: DatabaseCommonInteractionProps,
+    ): Promise<Record<string, unknown>> {
+      return (await UpdatePermission.checkUpdatePermissions(
+        Project,
+        { ...query } as any,
+        { letCustomerSupportAccessProject: true } as any,
+        props,
+      )) as unknown as Record<string, unknown>;
+    }
+
+    /*
+     * Asserted on the query that comes back rather than on "it did not
+     * throw": the non-admin path rewrites the query on its way through
+     * BasePermission - tenant scope, owner scope, access-control ids. Getting
+     * the caller's query back unchanged is what says the bypass was taken,
+     * and it is also what the admin page depends on, since the project it
+     * names is not one the staff user belongs to.
+     */
+    it("lets a master admin write the column with no project membership at all", async () => {
+      await expect(
+        checkUpdate({
+          userId,
+          isMasterAdmin: true,
+        }),
+      ).resolves.toEqual(query);
+    });
+
+    it("lets a master admin write it even while scoped to the project", async () => {
+      await expect(
+        checkUpdate(makeProps([], { isMasterAdmin: true })),
+      ).resolves.toEqual(query);
+    });
+
+    it("still refuses the same write from a signed-in user who is not a master admin", async () => {
+      /*
+       * The counterpart of the two cases above: if this stopped throwing, the
+       * bypass they rely on would no longer be what is letting them through,
+       * and any user could flip the switch on any project they can reach.
+       */
+      await expect(
+        checkUpdate(makeProps([Permission.ProjectMember])),
+      ).rejects.toThrow();
+    });
+  });
+});