@oneuptime/common 13.0.7 → 14.0.0

package/Tests/Types/Database/CanonicalModelInstance.test.ts

@@ -0,0 +1,190 @@
+import AllModelTypes from "../../../Models/DatabaseModels/Index";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import ProjectSCIM from "../../../Models/DatabaseModels/ProjectSCIM";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import UserEmail from "../../../Models/DatabaseModels/UserEmail";
+import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
+import ColumnBillingAccessControl from "../../../Types/BaseDatabase/ColumnBillingAccessControl";
+import { getColumnAccessControlForAllColumns } from "../../../Types/Database/AccessControl/ColumnAccessControl";
+import { getColumnBillingAccessControlForAllColumns } from "../../../Types/Database/AccessControl/ColumnBillingAccessControl";
+import { getOwnerOnlyColumns } from "../../../Types/Database/AccessControl/OwnerOnlyColumn";
+import Dictionary from "../../../Types/Dictionary";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+import { getMetadataArgsStorage } from "typeorm";
+
+/*
+ * WHY THIS FILE EXISTS - do not delete these as "obvious" assertions.
+ *
+ * Every "which columns does this model have" lookup answers the question by
+ * enumerating an INSTANCE's own keys, and caches the answer per CLASS, for the
+ * whole process. So the FIRST instance to ask used to define what the class is
+ * for everybody after it.
+ *
+ * BaseAPI.createItem deleted `_id` off the live model instance it handed to
+ * the service, and DatabaseService.create asks that instance for its columns
+ * (generateDefaultValues) before any permission check runs. One POST - even a
+ * POST that was refused - could therefore teach the process that a model has
+ * no `_id` column, and DatabaseBaseModel.toJSONObject serializes a row by
+ * iterating exactly that cached list, so every response for that model lost
+ * its id from then on. To any caller, on any route, including plain reads as
+ * root: the row still carried its real `_id` in memory and the SQL projection
+ * still selected it. The id was dropped on the way out, and it stayed a 200
+ * because `_id` is in ColumnPermissions.getExcludedColumnNames().
+ *
+ * The tests below do the mutation on purpose. No caller in the tree does it
+ * any more, and that is not what is being protected: the invariant is that it
+ * CANNOT MATTER who asks first or what they did to their own instance. Each
+ * test uses a different model class, because these caches are per class and
+ * per process - a class another test has already asked about has a warm cache
+ * and would pass vacuously.
+ */
+
+describe("column metadata does not depend on which instance asked first", () => {
+  test("getTableColumns: a mutilated instance asking first cannot strip _id from the class", () => {
+    const mutilated: ProjectSCIM = new ProjectSCIM();
+
+    // exactly what BaseAPI.createItem used to do before calling the service
+    delete (mutilated as unknown as Record<string, unknown>)["_id"];
+    expect(Object.keys(mutilated)).not.toContain("_id");
+
+    // the mutilated instance is the FIRST to ask, on a cold cache
+    expect(mutilated.getTableColumns().columns).toContain("_id");
+
+    // ...and a fresh instance of the same class is unharmed
+    expect(new ProjectSCIM().getTableColumns().columns).toContain("_id");
+  });
+
+  test("getTableColumns: a row still serializes with its _id after such a create", () => {
+    /*
+     * The assertion that matches the reported symptom: POST /api/project-scim
+     * answered 200 with every column except "_id", and a get-list selecting
+     * {_id, name} came back as {name} alone.
+     */
+    const mutilated: Monitor = new Monitor();
+    delete (mutilated as unknown as Record<string, unknown>)["_id"];
+    mutilated.getTableColumns();
+
+    const row: Monitor = new Monitor();
+    row._id = "22222222-2222-4222-8222-222222222222";
+    row.name = "a monitor";
+
+    const json: JSONObject = BaseModel.toJSONObject(row, Monitor);
+
+    expect(json["_id"]).toBe("22222222-2222-4222-8222-222222222222");
+    expect(json["name"]).toBe("a monitor");
+  });
+
+  test("getColumnAccessControlForAllColumns is instance-independent", () => {
+    const mutilated: StatusPage = new StatusPage();
+    delete (mutilated as unknown as Record<string, unknown>)["name"];
+
+    const fromMutilated: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(mutilated);
+
+    expect(fromMutilated["name"]).toBeDefined();
+    expect(
+      getColumnAccessControlForAllColumns(new StatusPage())["name"],
+    ).toBeDefined();
+  });
+
+  test("getColumnBillingAccessControlForAllColumns is instance-independent", () => {
+    const mutilated: StatusPage = new StatusPage();
+    delete (mutilated as unknown as Record<string, unknown>)["customCSS"];
+
+    const fromMutilated: Dictionary<ColumnBillingAccessControl> =
+      getColumnBillingAccessControlForAllColumns(mutilated);
+
+    expect(fromMutilated["customCSS"]).toBeDefined();
+    expect(
+      getColumnBillingAccessControlForAllColumns(new StatusPage())["customCSS"],
+    ).toBeDefined();
+  });
+
+  test("getOwnerOnlyColumns is instance-independent", () => {
+    /*
+     * This one is a permission list, not a projection: a marked column that
+     * goes unreported is a column OwnerOnlyColumnPermission stops protecting.
+     */
+    const mutilated: UserEmail = new UserEmail();
+    delete (mutilated as unknown as Record<string, unknown>)["email"];
+
+    expect(getOwnerOnlyColumns(mutilated)).toContain("email");
+    expect(getOwnerOnlyColumns(new UserEmail())).toContain("email");
+  });
+
+  test("mutating an instance after the class has been read changes nothing either", () => {
+    const first: UserEmail = new UserEmail();
+    expect(first.getTableColumns().columns).toContain("_id");
+
+    delete (first as unknown as Record<string, unknown>)["_id"];
+
+    expect(first.getTableColumns().columns).toContain("_id");
+    expect(new UserEmail().getTableColumns().columns).toContain("_id");
+  });
+});
+
+/*
+ * The premise of the fix: metadata enumeration reads a freshly constructed
+ * instance of the caller's class, so every model must be no-arg constructible
+ * and must expose every column it declares on a fresh instance (the class
+ * bodies do that with `= undefined` initializers). If a model is ever added
+ * that breaks either half, it would silently lose columns everywhere -
+ * responses, selects, permissions - so assert it for all of them at once.
+ */
+describe("every database model supports canonical-instance enumeration", () => {
+  test("all models are no-arg constructible and declare no column that a fresh instance lacks", () => {
+    const columnsByTarget: Map<unknown, Array<string>> = new Map();
+
+    const record: (target: unknown, propertyName: string) => void = (
+      target: unknown,
+      propertyName: string,
+    ): void => {
+      const list: Array<string> = columnsByTarget.get(target) || [];
+      list.push(propertyName);
+      columnsByTarget.set(target, list);
+    };
+
+    for (const column of getMetadataArgsStorage().columns) {
+      record(column.target, column.propertyName);
+    }
+
+    for (const relation of getMetadataArgsStorage().relations) {
+      record(relation.target, relation.propertyName);
+    }
+
+    const constructFailures: Array<string> = [];
+    const missingKeys: Array<string> = [];
+
+    for (const modelType of AllModelTypes) {
+      let instance: BaseModel | null = null;
+
+      try {
+        instance = new modelType();
+      } catch (err) {
+        constructFailures.push(`${modelType.name}: ${(err as Error).message}`);
+        continue;
+      }
+
+      const ownKeys: Set<string> = new Set(Object.keys(instance));
+
+      // inherited columns count too, so walk the constructor chain
+      let ctor: unknown = modelType;
+
+      while (ctor && ctor !== Function.prototype) {
+        for (const propertyName of columnsByTarget.get(ctor) || []) {
+          if (!ownKeys.has(propertyName)) {
+            missingKeys.push(`${modelType.name}.${propertyName}`);
+          }
+        }
+
+        ctor = Object.getPrototypeOf(ctor);
+      }
+    }
+
+    expect(constructFailures).toEqual([]);
+    expect(missingKeys).toEqual([]);
+    expect(AllModelTypes.length).toBeGreaterThan(400);
+  });
+});

