@oneuptime/common 13.0.0 → 13.0.3

package/Tests/UI/Components/useFeedItems.test.tsx

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import "@testing-library/jest-dom";
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import * as React from "react";
+
+/*
+ * Start next to the API ceiling so this regression reaches the boundary in a
+ * single click instead of issuing a thousand requests. The production values
+ * remain 10 and 10,000; only this test module's default page size is enlarged.
+ */
+jest.mock("../../../Types/Database/LimitMax", () => {
+  return {
+    __esModule: true,
+    default: 10000,
+    DEFAULT_LIMIT: 9995,
+    LIMIT_INFINITY: 999999999,
+    LIMIT_PER_PROJECT: 10000,
+  };
+});
+
+import { Blue500 } from "../../../Types/BrandColors";
+import IconProp from "../../../Types/Icon/IconProp";
+import useFeedItems, {
+  FeedPage,
+} from "../../../UI/Components/Feed/useFeedItems";
+import { FeedItemProps } from "../../../UI/Components/Feed/FeedItem";
+
+interface TestFeedModel {
+  id: string;
+}
+
+interface HarnessProps {
+  getItems: (limit: number) => Promise<FeedPage<TestFeedModel>>;
+}
+
+const Harness: React.FunctionComponent<HarnessProps> = (
+  props: HarnessProps,
+): React.ReactElement => {
+  const { feedItems, hasMore, isLoadingMore, loadMore } =
+    useFeedItems<TestFeedModel>({
+      resourceKey: "resource",
+      getItems: props.getItems,
+      mapItems: (items: Array<TestFeedModel>): Array<FeedItemProps> => {
+        return items.map((item: TestFeedModel): FeedItemProps => {
+          return {
+            key: item.id,
+            textInMarkdown: item.id,
+            itemDateTime: new Date("2026-09-11T12:00:00.000Z"),
+            icon: IconProp.Activity,
+            color: Blue500,
+          };
+        });
+      },
+    });
+
+  return (
+    <div>
+      {feedItems.map((item: FeedItemProps): React.ReactElement => {
+        return <span key={item.key}>{item.textInMarkdown}</span>;
+      })}
+      {hasMore && (
+        <button disabled={isLoadingMore} onClick={loadMore}>
+          More
+        </button>
+      )}
+    </div>
+  );
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("useFeedItems request limit", () => {
+  test("stops at the API's 10,000-row ceiling", async () => {
+    const requestedLimits: Array<number> = [];
+    const getItems: HarnessProps["getItems"] = async (
+      limit: number,
+    ): Promise<FeedPage<TestFeedModel>> => {
+      requestedLimits.push(limit);
+      return {
+        data: [{ id: `limit-${limit}` }],
+        count: 10001,
+      };
+    };
+
+    render(<Harness getItems={getItems} />);
+
+    const moreButton: HTMLElement = await screen.findByRole("button", {
+      name: "More",
+    });
+    expect(requestedLimits).toEqual([9995]);
+    fireEvent.click(moreButton);
+
+    await waitFor(() => {
+      expect(requestedLimits).toEqual([9995, 10000]);
+      expect(screen.getByText("limit-10000")).toBeVisible();
+      expect(screen.queryByRole("button", { name: "More" })).toBeNull();
+    });
+  });
+});

package/Tests/UI/MicrosoftTeams/MicrosoftTeamsMessagingEndpointGuidance.test.tsx

@@ -19,8 +19,8 @@ import MicrosoftTeamsIntegrationDocumentation from "../../../../App/FeatureSet/D
  * cheapest check an admin runs next — opening the messaging endpoint in a
  * browser — used to return "Page not found". So the docs are what has to
  * carry the diagnosis: the two directions are independent, a working alert
- * tests only one of them, and an empty Chats list is the confirmation rather
- * than a second unrelated bug.
+ * tests only one of them, and an empty Chats list calls for checking inbound
+ * delivery, authentication, and project mapping.
  *
  * These assertions are on prose because the failure was prose.
  */
@@ -174,20 +174,30 @@ describe("Self-hosted docs: the unreachable-endpoint troubleshooting section", (
     );
   });
 
