@oneuptime/common 13.0.7 → 14.0.0

package/Tests/App/Dashboard/EscalationRuleReadiness.test.tsx

@@ -1,5 +1,12 @@
 import "@testing-library/jest-dom";
-import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
 import {
   cleanup,
   fireEvent,
@@ -93,6 +100,25 @@ jest.mock("react-i18next", () => {
   };
 });
 
+/*
+ * axios is a pass-through spy: every call still goes to the real axios, so
+ * nothing else in this file behaves differently. Only the lapsed-session
+ * regression below scripts it, to drive the REAL browser client (not the mock
+ * above) through a 401, a refresh and a replay.
+ */
+jest.mock("axios", () => {
+  const actualAxios: (...args: Array<unknown>) => unknown = jest.requireActual(
+    "axios",
+  ) as (...args: Array<unknown>) => unknown;
+
+  return Object.assign(
+    jest.fn((...args: Array<unknown>): unknown => {
+      return actualAxios(...args);
+    }),
+    actualAxios,
+  );
+});
+
 import EscalationRules from "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/EscalationRule/EscalationRules";
 import {
   ResponderGroupRef,
@@ -125,9 +151,24 @@ import {
   parseReadinessSummary,
 } from "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/Readiness/ReadinessTypes";
 import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPMethod from "../../../Types/API/HTTPMethod";
 import HTTPResponse from "../../../Types/API/HTTPResponse";
+import Route from "../../../Types/API/Route";
+import URL from "../../../Types/API/URL";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
+import { APP_API_URL, IDENTITY_URL } from "../../../UI/Config";
+import type RealBaseAPI from "../../../UI/Utils/API/API";
+import Navigation from "../../../UI/Utils/Navigation";
+import User from "../../../UI/Utils/User";
+import FakeAxiosServer, {
+  FakeTransport,
+  SentRequest,
+} from "../../UI/Utils/API/FakeAxiosServer";
+import axios from "axios";
+import fs from "fs";
+import type { SpyInstance } from "jest-mock";
+import path from "path";
 
 const USER_ALEX: string = "aaaaaaaa-1111-4111-8111-111111111111";
 const USER_SAM: string = "bbbbbbbb-2222-4222-8222-222222222222";
@@ -1624,6 +1665,240 @@ describe("Sending the reminder", () => {
   });
 });
 
