@antelopejs/dms 0.9.2 → 0.9.3

package/frontend-vue/tests/quick-action-intent.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  QUICK_ACTION_ADD,
-  QUICK_ACTION_BUTTON,
-  QUICK_ACTION_BUTTON_KEY,
-  QUICK_ACTION_COMPONENT_KEY,
-  QUICK_ACTION_QUERY_KEY,
-  readQuickActionIntent,
-} from "../layers/dms-ui/app/types/quick-actions";
-
-const COMPONENT_ID = "table";
-
-describe("readQuickActionIntent", () => {
-  it("reads an open-form intent addressed to the table view", () => {
-    const intent = readQuickActionIntent(
-      {
-        [QUICK_ACTION_QUERY_KEY]: QUICK_ACTION_ADD,
-        [QUICK_ACTION_COMPONENT_KEY]: COMPONENT_ID,
-      },
-      COMPONENT_ID,
-    );
-
-    expect(intent).toEqual({ kind: "add" });
-  });
-
-  it("reads which button a button intent presses", () => {
-    const intent = readQuickActionIntent(
-      {
-        [QUICK_ACTION_QUERY_KEY]: QUICK_ACTION_BUTTON,
-        [QUICK_ACTION_COMPONENT_KEY]: COMPONENT_ID,
-        [QUICK_ACTION_BUTTON_KEY]: "invite",
-      },
-      COMPONENT_ID,
-    );
-
-    expect(intent).toEqual({ kind: "button", button: "invite" });
-  });
-
-  it("ignores a button intent that names no button", () => {
-    const intent = readQuickActionIntent(
-      {
-        [QUICK_ACTION_QUERY_KEY]: QUICK_ACTION_BUTTON,
-        [QUICK_ACTION_COMPONENT_KEY]: COMPONENT_ID,
-      },
-      COMPONENT_ID,
-    );
-
-    expect(intent).toBeUndefined();
-  });
-
-  it("ignores an intent addressed to another table view", () => {
-    const intent = readQuickActionIntent(
-      {
-        [QUICK_ACTION_QUERY_KEY]: QUICK_ACTION_ADD,
-        [QUICK_ACTION_COMPONENT_KEY]: "other-table",
-      },
-      COMPONENT_ID,
-    );
-
-    expect(intent).toBeUndefined();
-  });
-
-  it("ignores an unknown intent", () => {
-    const intent = readQuickActionIntent(
-      {
-        [QUICK_ACTION_QUERY_KEY]: "unknown",
-        [QUICK_ACTION_COMPONENT_KEY]: COMPONENT_ID,
-      },
-      COMPONENT_ID,
-    );
-
-    expect(intent).toBeUndefined();
-  });
-});

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

@@ -1,55 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { dispatchQuickActionTarget } from "../layers/dms-layout/app/composables/page/useQuickActions";
-import {
-  QUICK_ACTION_ADD,
-  QUICK_ACTION_BUTTON,
-  QUICK_ACTION_BUTTON_KEY,
-  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",
-      },
-    });
-  });
-
-  it("routes button actions to the target table with the button to press", () => {
-    const navigateDms = vi.fn();
-    vi.stubGlobal("navigateDms", navigateDms);
-
-    dispatchQuickActionTarget({
-      type: "button",
-      to: "/settings/workspace/members",
-      component: "table",
-      button: "invite",
-    });
-
-    expect(navigateDms).toHaveBeenCalledWith({
-      path: "/settings/workspace/members",
-      query: {
-        [QUICK_ACTION_QUERY_KEY]: QUICK_ACTION_BUTTON,
-        [QUICK_ACTION_COMPONENT_KEY]: "table",
-        [QUICK_ACTION_BUTTON_KEY]: "invite",
-      },
-    });
-  });
-});

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

@@ -1,146 +0,0 @@
-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/realtime-reconnect.test.ts