-  test("states the single root cause up front", () => {
-    expect(section).toContain(
-      "**Azure Bot Service cannot reach your messaging endpoint.**",
+  test("identifies inbound delivery as a likely cause and names the checks up front", () => {
+    const introduction: string = section.trim().split("\n\n")[0]!;
+
+    expect(introduction).toContain("These symptoms often mean");
+    expect(introduction).toContain(
+      "**Azure Bot Service cannot deliver authenticated activities to your messaging endpoint**",
     );
-    expect(section).toContain("These are one failure, not two");
+    expect(introduction).toContain(
+      "Check routing, bot authentication, and project configuration",
+    );
+    expect(introduction).not.toContain("These are one failure, not two");
   });
 
   test("explains that a working alert card tests the opposite direction", () => {
     const lowered: string = section.toLowerCase();
 
     expect(lowered).toContain("oneuptime calls microsoft");
-    expect(lowered).toMatch(
-      /tells you nothing at all about the bot endpoint|working alert/,
+    expect(lowered).toContain(
+      "a working alert verifies that particular outbound send",
     );
+    expect(lowered).toContain(
+      "it does not verify every graph permission or the inbound bot endpoint",
+    );
+    expect(lowered).not.toContain("graph permissions are fine");
   });
 
   test("tabulates which paths need inbound access and which do not", () => {
@@ -216,11 +226,17 @@ describe("Self-hosted docs: the unreachable-endpoint troubleshooting section", (
     ).toBeGreaterThanOrEqual(3);
   });
 
-  test("explains why the empty Chats list confirms the diagnosis", () => {
+  test("explains what an empty Chats list means and what Refresh Chats reads", () => {
     const lowered: string = section.toLowerCase();
 
-    expect(lowered).toContain("refresh chats");
-    expect(lowered).toContain("application permissions");
+    expect(lowered).toContain("no chat has been recorded for that project");
+    expect(lowered).toContain(
+      "check incoming requests, authentication errors, and tenant/project mapping",
+    );
+    expect(lowered).toContain(
+      "**refresh chats** re-reads oneuptime's stored chats",
+    );
+    expect(lowered).not.toContain("no bot activity has ever been received");
   });
 
   test("names all three activities that register a chat, not just the install event", () => {
@@ -238,7 +254,7 @@ describe("Self-hosted docs: the unreachable-endpoint troubleshooting section", (
 
     expect(lowered).toContain("installed");
     expect(lowered).toContain("added to the conversation");
-    expect(lowered).toContain("any message sent to the bot");
+    expect(lowered).toContain("a message sent to the bot in that chat");
   });
 
   test("the inbound table describes chat registration as an activity, not an install event", () => {
@@ -257,6 +273,21 @@ describe("Self-hosted docs: the unreachable-endpoint troubleshooting section", (
     expect(section).toContain("grep 'POST /api/microsoft-bot/messages'");
   });
 
+  test("checks log coverage when POSTs are absent and processing errors when they arrive", () => {
+    const lowered: string = section.toLowerCase();
+
+    expect(lowered).toContain(
+      "if there are no post lines, confirm that the correct access log is recording requests",
+    );
+    expect(lowered).toContain(
+      "check the configured azure endpoint and the network path",
+    );
+    expect(lowered).toContain(
+      "if posts arrive, inspect their responses and oneuptime's authentication or project-mapping errors",
+    );
+    expect(lowered).not.toContain("nothing inside oneuptime is at fault");
+  });
+
   test("covers the certificate chain, with a command that checks it", () => {
     expect(section).toContain("publicly trusted certificate");
     expect(section).toContain("full chain");

package/Tests/UI/ReactDomBuild.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "@jest/globals";
+import childProcess from "child_process";
+import path from "path";
+
+const COMMON_ROOT: string = path.resolve(__dirname, "..", "..");
+
+interface RendererBuild {
+  rendererFiles: Array<string>;
+  clientFiles: Array<string>;
+  foreignRendererFiles: Array<string>;
+  outputBytes: number;
+}
+
+describe("frontend renderer deduplication", () => {
+  test.each(["production", "development"])(
+    "bundles one renderer for the entry point and shared portals in %s",
+    (environment: string) => {
+      /*
+       * Use a subprocess because esbuild requires Node's native Uint8Array.
+       * Separate physical installs reproduce the app/Common package layout;
+       * symlinking both to one install would hide the original duplication.
+       */
+      const result: RendererBuild = JSON.parse(
+        childProcess.execFileSync(
+          process.execPath,
+          [
+            "-e",
+            String.raw`
+              const fs = require("fs");
+              const os = require("os");
+              const path = require("path");
+              const esbuild = require("esbuild");
+              const { createConfig } = require("./UI/esbuild-config");
+              const reactDomRoot = path.dirname(require.resolve("react-dom/package.json"));
+              const root = fs.mkdtempSync(path.join(os.tmpdir(), "oneuptime-renderer-"));
+
+              async function run() {
+                try {
+                  for (const name of ["app", "shared"]) {
+                    const destination = path.join(root, name, "node_modules/react-dom");
+                    fs.cpSync(reactDomRoot, destination, { recursive: true });
+                  }
+
+                  const entry = path.join(root, "app/index.js");
+                  fs.writeFileSync(entry, [
+                    'import { createRoot } from "react-dom/client";',
+                    'export { createRoot };',
+                    'export { createPortal, flushSync } from "../shared/index.js";',
+                  ].join("\n"));
+                  fs.writeFileSync(path.join(root, "shared/index.js"),
+                    'export { createPortal, flushSync } from "react-dom";');
+
+                  const config = createConfig({
+                    serviceName: "Dashboard",
+                    publicPath: "/dashboard/dist/",
+                    entryPoint: entry,
+                    outdir: path.join(root, "dist"),
+                  });
+                  const built = await esbuild.build({
+                    ...config,
+                    nodePaths: [path.resolve("node_modules")],
+                    metafile: true,
+                    write: false,
+                    logLevel: "silent",
+                  });
+                  const inputs = Object.keys(built.metafile.inputs);
+                  const rendererFiles = inputs.filter((file) =>
+                    /react-dom[/\\]cjs[/\\]react-dom\.(production\.min|development)\.js$/.test(file));
+                  const clientFiles = inputs.filter((file) => /react-dom[/\\]client\.js$/.test(file));
+                  const foreignRendererFiles = inputs.filter((file) =>
+                    path.resolve(file).startsWith(root) && file.includes("react-dom"));
+                  console.log(JSON.stringify({
+                    rendererFiles,
+                    clientFiles,
+                    foreignRendererFiles,
+                    outputBytes: built.outputFiles.reduce((sum, file) => sum + file.contents.length, 0),
+                  }));
+                } finally {
+                  fs.rmSync(root, { recursive: true, force: true });
+                }
+              }
+              run().catch((error) => { console.error(error); process.exitCode = 1; });
+            `,
+          ],
+          {
+            cwd: COMMON_ROOT,
+            env: { ...process.env, NODE_ENV: environment },
+            encoding: "utf8",
+          },
+        ),
+      ) as RendererBuild;
+
+      expect(result.outputBytes).toBeGreaterThan(0);
+      expect(result.rendererFiles).toHaveLength(1);
+      expect(result.rendererFiles[0]).toContain(
+        environment === "production"
+          ? "react-dom.production.min.js"
+          : "react-dom.development.js",
+      );
+      expect(result.clientFiles).toHaveLength(1);
+      expect(result.foreignRendererFiles).toEqual([]);
+    },
+  );
+});

package/Tests/UI/ReactRouterSingletonBuild.test.ts

@@ -58,12 +58,22 @@ function renderSharedLink(nodeEnv: string): RenderResult {
 
   fs.copyFileSync(APP_LINK, path.join(root, "shared", "AppLink.tsx"));
   const entry: string = path.join(root, "public", "Entry.tsx");
+  /*
+   * The entry renders through react-dom/server.browser rather than the bare
+   * react-dom/server specifier. esbuild-config aliases "react-dom" to an
+   * absolute directory, and an esbuild alias rewrites subpaths too, so
+   * "react-dom/server" would become a plain file path and skip react-dom's
+   * exports map - landing on server.node.js, which imports "stream" and "util"
+   * and cannot resolve on the browser platform this config builds for.
+   * server.browser is the renderer that exports map picks for a browser build
+   * anyway, so this asks for it directly instead of relying on the alias.
+   */
   fs.writeFileSync(
     entry,
     `
       import React from "react";
       import { MemoryRouter } from "react-router-dom";
-      import { renderToStaticMarkup } from "react-dom/server";
+      import { renderToStaticMarkup } from "react-dom/server.browser";
       import AppLink from "../shared/AppLink";
 
       globalThis.routerFixtureMarkup = renderToStaticMarkup(