@antelopejs/dms 0.5.5 → 0.6.0

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

@@ -38,13 +38,13 @@ describe("dispatchQuickActionTarget", () => {
 
     dispatchQuickActionTarget({
       type: "button",
-      to: "/settings/user/members",
+      to: "/settings/workspace/members",
       component: "table",
       button: "invite",
     });
 
     expect(navigateDms).toHaveBeenCalledWith({
-      path: "/settings/user/members",
+      path: "/settings/workspace/members",
       query: {
         [QUICK_ACTION_QUERY_KEY]: QUICK_ACTION_BUTTON,
         [QUICK_ACTION_COMPONENT_KEY]: "table",

package/frontend-vue/tests/record-card.test.ts

@@ -0,0 +1,73 @@
+// @vitest-environment jsdom
+import {
+  computed,
+  createApp,
+  defineComponent,
+  h,
+  nextTick,
+  type App,
+  type Component,
+} from "vue";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import DmsRecordCard from "../layers/dms-ui/app/components/record-card/RecordCard.vue";
+
+let app: App | undefined;
+
+function mount(component: Component, props: Record<string, unknown>) {
+  app = createApp(defineComponent({ setup: () => () => h(component, props) }));
+  app.component(
+    "UButton",
+    defineComponent({
+      props: { label: String },
+      emits: ["click"],
+      setup:
+        (props, { emit }) =>
+        () =>
+          h("button", { onClick: () => emit("click") }, props.label),
+    }),
+  );
+  app.component("UIcon", defineComponent({ render: () => h("i") }));
+  const container = document.createElement("div");
+  app.mount(container);
+  return container;
+}
+
+beforeEach(() => {
+  vi.stubGlobal("computed", computed);
+});
+
+afterEach(() => {
+  app?.unmount();
+  app = undefined;
+  vi.unstubAllGlobals();
+});
+
+describe("DmsRecordCard", () => {
+  it("draws the record and opens it, its buttons acting without opening it", async () => {
+    const onOpen = vi.fn();
+    const onEdit = vi.fn();
+    const container = mount(DmsRecordCard as Component, {
+      title: "Saved views",
+      subtitle: "@antelopejs/dms",
+      badge: { label: "Tables" },
+      tags: ["Tables"],
+      meta: "42 votes",
+      actions: [{ label: "Edit", onClick: onEdit }],
+      interactive: true,
+      onOpen,
+    });
+    const text = container.textContent ?? "";
+    expect(text).toContain("Saved views");
+    expect(text).toContain("@antelopejs/dms");
+    expect(text).toContain("42 votes");
+    expect(container.querySelector("article")?.getAttribute("tabindex")).toBe(
+      "0",
+    );
+
+    container.querySelector("button")!.click();
+    await nextTick();
+    expect(onOpen).not.toHaveBeenCalled();
+    container.querySelector("article")!.click();
+    expect(onOpen).toHaveBeenCalledTimes(1);
+  });
+});

package/frontend-vue/tests/regional-format.test.ts

@@ -0,0 +1,67 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ref } from "vue";
+import { useRegionalFormat } from "../layers/dms-core/app/composables/user/useRegionalFormat";
+import { setRegionalPreferencesSource } from "../layers/dms-core/app/utils/regional";
+
+// 23:30 UTC on 30 Sep: already 1 Oct in Brussels.
+const LATE_EVENING_UTC = new Date(Date.UTC(2026, 8, 30, 23, 30));
+const DAY_MONTH_YEAR: Intl.DateTimeFormatOptions = {
+  day: "numeric",
+  month: "long",
+  year: "numeric",
+};
+
+const locale = ref("fr-FR");
+
+beforeEach(() => {
+  locale.value = "fr-FR";
+  vi.stubGlobal("useI18n", () => ({
+    t: (key: string, params?: Record<string, unknown>) =>
+      `${key}:${JSON.stringify(params ?? {})}`,
+    locale,
+  }));
+  setRegionalPreferencesSource(() => ({ timeZone: "Europe/Brussels" }));
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  setRegionalPreferencesSource(() => ({}));
+});
+
+describe("useRegionalFormat", () => {
+  it("writes dates in the user's language and time zone", () => {
+    const { formatDate } = useRegionalFormat();
+    expect(formatDate(LATE_EVENING_UTC, DAY_MONTH_YEAR)).toBe("1 octobre 2026");
+  });
+
+  it("follows a language switch", () => {
+    const { formatDate } = useRegionalFormat();
+    locale.value = "en-GB";
+    expect(formatDate(LATE_EVENING_UTC, DAY_MONTH_YEAR)).toBe("1 October 2026");
+  });
+
+  it("applies the user's clock to its own formats", () => {
+    setRegionalPreferencesSource(() => ({
+      timeZone: "Europe/Brussels",
+      timeFormat: "h12",
+    }));
+    const { dateTimeFormat } = useRegionalFormat();
+    locale.value = "en-GB";
+    expect(
+      dateTimeFormat({ hour: "numeric", minute: "2-digit" }).format(
+        LATE_EVENING_UTC,
+      ),
+    ).toBe("1:30 am");
+  });
+
+  it("writes numbers in the user's language", () => {
+    const { formatNumber, formatPrice } = useRegionalFormat();
+    expect(formatNumber(1234.5)).toBe("1 234,5");
+    expect(formatPrice(12)).toBe("12,00 €");
+  });
+
+  it("translates relative dates with the application's messages", () => {
+    const { formatRelativeTime } = useRegionalFormat();
+    expect(formatRelativeTime(Date.now())).toBe("common.time.just_now:{}");
+  });
+});

package/frontend-vue/tests/regional-preferences.test.ts

@@ -0,0 +1,209 @@
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  formatDate,
+  formatDateTime,
+  formatRelativeTime,
+} from "../layers/dms-core/app/utils/formatter";
+import {
+  readRegionalPreferences,
+  regionalDayKey,
+  regionalDayNumber,
+  regionalWeekStart,
+  setRegionalPreferencesSource,
+  withRegionalOptions,
+} from "../layers/dms-core/app/utils/regional";
+import {
+  buildTimeZoneOptions,
+  timeZoneLabel,
+  timeZoneOffset,
+} from "../layers/dms-layout/app/build/components/pages/settings/region/timeZones";
+import { groupNotificationsByDay } from "../layers/dms-layout/app/build/components/pages/settings/notification/notificationDisplay";
+import type { UserNotification } from "../layers/dms-layout/app/composables/notification/useNotifications";
+
+// 23:30 UTC on 30 Sep: already 1 Oct in Brussels, still 30 Sep in New York.
+const LATE_EVENING_UTC = new Date(Date.UTC(2026, 8, 30, 23, 30));
+
+afterEach(() => {
+  setRegionalPreferencesSource(() => ({}));
+});
+
+describe("readRegionalPreferences", () => {
+  it("keeps the values this runtime can apply", () => {
+    expect(
+      readRegionalPreferences({
+        timeZone: "Europe/Brussels",
+        weekStart: 0,
+        timeFormat: "h12",
+        dateFormat: "numeric",
+      }),
+    ).toEqual({
+      timeZone: "Europe/Brussels",
+      weekStart: 0,
+      timeFormat: "h12",
+      dateFormat: "numeric",
+    });
+  });
+
+  it("drops unknown zones and values as automatic", () => {
+    expect(
+      readRegionalPreferences({
+        timeZone: "Mars/Olympus",
+        weekStart: 3,
+        timeFormat: "h24",
+        dateFormat: null,
+      }),
+    ).toEqual({
+      timeZone: undefined,
+      weekStart: undefined,
+      timeFormat: undefined,
+      dateFormat: undefined,
+    });
+    expect(readRegionalPreferences(null)).toEqual({});
+  });
+});
+
+describe("withRegionalOptions", () => {
+  it("adds the zone and the clock, never over what the caller states", () => {
+    const preferences = {
+      timeZone: "Asia/Tokyo",
+      timeFormat: "h12" as const,
+    };
+    expect(withRegionalOptions({ hour: "2-digit" }, {}, preferences)).toEqual({
+      hour: "2-digit",
+      timeZone: "Asia/Tokyo",
+      hourCycle: "h12",
+    });
+    expect(
+      withRegionalOptions(
+        { hour: "2-digit", hour12: false, timeZone: "UTC" },
+        {},
+        preferences,
+      ),
+    ).toEqual({ hour: "2-digit", hour12: false, timeZone: "UTC" });
+  });
+
+  it("leaves the clock alone on a date without time", () => {
+    expect(
+      withRegionalOptions({ day: "numeric" }, {}, { timeFormat: "h12" }),
+    ).toEqual({ day: "numeric" });
+  });
+
+  it("keeps the browser zone for calendar days", () => {
+    expect(
+      withRegionalOptions(
+        { day: "numeric" },
+        { keepLocalZone: true },
+        { timeZone: "Asia/Tokyo" },
+      ),
+    ).toEqual({ day: "numeric" });
+  });
+
+  it("rewrites full dates to the chosen date format only", () => {
+    const numeric = { dateFormat: "numeric" as const };
+    expect(
+      withRegionalOptions(
+        { day: "2-digit", month: "long", year: "numeric" },
+        {},
+        numeric,
+      ),
+    ).toEqual({ day: "2-digit", month: "2-digit", year: "numeric" });
+    expect(
+      withRegionalOptions(
+        { dateStyle: "medium", timeStyle: "short" },
+        {},
+        numeric,
+      ),
+    ).toEqual({
+      day: "2-digit",
+      month: "2-digit",
+      year: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+    });
+    // "Sep 27" has no year: not a full date.
+    expect(
+      withRegionalOptions({ day: "numeric", month: "short" }, {}, numeric),
+    ).toEqual({ day: "numeric", month: "short" });
+    expect(
+      withRegionalOptions(
+        { day: "2-digit", month: "2-digit", year: "numeric" },
+        {},
+        { dateFormat: "text" },
+      ),
+    ).toEqual({ day: "2-digit", month: "short", year: "numeric" });
+  });
+});
+
+describe("shared formatters follow the user's preferences", () => {
+  it("writes dates and times in the chosen zone and clock", () => {
+    setRegionalPreferencesSource(() => ({
+      timeZone: "Europe/Brussels",
+      timeFormat: "h12",
+      dateFormat: "numeric",
+    }));
+    expect(formatDate(LATE_EVENING_UTC, "en-GB")).toBe("01/10/2026");
+    expect(
+      formatDateTime(LATE_EVENING_UTC, "en-GB", { second: undefined }),
+    ).toMatch(/01\/10\/2026.*1:30.*am/i);
+
+    setRegionalPreferencesSource(() => ({ timeZone: "America/New_York" }));
+    expect(formatDate(LATE_EVENING_UTC, "en-GB")).toBe("30 September 2026");
+  });
+
+  it("counts days in the chosen zone", () => {
+    const brussels = { timeZone: "Europe/Brussels" };
+    const newYork = { timeZone: "America/New_York" };
+    expect(
+      regionalDayNumber(LATE_EVENING_UTC, brussels) -
+        regionalDayNumber(LATE_EVENING_UTC, newYork),
+    ).toBe(1);
+    setRegionalPreferencesSource(() => brussels);
+    expect(regionalDayKey(LATE_EVENING_UTC)).toBe("2026-10-01");
+  });
+
+  it("names yesterday in the chosen zone", () => {
+    setRegionalPreferencesSource(() => ({ timeFormat: "h23" }));
+    const t = (key: string, params?: Record<string, unknown>) =>
+      `${key}:${JSON.stringify(params ?? {})}`;
+    const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
+    expect(formatRelativeTime(twoDaysAgo, t, "fr-FR")).toContain(
+      "common.time.on_date",
+    );
+  });
+
+  it("files notifications under the reader's day", () => {
+    setRegionalPreferencesSource(() => ({ timeZone: "Europe/Brussels" }));
+    const now = new Date(Date.UTC(2026, 9, 1, 8));
+    const groups = groupNotificationsByDay(
+      [{ createdAt: LATE_EVENING_UTC.toISOString() } as UserNotification],
+      now,
+    );
+    expect(groups.map((group) => group.key)).toEqual(["today"]);
+  });
+
+  it("starts the week on the chosen day, else the locale's", () => {
+    expect(regionalWeekStart("en", { weekStart: 0 })).toBe(0);
+    expect(regionalWeekStart("fr", {})).toBe(1);
+  });
+});
+
+describe("time zone picker entries", () => {
+  it("labels and sorts zones by offset", () => {
+    const at = new Date(Date.UTC(2026, 0, 15));
+    expect(timeZoneLabel("America/Argentina/Buenos_Aires")).toBe(
+      "America / Argentina / Buenos Aires",
+    );
+    expect(timeZoneOffset("UTC", at)).toBe("UTC+00:00");
+    expect(timeZoneOffset("Asia/Kolkata", at)).toBe("UTC+05:30");
+    const options = buildTimeZoneOptions(
+      ["Asia/Tokyo", "UTC", "America/New_York"],
+      at,
+      ["UTC", ""],
+    );
+    expect(options.map((option) => option.value)).toEqual([
+      "America/New_York",
+      "UTC",
+      "Asia/Tokyo",
+    ]);
+  });
+});

package/frontend-vue/tests/relation-value.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { sameRelationValue } from "../layers/dms-ui/app/build/composables/data-types/relationValue";
+
+const ANN = { _id: "u-1", name: "Ann", avatar: "ann.png" };
+const BOB = { _id: "u-2", name: "Bob" };
+const SINGLE = { keyMapping: { label: "name", value: "_id" } };
+const MULTIPLE = { ...SINGLE, multiple: true };
+
+describe("sameRelationValue", () => {
+  it("matches the row the server joined with the id the picker holds", () => {
+    expect(sameRelationValue(ANN, "u-1", SINGLE)).toBe(true);
+    expect(sameRelationValue("u-1", ANN, SINGLE)).toBe(true);
+  });
+
+  it("tells another row apart", () => {
+    expect(sameRelationValue(ANN, "u-2", SINGLE)).toBe(false);
+  });
+
+  it("reads the id under the field's value key", () => {
+    const bySlug = { keyMapping: { value: "slug" } };
+    expect(sameRelationValue({ slug: "ann" }, "ann", bySlug)).toBe(true);
+    expect(sameRelationValue({ slug: "ann", _id: "u-1" }, "u-1", bySlug)).toBe(
+      false,
+    );
+  });
+
+  it("compares the picks of a multiple relation as a set", () => {
+    expect(sameRelationValue([ANN, BOB], ["u-2", "u-1"], MULTIPLE)).toBe(true);
+    expect(sameRelationValue([ANN, BOB], ["u-1"], MULTIPLE)).toBe(false);
+    expect(sameRelationValue([ANN], ["u-1", "u-1"], MULTIPLE)).toBe(false);
+  });
+
+  it("holds every empty value the same, and none the same as a pick", () => {
+    expect(sameRelationValue(null, undefined, SINGLE)).toBe(true);
+    expect(sameRelationValue([], undefined, MULTIPLE)).toBe(true);
+    expect(sameRelationValue(null, "u-1", SINGLE)).toBe(false);
+    expect(sameRelationValue([], [ANN], MULTIPLE)).toBe(false);
+  });
+});

package/frontend-vue/tests/resolve-dms-component.test.ts

@@ -0,0 +1,47 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const engine = vi.hoisted(() => ({
+  resolveDmsComponent: vi.fn(),
+}));
+
+vi.mock("#dms/frontend-module", () => engine);
+
+const SecurityStatus = { name: "SecurityStatus" };
+
+describe("resolveDmsComponent", () => {
+  beforeEach(() => {
+    engine.resolveDmsComponent.mockImplementation((name: string) =>
+      name === "DmsSecurityStatus" ? SecurityStatus : undefined,
+    );
+  });
+
+  afterEach(() => {
+    engine.resolveDmsComponent.mockReset();
+  });
+
+  async function load() {
+    return import("../layers/dms-ui/app/composables/resolveDmsComponent");
+  }
+
+  it("resolves a component through the engine by its full name", async () => {
+    const { resolveDmsComponent } = await load();
+
+    expect(resolveDmsComponent("DmsSecurityStatus")).toBe(SecurityStatus);
+    expect(engine.resolveDmsComponent).toHaveBeenCalledWith(
+      "DmsSecurityStatus",
+    );
+  });
+
+  it("resolves nothing for a name the engine does not know", async () => {
+    const { resolveDmsComponent } = await load();
+
+    expect(resolveDmsComponent("SecurityStatus")).toBeUndefined();
+  });
+
+  it("resolves nothing without a name", async () => {
+    const { resolveDmsComponent } = await load();
+
+    expect(resolveDmsComponent(undefined)).toBeUndefined();
+    expect(engine.resolveDmsComponent).not.toHaveBeenCalled();
+  });
+});

package/frontend-vue/tests/response-warning-toast.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 import {
   readResponseWarning,
   resolveResponseToast,
-} from "../layers/dms-ui/app/utils/responseWarning";
+} from "../layers/dms-ui/app/build/utils/responseWarning";
 import en from "../layers/dms-layout/i18n/locales/layout-en-GB.json";
 import fr from "../layers/dms-layout/i18n/locales/layout-fr-FR.json";
 import uiEn from "../layers/dms-ui/i18n/locales/ui-en-GB.json";

package/frontend-vue/tests/revealed-backup-codes.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { nextTick, ref } from "vue";
+import { useRevealedBackupCodes } from "../layers/dms-layout/app/build/composables/settings/security/useRevealedBackupCodes";
+
+const ALICE = "user-alice";
+const BOB = "user-bob";
+const ALICE_CODES = ["11111111", "22222222"];
+
+async function revealForAlice() {
+  const userId = ref<string | undefined>(ALICE);
+  const revealed = useRevealedBackupCodes(userId);
+  revealed.reveal(ALICE_CODES, true);
+  revealed.isOpen.value = true;
+  await nextTick();
+  return { userId, ...revealed };
+}
+
+describe("useRevealedBackupCodes", () => {
+  it("shows a freshly issued set to the account it was issued for", async () => {
+    const { codes, isRegenerated } = await revealForAlice();
+    expect(codes.value).toEqual(ALICE_CODES);
+    expect(isRegenerated.value).toBe(true);
+  });
+
+  // Switching accounts in the same tab does not reload the page: the next
+  // account could open the dialog and read, or "save", the previous codes.
+  it("never shows them to another account of the same tab", async () => {
+    const { userId, codes, isOpen } = await revealForAlice();
+    userId.value = BOB;
+    expect(codes.value).toEqual([]);
+    await nextTick();
+    expect(isOpen.value).toBe(false);
+    userId.value = ALICE;
+    expect(codes.value).toEqual([]);
+  });
+
+  it("forgets them on sign-out", async () => {
+    const { userId, codes } = await revealForAlice();
+    userId.value = undefined;
+    await nextTick();
+    userId.value = ALICE;
+    expect(codes.value).toEqual([]);
+  });
+
+  it("forgets them once their dialog closes", async () => {
+    const { codes, isOpen, isRegenerated } = await revealForAlice();
+    isOpen.value = false;
+    await nextTick();
+    expect(codes.value).toEqual([]);
+    expect(isRegenerated.value).toBe(false);
+  });
+
+  it("keeps nothing without a signed-in account", () => {
+    const { codes, reveal } = useRevealedBackupCodes(ref(undefined));
+    reveal(ALICE_CODES);
+    expect(codes.value).toEqual([]);
+  });
+});