@antelopejs/dms 0.0.1

package/frontend-vue/tests/period-scope-first-fetch.test.ts

@@ -0,0 +1,276 @@
+// @vitest-environment jsdom
+/**
+ * A period-scoped card must issue exactly one request on mount, before any
+ * interaction — see AntelopeJS/dms#365. The failure mode is silent (the card
+ * renders an empty value and nothing throws), so only an assertion on the
+ * request count catches it, and only a run that covers both mount orders:
+ * the selector registers its scope during its own setup, which may run before
+ * or after the cards'.
+ */
+import {
+  computed,
+  createSSRApp,
+  defineAsyncComponent,
+  defineComponent,
+  h,
+  nextTick,
+  ref,
+} from "vue";
+import { renderToString } from "vue/server-renderer";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PeriodState } from "../layers/dms-core/app/composables/period/types";
+
+const requests: string[] = [];
+
+vi.stubGlobal("useAuthFetch", () => ({
+  $authFetch: async (url: string) => {
+    requests.push(url);
+    return { value: 1 };
+  },
+}));
+vi.stubGlobal("useI18n", () => ({
+  locale: ref("fr-FR"),
+  t: (key: string, fallback?: string) => fallback ?? key,
+}));
+vi.stubGlobal("useTranslation", () => ({
+  processI18n: (text: string) => text,
+}));
+vi.stubGlobal("useComponentEvent", () => ({}));
+vi.stubGlobal("useWatch", () => ({ state: ref({}) }));
+
+const { usePeriod } = await import(
+  "../layers/dms-core/app/composables/period/usePeriod"
+);
+const { registerPeriodScope } = await import(
+  "../layers/dms-core/app/composables/period/usePeriodScope"
+);
+const { useChartFetch } = await import(
+  "../layers/dms-ui/app/composables/chart/useChartFetch"
+);
+const KpiCard = (
+  await import("../layers/dms-ui/app/components/kpi/KpiCard.vue")
+).default;
+
+const SCOPE = "demo";
+const GRACE_MS = 250;
+// useChartFetch debounces every refresh past the first by 180ms; settle past
+// that, or a duplicate first fetch lands after the assertions and goes unseen.
+const SETTLE_MS = 300;
+
+/** Same registration shape as PeriodSelector.vue: usePeriod() in setup. */
+const Selector = defineComponent({
+  setup() {
+    const period = usePeriod({ defaultPreset: "last-7-days" });
+    registerPeriodScope(SCOPE, period.state);
+    return () => h("div", { class: "selector" }, period.state.value.key);
+  },
+});
+
+const Card = defineComponent({
+  props: {
+    url: { type: String, required: true },
+    scope: { type: String, default: SCOPE },
+  },
+  setup(props) {
+    const { isLoading } = useChartFetch<{ value: number }>({
+      fetchUrl: props.url,
+      periodScope: props.scope || undefined,
+    });
+    return () => h("div", { class: "card" }, String(isLoading.value));
+  },
+});
+
+const Passthrough = defineComponent({
+  setup:
+    (_, { slots }) =>
+    () =>
+      h("div", slots.default?.() ?? []),
+});
+const Skeleton = defineComponent({ setup: () => () => h("div", "SKELETON") });
+
+/** Defer a component's resolution to mimic a lazily chunked global. */
+function lazy(component: unknown, delayMs: number) {
+  return defineAsyncComponent(
+    () =>
+      new Promise((resolve) =>
+        setTimeout(() => resolve(component as never), delayMs),
+      ),
+  );
+}
+
+function page(selectorDelayMs: number, cardDelayMs: number) {
+  const LazySelector = lazy(Selector, selectorDelayMs);
+  const LazyCard = lazy(Card, cardDelayMs);
+  return defineComponent({
+    setup: () => () =>
+      h("main", [
+        h(LazySelector),
+        h(LazyCard, { url: "/api/metrics/kpi/a" }),
+        h(LazyCard, { url: "/api/metrics/kpi/b" }),
+      ]),
+  });
+}
+
+/**
+ * Every component resolved in the same flush, the selector's setup running
+ * after the cards'. This is the order measured in the running dashboard: the
+ * cards register their watcher with no scope, the selector registers one, the
+ * pre-flush watcher fires the first fetch, and only then does onMounted run.
+ */
+function sameFlushPage() {
+  return defineComponent({
+    setup: () => () =>
+      h("main", [
+        h(Card, { url: "/api/metrics/kpi/a" }),
+        h(Card, { url: "/api/metrics/kpi/b" }),
+        h(Selector),
+      ]),
+  });
+}
+
+const mounted: Array<{ unmount: () => void }> = [];
+
+async function ssrThenHydrate(
+  root: unknown,
+  components: Record<string, unknown> = {},
+) {
+  const html = await renderToString(
+    withComponents(createSSRApp(root as never), components),
+  );
+  const container = document.createElement("div");
+  container.innerHTML = html;
+  document.body.appendChild(container);
+  const app = withComponents(createSSRApp(root as never), components);
+  app.mount(container);
+  mounted.push(app);
+  const deadline = Date.now() + SETTLE_MS;
+  while (Date.now() < deadline) {
+    await nextTick();
+    await new Promise((resolve) => setTimeout(resolve, 12));
+  }
+  return { container, html };
+}
+
+function withComponents<
+  A extends { component: (n: string, c: never) => unknown },
+>(app: A, components: Record<string, unknown>): A {
+  for (const [name, component] of Object.entries(components)) {
+    app.component(name, component as never);
+  }
+  return app;
+}
+
+beforeEach(() => {
+  requests.length = 0;
+});
+afterEach(() => {
+  // Unmount, don't just drop the DOM: a live card keeps its watcher and its
+  // debounce timer, and would fetch into the next test's request log.
+  for (const app of mounted.splice(0)) app.unmount();
+  document.body.innerHTML = "";
+});
+
+describe("period-scoped cards on first paint", () => {
+  it.each([
+    ["selector chunk first", 0, 8],
+    ["card chunks first", 8, 0],
+    ["same tick", 0, 0],
+  ])(
+    "issues exactly one request per card (%s)",
+    async (_label, selectorDelay, cardDelay) => {
+      await ssrThenHydrate(page(selectorDelay, cardDelay));
+
+      expect(requests).toHaveLength(2);
+      expect(new Set(requests).size).toBe(2);
+      for (const url of requests) {
+        expect(url).toMatch(/[?&]from=/);
+        expect(url).toMatch(/[?&]to=/);
+        expect(url).toMatch(/[?&]preset=last-7-days/);
+      }
+    },
+  );
+
+  it("does not fetch twice when the scope registers between setup and mount", async () => {
+    await ssrThenHydrate(sameFlushPage());
+
+    expect(requests).toHaveLength(2);
+    expect(new Set(requests).size).toBe(2);
+  });
+
+  it("fetches a pending period after its scope disappears and returns", async () => {
+    const scope = "returning-scope";
+    const state = ref<PeriodState>({
+      key: "initial",
+      preset: "custom",
+      comparison: "none",
+      range: { from: new Date("2026-01-01"), to: new Date("2026-02-01") },
+      compareRange: null,
+    });
+    const period = computed(() => state.value);
+    let unregister = registerPeriodScope(scope, period);
+    try {
+      await ssrThenHydrate(
+        defineComponent({
+          setup: () => () => h(Card, { url: "/api/metrics/returning", scope }),
+        }),
+      );
+      expect(requests).toHaveLength(1);
+      state.value = {
+        ...state.value,
+        key: "next",
+        range: { from: new Date("2026-02-01"), to: new Date("2026-03-01") },
+      };
+      await nextTick();
+      unregister();
+      await nextTick();
+      unregister = registerPeriodScope(scope, period);
+      await nextTick();
+      await new Promise((resolve) => setTimeout(resolve, SETTLE_MS));
+      expect(requests).toHaveLength(2);
+      const query = new URL(requests[1]!, "https://example.test").searchParams;
+      expect(query.get("from")).toBe("2026-02-01T00:00:00.000Z");
+      expect(query.get("to")).toBe("2026-03-01T00:00:00.000Z");
+    } finally {
+      unregister();
+    }
+  });
+
+  it("shows a loading placeholder server-side rather than an empty value", async () => {
+    const app = createSSRApp({
+      render: () =>
+        h(KpiCard as never, {
+          title: "Revenue",
+          componentId: "card",
+          pageId: "page",
+          fetchUrl: "/api/metrics/kpi/revenue",
+          periodScope: SCOPE,
+        }),
+    });
+    withComponents(app, {
+      DmsCard: Passthrough,
+      UIcon: Passthrough,
+      USkeleton: Skeleton,
+      DmsTrendBadge: Passthrough,
+      DmsSparkline: Passthrough,
+      ClientOnly: Passthrough,
+    });
+
+    const html = await renderToString(app);
+
+    expect(html).toContain("SKELETON");
+    expect(html).not.toContain("<span>0</span>");
+  });
+
+  it("stops loading when no selector ever registers the scope", async () => {
+    const Orphan = defineComponent({
+      setup: () => () =>
+        h(Card, { url: "/api/metrics/kpi/orphan", scope: "never-registered" }),
+    });
+    const { container } = await ssrThenHydrate(Orphan);
+    await new Promise((resolve) => setTimeout(resolve, GRACE_MS + 50));
+    await nextTick();
+
+    expect(requests).toHaveLength(0);
+    expect(container.querySelector(".card")?.textContent).toBe("false");
+  });
+});

