@antelopejs/dms 0.9.1 → 0.9.3

package/frontend-vue/tests/menu-navigation.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  addActiveStateToMenuItems,
-  isMenuItemActive,
-} from "../layers/dms-core/app/utils/menu";
-import { buildMenuItemTarget } from "../layers/dms-ui/app/build/types/tree";
-
-type TreeNode = Parameters<typeof buildMenuItemTarget>[0];
-
-function node(overrides: Partial<TreeNode>): TreeNode {
-  return {
-    id: "project",
-    fullId: "cloud.projects.project",
-    fullSlug: "/project",
-    displayName: "Project",
-    layoutUrl: "/project/pagelayout",
-    children: {},
-    childrenOrders: [],
-    ...overrides,
-  } as TreeNode;
-}
-
-function route(path: string, query: Record<string, unknown> = {}) {
-  return { path, query };
-}
-
-describe("buildMenuItemTarget", () => {
-  it("returns the bare slug when the entry declares no query", () => {
-    expect(buildMenuItemTarget(node({}))).to.equal("/project");
-  });
-
-  it("returns a string link carrying the query the entry declares", () => {
-    expect(
-      buildMenuItemTarget(node({ query: { project: "invoicer" } })),
-    ).to.equal("/project?project=invoicer");
-  });
-
-  it("encodes the query values of the link", () => {
-    expect(
-      buildMenuItemTarget(node({ query: { project: "a b&c", env: "prod" } })),
-    ).to.equal("/project?project=a+b%26c&env=prod");
-  });
-
-  it("returns no target for a category that has no page behind it", () => {
-    expect(buildMenuItemTarget(node({ layoutUrl: undefined }))).to.equal(
-      undefined,
-    );
-  });
-});
-
-describe("isMenuItemActive with query entries", () => {
-  const invoicer = {
-    fullId: "cloud.projects.invoicer",
-    to: "/project?project=invoicer",
-  };
-  const resto = {
-    fullId: "cloud.projects.resto",
-    to: "/project?project=resto",
-  };
-
-  it("highlights only the entry matching the current query", () => {
-    const current = route("/project", { project: "invoicer" });
-    expect(isMenuItemActive(invoicer, null, current)).to.equal(true);
-    expect(isMenuItemActive(resto, null, current)).to.equal(false);
-  });
-
-  it("ignores query parameters the entry does not declare", () => {
-    const current = route("/project", { project: "invoicer", env: "prod" });
-    expect(isMenuItemActive(invoicer, null, current)).to.equal(true);
-  });
-
-  it("tells apart entries whose query values share a prefix", () => {
-    const current = route("/project", { project: "invoicer-2" });
-    expect(isMenuItemActive(invoicer, null, current)).to.equal(false);
-  });
-
-  it("stays active on the entry's sub-routes carrying its query", () => {
-    const current = route("/project/settings", { project: "invoicer" });
-    expect(isMenuItemActive(invoicer, null, current)).to.equal(true);
-  });
-
-  it("still accepts an object target", () => {
-    const entry = { to: { path: "/project", query: { project: "invoicer" } } };
-    const current = route("/project", { project: "invoicer" });
-    expect(isMenuItemActive(entry, null, current)).to.equal(true);
-  });
-
-  it("stays inactive on the same path without the entry's query", () => {
-    expect(isMenuItemActive(invoicer, null, route("/project"))).to.equal(false);
-  });
-
-  it("does not let the fullId fallback override a query mismatch", () => {
-    const current = route("/project", { project: "resto" });
-    expect(
-      isMenuItemActive(invoicer, "cloud.projects.invoicer", current),
-    ).to.equal(false);
-  });
-
-  it("keeps highlighting a plain entry on its sub-routes", () => {
-    const orders = { fullId: "pages.orders", to: "/orders" };
-    expect(isMenuItemActive(orders, null, route("/orders/detail/42"))).to.equal(
-      true,
-    );
-  });
-});
-
-describe("addActiveStateToMenuItems", () => {
-  it("marks a single query entry active across a group", () => {
-    const groups = [
-      [
-        { id: "invoicer", to: "/project?project=invoicer" },
-        { id: "resto", to: "/project?project=resto" },
-      ],
-    ];
-
-    const [group] = addActiveStateToMenuItems(
-      groups,
-      null,
-      route("/project", { project: "resto" }),
-    );
-
-    expect(group?.[0]?.active).to.equal(false);
-    expect(group?.[1]?.active).to.equal(true);
-  });
-
-  it("leaves the native highlighting of an inactive plain entry alone", () => {
-    const [group] = addActiveStateToMenuItems(
-      [[{ id: "orders", to: "/orders" }]],
-      null,
-      route("/invoices"),
-    );
-
-    expect(group?.[0]?.active).to.equal(undefined);
-  });
-});