@@ -1,234 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { nextTick, ref, watch } from "vue";
-import type { UserRealtimeApi } from "../layers/dms-core/app/composables/realtime/useUserRealtime";
-
-const BASE_URL = "http://api";
-const USER_STREAM_URL = `${BASE_URL}/api/realtime/user`;
-const SUBSCRIBE_URL_PREFIX = `${BASE_URL}/api/realtime/subscribe/`;
-const SESSION_HEADER = "x-realtime-session";
-const PAGE_ID = "orders";
-const INITIAL_DELAY_MS = 500;
-const SECOND_DELAY_MS = 1000;
-const LONG_WAIT_MS = 120_000;
-
-interface FakeStream {
-  signal: AbortSignal;
-  end(): void;
-  isOpen(): boolean;
-}
-
-interface PageSubscription {
-  pageId: string;
-  sessionId: string;
-}
-
-interface FakeServer {
-  streams: FakeStream[];
-  subscriptions: PageSubscription[];
-  maxOpenStreams: number;
-  isDown: boolean;
-}
-
-const encoder = new TextEncoder();
-
-const helloFrame = (sessionId: string): Uint8Array =>
-  encoder.encode(`event: hello\ndata: ${JSON.stringify({ sessionId })}\n\n`);
-
-const openStreamCount = (server: FakeServer): number =>
-  server.streams.filter((stream) => stream.isOpen()).length;
-
-const openUserStream = (server: FakeServer, signal: AbortSignal) => {
-  let controller!: ReadableStreamDefaultController<Uint8Array>;
-  let isOpen = true;
-  const body = new ReadableStream<Uint8Array>({
-    start(streamController) {
-      controller = streamController;
-    },
-    cancel() {
-      isOpen = false;
-    },
-  });
-  signal.addEventListener("abort", () => {
-    isOpen = false;
-  });
-  server.streams.push({
-    signal,
-    end: () => {
-      isOpen = false;
-      controller.close();
-    },
-    isOpen: () => isOpen && !signal.aborted,
-  });
-  server.maxOpenStreams = Math.max(
-    server.maxOpenStreams,
-    openStreamCount(server),
-  );
-  controller.enqueue(helloFrame(`session-${server.streams.length}`));
-  return { ok: true, status: 200, body };
-};
-
-const installFetch = (server: FakeServer): void => {
-  globalThis.fetch = vi.fn(async (url: string, init?: RequestInit) => {
-    if (url === USER_STREAM_URL) {
-      if (server.isDown) throw new Error("connection refused");
-      return openUserStream(server, init!.signal!);
-    }
-    const headers = init?.headers as Record<string, string>;
-    const pageId = url.slice(SUBSCRIBE_URL_PREFIX.length);
-    server.subscriptions.push({
-      pageId,
-      sessionId: headers[SESSION_HEADER]!,
-    });
-    return {
-      ok: true,
-      status: 200,
-      json: async () => ({ ok: true, topics: [`table:${pageId}`] }),
-    };
-  }) as unknown as typeof fetch;
-};
-
-const settle = async (): Promise<void> => {
-  await vi.advanceTimersByTimeAsync(0);
-  await nextTick();
-  await vi.advanceTimersByTimeAsync(0);
-};
-
-const realFetch = globalThis.fetch;
-let loggedIn = ref(false);
-let server: FakeServer;
-
-const loadApi = async (): Promise<UserRealtimeApi> => {
-  const module = await import(
-    "../layers/dms-core/app/composables/realtime/useUserRealtime"
-  );
-  return module.useUserRealtime();
-};
-
-const lastStream = (): FakeStream => server.streams[server.streams.length - 1]!;
-
-beforeEach(() => {
-  vi.resetModules();
-  vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-  vi.stubEnv("SSR", false);
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("watch", watch);
-  vi.stubGlobal("useDmsState", (_key: string, init: () => unknown) =>
-    ref(init()),
-  );
-  vi.stubGlobal("useDmsRuntimeConfig", () => ({
-    public: { dms: { baseURL: BASE_URL } },
-  }));
-  vi.stubGlobal("useDmsUserSession", () => ({ loggedIn }));
-  vi.stubGlobal("useSessionRecovery", () => ({
-    refreshSession: async () => true,
-    redirectToAuth: async () => {},
-  }));
-  server = { streams: [], subscriptions: [], maxOpenStreams: 0, isDown: false };
-  installFetch(server);
-  // Fresh per test: the singleton of a previous test keeps watching its own.
-  loggedIn = ref(true);
-});
-
-afterEach(async () => {
-  loggedIn.value = false;
-  await settle();
-  globalThis.fetch = realFetch;
-  vi.useRealTimers();
-  vi.unstubAllGlobals();
-  vi.unstubAllEnvs();
-});
-
-describe("useUserRealtime reconnection", () => {
-  it("reconnects with backoff when the server ends the stream, then resubscribes the page", async () => {
-    const api = await loadApi();
-    await settle();
-    await api.setPage(PAGE_ID);
-    expect(api.sessionId.value).toBe("session-1");
-    expect(server.subscriptions).toEqual([
-      { pageId: PAGE_ID, sessionId: "session-1" },
-    ]);
-
-    lastStream().end();
-    await settle();
-    expect(api.sessionId.value).toBeUndefined();
-    await vi.advanceTimersByTimeAsync(INITIAL_DELAY_MS - 1);
-    expect(server.streams).toHaveLength(1);
-
-    await vi.advanceTimersByTimeAsync(1);
-    await settle();
-    expect(server.streams).toHaveLength(2);
-    expect(api.sessionId.value).toBe("session-2");
-    expect(server.subscriptions).toEqual([
-      { pageId: PAGE_ID, sessionId: "session-1" },
-      { pageId: PAGE_ID, sessionId: "session-2" },
-    ]);
-  });
-
-  it("holds the page's topics its subscription answered, until the stream drops", async () => {
-    const api = await loadApi();
-    await settle();
-    await api.setPage(PAGE_ID);
-    expect(api.pageTopics.value).toEqual([`table:${PAGE_ID}`]);
-
-    lastStream().end();
-    await settle();
-    expect(api.pageTopics.value).toEqual([]);
-    await vi.advanceTimersByTimeAsync(INITIAL_DELAY_MS);
-    await settle();
-    expect(api.pageTopics.value).toEqual([`table:${PAGE_ID}`]);
-  });
-
-  it("backs off further while the server stays unreachable", async () => {
-    await loadApi();
-    await settle();
-    server.isDown = true;
-
-    lastStream().end();
-    await settle();
-    await vi.advanceTimersByTimeAsync(INITIAL_DELAY_MS);
-    await settle();
-    expect(vi.mocked(globalThis.fetch)).toHaveBeenCalledTimes(2);
-
-    server.isDown = false;
-    await vi.advanceTimersByTimeAsync(SECOND_DELAY_MS - 1);
-    expect(server.streams).toHaveLength(1);
-    await vi.advanceTimersByTimeAsync(1);
-    await settle();
-    expect(server.streams).toHaveLength(2);
-    expect(lastStream().isOpen()).toBe(true);
-  });
-
-  it("does not reconnect after an intentional close", async () => {
-    await loadApi();
-    await settle();
-    const stream = lastStream();
-
-    loggedIn.value = false;
-    await settle();
-    expect(stream.signal.aborted).toBe(true);
-
-    await vi.advanceTimersByTimeAsync(LONG_WAIT_MS);
-    await settle();
-    expect(server.streams).toHaveLength(1);
-  });
-
-  it("never holds more than one stream at a time", async () => {
-    await loadApi();
-    await settle();
-
-    for (let cycle = 0; cycle < 3; cycle += 1) {
-      lastStream().end();
-      await settle();
-      await vi.advanceTimersByTimeAsync(INITIAL_DELAY_MS);
-      await settle();
-    }
-    loggedIn.value = false;
-    await settle();
-    loggedIn.value = true;
-    await settle();
-
-    expect(server.streams).toHaveLength(5);
-    expect(server.maxOpenStreams).toBe(1);
-    expect(openStreamCount(server)).toBe(1);
-  });
-});

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

@@ -1,73 +0,0 @@
-// @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);
-  });
-});