package/frontend-vue/tests/post-login-redirect.test.ts

@@ -0,0 +1,87 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { usePostLoginRedirect } from "../layers/dms-auth/app/composables/usePostLoginRedirect";
+
+const refreshUser = vi.fn();
+const refreshLayout = vi.fn();
+const addCurrentAccount = vi.fn();
+const setLocale = vi.fn();
+const navigateTo = vi.fn();
+
+beforeEach(() => {
+  vi.stubGlobal("useDmsApp", () => ({ $i18n: { setLocale } }));
+  vi.stubGlobal("useUserSession", () => ({
+    fetch: refreshUser,
+    user: { value: { language: "fr" } },
+  }));
+  vi.stubGlobal("useMultiAccount", () => ({ addCurrentAccount }));
+  vi.stubGlobal("useSiteLayout", () => ({ refresh: refreshLayout }));
+  vi.stubGlobal("useHomepage", () => "/");
+  vi.stubGlobal("navigateDms", navigateTo);
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.resetAllMocks();
+});
+
+describe("post-login redirect", () => {
+  it("resolves the onboarding destination only after session and permissions refresh", async () => {
+    const resolveDestination = vi.fn(() => {
+      expect(refreshUser).toHaveBeenCalledOnce();
+      expect(addCurrentAccount).toHaveBeenCalledOnce();
+      expect(refreshLayout).toHaveBeenCalledOnce();
+      expect(setLocale).toHaveBeenCalledWith("fr");
+      return "/dashboard";
+    });
+
+    await usePostLoginRedirect(resolveDestination);
+
+    expect(resolveDestination).toHaveBeenCalledOnce();
+    expect(navigateTo).toHaveBeenCalledWith("/dashboard");
+    expect(refreshUser.mock.invocationCallOrder[0]).toBeLessThan(
+      refreshLayout.mock.invocationCallOrder[0]!,
+    );
+  });
+
+  it("preserves explicit login destinations", async () => {
+    await usePostLoginRedirect("/reports");
+    expect(navigateTo).toHaveBeenCalledWith("/reports");
+  });
+
+  it("falls back to the homepage when no page is accessible", async () => {
+    await usePostLoginRedirect(() => undefined);
+    expect(navigateTo).toHaveBeenCalledWith("/");
+  });
+
+  it("does not navigate when session refresh fails", async () => {
+    refreshUser.mockRejectedValueOnce(new Error("Session failed"));
+    await expect(usePostLoginRedirect()).rejects.toThrow("Session failed");
+    expect(refreshLayout).not.toHaveBeenCalled();
+    expect(navigateTo).not.toHaveBeenCalled();
+  });
+
+  it("rejects a session refresh that resolves without an authenticated user", async () => {
+    vi.stubGlobal("useUserSession", () => ({
+      fetch: refreshUser,
+      user: { value: null },
+    }));
+    const resolveDestination = vi.fn();
+    await expect(usePostLoginRedirect(resolveDestination)).rejects.toThrow(
+      "Unable to load the authenticated session",
+    );
+    expect(addCurrentAccount).not.toHaveBeenCalled();
+    expect(refreshLayout).not.toHaveBeenCalled();
+    expect(resolveDestination).not.toHaveBeenCalled();
+    expect(navigateTo).not.toHaveBeenCalled();
+  });
+
+  it("propagates layout failures without resolving or opening the destination", async () => {
+    refreshLayout.mockRejectedValueOnce(new Error("Layout failed"));
+    const resolveDestination = vi.fn();
+    await expect(usePostLoginRedirect(resolveDestination)).rejects.toThrow(
+      "Layout failed",
+    );
+    expect(resolveDestination).not.toHaveBeenCalled();
+    expect(navigateTo).not.toHaveBeenCalled();
+  });
+});