package/frontend-vue/tests/menu-sync-reconnect.test.ts

@@ -1,47 +0,0 @@
-import { nextTick, ref } from "vue";
-import { describe, expect, it, vi } from "vitest";
-
-vi.stubGlobal("defineDmsPlugin", (setup: unknown) => setup);
-const { watchRealtimeReconnects } = await import(
-  "../layers/dms-layout/app/plugins/dms-menu-sync.client"
-);
-
-// A realtime stream that drops and opens again missed the menu events sent
-// meanwhile: the menu resyncs once it is back, but not on the first opening,
-// which follows the page load that brought the current menu.
-
-describe("the menu resync on a realtime reconnect", () => {
-  it("leaves the first opening alone and resyncs on each reopening", async () => {
-    const sessionId = ref<string | undefined>(undefined);
-    const onReconnect = vi.fn();
-    watchRealtimeReconnects(sessionId, onReconnect);
-
-    sessionId.value = "session-1";
-    await nextTick();
-    expect(onReconnect).not.toHaveBeenCalled();
-
-    sessionId.value = undefined;
-    await nextTick();
-    sessionId.value = "session-2";
-    await nextTick();
-    expect(onReconnect).toHaveBeenCalledOnce();
-
-    sessionId.value = undefined;
-    await nextTick();
-    sessionId.value = "session-3";
-    await nextTick();
-    expect(onReconnect).toHaveBeenCalledTimes(2);
-  });
-
-  it("counts a stream already open when it starts as its first opening", async () => {
-    const sessionId = ref<string | undefined>("session-1");
-    const onReconnect = vi.fn();
-    watchRealtimeReconnects(sessionId, onReconnect);
-
-    sessionId.value = undefined;
-    await nextTick();
-    sessionId.value = "session-2";
-    await nextTick();
-    expect(onReconnect).toHaveBeenCalledOnce();
-  });
-});

package/frontend-vue/tests/metadata-retry.test.ts

