@antelopejs/dms 0.9.1 → 0.9.3

package/frontend-vue/tests/sse-stream.test.ts

@@ -1,268 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-  openSseStream,
-  type SseCloseReason,
-  type SseStreamOptions,
-} from "../layers/dms-core/app/composables/realtime/useSseStream";
-
-const STREAM_URL = "https://api.example.test/events";
-const encoder = new TextEncoder();
-
-afterEach(() => vi.unstubAllGlobals());
-
-function respond(chunks: Uint8Array[]): Response {
-  return new Response(
-    new ReadableStream<Uint8Array>({
-      start(controller) {
-        for (const chunk of chunks) controller.enqueue(chunk);
-        controller.close();
-      },
-    }),
-  );
-}
-
-function read(
-  options: Partial<SseStreamOptions> = {},
-): Promise<SseCloseReason> {
-  return new Promise((resolve) => {
-    openSseStream({
-      url: STREAM_URL,
-      onEvent: vi.fn(),
-      ...options,
-      onClose: resolve,
-    });
-  });
-}
-
-describe("SSE transport lifecycle", () => {
-  it("opens before frames, preserves ids and reports EOF after releasing the reader", async () => {
-    const response = respond([
-      encoder.encode('id: cursor-1\nevent: log\ndata: {"line":"ready"}\n\n'),
-    ]);
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
-    const calls: unknown[] = [];
-    expect(
-      await read({
-        onOpen: () => calls.push("open"),
-        onEvent: (...args) => calls.push(args),
-      }),
-    ).toBe("eof");
-    expect(calls).toEqual(["open", ["log", { line: "ready" }, "cursor-1"]]);
-    expect(response.body?.locked).toBe(false);
-  });
-
-  it("decodes fragmented UTF-8 and CRLF and preserves text whitespace and empty ids", async () => {
-    const bytes = encoder.encode(
-      ": ping\r\n\r\nid: old\r\nid: c1\r\nevent: log\r\ndata:  été  \r\ndata: next\r\n\r\ndata:\r\nid:\r\n\r\ndata: true\r\n\r\n",
-    );
-    vi.stubGlobal(
-      "fetch",
-      vi
-        .fn()
-        .mockResolvedValue(
-          respond(Array.from(bytes, (byte) => Uint8Array.of(byte))),
-        ),
-    );
-    const onEvent = vi.fn();
-    expect(await read({ onEvent })).toBe("eof");
-    expect(onEvent.mock.calls).toEqual([
-      ["log", " été  \nnext", "c1"],
-      ["message", "", ""],
-      ["message", true, null],
-    ]);
-  });
-
-  it("ignores id-only frames, invalid ids and an unfinished frame at EOF", async () => {
-    vi.stubGlobal(
-      "fetch",
-      vi
-        .fn()
-        .mockResolvedValue(
-          respond([
-            encoder.encode(
-              "id: alone\n\nid: valid\nid: bad\0id\nevent:\ndata: 1\n\ndata: unfinished",
-            ),
-          ]),
-        ),
-    );
-    const onEvent = vi.fn();
-    expect(await read({ onEvent })).toBe("eof");
-    expect(onEvent.mock.calls).toEqual([["message", 1, "valid"]]);
-  });
-
-  it("reports an empty accepted response as open then EOF", async () => {
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(respond([])));
-    const onOpen = vi.fn();
-    const onError = vi.fn();
-    expect(await read({ onOpen, onError })).toBe("eof");
-    expect(onOpen).toHaveBeenCalledOnce();
-    expect(onError).not.toHaveBeenCalled();
-  });
-
-  it("reports HTTP rejection as error without opening", async () => {
-    vi.stubGlobal(
-      "fetch",
-      vi.fn().mockResolvedValue(new Response(null, { status: 401 })),
-    );
-    const onOpen = vi.fn();
-    const onError = vi.fn();
-    expect(await read({ onOpen, onError })).toBe("error");
-    expect(onOpen).not.toHaveBeenCalled();
-    expect(onError).toHaveBeenCalledExactlyOnceWith(
-      expect.objectContaining({ status: 401 }),
-    );
-  });
-
-  it("does not dispatch a throwing consumer twice or reinterpret its JSON", async () => {
-    const response = respond([encoder.encode("data: {}\n\ndata: 2\n\n")]);
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
-    const error = new Error("consumer failed");
-    const onEvent = vi.fn(() => {
-      throw error;
-    });
-    const onError = vi.fn();
-    expect(await read({ onEvent, onError })).toBe("error");
-    expect(onEvent).toHaveBeenCalledExactlyOnceWith("message", {}, null);
-    expect(onError).toHaveBeenCalledExactlyOnceWith(error);
-    expect(response.body?.locked).toBe(false);
-  });
-
-  it("reports a read failure before the error close notification", async () => {
-    const error = new Error("connection reset");
-    const response = new Response(
-      new ReadableStream({
-        start(controller) {
-          controller.error(error);
-        },
-      }),
-    );
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
-    const calls: unknown[] = [];
-    await new Promise<void>((resolve) => {
-      openSseStream({
-        url: STREAM_URL,
-        onEvent: vi.fn(),
-        onOpen: () => calls.push("open"),
-        onError: (value) => calls.push(value),
-        onClose: (reason) => {
-          calls.push(reason);
-          resolve();
-        },
-      });
-    });
-    expect(calls).toEqual(["open", error, "error"]);
-    expect(response.body?.locked).toBe(false);
-  });
-
-  it("can close synchronously from onOpen without delivering a frame", async () => {
-    const response = respond([encoder.encode("data: 1\n\n")]);
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
-    const onEvent = vi.fn();
-    const reason = await new Promise<SseCloseReason>((resolve) => {
-      const handle = openSseStream({
-        url: STREAM_URL,
-        onEvent,
-        onOpen: () => handle.close(),
-        onClose: resolve,
-      });
-    });
-    expect(reason).toBe("aborted");
-    expect(onEvent).not.toHaveBeenCalled();
-    expect(response.body?.locked).toBe(false);
-  });
-
-  it("stops buffered events after close and notifies cancellation only once", async () => {
-    vi.stubGlobal(
-      "fetch",
-      vi
-        .fn()
-        .mockResolvedValue(respond([encoder.encode("data: 1\n\ndata: 2\n\n")])),
-    );
-    const onError = vi.fn();
-    const onEvent = vi.fn();
-    const onClose = vi.fn();
-    const reason = await new Promise<SseCloseReason>((resolve) => {
-      const handle = openSseStream({
-        url: STREAM_URL,
-        onError,
-        onEvent: (...args) => {
-          onEvent(...args);
-          handle.close();
-          handle.close();
-        },
-        onClose: (value) => {
-          onClose(value);
-          resolve(value);
-        },
-      });
-    });
-    expect(reason).toBe("aborted");
-    expect(onEvent).toHaveBeenCalledOnce();
-    expect(onClose).toHaveBeenCalledOnce();
-    expect(onError).not.toHaveBeenCalled();
-  });
-
-  it("cancels a pending read and releases its lock", async () => {
-    const cancel = vi.fn();
-    const response = new Response(new ReadableStream({ cancel }));
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
-    const reason = await new Promise<SseCloseReason>((resolve) => {
-      const handle = openSseStream({
-        url: STREAM_URL,
-        onEvent: vi.fn(),
-        onClose: resolve,
-        onOpen: () => queueMicrotask(() => handle.close()),
-      });
-    });
-    expect(reason).toBe("aborted");
-    expect(cancel).toHaveBeenCalledOnce();
-    expect(response.body?.locked).toBe(false);
-  });
-
-  it("suppresses opening and frames when closed before fetch resolves", async () => {
-    const response = respond([encoder.encode("data: 1\n\n")]);
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
-    const onOpen = vi.fn();
-    const onEvent = vi.fn();
-    const reason = await new Promise<SseCloseReason>((resolve) => {
-      const handle = openSseStream({
-        url: STREAM_URL,
-        onOpen,
-        onEvent,
-        onClose: resolve,
-      });
-      handle.close();
-    });
-    expect(reason).toBe("aborted");
-    expect(onOpen).not.toHaveBeenCalled();
-    expect(onEvent).not.toHaveBeenCalled();
-  });
-
-  it("lets the caller resume after EOF using fresh auth and Last-Event-ID", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(respond([encoder.encode("id: c1\ndata: 1\n\n")]))
-      .mockResolvedValueOnce(respond([encoder.encode("id: c2\ndata: 2\n\n")]));
-    vi.stubGlobal("fetch", fetchMock);
-    let cursor: string | null = null;
-    let token = "first";
-    const options: Partial<SseStreamOptions> = {
-      headers: () => ({
-        Authorization: `Bearer ${token}`,
-        ...(cursor ? { "Last-Event-ID": cursor } : {}),
-      }),
-      onEvent: (_name, _data, id) => {
-        if (id !== null) cursor = id;
-      },
-    };
-    expect(await read(options)).toBe("eof");
-    expect(fetchMock).toHaveBeenCalledOnce();
-    token = "renewed";
-    expect(await read(options)).toBe("eof");
-    expect(fetchMock.mock.calls[1]?.[1].headers).toEqual({
-      Authorization: "Bearer renewed",
-      "Last-Event-ID": "c1",
-    });
-    expect(cursor).toBe("c2");
-  });
-});