package/frontend-vue/tests/quick-actions.test.ts

@@ -0,0 +1,32 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { dispatchQuickActionTarget } from "../layers/dms-layout/app/composables/page/useQuickActions";
+import {
+  QUICK_ACTION_ADD,
+  QUICK_ACTION_COMPONENT_KEY,
+  QUICK_ACTION_QUERY_KEY,
+} from "../layers/dms-ui/app/types/quick-actions";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("dispatchQuickActionTarget", () => {
+  it("routes open-form actions to the target table", () => {
+    const navigateDms = vi.fn();
+    vi.stubGlobal("navigateDms", navigateDms);
+
+    dispatchQuickActionTarget({
+      type: "openForm",
+      to: "/members",
+      component: "members-table",
+    });
+
+    expect(navigateDms).toHaveBeenCalledWith({
+      path: "/members",
+      query: {
+        [QUICK_ACTION_QUERY_KEY]: QUICK_ACTION_ADD,
+        [QUICK_ACTION_COMPONENT_KEY]: "members-table",
+      },
+    });
+  });
+});

package/frontend-vue/tests/realtime-auth-recovery.test.ts

@@ -0,0 +1,146 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  isUnauthorizedStreamError,
+  openSseStream,
+} from "../layers/dms-core/app/composables/realtime/useSseStream";
+import { runDeduped } from "../layers/dms-core/app/utils/dedupedRefresh";
+
+const realFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = realFetch;
+  vi.restoreAllMocks();
+});
+
+function streamingResponse(frames: string[]) {
+  const encoder = new TextEncoder();
+  let index = 0;
+  const body = new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (index < frames.length) {
+        controller.enqueue(encoder.encode(frames[index]!));
+        index += 1;
+      } else {
+        controller.close();
+      }
+    },
+  });
+  return { ok: true, status: 200, body };
+}
+
+describe("openSseStream", () => {
+  it("surfaces the HTTP status on a non-ok response so 401 stays detectable", async () => {
+    globalThis.fetch = vi.fn(async () => ({
+      ok: false,
+      status: 401,
+      body: null,
+    })) as unknown as typeof fetch;
+
+    const error = await new Promise<unknown>((resolve) => {
+      openSseStream({
+        url: "http://api/realtime/user",
+        onEvent: () => {},
+        onError: resolve,
+      });
+    });
+
+    expect((error as { status?: number }).status).toBe(401);
+    expect(isUnauthorizedStreamError(error)).toBe(true);
+  });
+
+  it("parses SSE frames from the stream body", async () => {
+    globalThis.fetch = vi.fn(async () =>
+      streamingResponse(['event: hello\ndata: {"sessionId":"s1"}\n\n']),
+    ) as unknown as typeof fetch;
+
+    const event = await new Promise<{ name: string; data: unknown }>(
+      (resolve) => {
+        openSseStream({
+          url: "http://api/realtime/user",
+          onEvent: (name, data) => resolve({ name, data }),
+          onError: () => {},
+        });
+      },
+    );
+
+    expect(event.name).toBe("hello");
+    expect(event.data).toEqual({ sessionId: "s1" });
+  });
+
+  it("reports a network failure without a status (not treated as a 401)", async () => {
+    globalThis.fetch = vi.fn(async () => {
+      throw new Error("network down");
+    }) as unknown as typeof fetch;
+
+    const error = await new Promise<unknown>((resolve) => {
+      openSseStream({ url: "http://api", onEvent: () => {}, onError: resolve });
+    });
+
+    expect(isUnauthorizedStreamError(error)).toBe(false);
+  });
+});
+
+describe("isUnauthorizedStreamError", () => {
+  it("is true only for an error carrying status 401", () => {
+    expect(isUnauthorizedStreamError({ status: 401 })).toBe(true);
+    expect(
+      isUnauthorizedStreamError(Object.assign(new Error("x"), { status: 401 })),
+    ).toBe(true);
+    expect(isUnauthorizedStreamError({ status: 500 })).toBe(false);
+    expect(isUnauthorizedStreamError(new Error("x"))).toBe(false);
+    expect(isUnauthorizedStreamError(undefined)).toBe(false);
+    expect(isUnauthorizedStreamError(null)).toBe(false);
+  });
+});
+
+describe("runDeduped", () => {
+  it("coalesces concurrent calls into a single run", async () => {
+    const holder: Record<PropertyKey, unknown> = {};
+    let runs = 0;
+    let release!: (value: boolean) => void;
+    const task = () => {
+      runs += 1;
+      return new Promise<boolean>((resolve) => {
+        release = resolve;
+      });
+    };
+
+    const first = runDeduped(holder, "session", task);
+    const second = runDeduped(holder, "session", task);
+
+    expect(runs).toBe(1);
+    expect(first).toBe(second);
+
+    release(true);
+    await expect(first).resolves.toBe(true);
+    await expect(second).resolves.toBe(true);
+  });
+
+  it("starts a fresh run once the previous one has settled", async () => {
+    const holder: Record<PropertyKey, unknown> = {};
+    let runs = 0;
+    const task = () => {
+      runs += 1;
+      return Promise.resolve(true);
+    };
+
+    await runDeduped(holder, "session", task);
+    await runDeduped(holder, "session", task);
+
+    expect(runs).toBe(2);
+  });
+
+  it("clears the slot even when the task rejects", async () => {
+    const holder: Record<PropertyKey, unknown> = {};
+    await expect(
+      runDeduped(holder, "session", () => Promise.reject(new Error("boom"))),
+    ).rejects.toThrow("boom");
+
+    let reran = false;
+    await runDeduped(holder, "session", async () => {
+      reran = true;
+      return true;
+    });
+    expect(reran).toBe(true);
+  });
+});

