@oneuptime/common 12.0.17 → 12.0.19

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

@@ -7,6 +7,7 @@ import {
   buildRightSizingRecommendation,
   formatCpuCores,
   formatMemoryBytes,
+  getVerdictLabel,
   hasActionableRecommendation,
 } from "../../../Types/Kubernetes/KubernetesRightSizing";
 import { describe, expect, test } from "@jest/globals";
@@ -321,3 +322,55 @@ describe("formatting", () => {
     expect(formatMemoryBytes(null)).toBe("-");
   });
 });
+
+/*
+ * getVerdictLabel turns the internal verdict enum into the human string the
+ * right-sizing UI renders. It is a switch with a default arm, so the failure it
+ * invites is a new verdict added to the enum without a matching case — it would
+ * silently render as "Unavailable". This block pins each label and, crucially,
+ * that every enum member has an explicit, distinct, non-"Unavailable" label
+ * except the one that is meant to be Unavailable.
+ */
+describe("getVerdictLabel", () => {
+  const EXPECTED: Array<[RightSizingVerdict, string]> = [
+    [RightSizingVerdict.Overprovisioned, "Over-provisioned"],
+    [RightSizingVerdict.Underprovisioned, "Under-provisioned"],
+    [RightSizingVerdict.Optimal, "Right-sized"],
+    [RightSizingVerdict.NoRequestSet, "No request set"],
+    [RightSizingVerdict.Unavailable, "Unavailable"],
+  ];
+
+  test.each(EXPECTED)(
+    "maps %s to its label",
+    (verdict: RightSizingVerdict, label: string) => {
+      expect(getVerdictLabel(verdict)).toBe(label);
+    },
+  );
+
+  test("every verdict produces a non-empty label", () => {
+    for (const verdict of Object.values(RightSizingVerdict)) {
+      const label: string = getVerdictLabel(verdict);
+      expect(typeof label).toBe("string");
+      expect(label.length).toBeGreaterThan(0);
+    }
+  });
+
+  test('only the Unavailable verdict resolves to "Unavailable"', () => {
+    /*
+     * If a new verdict fell through to the default arm, more than one enum
+     * member would carry the "Unavailable" label — catch that here.
+     */
+    const unavailableCount: number = Object.values(RightSizingVerdict).filter(
+      (verdict: RightSizingVerdict) => {
+        return getVerdictLabel(verdict) === "Unavailable";
+      },
+    ).length;
+    expect(unavailableCount).toBe(1);
+  });
+
+  test("an unknown verdict falls back to Unavailable", () => {
+    expect(getVerdictLabel("SomethingElse" as RightSizingVerdict)).toBe(
+      "Unavailable",
+    );
+  });
+});