package/frontend-vue/tests/ssr-guard-preload.test.ts

@@ -1,188 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A server render of a protected page waits on two requests made by its
- * middlewares, one after the other: the onboarding status (`onboarding`),
- * then the permission set (`auth`). Both start with the app instead, through
- * the real renderer runtime, middlewares and composables, and each middleware
- * joins the request already in flight.
- */
-import { createSSRApp, defineComponent, h, nextTick, type App } from "vue";
-import { renderToString } from "vue/server-renderer";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { DmsAppContext, DmsFrontendRuntime } from "#dms/frontend-module";
-
-const engine = await import("#dms/frontend-module");
-const { createTrailingDeduper } = await import(
-  "../layers/dms-core/app/utils/trailingDeduper"
-);
-for (const name of [
-  "useDmsState",
-  "useDmsApp",
-  "useDmsRoute",
-  "defineDmsMiddleware",
-  "defineDmsPlugin",
-  "useDmsError",
-  "abortDmsNavigation",
-  "navigateDms",
-] as const) {
-  vi.stubGlobal(name, engine[name]);
-}
-vi.stubGlobal("createTrailingDeduper", createTrailingDeduper);
-vi.stubGlobal("useDmsRuntimeConfig", () => ({ public: { dms: {} } }));
-vi.stubGlobal("useHomepage", () => "/home");
-
-const session = { loggedIn: { value: true } };
-vi.stubGlobal("useDmsUserSession", () => ({
-  ...session,
-  user: { value: { isValidated: true } },
-}));
-let pagePublic = false;
-vi.stubGlobal("useSiteLayout", () => ({
-  siteLayout: { value: {} },
-  findMatchingRoute: (path: string) =>
-    path === "/orders" ? { metadata: { publicAccess: pagePublic } } : null,
-}));
-
-const { useTrailingDeduper } = await import(
-  "../layers/dms-core/app/composables/useTrailingDeduper"
-);
-vi.stubGlobal("useTrailingDeduper", useTrailingDeduper);
-const { usePermissions } = await import(
-  "../layers/dms-core/app/composables/auth/usePermissions"
-);
-vi.stubGlobal("usePermissions", usePermissions);
-const { useOnboarding } = await import(
-  "../layers/dms-onboarding/app/composables/onboarding/useOnboarding"
-);
-vi.stubGlobal("useOnboarding", useOnboarding);
-const { default: onboardingMiddleware } = await import(
-  "../layers/dms-onboarding/app/middleware/onboarding.global"
-);
-const { default: authMiddleware } = await import(
-  "../layers/dms-auth/app/middleware/auth"
-);
-const { default: onboardingPreload } = await import(
-  "../layers/dms-onboarding/app/plugins/onboarding-preload"
-);
-const { default: permissionsPreload } = await import(
-  "../layers/dms-auth/app/plugins/permissions-preload"
-);
-
-const ONBOARDING = "/api/onboarding/informations";
-const PERMISSIONS = "/dms/permissions";
-const ANSWERS: Record<string, unknown> = {
-  [ONBOARDING]: { has_onboarded: true },
-  [PERMISSIONS]: ["orders.read"],
-};
-
-interface PendingRequest {
-  url: string;
-  resolve: (value: unknown) => void;
-}
-
-const pending: PendingRequest[] = [];
-const asked: string[] = [];
-// Each request waits for the test to answer it.
-const $authFetch = vi.fn(
-  (url: string) =>
-    new Promise((resolve) => {
-      asked.push(url);
-      pending.push({ url, resolve });
-    }),
-);
-vi.stubGlobal("useAuthFetch", () => ({ $authFetch }));
-
-const settle = async () => {
-  await nextTick();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-};
-
-/** The requests waiting at once, each round, until none is left. */
-async function answerRounds(): Promise<string[][]> {
-  const rounds: string[][] = [];
-  for (let round = 0; round < 6; round++) {
-    await settle();
-    const waiting = pending.splice(0);
-    if (waiting.length === 0) continue;
-    rounds.push(waiting.map((request) => request.url).sort());
-    for (const request of waiting) request.resolve(ANSWERS[request.url]);
-  }
-  return rounds;
-}
-
-const Page = defineComponent({
-  setup() {
-    engine.defineDmsPageMeta({ auth: true });
-    const { hasPermission } = usePermissions();
-    return () =>
-      h("p", hasPermission("orders.read") ? "can read" : "cannot read");
-  },
-});
-
-/** A server runtime, its app set up the way the DMS module registers it. */
-function serverRender(path: string): { app: App; html: Promise<string> } {
-  const runtime = engine.createDmsFrontendRuntime(undefined, {}, true);
-  const app = createSSRApp(Page);
-  const context = {
-    runWithContext: (callback: () => unknown) => app.runWithContext(callback),
-  } as unknown as DmsAppContext;
-  app.config.globalProperties.$dms = context;
-  runtime.appContext = context;
-  runtime.route.path = path;
-  runtime.route.fullPath = path;
-  runtime.route.matched = [{}];
-  engine.provideDmsFrontendRuntime(app, runtime as DmsFrontendRuntime);
-  // The plugins run before the page renders, as `installDmsPlugins` does.
-  for (const plugin of [onboardingPreload, permissionsPreload])
-    app.runWithContext(() => plugin(context));
-  return { app, html: renderToString(app) };
-}
-
-beforeEach(async () => {
-  pending.length = 0;
-  asked.length = 0;
-  $authFetch.mockClear();
-  session.loggedIn.value = true;
-  pagePublic = false;
-  await engine.setupFrontendModules([
-    {
-      options: { public: {} },
-      module: {
-        setup(sdk) {
-          sdk.registerMiddleware("auth", authMiddleware);
-          sdk.registerMiddleware("onboarding", onboardingMiddleware, {
-            global: true,
-          });
-        },
-      },
-    },
-  ]);
-});
-
-describe("the requests a server render's middlewares wait on", () => {
-  it("start together, and each middleware joins its own", async () => {
-    const { html } = serverRender("/orders");
-    const rounds = await answerRounds();
-
-    expect(rounds).toEqual([[PERMISSIONS, ONBOARDING].sort()]);
-    expect(asked.sort()).toEqual([PERMISSIONS, ONBOARDING].sort());
-    expect(await html).toContain("can read");
-  });
-
-  it("ask for no permission set the middleware would not load", async () => {
-    pagePublic = true;
-    const { html } = serverRender("/orders");
-    await answerRounds();
-    expect(asked).toEqual([ONBOARDING]);
-    expect(await html).toContain("cannot read");
-
-    pending.length = 0;
-    asked.length = 0;
-    pagePublic = false;
-    session.loggedIn.value = false;
-    const signedOut = serverRender("/orders");
-    await answerRounds();
-    expect(asked).toEqual([ONBOARDING]);
-    await signedOut.html.catch(() => undefined);
-  });
-});