package/frontend-vue/tests/sidebar-footer-navigation.test.ts

@@ -0,0 +1,128 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import {
+  computed,
+  createApp,
+  defineComponent,
+  h,
+  onBeforeUnmount,
+  onMounted,
+  reactive,
+  ref,
+  watch,
+  type App,
+  type PropType,
+} from "vue";
+import type { NavigationMenuItem } from "@nuxt/ui";
+import Sidebar from "../layers/dms-layout/app/build/components/layout/DashboardSidebar.vue";
+import { addActiveStateToMenuItem } from "../layers/dms-core/app/utils/menu";
+
+const route = reactive({ path: "/modules/automation/runs", query: {} });
+let app: App;
+let host: HTMLDivElement;
+
+const Navigation = defineComponent({
+  props: {
+    items: { type: Array as PropType<NavigationMenuItem[]>, required: true },
+  },
+  setup: (props) => () =>
+    h(
+      "nav",
+      props.items.map((item) =>
+        h(
+          "a",
+          {
+            href: item.to,
+            "data-exact": String(item.exact),
+            "data-active": String(item.active),
+          },
+          item.label,
+        ),
+      ),
+    ),
+});
+
+function installRuntime() {
+  Object.entries({
+    computed,
+    ref,
+    watch,
+    onMounted,
+    onBeforeUnmount,
+    addActiveStateToMenuItem,
+  }).forEach(([key, value]) => vi.stubGlobal(key, value));
+  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
+  vi.stubGlobal("useDmsAppConfig", () => ({}));
+  vi.stubGlobal("useTranslation", () => ({
+    processI18n: (value: string) => value,
+  }));
+  vi.stubGlobal("useDmsRoute", () => route);
+  vi.stubGlobal("useDmsState", (_key: string, initial: () => unknown) =>
+    ref(initial()),
+  );
+  vi.stubGlobal("useSiteLayout", () => ({
+    siteLayout: ref({}),
+    siteLayoutTree: ref(),
+    findMatchingRoute: () => null,
+    findMatchingRouteOrCategory: () => null,
+  }));
+  vi.stubGlobal("useFavoritePages", () => ({
+    cleanupInvalidFavorites: vi.fn(),
+    sortedFavorites: ref([]),
+  }));
+  vi.stubGlobal("useIsOwner", () => ref(true));
+  vi.stubGlobal("useCurrentModule", () =>
+    computed(() =>
+      route.path.startsWith("/modules/automation")
+        ? { id: "automation" }
+        : null,
+    ),
+  );
+  vi.stubGlobal("useSidebarWidgets", () => ({ widgets: ref([]) }));
+  vi.stubGlobal("useHomepage", () => "/settings");
+  vi.stubGlobal("getExpandedItemIds", () => []);
+}
+
+beforeEach(() => {
+  installRuntime();
+  host = document.createElement("div");
+});
+afterEach(() => {
+  app?.unmount();
+  vi.unstubAllGlobals();
+});
+
+it.each(["/modules/automation/runs", "/modules", "/settings/user/profile"])(
+  "keeps exact footer destinations and Settings prefix highlighting on %s",
+  (path) => {
+    route.path = path;
+    app = createApp(Sidebar);
+    app.component(
+      "UDashboardSidebar",
+      defineComponent({
+        setup:
+          (_, { slots }) =>
+          () =>
+            slots.footer?.({ collapsed: false }),
+      }),
+    );
+    app.component("DmsNavigationMenu", Navigation);
+    app.component(
+      "DmsDashboardSearch",
+      defineComponent({ render: () => null }),
+    );
+    app.mount(host);
+    const modules = [...host.querySelectorAll('a[href="/modules"]')];
+    expect(modules).toHaveLength(
+      path.startsWith("/modules/automation") ? 2 : 1,
+    );
+    modules.forEach((link) =>
+      expect(link.getAttribute("data-exact")).toBe("true"),
+    );
+    const settings = host.querySelector('a[href="/settings"]')!;
+    expect(settings.getAttribute("data-exact")).not.toBe("true");
+    expect(settings.getAttribute("data-active") === "true").toBe(
+      path.startsWith("/settings"),
+    );
+  },
+);