package/Tests/Types/Measurement/MeasurementAggregationType.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "@jest/globals";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import MeasurementAggregationType, {
+  MeasurementAggregationTypeUtil,
+} from "../../../Types/Measurement/MeasurementAggregationType";
+
+/*
+ * MeasurementAggregationType is the deliberately-narrow subset of
+ * AggregationType a measurement chart is allowed to default to (Sum is left
+ * out on purpose: summing durations across incidents is meaningless). The Util
+ * maps each subset member onto the full AggregationType the query layer
+ * understands. The mapping is a switch with a default arm, so the failure it
+ * invites is a member added to the enum without a matching case — it would
+ * silently fall through to Avg. This suite pins the mapping and that
+ * exhaustiveness.
+ */
+
+describe("MeasurementAggregationType", () => {
+  test("is a strict subset of AggregationType and excludes Sum/Count", () => {
+    const full: Array<string> = Object.values(AggregationType);
+    for (const member of Object.values(MeasurementAggregationType)) {
+      // Every measurement member must be a real AggregationType value.
+      expect(full).toContain(member);
+    }
+    // The two intentionally-omitted members must never appear here.
+    expect(Object.values(MeasurementAggregationType)).not.toContain(
+      AggregationType.Sum as unknown as MeasurementAggregationType,
+    );
+    expect(Object.values(MeasurementAggregationType)).not.toContain(
+      AggregationType.Count as unknown as MeasurementAggregationType,
+    );
+  });
+});
+
+describe("MeasurementAggregationTypeUtil.toAggregationType", () => {
+  const CASES: Array<[MeasurementAggregationType, AggregationType]> = [
+    [MeasurementAggregationType.Avg, AggregationType.Avg],
+    [MeasurementAggregationType.Max, AggregationType.Max],
+    [MeasurementAggregationType.Min, AggregationType.Min],
+    [MeasurementAggregationType.P50, AggregationType.P50],
+    [MeasurementAggregationType.P90, AggregationType.P90],
+    [MeasurementAggregationType.P95, AggregationType.P95],
+    [MeasurementAggregationType.P99, AggregationType.P99],
+  ];
+
+  test.each(CASES)(
+    "maps %s to the matching AggregationType",
+    (input: MeasurementAggregationType, expected: AggregationType) => {
+      expect(MeasurementAggregationTypeUtil.toAggregationType(input)).toBe(
+        expected,
+      );
+    },
+  );
+
+  test("covers every enum member (no member falls through to the default)", () => {
+    /*
+     * If a new member is added to MeasurementAggregationType without its own
+     * case, it would resolve to Avg here. Compare against an independently
+     * built expectation so that fall-through is caught rather than accepted.
+     */
+    const mapped: Set<AggregationType> = new Set<AggregationType>(
+      Object.values(MeasurementAggregationType).map(
+        (m: MeasurementAggregationType) => {
+          return MeasurementAggregationTypeUtil.toAggregationType(m);
+        },
+      ),
+    );
+    // Avg, Max, Min, P50, P90, P95, P99 => 7 distinct targets.
+    expect(mapped.size).toBe(Object.values(MeasurementAggregationType).length);
+  });
+
+  test("defaults undefined to Avg", () => {
+    // The picker can be empty; an unset selection must resolve to a safe Avg.
+    expect(MeasurementAggregationTypeUtil.toAggregationType(undefined)).toBe(
+      AggregationType.Avg,
+    );
+  });
+
+  test("an unknown value falls back to Avg rather than throwing", () => {
+    // Defensive: a value outside the enum (bad persisted data) must not crash.
+    expect(
+      MeasurementAggregationTypeUtil.toAggregationType(
+        "NotARealAggregation" as MeasurementAggregationType,
+      ),
+    ).toBe(AggregationType.Avg);
+  });
+
+  test("only ever returns AggregationTypes valid for measurements", () => {
+    /*
+     * The mapping must never emit Sum or Count — those are exactly the
+     * aggregations the measurement subset exists to keep out.
+     */
+    for (const member of Object.values(MeasurementAggregationType)) {
+      const result: AggregationType =
+        MeasurementAggregationTypeUtil.toAggregationType(member);
+      expect(result).not.toBe(AggregationType.Sum);
+      expect(result).not.toBe(AggregationType.Count);
+    }
+  });
+});

package/Tests/Types/Monitor/MonitorStepConfigHelpers.test.ts

@@ -1,7 +1,10 @@
 import {
   DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS,
+  DEFAULT_MONITOR_RETRY_COUNT,
   MAX_MONITOR_REQUEST_TIMEOUT_IN_MS,
+  MAX_MONITOR_RETRY_COUNT,
   clampMonitorRequestTimeoutInMs,
+  clampMonitorRetryCount,
 } from "../../../Types/Monitor/MonitorStep";
 import { describe, expect, test } from "@jest/globals";
 
@@ -163,3 +166,114 @@ describe("clampMonitorRequestTimeoutInMs", () => {
     });
   });
 });