@@ -1,202 +0,0 @@
-// @vitest-environment jsdom
-import {
-  type App,
-  type Component,
-  computed,
-  createApp,
-  type FunctionalComponent,
-  h,
-  inject,
-  onBeforeUnmount,
-  onScopeDispose,
-  ref,
-  shallowReactive,
-  useId,
-  watch,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import File from "../layers/dms-ui/app/components/form/components/File.vue";
-import Image from "../layers/dms-ui/app/components/form/components/Image.vue";
-import { browserRuntime, stubApiData } from "./helpers/api-data-runtime";
-import {
-  isDefinitiveMetadataFailure,
-  resolveMetadataRetryDelay,
-} from "../layers/dms-ui/app/utils/metadataRetry";
-
-const authFetch = vi.fn();
-const LONG_WAIT_MS = 120000;
-
-interface FieldCase {
-  name: string;
-  component: Component;
-  modelValue: unknown;
-  unavailableLabel: string;
-  metadata: Record<string, unknown>;
-}
-
-const FIELD_CASES: FieldCase[] = [
-  {
-    name: "File",
-    component: File,
-    modelValue: "files/profile/avatar.pdf",
-    unavailableLabel: "dms.form.file.file_unavailable",
-    metadata: {
-      resourceKey: "files/profile/avatar.pdf",
-      filename: "avatar.pdf",
-      size: 2048,
-      mimetype: "application/pdf",
-      url: "https://example.test/avatar.pdf",
-    },
-  },
-  {
-    name: "Image",
-    component: Image,
-    modelValue: { key: "files/profile/cover.png", alt: "Cover" },
-    unavailableLabel: "dms.form.image.file_unavailable",
-    metadata: {
-      resourceKey: "files/profile/cover.png",
-      filename: "cover.png",
-      size: 2048,
-      mimetype: "image/png",
-      url: "https://example.test/cover.png",
-    },
-  },
-];
-
-const passthrough: FunctionalComponent = (_, { slots }) =>
-  h("span", slots.default?.());
-
-const renderTag =
-  (tag: string): FunctionalComponent =>
-  () =>
-    h(tag);
-
-function httpError(status: number): Error {
-  return Object.assign(new Error(`HTTP ${status}`), {
-    status,
-    statusCode: status,
-  });
-}
-
-function mountField(field: FieldCase): { app: App; container: HTMLElement } {
-  const app = createApp({
-    render: () => h(field.component, { modelValue: field.modelValue }),
-  });
-  browserRuntime(app);
-  app.config.globalProperties.$t = (key: string) => key;
-  for (const name of ["UFileUpload", "ULink", "UTooltip"])
-    app.component(name, passthrough);
-  app.component("UButton", renderTag("button"));
-  app.component("UIcon", renderTag("i"));
-  app.component("UInput", renderTag("input"));
-  app.component("UModal", () => null);
-  const container = document.createElement("div");
-  app.mount(container);
-  return { app, container };
-}
-
-beforeEach(() => {
-  vi.useFakeTimers();
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("watch", watch);
-  vi.stubGlobal("inject", inject);
-  vi.stubGlobal("useId", useId);
-  vi.stubGlobal("onBeforeUnmount", onBeforeUnmount);
-  vi.stubGlobal("onScopeDispose", onScopeDispose);
-  vi.stubGlobal("FORM_FIELD_LOADING_KEY", Symbol());
-  vi.stubGlobal("FORM_CONTENT_LANGUAGE_KEY", Symbol());
-  vi.stubGlobal("CONTENT_LANGUAGE_HEADER", "x-content-language");
-  vi.stubGlobal("shallowReactive", shallowReactive);
-  stubApiData(authFetch);
-  vi.stubGlobal("useUploadWithProgress", () => ({
-    uploadWithProgress: vi.fn(),
-  }));
-  // Outside a UFormField: no error, no aria attributes.
-  vi.stubGlobal("useFormField", () => ({
-    emitFormChange: vi.fn(),
-    color: ref(undefined),
-    highlight: ref(undefined),
-    ariaAttrs: ref(undefined),
-  }));
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  vi.stubGlobal(
-    "useDmsCookie",
-    (_key: string, options: { default: () => unknown }) =>
-      ref(options.default()),
-  );
-  vi.stubGlobal("useToast", () => ({ add: vi.fn() }));
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-  vi.unstubAllGlobals();
-  vi.resetAllMocks();
-});
-
-describe.each(FIELD_CASES)("$name stored-value metadata", (field) => {
-  it.each([403, 404, 410])(
-    "reads a file answered with %i exactly once and shows it unavailable",
-    async (status) => {
-      authFetch.mockRejectedValue(httpError(status));
-      const { app, container } = mountField(field);
-
-      await vi.advanceTimersByTimeAsync(LONG_WAIT_MS);
-
-      expect(authFetch).toHaveBeenCalledTimes(1);
-      expect(container.textContent).toContain(field.unavailableLabel);
-      app.unmount();
-    },
-  );
-
-  it("retries transient failures with a growing delay until the read succeeds", async () => {
-    authFetch
-      .mockRejectedValueOnce(httpError(503))
-      .mockRejectedValueOnce(new Error("network down"))
-      .mockRejectedValueOnce(httpError(429))
-      .mockResolvedValueOnce(field.metadata);
-    const { app, container } = mountField(field);
-    await vi.advanceTimersByTimeAsync(0);
-    expect(authFetch).toHaveBeenCalledTimes(1);
-    expect(container.textContent).toContain(field.unavailableLabel);
-
-    await vi.advanceTimersByTimeAsync(1000);
-    expect(authFetch).toHaveBeenCalledTimes(2);
-    await vi.advanceTimersByTimeAsync(1999);
-    expect(authFetch).toHaveBeenCalledTimes(2);
-    await vi.advanceTimersByTimeAsync(1);
-    expect(authFetch).toHaveBeenCalledTimes(3);
-    await vi.advanceTimersByTimeAsync(4000);
-    expect(authFetch).toHaveBeenCalledTimes(4);
-
-    expect(container.textContent).not.toContain(field.unavailableLabel);
-    await vi.advanceTimersByTimeAsync(LONG_WAIT_MS);
-    expect(authFetch).toHaveBeenCalledTimes(4);
-    app.unmount();
-  });
-});
-
-describe("metadata retry policy", () => {
-  it("treats refusals and missing files as definitive", () => {
-    for (const status of [400, 401, 403, 404, 410])
-      expect(isDefinitiveMetadataFailure(httpError(status))).toBe(true);
-    for (const error of [
-      httpError(408),
-      httpError(429),
-      httpError(500),
-      httpError(503),
-      new Error("network down"),
-      undefined,
-    ])
-      expect(isDefinitiveMetadataFailure(error)).toBe(false);
-  });
-
-  it("backs off exponentially up to a cap and never retries a definitive failure", () => {
-    const transient = httpError(503);
-    expect(resolveMetadataRetryDelay(transient, 1)).toBe(1000);
-    expect(resolveMetadataRetryDelay(transient, 2)).toBe(2000);
-    expect(resolveMetadataRetryDelay(transient, 3)).toBe(4000);
-    expect(resolveMetadataRetryDelay(transient, 50)).toBe(30000);
-    expect(resolveMetadataRetryDelay(httpError(404), 1)).toBeNull();
-  });
-});

package/frontend-vue/tests/meter-block-load-error.test.ts

@@ -1,70 +0,0 @@
-import { createSSRApp, defineComponent, h, ref } from "vue";
-import { renderToString } from "vue/server-renderer";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import MeterBlock from "../layers/dms-ui/app/components/meter/MeterBlock.vue";
-
-const data = ref<Record<string, unknown> | null>(null);
-const error = ref<unknown>(null);
-
-vi.mock("../layers/dms-ui/app/composables/chart/useChartFetch", () => ({
-  useChartFetch: () => ({
-    data,
-    isLoading: ref(false),
-    error,
-    refresh: async () => {},
-  }),
-}));
-
-vi.mock("../layers/dms-core/app/composables/watch/useWatch", () => ({
-  useWatch: () => ({ state: ref({}) }),
-}));
-
-const Slot = defineComponent({
-  props: { label: { type: String, default: undefined } },
-  setup:
-    (props, { slots }) =>
-    () =>
-      h("div", [props.label, slots.default?.()]),
-});
-
-async function render(): Promise<string> {
-  const app = createSSRApp({
-    render: () =>
-      h(MeterBlock, {
-        componentId: "meter",
-        pageId: "page",
-        label: "Seats",
-        fetchUrl: "/seats",
-      }),
-  });
-  for (const name of ["DmsCard", "UIcon", "USkeleton", "UButton"]) {
-    app.component(name, Slot);
-  }
-  return renderToString(app);
-}
-
-beforeEach(() => {
-  data.value = null;
-  error.value = null;
-  vi.stubGlobal("useI18n", () => ({ locale: ref("en-GB"), t: String }));
-  vi.stubGlobal("useTranslation", () => ({ processI18n: String }));
-});
-
-afterEach(() => vi.unstubAllGlobals());
-
-it("shows a failed load as an error with a retry, not as 0 / 100", async () => {
-  error.value = new Error("network");
-  const html = await render();
-  expect(html).toContain("dms.table.load_error_title");
-  expect(html).toContain("dms.table.load_error_retry");
-  expect(html).toContain("Seats");
-  expect(html).not.toContain("100");
-});
-
-it("keeps the last figures when only a refetch fails", async () => {
-  data.value = { value: 8, max: 10 };
-  error.value = new Error("network");
-  const html = await render();
-  expect(html).not.toContain("dms.table.load_error_title");
-  expect(html).toMatch(/8\s*\/\s*10/);
-});

package/frontend-vue/tests/module-routing.test.ts

@@ -1,155 +0,0 @@
-/**
- * A module's own address (`/modules/<id>`) has no page: the navigation that
- * enters it goes to the module's landing page instead — its `landingPage`
- * when the caller may open it, else its first page — keeping the query and
- * the hash it was entered with. The middleware answers the landing page
- * rather than navigating to it, so the module's address never renders and,
- * in a server render, becomes the response's redirect. A page the browser
- * already draws at the module's address (a link that skipped the guard) loads
- * the landing page instead of navigating from its own setup.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { ref } from "vue";
-import { MODULE_URL_PREFIX } from "../layers/dms-layout/app/types/page";
-
-interface TreeNode {
-  id: string;
-  fullSlug: string;
-  layoutUrl?: string;
-  hasAccess?: boolean;
-  isModuleRoot?: boolean;
-  children: Record<string, TreeNode>;
-  childrenOrders: string[];
-}
-
-interface GuardedRoute {
-  path: string;
-  fullPath: string;
-}
-
-type Middleware = (to: GuardedRoute, from?: GuardedRoute) => Promise<unknown>;
-
-const navigateDms = vi.fn();
-
-function node(
-  id: string,
-  fullSlug: string,
-  children: TreeNode[] = [],
-  page: Partial<TreeNode> = {},
-): TreeNode {
-  return {
-    id,
-    fullSlug,
-    children: Object.fromEntries(children.map((child) => [child.id, child])),
-    childrenOrders: children.map((child) => child.id),
-    ...page,
-  };
-}
-
-const PAGE = { layoutUrl: "/layout" };
-
-function treeOf(moduleRoot: TreeNode): TreeNode {
-  return node("", "/", [node("modules", "/modules", [moduleRoot])]);
-}
-
-const apiModule = (pages: Partial<Record<string, Partial<TreeNode>>> = {}) =>
-  node(
-    "api",
-    "/modules/api",
-    [
-      node("monitor", "/modules/api", [
-        node("routes", "/modules/api/routes", [], { ...PAGE, ...pages.routes }),
-        node("overview", "/modules/api/overview", [], {
-          ...PAGE,
-          ...pages.overview,
-        }),
-      ]),
-    ],
-    { isModuleRoot: true },
-  );
-
-function stubSiteLayout(moduleRoot: TreeNode, landingPage?: string) {
-  vi.stubGlobal("useSiteLayout", () => ({
-    siteLayout: ref({}),
-    siteLayoutTree: ref(treeOf(moduleRoot)),
-    modules: ref({ api: { id: "api", hasAccess: true, landingPage } }),
-    findMatchingRoute: (path: string) =>
-      path.startsWith("/modules/api/") ? { metadata: {} } : null,
-    loadSiteLayout: vi.fn(),
-  }));
-}
-
-async function enter(fullPath: string, drawnThere = false): Promise<unknown> {
-  const middleware = (
-    await import("../layers/dms-layout/app/middleware/module-routing.global")
-  ).default as unknown as Middleware;
-  const path = fullPath.replace(/[?#].*$/, "");
-  const to = { path, fullPath };
-  return middleware(to, drawnThere ? to : { path: "/home", fullPath: "/home" });
-}
-
-beforeEach(() => {
-  vi.resetModules();
-  vi.stubGlobal("defineDmsMiddleware", (handler: Middleware) => handler);
-  vi.stubGlobal("MODULE_URL_PREFIX", MODULE_URL_PREFIX);
-  vi.stubGlobal("navigateDms", navigateDms);
-  vi.stubGlobal("useHomepage", () => "/dashboard");
-  vi.stubGlobal("useModuleHistory", () => ({ record: vi.fn() }));
-  vi.stubGlobal("createDmsError", (error: unknown) => error);
-});
-
-afterEach(() => {
-  navigateDms.mockReset();
-  vi.unstubAllGlobals();
-});
-
-describe("entering a module", () => {
-  it("goes to the module's landingPage", async () => {
-    stubSiteLayout(apiModule(), "overview");
-    expect(await enter("/modules/api")).toBe("/modules/api/overview");
-    expect(navigateDms).not.toHaveBeenCalled();
-  });
-
-  it("keeps the query and the hash it was entered with", async () => {
-    stubSiteLayout(apiModule(), "overview");
-    expect(await enter("/modules/api?live=0#errors")).toBe(
-      "/modules/api/overview?live=0#errors",
-    );
-  });
-
-  it("goes to the first page when there is no landingPage", async () => {
-    stubSiteLayout(apiModule());
-    expect(await enter("/modules/api")).toBe("/modules/api/routes");
-  });
-
-  it("goes to the first page the caller may open when the landingPage is closed to them", async () => {
-    stubSiteLayout(apiModule({ overview: { hasAccess: false } }), "overview");
-    expect(await enter("/modules/api")).toBe("/modules/api/routes");
-  });
-
-  it("sends to the homepage a caller who may open none of its pages", async () => {
-    stubSiteLayout(
-      apiModule({
-        routes: { hasAccess: false },
-        overview: { hasAccess: false },
-      }),
-      "overview",
-    );
-    await enter("/modules/api");
-    expect(navigateDms).toHaveBeenCalledWith("/dashboard", { replace: true });
-  });
-
-  it("loads the landing page when the browser already draws the module's address", async () => {
-    stubSiteLayout(apiModule(), "overview");
-    const replace = vi.fn();
-    vi.stubGlobal("window", { location: { replace } });
-    expect(await enter("/modules/api?live=0", true)).toBe(false);
-    expect(replace).toHaveBeenCalledWith("/modules/api/overview?live=0");
-  });
-
-  it("leaves a module page alone", async () => {
-    stubSiteLayout(apiModule(), "overview");
-    expect(await enter("/modules/api/routes?tab=tester")).toBeUndefined();
-    expect(navigateDms).not.toHaveBeenCalled();
-  });
-});