+/*
+ * ---------------------------------------------------------------------------
+ * THE REMINDER AFTER THE SESSION LAPSED
+ * ---------------------------------------------------------------------------
+ *
+ * The customer's report, reproduced. The Dashboard was left open for more than
+ * fifteen minutes, so the browser had already dropped the access-token cookie
+ * (its maxAge is the JWT's lifetime) when "Send setup reminder" was pressed.
+ * The request reached the server with no credentials, and the reminder came
+ * back "You are not authorized to access this project's data." - a 422, which
+ * the browser client has no reason to treat as a lapsed session, so it never
+ * refreshed and the reminder was reported as failed.
+ *
+ * The server now answers a request with no credentials 401, and the client
+ * refreshes on a 401 and replays. These cases run requestSetupReminders
+ * through the REAL browser client rather than the API mock the rest of this
+ * file uses: the mock's post is pointed at the actual BaseAPI.post, and axios
+ * underneath it is scripted like a server.
+ */
+describe("Sending the reminder after the session lapsed", () => {
+  const SEND_URL: string = URL.fromString(APP_API_URL.toString())
+    .addRoute("/on-call-readiness/send-setup-reminder")
+    .toString();
+
+  const REFRESH_URL: string = URL.fromString(IDENTITY_URL.toString())
+    .addRoute("/refresh-token")
+    .toString();
+
+  const NO_CREDENTIALS_BODY: JSONObject = {
+    message: "Authentication required. Please log in to access this resource.",
+  };
+
+  const realBaseAPI: typeof RealBaseAPI = (
+    jest.requireActual("../../../UI/Utils/API/API") as {
+      default: typeof RealBaseAPI;
+    }
+  ).default;
+
+  const mockedAxios: FakeTransport = axios as unknown as FakeTransport;
+
+  let server: FakeAxiosServer;
+  let logoutSpy: SpyInstance<typeof User.logout>;
+  let navigateSpy: SpyInstance<typeof Navigation.navigate>;
+  let currentRouteSpy: SpyInstance<typeof Navigation.getCurrentRoute>;
+
+  beforeEach(() => {
+    server = new FakeAxiosServer(mockedAxios);
+
+    getCommonHeadersMock.mockReturnValue({ tenantid: PROJECT_ID.toString() });
+
+    postMock.mockImplementation((...args: Array<any>): Promise<unknown> => {
+      return realBaseAPI.post(args[0]);
+    });
+
+    logoutSpy = jest.spyOn(User, "logout").mockImplementation((): void => {});
+
+    navigateSpy = jest
+      .spyOn(Navigation, "navigate")
+      .mockImplementation((): void => {});
+
+    currentRouteSpy = jest
+      .spyOn(Navigation, "getCurrentRoute")
+      .mockReturnValue(
+        new Route(`/dashboard/${PROJECT_ID.toString()}/on-call-duty`),
+      );
+  });
+
+  afterEach(() => {
+    logoutSpy.mockRestore();
+    navigateSpy.mockRestore();
+    currentRouteSpy.mockRestore();
+
+    // Back to the pass-through the rest of this file runs on.
+    const actualAxios: (...args: Array<unknown>) => unknown =
+      jest.requireActual("axios") as (...args: Array<unknown>) => unknown;
+
+    mockedAxios.mockImplementation(((...args: Array<unknown>): unknown => {
+      return actualAxios(...args);
+    }) as never);
+  });
+
+  type SentFunction = () => Array<string>;
+
+  const sentOnTheWire: SentFunction = (): Array<string> => {
+    return server.sent.map((request: SentRequest): string => {
+      return `${request.method.toUpperCase()} ${request.url}`;
+    });
+  };
+
+  test("a reminder refused 401 is refreshed, replayed, and reported as SENT", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+        {
+          status: 200,
+          data: {
+            sentCount: 1,
+            results: [
+              { userId: USER_ALEX, outcome: "Sent", message: "Emailed." },
+            ],
+          },
+        },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 200 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    // Not the "failed" / "not authorized" state from the customer's screenshot.
+    expect(statuses).toEqual({
+      [USER_ALEX]: { state: "sent", message: "Emailed." },
+    });
+
+    expect(sentOnTheWire()).toEqual([
+      `POST ${SEND_URL}`,
+      `POST ${REFRESH_URL}`,
+      `POST ${SEND_URL}`,
+    ]);
+
+    // The replay is the same reminder, for the same project, sent once more.
+    const replay: SentRequest = server.sent[2]!;
+
+    expect(replay.data).toEqual({ userIds: [USER_ALEX] });
+    expect(replay.data).toEqual(server.sent[0]!.data);
+    expect(replay.headers["tenantid"]).toBe(PROJECT_ID.toString());
+
+    // The lapse is invisible: nobody is logged out, nothing navigates.
+    expect(logoutSpy).not.toHaveBeenCalled();
+    expect(navigateSpy).not.toHaveBeenCalled();
+  });
+
+  test("a batch refused 401 is replayed as one batch, and each person is reported", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+        {
+          status: 200,
+          data: {
+            sentCount: 1,
+            results: [
+              { userId: USER_ALEX, outcome: "Sent", message: "Emailed." },
+              {
+                userId: USER_SAM,
+                outcome: "SkippedThrottled",
+                message: "Already reminded in the last 24 hours.",
+              },
+            ],
+          },
+        },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 200 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+      USER_SAM,
+    ]);
+
+    expect(statuses[USER_ALEX]).toEqual({ state: "sent", message: "Emailed." });
+    expect(statuses[USER_SAM]).toEqual({
+      state: "skipped",
+      message: "Already reminded in the last 24 hours.",
+    });
+    expect(server.requestsTo(HTTPMethod.POST, REFRESH_URL)).toHaveLength(1);
+    expect(server.requestsTo(HTTPMethod.POST, SEND_URL)).toHaveLength(2);
+  });
+
+  /*
+   * The symptom itself, kept as a contrast: had the server kept answering 422
+   * for a request with no credentials, the client could not have told it from
+   * a real permission refusal, and correctly would not have refreshed. The
+   * reminder stays failed. This is why the fix is a 401 on the server and not
+   * a wider net on the client.
+   */
+  test("the old 422 answer is terminal: no refresh, no replay, reported as failed", async () => {
+    server.on(HTTPMethod.POST, SEND_URL, [
+      {
+        status: 422,
+        data: {
+          message: "You are not authorized to access this project's data.",
+        },
+      },
+    ]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    expect(statuses[USER_ALEX]!.state).toBe("failed");
+    expect(sentOnTheWire()).toEqual([`POST ${SEND_URL}`]);
+    expect(logoutSpy).not.toHaveBeenCalled();
+  });
+
+  test("a session that cannot be refreshed reports the reminder as not sent and goes to login", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 401 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    // A 401 is refused before any mail is sent, so "not sent" is certain.
+    expect(statuses[USER_ALEX]!.state).toBe("failed");
+    // Never replayed: the reminder was not sent twice behind the reader's back.
+    expect(server.requestsTo(HTTPMethod.POST, SEND_URL)).toHaveLength(1);
+    expect(logoutSpy).toHaveBeenCalled();
+    expect(navigateSpy).toHaveBeenCalledWith(new Route("/accounts/login"), {
+      forceNavigate: true,
+    });
+  });
+
+  /*
+   * The mock at the top of this file stands in for the refresh-aware client,
+   * so every other test here would pass just the same if the reminder were
+   * sent through the bare Common/Utils/API - which has no refresh at all. Pin
+   * the import itself.
+   */
+  test("the reminder is sent through the refresh-aware client", () => {
+    const source: string = fs.readFileSync(
+      path.join(
+        __dirname,
+        "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/EscalationRule/EscalationRuleReadiness.tsx",
+      ),
+      "utf8",
+    );
+
+    expect(source).toMatch(/import API from "Common\/UI\/Utils\/API\/API";/);
+    expect(source).not.toMatch(/from "Common\/Utils\/API"/);
+  });
+});
+
 /*
  * ---------------------------------------------------------------------------
  * EXPANDING TEAMS AND SCHEDULES

package/Tests/App/Dashboard/IdentityEnterpriseShells.test.tsx

@@ -0,0 +1,319 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { cleanup, render, screen } from "@testing-library/react";
+import React, { FunctionComponent, ReactElement } from "react";
+
+/*
+ * The six identity pages the Dashboard routes to - Settings > SSO / OIDC /
+ * SCIM and Status page > SSO / OIDC / SCIM - are Enterprise Edition screens
+ * (ee/Dashboard/SSO). Core keeps a shell at each page's original path, so the
+ * route files and the lazy page map never changed: the shell renders the
+ * Enterprise screen when the project may use the feature AND the bundle
+ * includes it, and the upsell card the page used to show otherwise.
+ *
+ * "@oneuptime/ee-dashboard" is replaced by a plugin object the tests fill in,
+ * standing in for the Enterprise bundle; left empty it is the Community
+ * bundle. Billing, the edition and the plan are pinned in every test: CI's
+ * config.env sets BILLING_ENABLED=true.
+ */
+
+let billingEnabledForTest: boolean = false;
+let enterpriseEditionForTest: boolean = false;
+let currentPlanForTest: string | null = null;
+
+const CLOUD_PLAN_ENV: Record<string, string> = {
+  SUBSCRIPTION_PLAN_BASIC: "Free,priceMonthlyId1,priceYearlyId1,0,0,1,0",
+  SUBSCRIPTION_PLAN_GROWTH: "Growth,priceMonthlyId2,priceYearlyId2,0,0,2,14",
+  SUBSCRIPTION_PLAN_SCALE: "Scale,priceMonthlyId3,priceYearlyId3,0,0,3,0",
+  SUBSCRIPTION_PLAN_ENTERPRISE:
+    "Enterprise,priceMonthlyId4,priceYearlyId4,-1,-1,4,14",
+};
+
+jest.mock("../../../UI/Config", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "../../../UI/Config",
+  ) as Record<string, unknown>;
+
+  const mocked: Record<string, unknown> = { ...actual };
+
+  Object.defineProperty(mocked, "BILLING_ENABLED", {
+    get: (): boolean => {
+      return billingEnabledForTest;
+    },
+  });
+
+  Object.defineProperty(mocked, "IS_ENTERPRISE_EDITION", {
+    get: (): boolean => {
+      return enterpriseEditionForTest;
+    },
+  });
+
+  mocked["getAllEnvVars"] = (): Record<string, string> => {
+    return CLOUD_PLAN_ENV;
+  };
+
+  return mocked;
+});
+
+jest.mock("../../../UI/Utils/Project", () => {
+  const actual: Record<string, any> = jest.requireActual(
+    "../../../UI/Utils/Project",
+  ) as Record<string, any>;
+
+  return {
+    __esModule: true,
+    ...actual,
+    default: {
+      ...actual["default"],
+      getCurrentPlan: (): string | null => {
+        return currentPlanForTest;
+      },
+    },
+  };
+});
+
+/*
+ * What getDashboardPlugins() returns in this suite. The shells read it on
+ * every render, so each test fills it in after the shells were imported.
+ */
+const mockEnterprisePlugins: Record<string, unknown> = {};
+
+jest.mock("@oneuptime/ee-dashboard", () => {
+  return { __esModule: true, default: mockEnterprisePlugins };
+});
+
+import SettingsOIDC from "../../../../App/FeatureSet/Dashboard/src/Pages/Settings/OIDC";
+import SettingsSCIM from "../../../../App/FeatureSet/Dashboard/src/Pages/Settings/SCIM";
+import SettingsSSO from "../../../../App/FeatureSet/Dashboard/src/Pages/Settings/SSO";
+import StatusPageViewOIDC from "../../../../App/FeatureSet/Dashboard/src/Pages/StatusPages/View/OIDC";
+import StatusPageViewSCIM from "../../../../App/FeatureSet/Dashboard/src/Pages/StatusPages/View/SCIM";
+import StatusPageViewSSO from "../../../../App/FeatureSet/Dashboard/src/Pages/StatusPages/View/SSO";
+import PageComponentProps from "../../../../App/FeatureSet/Dashboard/src/Pages/PageComponentProps";
+import { DashboardEnterprisePluginKey } from "../../../../App/FeatureSet/Dashboard/src/Enterprise/EnterprisePlugins";
+import Route from "../../../Types/API/Route";
+import { PlanType } from "../../../Types/Billing/SubscriptionPlan";
+
+interface ShellCase {
+  name: string;
+  Shell: FunctionComponent<PageComponentProps>;
+  pluginKey: DashboardEnterprisePluginKey;
+  // The upsell copy the page showed before it moved to ee/.
+  upsellTitle: string;
+  featureName: string;
+}
+
+const SHELLS: Array<ShellCase> = [
+  {
+    name: "Settings > SSO",
+    Shell: SettingsSSO,
+    pluginKey: "SettingsSSO",
+    upsellTitle: "Single Sign On (SSO)",
+    featureName: "SAML Single Sign On",
+  },
+  {
+    name: "Settings > OIDC",
+    Shell: SettingsOIDC,
+    pluginKey: "SettingsOIDC",
+    upsellTitle: "OpenID Connect (OIDC)",
+    featureName: "OIDC Single Sign On",
+  },
+  {
+    name: "Settings > SCIM",
+    Shell: SettingsSCIM,
+    pluginKey: "SettingsSCIM",
+    upsellTitle: "SCIM User Provisioning",
+    featureName: "SCIM User Provisioning",
+  },
+  {
+    name: "Status page > SSO",
+    Shell: StatusPageViewSSO,
+    pluginKey: "StatusPageSSO",
+    upsellTitle: "Status Page SSO",
+    featureName: "Status Page SAML SSO",
+  },
+  {
+    name: "Status page > OIDC",
+    Shell: StatusPageViewOIDC,
+    pluginKey: "StatusPageOIDC",
+    upsellTitle: "Status Page OIDC",
+    featureName: "Status Page OIDC SSO",
+  },
+  {
+    name: "Status page > SCIM",
+    Shell: StatusPageViewSCIM,
+    pluginKey: "StatusPageSCIM",
+    upsellTitle: "Status Page SCIM",
+    featureName: "Status Page SCIM Provisioning",
+  },
+];
+
+const PAGE_PROPS: PageComponentProps = {
+  pageRoute: new Route("/dashboard/project-id/settings/identity"),
+  currentProject: null,
+  hasPaymentMethod: true,
+};
+
+/*
+ * Stands in for an Enterprise screen: says which plugin key it is and echoes
+ * the props the shell handed it.
+ */
+const makeFakeScreen: (
+  pluginKey: string,
+) => FunctionComponent<PageComponentProps> = (
+  pluginKey: string,
+): FunctionComponent<PageComponentProps> => {
+  const FakeScreen: FunctionComponent<PageComponentProps> = (
+    props: PageComponentProps,
+  ): ReactElement => {
+    return (
+      <div data-testid="enterprise-screen">
+        {pluginKey}|{props.pageRoute.toString()}|
+        {String(props.hasPaymentMethod)}
+      </div>
+    );
+  };
+
+  return FakeScreen;
+};
+
+const installPlugins: (keys: Array<DashboardEnterprisePluginKey>) => void = (
+  keys: Array<DashboardEnterprisePluginKey>,
+): void => {
+  for (const key of keys) {
+    mockEnterprisePlugins[key] = makeFakeScreen(key);
+  }
+};
+
+const clearPlugins: () => void = (): void => {
+  for (const key of Object.keys(mockEnterprisePlugins)) {
+    delete mockEnterprisePlugins[key];
+  }
+};
+
+beforeEach(() => {
+  billingEnabledForTest = false;
+  enterpriseEditionForTest = false;
+  currentPlanForTest = null;
+  clearPlugins();
+});
+
+afterEach(() => {
+  cleanup();
+  clearPlugins();
+});
+
+describe.each(SHELLS)("$name shell", (shell: ShellCase) => {
+  test("Community Edition: the upsell card, even when a plugin is present", () => {
+    installPlugins([shell.pluginKey]);
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getAllByText(shell.featureName).length).toBeGreaterThan(0);
+    expect(screen.getAllByText(shell.upsellTitle).length).toBeGreaterThan(0);
+    expect(
+      screen.getAllByText("Learn about Enterprise Edition").length,
+    ).toBeGreaterThan(0);
+    expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+  });
+
+  test("Enterprise Edition: the Enterprise screen, with the page props", () => {
+    enterpriseEditionForTest = true;
+    installPlugins([shell.pluginKey]);
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getByTestId("enterprise-screen")).toHaveTextContent(
+      `${shell.pluginKey}|/dashboard/project-id/settings/identity|true`,
+    );
+    expect(screen.queryByText(shell.featureName)).not.toBeInTheDocument();
+  });
+
+  test("Enterprise Edition on a Community bundle: the upsell, pointing at the edition", () => {
+    enterpriseEditionForTest = true;
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getAllByText(shell.featureName).length).toBeGreaterThan(0);
+    expect(
+      screen.getAllByText("Learn about Enterprise Edition").length,
+    ).toBeGreaterThan(0);
+    expect(screen.queryByText("Upgrade to Scale")).not.toBeInTheDocument();
+  });
+
+  test("OneUptime Cloud below Scale: the plan upsell, never the screen", () => {
+    billingEnabledForTest = true;
+    enterpriseEditionForTest = true;
+    currentPlanForTest = PlanType.Growth;
+    installPlugins([shell.pluginKey]);
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getAllByText("Upgrade to Scale").length).toBeGreaterThan(0);
+    expect(screen.getAllByText(shell.featureName).length).toBeGreaterThan(0);
+    expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+  });
+
+  test.each([PlanType.Scale, PlanType.Enterprise])(
+    "OneUptime Cloud on %s: the Enterprise screen",
+    (plan: PlanType) => {
+      billingEnabledForTest = true;
+      enterpriseEditionForTest = true;
+      currentPlanForTest = plan;
+      installPlugins([shell.pluginKey]);
+
+      render(<shell.Shell {...PAGE_PROPS} />);
+
+      expect(screen.getByTestId("enterprise-screen")).toHaveTextContent(
+        shell.pluginKey,
+      );
+    },
+  );
+
+  test("renders its own plugin key when every identity screen is present", () => {
+    enterpriseEditionForTest = true;
+    installPlugins(
+      SHELLS.map((each: ShellCase) => {
+        return each.pluginKey;
+      }),
+    );
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getByTestId("enterprise-screen")).toHaveTextContent(
+      `${shell.pluginKey}|`,
+    );
+  });
+
+  test("ignores other features' screens", () => {
+    enterpriseEditionForTest = true;
+    installPlugins(
+      SHELLS.map((each: ShellCase) => {
+        return each.pluginKey;
+      }).filter((key: DashboardEnterprisePluginKey) => {
+        return key !== shell.pluginKey;
+      }),
+    );
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+    expect(screen.getAllByText(shell.featureName).length).toBeGreaterThan(0);
+  });
+});
+
+describe("identity shells", () => {
+  test("each reads a different plugin key", () => {
+    const keys: Array<string> = SHELLS.map((shell: ShellCase) => {
+      return shell.pluginKey;
+    });
+
+    expect(new Set(keys).size).toBe(SHELLS.length);
+  });
+});

package/Tests/App/Dashboard/OnCallCalendarFeedSideMenus.test.tsx

@@ -115,11 +115,19 @@ describe("On-Call Duty side menu - Calendar Feeds item", () => {
       return link.title;
     });
 
+    /*
+     * The two views of the schedules come first - the list and the timeline
+     * of all of them - and the feeds that export them follow directly.
+     */
     expect(titles).toContain("On-Call Schedules");
+    expect(titles).toContain("Schedule Timeline");
     expect(titles).toContain("Calendar Feeds");
-    expect(titles.indexOf("Calendar Feeds")).toBe(
+    expect(titles.indexOf("Schedule Timeline")).toBe(
       titles.indexOf("On-Call Schedules") + 1,
     );
+    expect(titles.indexOf("Calendar Feeds")).toBe(
+      titles.indexOf("Schedule Timeline") + 1,
+    );
 
     const calendarFeeds: MenuLink | undefined = links.find(
       (link: MenuLink): boolean => {