+
+/*
+ * clampMonitorRetryCount constrains how many times a probe retries a step. Its
+ * guard differs from the timeout clamp in one behaviour that matters: the lower
+ * bound is `value < 0`, NOT `value <= 0`. Zero is therefore a VALID retry count
+ * (retry never) and must pass through unchanged, whereas only genuinely invalid
+ * inputs (undefined / null / NaN / negative) fall back to the default. These
+ * tests pin exactly that zero-is-valid distinction plus the usual boundary and
+ * defensive-coercion cases.
+ */
+describe("clampMonitorRetryCount", () => {
+  describe("invalid inputs fall back to the default", () => {
+    test("NaN returns the default", () => {
+      expect(clampMonitorRetryCount(NaN)).toBe(DEFAULT_MONITOR_RETRY_COUNT);
+    });
+
+    test("a negative value returns the default (not a clamp to zero)", () => {
+      expect(clampMonitorRetryCount(-1)).toBe(DEFAULT_MONITOR_RETRY_COUNT);
+    });
+
+    test("negative Infinity returns the default", () => {
+      expect(clampMonitorRetryCount(-Infinity)).toBe(
+        DEFAULT_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("undefined coerced through the signature returns the default", () => {
+      expect(clampMonitorRetryCount(undefined as unknown as number)).toBe(
+        DEFAULT_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("null coerced through the signature returns the default", () => {
+      expect(clampMonitorRetryCount(null as unknown as number)).toBe(
+        DEFAULT_MONITOR_RETRY_COUNT,
+      );
+    });
+  });
+
+  describe("zero is a valid retry count", () => {
+    test("zero passes through unchanged (retry never)", () => {
+      // The whole point of `< 0` rather than `<= 0`: 0 is a real choice.
+      expect(clampMonitorRetryCount(0)).toBe(0);
+    });
+
+    test("negative zero also passes through as a numeric zero", () => {
+      /*
+       * -0 < 0 is false, so -0 is not treated as invalid and passes through.
+       * It stays -0 (toBe uses Object.is, under which -0 !== 0), which is still
+       * numerically zero — assert that rather than the Object.is identity.
+       */
+      const result: number = clampMonitorRetryCount(-0);
+      expect(result === 0).toBe(true);
+      expect(Math.abs(result)).toBe(0);
+    });
+  });
+
+  describe("in-range and boundary values", () => {
+    test("a value between 0 and the cap is returned unchanged", () => {
+      expect(clampMonitorRetryCount(1)).toBe(1);
+      expect(clampMonitorRetryCount(2)).toBe(2);
+    });
+
+    test("a value exactly at the cap is returned, not clamped", () => {
+      expect(clampMonitorRetryCount(MAX_MONITOR_RETRY_COUNT)).toBe(
+        MAX_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("one over the cap is clamped down to the cap", () => {
+      expect(clampMonitorRetryCount(MAX_MONITOR_RETRY_COUNT + 1)).toBe(
+        MAX_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("positive Infinity is clamped to the cap", () => {
+      expect(clampMonitorRetryCount(Infinity)).toBe(MAX_MONITOR_RETRY_COUNT);
+    });
+  });
+
+  describe("stability and invariants", () => {
+    test("the exported cap and default are non-negative finite numbers", () => {
+      expect(Number.isFinite(MAX_MONITOR_RETRY_COUNT)).toBe(true);
+      expect(MAX_MONITOR_RETRY_COUNT).toBeGreaterThanOrEqual(0);
+      expect(DEFAULT_MONITOR_RETRY_COUNT).toBeGreaterThanOrEqual(0);
+      expect(DEFAULT_MONITOR_RETRY_COUNT).toBeLessThanOrEqual(
+        MAX_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("across a sweep the result is always within [0, cap]", () => {
+      const samples: Array<number> = [
+        -100,
+        -1,
+        0,
+        1,
+        2,
+        3,
+        4,
+        1000,
+        Infinity,
+        NaN,
+      ];
+      for (const sample of samples) {
+        const result: number = clampMonitorRetryCount(sample);
+        expect(result).toBeGreaterThanOrEqual(0);
+        expect(result).toBeLessThanOrEqual(MAX_MONITOR_RETRY_COUNT);
+      }
+    });
+  });
+});

package/Tests/Types/Workspace/WorkspaceType.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "@jest/globals";
+import WorkspaceType, {
+  getWorkspaceTypeDisplayName,
+} from "../../../Types/Workspace/WorkspaceType";
+
+/*
+ * getWorkspaceTypeDisplayName turns the WorkspaceType enum into the label shown
+ * wherever a workspace integration is named in the UI. The only member whose
+ * display name differs from its enum value is MicrosoftTeams ("Microsoft Teams"
+ * with a space); the rest fall through to returning the raw value. The suite
+ * pins that spacing and guards the fall-through: a new workspace type added to
+ * the enum must still yield a non-empty label rather than undefined.
+ */
+
+describe("getWorkspaceTypeDisplayName", () => {
+  test("renders Microsoft Teams with a space", () => {
+    // The enum value is "MicrosoftTeams"; the label must be human-spaced.
+    expect(getWorkspaceTypeDisplayName(WorkspaceType.MicrosoftTeams)).toBe(
+      "Microsoft Teams",
+    );
+  });
+
+  test("renders Slack as-is", () => {
+    expect(getWorkspaceTypeDisplayName(WorkspaceType.Slack)).toBe("Slack");
+  });
+
+  test("every workspace type yields a non-empty display name", () => {
+    for (const type of Object.values(WorkspaceType)) {
+      const label: string = getWorkspaceTypeDisplayName(type);
+      expect(typeof label).toBe("string");
+      expect(label.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("display names are unique across workspace types", () => {
+    const labels: Array<string> = Object.values(WorkspaceType).map(
+      (type: WorkspaceType) => {
+        return getWorkspaceTypeDisplayName(type);
+      },
+    );
+    expect(new Set<string>(labels).size).toBe(labels.length);
+  });
+
+  test("an unknown value falls back to the raw string it was given", () => {
+    /*
+     * The function's default arm returns its argument unchanged. Persisted or
+     * mistyped data must therefore round-trip rather than become undefined.
+     */
+    expect(getWorkspaceTypeDisplayName("Discord" as WorkspaceType)).toBe(
+      "Discord",
+    );
+  });
+});

package/Tests/UI/Utils/NotificationMethodUtil.test.ts

@@ -7,8 +7,10 @@ import NotificationMethodUtil, {
 import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
 import UserCall from "../../../Models/DatabaseModels/UserCall";
 import UserEmail from "../../../Models/DatabaseModels/UserEmail";
+import UserMicrosoftTeams from "../../../Models/DatabaseModels/UserMicrosoftTeams";
 import UserNotificationRule from "../../../Models/DatabaseModels/UserNotificationRule";
 import UserPush from "../../../Models/DatabaseModels/UserPush";
+import UserSlack from "../../../Models/DatabaseModels/UserSlack";
 import UserSMS from "../../../Models/DatabaseModels/UserSMS";
 import UserTelegram from "../../../Models/DatabaseModels/UserTelegram";
 import UserWebhook from "../../../Models/DatabaseModels/UserWebhook";
@@ -95,6 +97,34 @@ function push(id: string, deviceName?: string): UserPush {
   return model;
 }
 
+function slack(id: string, userName?: string, userId?: string): UserSlack {
+  const model: UserSlack = new UserSlack();
+  model.id = new ObjectID(id);
+  if (userName !== undefined) {
+    model.slackUserName = userName;
+  }
+  if (userId !== undefined) {
+    model.slackUserId = userId;
+  }
+  return model;
+}
+
+function microsoftTeams(
+  id: string,
+  userName?: string,
+  userId?: string,
+): UserMicrosoftTeams {
+  const model: UserMicrosoftTeams = new UserMicrosoftTeams();
+  model.id = new ObjectID(id);
+  if (userName !== undefined) {
+    model.microsoftTeamsUserName = userName;
+  }
+  if (userId !== undefined) {
+    model.microsoftTeamsUserId = userId;
+  }
+  return model;
+}
+
 function emptyModels(): NotificationMethodModels {
   return {
     userCalls: [],
@@ -103,20 +133,25 @@ function emptyModels(): NotificationMethodModels {
     userPush: [],
     userWhatsApps: [],
     userTelegrams: [],
+    userSlacks: [],
+    userMicrosoftTeamsAccounts: [],
     userWebhooks: [],
   };
 }
 
 // A 24-hex-char string is a valid ObjectID.
-const ID: Record<"a" | "b" | "c" | "d" | "e" | "f" | "g", string> = {
-  a: "aaaaaaaaaaaaaaaaaaaaaaaa",
-  b: "bbbbbbbbbbbbbbbbbbbbbbbb",
-  c: "cccccccccccccccccccccccc",
-  d: "dddddddddddddddddddddddd",
-  e: "eeeeeeeeeeeeeeeeeeeeeeee",
-  f: "ffffffffffffffffffffffff",
-  g: "abcabcabcabcabcabcabcabc",
-};
+const ID: Record<"a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i", string> =
+  {
+    a: "aaaaaaaaaaaaaaaaaaaaaaaa",
+    b: "bbbbbbbbbbbbbbbbbbbbbbbb",
+    c: "cccccccccccccccccccccccc",
+    d: "dddddddddddddddddddddddd",
+    e: "eeeeeeeeeeeeeeeeeeeeeeee",
+    f: "ffffffffffffffffffffffff",
+    g: "abcabcabcabcabcabcabcabc",
+    h: "cdecdecdecdecdecdecdecde",
+    i: "fabfabfabfabfabfabfabfab",
+  };
 
 /*
  * A minimal stand-in for a model row: getDisplayItems only needs getColumnValue,
@@ -144,7 +179,9 @@ describe("NotificationMethodUtil.getSelectForNotificationMethods", () => {
       [
         "userCall",
         "userEmail",
+        "userMicrosoftTeams",
         "userPush",
+        "userSlack",
         "userSms",
         "userTelegram",
         "userWebhook",
@@ -171,6 +208,14 @@ describe("NotificationMethodUtil.getSelectForNotificationMethods", () => {
       telegramUserHandle: true,
       telegramChatId: true,
     });
+    expect(select["userSlack"]).toEqual({
+      slackUserName: true,
+      slackUserId: true,
+    });
+    expect(select["userMicrosoftTeams"]).toEqual({
+      microsoftTeamsUserName: true,
+      microsoftTeamsUserId: true,
+    });
   });
 
   test("selects ONLY name for a webhook — never the credential-bearing URL or secret", () => {
@@ -284,6 +329,51 @@ describe("NotificationMethodUtil.getDisplayItems", () => {
     expect(items).toEqual([{ title: "Telegram", value: "999" }]);
   });
 
+  test("prefers the Slack user name over the Slack member id", () => {
+    const items: Array<NotificationMethodDisplayItem> =
+      NotificationMethodUtil.getDisplayItems(
+        reader({
+          userSlack: { slackUserName: "alice", slackUserId: "U0123ABCD" },
+        }),
+      );
+
+    expect(items).toEqual([{ title: "Slack", value: "alice" }]);
+  });
+
+  test("falls back to the Slack member id when the user name is absent", () => {
+    const items: Array<NotificationMethodDisplayItem> =
+      NotificationMethodUtil.getDisplayItems(
+        reader({ userSlack: { slackUserId: "U0123ABCD" } }),
+      );
+
+    expect(items).toEqual([{ title: "Slack", value: "U0123ABCD" }]);
+  });
+
+  test("prefers the Microsoft Teams user name over the Teams user id", () => {
+    const items: Array<NotificationMethodDisplayItem> =
+      NotificationMethodUtil.getDisplayItems(
+        reader({
+          userMicrosoftTeams: {
+            microsoftTeamsUserName: "Alice Example",
+            microsoftTeamsUserId: "29:1abc",
+          },
+        }),
+      );
+
+    expect(items).toEqual([
+      { title: "Microsoft Teams", value: "Alice Example" },
+    ]);
+  });
+
+  test("falls back to the Teams user id when the user name is absent", () => {
+    const items: Array<NotificationMethodDisplayItem> =
+      NotificationMethodUtil.getDisplayItems(
+        reader({ userMicrosoftTeams: { microsoftTeamsUserId: "29:1abc" } }),
+      );
+
+    expect(items).toEqual([{ title: "Microsoft Teams", value: "29:1abc" }]);
+  });
+
   test("ignores a relation whose value is not an object", () => {
     expect(
       NotificationMethodUtil.getDisplayItems(
@@ -306,12 +396,14 @@ describe("NotificationMethodUtil.getDisplayItems", () => {
         reader({
           userPush: { deviceName: "Pixel" },
           userEmail: { email: "jane@example.com" },
+          userSlack: { slackUserName: "alice" },
           userWebhook: { name: "Hook" },
         }),
       );
 
     expect(items).toEqual([
       { title: "Email", value: "jane@example.com" },
+      { title: "Slack", value: "alice" },
       { title: "Webhook", value: "Hook" },
       { title: "Push", value: "Pixel" },
     ]);
@@ -370,6 +462,32 @@ describe("NotificationMethodUtil.getLabel", () => {
     );
   });
 
+  test("labels a Slack method by user name, then member id, then Unknown Account", () => {
+    expect(NotificationMethodUtil.getLabel(slack(ID.a, "alice"))).toBe(
+      "Slack: alice",
+    );
+    expect(
+      NotificationMethodUtil.getLabel(slack(ID.b, undefined, "U0123ABCD")),
+    ).toBe("Slack: U0123ABCD");
+    expect(NotificationMethodUtil.getLabel(slack(ID.c))).toBe(
+      "Slack: Unknown Account",
+    );
+  });
+
+  test("labels a Teams method by user name, then user id, then Unknown Account", () => {
+    expect(
+      NotificationMethodUtil.getLabel(microsoftTeams(ID.a, "Alice Example")),
+    ).toBe("Microsoft Teams: Alice Example");
+    expect(
+      NotificationMethodUtil.getLabel(
+        microsoftTeams(ID.b, undefined, "29:1abc"),
+      ),
+    ).toBe("Microsoft Teams: 29:1abc");
+    expect(NotificationMethodUtil.getLabel(microsoftTeams(ID.c))).toBe(
+      "Microsoft Teams: Unknown Account",
+    );
+  });
+
   test("labels call, sms, whatsapp with the phone number and their prefix", () => {
     expect(NotificationMethodUtil.getLabel(call(ID.a, "+15555550100"))).toBe(
       "Call: +15555550100",
@@ -418,6 +536,8 @@ describe("NotificationMethodUtil.getDropdownOptions", () => {
       userPush: [push(ID.d, "Pixel")],
       userWhatsApps: [whatsApp(ID.e, "+15555550102")],
       userTelegrams: [telegram(ID.f, "@jane")],
+      userSlacks: [slack(ID.h, "alice")],
+      userMicrosoftTeamsAccounts: [microsoftTeams(ID.i, "Alice Example")],
       userWebhooks: [webhook(ID.g, "Hook")],
     };
 
@@ -434,6 +554,8 @@ describe("NotificationMethodUtil.getDropdownOptions", () => {
       "Push: Pixel",
       "WhatsApp: +15555550102",
       "Telegram: @jane",
+      "Slack: alice",
+      "Microsoft Teams: Alice Example",
       "Webhook: Hook",
     ]);
   });
@@ -465,6 +587,8 @@ describe("NotificationMethodUtil.setSelectedMethodOnRule", () => {
       userPush: [push(ID.d, "Pixel")],
       userWhatsApps: [whatsApp(ID.e, "+15555550102")],
       userTelegrams: [telegram(ID.f, "@jane")],
+      userSlacks: [slack(ID.h, "alice")],
+      userMicrosoftTeamsAccounts: [microsoftTeams(ID.i, "Alice Example")],
       userWebhooks: [webhook(ID.g, "Hook")],
     };
   }
@@ -489,6 +613,8 @@ describe("NotificationMethodUtil.setSelectedMethodOnRule", () => {
     expect(rule.userPushId).toBeUndefined();
     expect(rule.userWhatsAppId).toBeUndefined();
     expect(rule.userTelegramId).toBeUndefined();
+    expect(rule.userSlackId).toBeUndefined();
+    expect(rule.userMicrosoftTeamsId).toBeUndefined();
   });
 
   test("maps each method type to its own foreign key", () => {
@@ -499,6 +625,8 @@ describe("NotificationMethodUtil.setSelectedMethodOnRule", () => {
       { id: ID.d, key: "userPushId" },
       { id: ID.e, key: "userWhatsAppId" },
       { id: ID.f, key: "userTelegramId" },
+      { id: ID.h, key: "userSlackId" },
+      { id: ID.i, key: "userMicrosoftTeamsId" },
       { id: ID.g, key: "userWebhookId" },
     ];