package/frontend-vue/tests/stat-cell-shared.test.ts

@@ -1,64 +0,0 @@
-import { createSSRApp, defineComponent, h, ref, type Component } from "vue";
-import { renderToString } from "vue/server-renderer";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import KpiCard from "../layers/dms-ui/app/components/kpi/KpiCard.vue";
-import StatGroup from "../layers/dms-ui/app/components/stat-group/StatGroup.vue";
-
-vi.mock("../layers/dms-ui/app/composables/chart/useChartFetch", () => ({
-  useChartFetch: () => ({
-    data: ref({ value: 12 }),
-    isLoading: ref(false),
-    error: ref(null),
-    refresh: async () => {},
-  }),
-}));
-
-const Slot = defineComponent({
-  setup:
-    (_, { slots }) =>
-    () =>
-      h("div", slots.default?.()),
-});
-
-// The compact stat card both components draw through DmsStatCell.
-const STAT_CARD = 'class="dms-card flex items-center gap-3.5 px-4 py-3.5';
-const STAT_VALUE =
-  "text-highlighted text-[22px] leading-[1.1] font-[650] tracking-[-0.035em] tabular-nums";
-
-async function render(component: Component, props: Record<string, unknown>) {
-  const app = createSSRApp({ render: () => h(component, props) });
-  for (const name of ["DmsCard", "UIcon", "USkeleton", "UButton"]) {
-    app.component(name, Slot);
-  }
-  return renderToString(app);
-}
-
-beforeEach(() => {
-  vi.stubGlobal("useI18n", () => ({ locale: ref("en-GB"), t: String }));
-  vi.stubGlobal("useTranslation", () => ({ processI18n: String }));
-  vi.stubGlobal("useComponentEvent", () => ({}));
-  vi.stubGlobal("useWatch", () => ({ state: ref({}) }));
-});
-
-afterEach(() => vi.unstubAllGlobals());
-
-describe("the compact stat card", () => {
-  it("is the same cell in a stat KPI card and a StatGroup of cards", async () => {
-    const kpi = await render(KpiCard, {
-      title: "Installed",
-      icon: "i-ph-package",
-      variant: "stat",
-      componentId: "kpi",
-      pageId: "page",
-    });
-    const group = await render(StatGroup, {
-      layout: "cards",
-      items: [{ icon: "i-ph-package", eyebrow: "Installed", value: "12" }],
-    });
-    for (const html of [kpi, group]) {
-      expect(html).toContain(STAT_CARD);
-      expect(html).toContain(STAT_VALUE);
-      expect(html).toContain("Installed");
-    }
-  });
-});