package/Tests/Types/Kubernetes/KubernetesCostIngest.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import {
+  KubernetesCostAllocationIngestRow,
+  KubernetesCostIngestPayload,
+  MAX_KUBERNETES_COST_ALLOCATIONS_PER_REQUEST,
+} from "../../../Types/Kubernetes/KubernetesCostIngest";
+
+/*
+ * KubernetesCostIngest is the wire contract for POST /kubernetes-cost/ingest.
+ * The Kubernetes cost agent is a standalone project that cannot import
+ * Common, so it carries a hand-written mirror of these interfaces
+ * (agents/KubernetesCostAgent/Types.ts) with a "keep the two in sync" note.
+ * These tests enforce that note mechanically and pin the request cap.
+ */
+
+const COMMON_SOURCE_PATH: string = path.resolve(
+  __dirname,
+  "../../../Types/Kubernetes/KubernetesCostIngest.ts",
+);
+const AGENT_MIRROR_PATH: string = path.resolve(
+  __dirname,
+  "../../../../../agents/KubernetesCostAgent/Types.ts",
+);
+
+interface FieldSignature {
+  name: string;
+  optional: boolean;
+  type: string;
+}
+
+/*
+ * Pull the top-level property signatures out of `export interface <name> {}`.
+ * Comments are stripped first so prose containing ":" cannot masquerade as a
+ * field. Neither contract interface nests object literal types, so a flat
+ * line-based match over the interface body is sufficient.
+ */
+const extractInterfaceFields: (
+  source: string,
+  interfaceName: string,
+) => Array<FieldSignature> = (
+  source: string,
+  interfaceName: string,
+): Array<FieldSignature> => {
+  const withoutComments: string = source
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\/\/.*$/gm, "");
+
+  const header: string = `export interface ${interfaceName} {`;
+  const start: number = withoutComments.indexOf(header);
+  if (start === -1) {
+    throw new Error(`interface ${interfaceName} not found`);
+  }
+
+  let depth: number = 0;
+  let body: string = "";
+  for (
+    let i: number = start + header.length - 1;
+    i < withoutComments.length;
+    i++
+  ) {
+    const char: string = withoutComments[i]!;
+    if (char === "{") {
+      depth++;
+      if (depth === 1) {
+        continue;
+      }
+    }
+    if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        break;
+      }
+    }
+    body += char;
+  }
+
+  const fields: Array<FieldSignature> = [];
+  const fieldPattern: RegExp = /^\s*([A-Za-z_$][\w$]*)(\?)?\s*:\s*([^;]+);/gm;
+  let match: RegExpExecArray | null = fieldPattern.exec(body);
+  while (match) {
+    fields.push({
+      name: match[1]!,
+      optional: match[2] === "?",
+      type: match[3]!.replace(/\s+/g, " ").trim(),
+    });
+    match = fieldPattern.exec(body);
+  }
+  return fields;
+};
+
+const byName: (
+  fields: Array<FieldSignature>,
+) => Record<string, FieldSignature> = (
+  fields: Array<FieldSignature>,
+): Record<string, FieldSignature> => {
+  const result: Record<string, FieldSignature> = {};
+  for (const field of fields) {
+    result[field.name] = field;
+  }
+  return result;
+};
+
+describe("KubernetesCostIngest", () => {
+  test("pins the per-request allocation cap", () => {
+    expect(MAX_KUBERNETES_COST_ALLOCATIONS_PER_REQUEST).toBe(5000);
+    expect(Number.isInteger(MAX_KUBERNETES_COST_ALLOCATIONS_PER_REQUEST)).toBe(
+      true,
+    );
+  });
+
+  test("a minimal payload only needs clusterName and allocations", () => {
+    const row: KubernetesCostAllocationIngestRow = {
+      windowStart: "2026-09-19T00:00:00Z",
+      windowEnd: "2026-09-19T01:00:00Z",
+    };
+    const payload: KubernetesCostIngestPayload = {
+      clusterName: "prod-eu",
+      allocations: [row],
+    };
+
+    const roundTripped: KubernetesCostIngestPayload = JSON.parse(
+      JSON.stringify(payload),
+    ) as KubernetesCostIngestPayload;
+    expect(roundTripped).toEqual(payload);
+    expect(roundTripped.currency).toBeUndefined();
+    expect(roundTripped.shipmentId).toBeUndefined();
+  });
+
+  test("a fully populated row survives a JSON round trip unchanged", () => {
+    const row: KubernetesCostAllocationIngestRow = {
+      windowStart: "2026-09-19T00:00:00Z",
+      windowEnd: "2026-09-19T01:00:00Z",
+      namespace: "checkout",
+      controllerKind: "deployment",
+      controllerName: "checkout-api",
+      podName: "checkout-api-7c9d-abcde",
+      containerName: "api",
+      nodeName: "ip-10-0-0-1",
+      providerId: "aws:///eu-west-1a/i-0123",
+      labels: { app: "checkout", team: "payments" },
+      cpuCoreHours: 0.5,
+      cpuCoreRequestAverage: 0.5,
+      cpuCoreUsageAverage: 0.2,
+      cpuCoreLimitAverage: 1,
+      gpuHours: 0,
+      ramByteHours: 536870912,
+      ramBytesRequestAverage: 536870912,
+      ramBytesUsageAverage: 268435456,
+      ramBytesLimitAverage: 1073741824,
+      ramBytesUsageMax: 402653184,
+      pvByteHours: 0,
+      cpuCost: 0.012,
+      gpuCost: 0,
+      ramCost: 0.003,
+      pvCost: 0,
+      networkCost: 0.001,
+      loadBalancerCost: 0,
+      sharedCost: 0,
+      externalCost: 0,
+      totalCost: 0.016,
+      cpuEfficiency: 0.4,
+      ramEfficiency: 0.5,
+      totalEfficiency: 0.42,
+    };
+    const payload: KubernetesCostIngestPayload = {
+      clusterName: "prod-eu",
+      currency: "USD",
+      shipmentId: "sha256:abc",
+      shipmentChunk: 0,
+      allocations: [row, { ...row, namespace: "__idle__" }],
+    };
+
+    expect(JSON.parse(JSON.stringify(payload))).toEqual(payload);
+  });
+
+  describe("agent mirror (agents/KubernetesCostAgent/Types.ts)", () => {
+    const commonSource: string = fs.readFileSync(COMMON_SOURCE_PATH, "utf8");
+    const agentSource: string = fs.readFileSync(AGENT_MIRROR_PATH, "utf8");
+
+    test.each([
+      "KubernetesCostAllocationIngestRow",
+      "KubernetesCostIngestPayload",
+    ])("%s declares the same fields, optionality and types", (name: string) => {
+      const commonFields: Array<FieldSignature> = extractInterfaceFields(
+        commonSource,
+        name,
+      );
+      const agentFields: Array<FieldSignature> = extractInterfaceFields(
+        agentSource,
+        name,
+      );
+
+      // Guard against the parser silently returning nothing.
+      expect(commonFields.length).toBeGreaterThan(2);
+
+      expect(byName(agentFields)).toEqual(byName(commonFields));
+    });
+
+    test("the parser sees the fields the contract documents", () => {
+      const rowFields: Record<string, FieldSignature> = byName(
+        extractInterfaceFields(
+          commonSource,
+          "KubernetesCostAllocationIngestRow",
+        ),
+      );
+      expect(rowFields["windowStart"]).toEqual({
+        name: "windowStart",
+        optional: false,
+        type: "string",
+      });
+      expect(rowFields["ramBytesUsageMax"]).toEqual({
+        name: "ramBytesUsageMax",
+        optional: true,
+        type: "number | undefined",
+      });
+      expect(rowFields["labels"]?.type).toBe(
+        "Record<string, string> | undefined",
+      );
+
+      const payloadFields: Record<string, FieldSignature> = byName(
+        extractInterfaceFields(commonSource, "KubernetesCostIngestPayload"),
+      );
+      expect(Object.keys(payloadFields).sort()).toEqual([
+        "allocations",
+        "clusterName",
+        "currency",
+        "shipmentChunk",
+        "shipmentId",
+      ]);
+      expect(payloadFields["clusterName"]?.optional).toBe(false);
+      expect(payloadFields["allocations"]?.optional).toBe(false);
+    });
+  });
+});