package/frontend-vue/tests/stat-group-detail-lines.test.ts

@@ -1,63 +0,0 @@
-import { createSSRApp, defineComponent, h, ref, type Component } from "vue";
-import { renderToString } from "vue/server-renderer";
-import { beforeAll, describe, expect, it, vi } from "vitest";
-import StatGroup from "../layers/dms-ui/app/components/stat-group/StatGroup.vue";
-import NavCard from "../layers/dms-ui/app/components/card/NavCard.vue";
-
-// A detail or a title cut on its first line loses what it says: a stat
-// group's details and a nav card's title take two lines before the ellipsis.
-
-const Slot = defineComponent({
-  setup:
-    (_, { slots }) =>
-    () =>
-      h("div", slots.default?.()),
-});
-
-async function render(component: Component, props: Record<string, unknown>) {
-  const app = createSSRApp({ render: () => h(component, props) });
-  for (const name of ["UIcon", "USkeleton", "DmsLink"]) {
-    app.component(name, Slot);
-  }
-  return renderToString(app);
-}
-
-beforeAll(() => {
-  vi.stubGlobal("useI18n", () => ({ locale: ref("en-GB"), t: String }));
-});
-
-const DETAIL = "Next invoice on Nov 1 for the three seats left";
-
-function detailClasses(html: string): string {
-  const element = new RegExp(
-    `<(?:p|small) class="([^"]*)"[^>]*>\\s*${DETAIL}`,
-  ).exec(html);
-  return element?.[1] ?? "";
-}
-
-describe("StatGroup detail", () => {
-  it.each(["joined", "cards"])(
-    "gives a %s cell's detail two lines before its ellipsis",
-    async (layout) => {
-      const html = await render(StatGroup, {
-        layout,
-        items: [{ eyebrow: "Billing", value: "On", detail: DETAIL }],
-      });
-      expect(detailClasses(html)).toContain("line-clamp-2");
-      expect(detailClasses(html)).not.toContain("truncate");
-    },
-  );
-});
-
-describe("NavCard title", () => {
-  it("takes two lines before its ellipsis", async () => {
-    const html = await render(NavCard, {
-      to: "/workspaces?view=past-due",
-      icon: "i-ph-warning",
-      title: "Workspaces past due for more than seven days",
-    });
-    const title = /<h3 class="([^"]*)"/.exec(html)?.[1] ?? "";
-    expect(title).toContain("line-clamp-2");
-    expect(title).not.toContain("truncate");
-  });
-});

package/frontend-vue/tests/string-type-parser.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  parse,
-  parseObject,
-} from "../layers/dms-core/app/utils/stringTypeParser";
-
-const FUNCTION_STRINGS = [
-  "(x) => x + 1",
-  "x => x * 2",
-  "function(a) { return a }",
-  '(() => { throw new Error("Input executed"); })()',
-  'function() {} , (() => { throw new Error("Input executed"); })()',
-];
-
-describe("stringTypeParser", () => {
-  it("preserves supported data conversions", () => {
-    expect(
-      parseObject([
-        { key: "enabled", value: "true" },
-        { key: "disabled", value: "false" },
-        { key: "count", value: "42" },
-        { key: "ratio", value: "3.14" },
-        { key: "empty", value: "null" },
-        { key: "missing", value: "undefined" },
-        { key: "date", value: "2024-01-01" },
-        { key: "object", value: '{"key":"value"}' },
-        { key: "array", value: "[1,2,3]" },
-        { key: "name", value: "hello world" },
-      ]),
-    ).toEqual({
-      enabled: true,
-      disabled: false,
-      count: 42,
-      ratio: 3.14,
-      empty: null,
-      missing: undefined,
-      date: new Date("2024-01-01T00:00:00.000Z"),
-      object: { key: "value" },
-      array: [1, 2, 3],
-      name: "hello world",
-    });
-  });
-
-  it.each(FUNCTION_STRINGS)("preserves function syntax: %s", (input) => {
-    expect(parse(input)).toBe(input);
-    expect(parseObject([{ key: "filter", value: input }])).toEqual({
-      filter: input,
-    });
-  });
-});