@antelopejs/dms 0.7.13 → 0.7.15

package/frontend-vue/tests/page-validation-redirect.test.ts

@@ -0,0 +1,221 @@
+// @vitest-environment jsdom
+import {
+  computed,
+  createSSRApp,
+  h,
+  inject,
+  onMounted,
+  onUnmounted,
+  provide,
+  ref,
+  toRef,
+  watch,
+  type FunctionalComponent,
+} from "vue";
+import { renderToString } from "vue/server-renderer";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import CatchAllPage from "../layers/dms-layout/app/pages/[...slug].vue";
+import { pageValidationRedirect } from "../layers/dms-layout/app/build/utils/pageValidationRedirect";
+import {
+  runCustomValidation,
+  validateRequiredQueryParams,
+} from "../layers/dms-core/app/utils/query-validation";
+import {
+  PAGE_FILL_HEIGHT_CLASSES,
+  providePageFillHeight,
+  usePageFillHeight,
+} from "../layers/dms-layout/app/composables/layout/usePageFillHeight";
+import type { PageValidation } from "../layers/dms-layout/app/types/page";
+
+vi.mock(
+  "../layers/dms-layout/app/build/composables/dev-reload/useDevReloadHolder",
+  async () => {
+    const { ref } = await import("vue");
+    return { useDevReloading: () => ref(false) };
+  },
+);
+
+const PAGE_PATH = "/modules/marketing/funnel";
+const LIST_PATH = "/modules/marketing/funnels";
+const NOT_FOUND = 404;
+
+class HttpError extends Error {
+  constructor(readonly statusCode: number) {
+    super(`HTTP ${statusCode}`);
+  }
+}
+
+const navigateDms = vi.fn(async () => {});
+const pageQuery = ref<Record<string, unknown>>({});
+const validation = ref<PageValidation | undefined>(undefined);
+
+const PageComponent: FunctionalComponent<{ componentId: string }> = (props) =>
+  h("section", { "data-component": props.componentId });
+PageComponent.props = ["componentId"];
+
+function installRuntime(): void {
+  const pageLayout = ref({
+    components: { report: { componentName: "FunnelReport" } },
+  });
+  const runtime: Record<string, unknown> = {
+    computed,
+    inject,
+    onMounted,
+    onUnmounted,
+    provide,
+    ref,
+    toRef,
+    watch,
+    HTTP_FORBIDDEN: 403,
+    HTTP_INTERNAL_SERVER_ERROR: 500,
+    HTTP_NOT_FOUND: NOT_FOUND,
+    PAGE_FILL_HEIGHT_CLASSES,
+    providePageFillHeight,
+    usePageFillHeight,
+    createError: ({ statusCode }: { statusCode: number }) =>
+      new HttpError(statusCode),
+    defineDmsPageMeta: vi.fn(),
+    firstAccessiblePagePath: vi.fn(),
+    navigateDms,
+    preloadPageLayoutComponents: vi.fn(),
+    providePageRealtime: vi.fn(),
+    resolveDmsComponent: () => "div",
+    runCustomValidation,
+    showError: vi.fn(),
+    validateRequiredQueryParams,
+    useDefinedFunctions: () => ({ getFunction: () => undefined }),
+    useDmsRoute: () => ({ path: PAGE_PATH, query: pageQuery.value }),
+    useHomepage: () => "/",
+    useI18n: () => ({ t: (key: string) => key }),
+    usePageLayout: async () => ({ pageLayout }),
+    usePageRealtime: () => ({}),
+    usePermissions: () => ({
+      permissions: ref([]),
+      refreshIfStale: async () => {},
+    }),
+    useSessionRecovery: () => ({
+      loggedIn: ref(true),
+      reconcileSession: async () => {},
+      redirectToAuth: async () => {},
+    }),
+    useSiteLayout: () => ({
+      siteLayout: ref({ pages: {} }),
+      siteLayoutTree: ref(undefined),
+      loadingError: ref(null),
+      loadSiteLayout: async () => {},
+      refreshIfStale: async () => {},
+      findMatchingRoute: () => ({
+        metadata: {
+          fullId: "marketing.funnel",
+          hasAccess: true,
+          validation: validation.value,
+        },
+        params: {},
+      }),
+    }),
+  };
+  Object.entries(runtime).forEach(([name, value]) =>
+    vi.stubGlobal(name, value),
+  );
+}
+
+interface RenderedPage {
+  host: HTMLElement;
+  errors: unknown[];
+}
+
+async function renderPage(): Promise<RenderedPage> {
+  const errors: unknown[] = [];
+  const app = createSSRApp(() => h(CatchAllPage));
+  app.config.errorHandler = (error) => {
+    errors.push(error);
+  };
+  app.component("DmsRecursiveComponent", PageComponent);
+  const host = document.createElement("div");
+  host.innerHTML = await renderToString(app);
+  return { host, errors };
+}
+
+beforeEach(() => {
+  navigateDms.mockClear();
+  pageQuery.value = {};
+  validation.value = undefined;
+  installRuntime();
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("pageValidationRedirect", () => {
+  const context = {
+    routeParams: { id: "42" },
+    routeQuery: { website: "site-1" },
+  };
+
+  it("is undefined without a redirectTo", () => {
+    expect(
+      pageValidationRedirect(
+        { requiredQueryParams: ["id"] },
+        PAGE_PATH,
+        context,
+      ),
+    ).toBeUndefined();
+  });
+
+  it("fills the page URL's tokens and leaves out an empty query pair", () => {
+    expect(
+      pageValidationRedirect(
+        {
+          redirectTo: `${LIST_PATH}?website={{query.website}}&tab={{query.tab}}`,
+        },
+        PAGE_PATH,
+        context,
+      ),
+    ).toBe(`${LIST_PATH}?website=site-1`);
+  });
+
+  it("refuses a target on the page's own path, which would fail again", () => {
+    expect(
+      pageValidationRedirect(
+        { redirectTo: `${PAGE_PATH}/?id={{query.id}}` },
+        PAGE_PATH,
+        context,
+      ),
+    ).toBeUndefined();
+    expect(
+      pageValidationRedirect({ redirectTo: "?id=1" }, PAGE_PATH, context),
+    ).toBeUndefined();
+  });
+});
+
+describe("a page failing its validation", () => {
+  it("answers not found without a redirectTo", async () => {
+    validation.value = { requiredQueryParams: ["id"] };
+    const { errors } = await renderPage();
+    expect(errors).toEqual([new HttpError(NOT_FOUND)]);
+    expect(navigateDms).not.toHaveBeenCalled();
+  });
+
+  it("replaces the URL with its redirectTo, drawing none of its blocks", async () => {
+    validation.value = {
+      requiredQueryParams: ["id"],
+      redirectTo: `${LIST_PATH}?website={{query.website}}`,
+    };
+    pageQuery.value = { website: "site-1" };
+    const { host, errors } = await renderPage();
+    expect(errors).toEqual([]);
+    expect(navigateDms).toHaveBeenCalledWith(`${LIST_PATH}?website=site-1`, {
+      replace: true,
+    });
+    expect(host.querySelector("[data-component]")).toBeNull();
+  });
+
+  it("draws its blocks once the required query is there", async () => {
+    validation.value = { requiredQueryParams: ["id"], redirectTo: LIST_PATH };
+    pageQuery.value = { id: "f1" };
+    const { host } = await renderPage();
+    expect(navigateDms).not.toHaveBeenCalled();
+    expect(host.querySelector("[data-component]")).not.toBeNull();
+  });
+});

package/frontend-vue/tests/row-side-panel.test.ts

@@ -453,13 +453,13 @@ describe("deep link to a row the table does not list", () => {
     ).toEqual({ isMissing: true });
   });
 
-  it("finds nothing, missing or not, on a refusal or without a row route", async () => {
+  it("marks a refused read as failed and finds nothing without a row route", async () => {
     const refused = async () => {
       throw Object.assign(new Error("Forbidden"), { status: 403 });
     };
     expect(
       await resolveDeepLinkedRow("r9", { listed: rows, idOf, getRow: refused }),
-    ).toEqual({ isMissing: false });
+    ).toEqual({ isMissing: false, isFailed: true });
     const noRoute = async () => undefined;
     expect(
       await resolveDeepLinkedRow("r9", { listed: rows, idOf, getRow: noRoute }),

package/frontend-vue/tests/table-url-filters.test.ts

@@ -0,0 +1,158 @@
+// @vitest-environment jsdom
+import {
+  computed,
+  createApp,
+  defineComponent,
+  h,
+  nextTick,
+  provide,
+  ref,
+  shallowRef,
+  type App,
+  type FunctionalComponent,
+} from "vue";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import TableFiltersRow from "../layers/dms-ui/app/build/components/table/FiltersRow.vue";
+import type { TableUrlFilter } from "../layers/dms-ui/app/build/components/table/Table.vue";
+import {
+  visibleUrlFilters,
+  withoutQueryParam,
+} from "../layers/dms-ui/app/build/composables/table-view/utils/urlFilters";
+
+describe("visibleUrlFilters", () => {
+  const declared = {
+    email: { field: "email", visible: true, label: "$app.email" },
+    template: { field: "templateSlug", mode: "is_not", visible: true },
+    tenant: { field: "tenantId" },
+  };
+
+  it("lists the visible filters the URL applies, hidden ones left out", () => {
+    expect(
+      visibleUrlFilters(declared, {
+        email: "a@b.test",
+        tenant: "t1",
+        page: "2",
+      }),
+    ).toEqual([
+      {
+        param: "email",
+        label: "$app.email",
+        accessorKey: "email",
+        mode: "is",
+        value: "a@b.test",
+      },
+    ]);
+    expect(visibleUrlFilters(declared, { template: "welcome" })).toEqual([
+      {
+        param: "template",
+        label: undefined,
+        accessorKey: "templateSlug",
+        mode: "is_not",
+        value: "welcome",
+      },
+    ]);
+    expect(visibleUrlFilters(undefined, { email: "a@b.test" })).toEqual([]);
+  });
+
+  it("removes one parameter from the query", () => {
+    expect(withoutQueryParam({ email: "a", tab: "all" }, "email")).toEqual({
+      tab: "all",
+    });
+  });
+});
+
+describe("filters row URL chips", () => {
+  let app: App | undefined;
+  const emits = vi.fn();
+
+  const mount = (urlFilters: TableUrlFilter[]) => {
+    const Host = defineComponent({
+      setup() {
+        provide(
+          "tableSharedData",
+          shallowRef({
+            columnFiltersState: ref([]),
+            labeledColumns: computed(() => [
+              {
+                column: { id: "templateSlug", columnDef: {} },
+                label: "Template",
+              },
+            ]),
+            clearableFilters: computed(() => ({
+              filters: false,
+              search: false,
+            })),
+            urlFilters,
+            emits,
+          }),
+        );
+        return () => h(TableFiltersRow);
+      },
+    });
+    app = createApp(Host);
+    const passthrough =
+      (tag: string): FunctionalComponent =>
+      (_props, { slots }) =>
+        h(tag, slots.default?.());
+    app.component("UPopover", passthrough("div"));
+    app.component("UButton", passthrough("button"));
+    app.component("UIcon", passthrough("i"));
+    app.component("Suspense", passthrough("div"));
+    const container = document.createElement("div");
+    app.mount(container);
+    return container;
+  };
+
+  beforeEach(() => {
+    emits.mockClear();
+    vi.stubGlobal("computed", computed);
+    vi.stubGlobal("ref", ref);
+    vi.stubGlobal("useI18n", () => ({
+      t: (key: string) => key,
+      locale: ref("en"),
+    }));
+    vi.stubGlobal("useTranslation", () => ({
+      processI18n: (text: string) =>
+        text.startsWith("$") ? `t:${text.slice(1)}` : text,
+    }));
+    vi.stubGlobal("useDmsAppConfig", () => ({
+      ui: { icons: { close: "i-close", plus: "i-plus" } },
+    }));
+    vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
+    vi.stubGlobal("isString", (value: unknown) => typeof value === "string");
+    vi.stubGlobal("resolveDmsComponent", () => undefined);
+  });
+
+  afterEach(() => {
+    app?.unmount();
+    app = undefined;
+    vi.unstubAllGlobals();
+  });
+
+  it("draws a chip per URL filter and asks to remove its parameter", async () => {
+    const container = mount([
+      {
+        param: "email",
+        label: "$app.email",
+        accessorKey: "email",
+        mode: "is",
+        value: "a@b.test",
+      },
+      {
+        param: "template",
+        accessorKey: "templateSlug",
+        mode: "is",
+        value: "welcome",
+      },
+    ]);
+    const chips = container.querySelectorAll("[data-dms-url-filter]");
+    expect(chips).toHaveLength(2);
+    expect(chips[0]!.textContent).toContain("t:app.email");
+    expect(chips[0]!.textContent).toContain("a@b.test");
+    expect(chips[1]!.textContent).toContain("Template");
+
+    chips[1]!.querySelector("button")!.click();
+    await nextTick();
+    expect(emits).toHaveBeenCalledWith("removeUrlFilter", "template");
+  });
+});

package/frontend-vue/tests/table-view-bulk-drawer.test.ts

@@ -13,6 +13,7 @@ import {
   rowNavigation,
 } from "../layers/dms-ui/app/build/composables/actions/rowNavigation";
 import {
+  deepLinkOutcome,
   readRecordId,
   recordUrlKey,
   writeRecordId,
@@ -130,6 +131,28 @@ describe("record deep links", () => {
     writeRecordId({ tableId: "runs", isSoleTableView: true });
     expect(window.location.search).toBe("?tab=open");
   });
+
+  it("notifies a link no row answers, unless a side panel shows it missing", () => {
+    const panel = {
+      target: { type: "sidePanel" },
+    } as unknown as CustomRowAction;
+    const drawer = {
+      target: { type: "drawer" },
+      deepLink: true,
+    } as unknown as CustomRowAction;
+    const row = { id: "r1" };
+    expect(deepLinkOutcome({ row, isMissing: false }, drawer)).toBe("open");
+    expect(deepLinkOutcome({ isMissing: true }, panel)).toBe("missingPanel");
+    expect(deepLinkOutcome({ isMissing: true }, drawer)).toBe("notify");
+    expect(deepLinkOutcome({ isMissing: false }, panel)).toBe("notify");
+    expect(deepLinkOutcome({ isMissing: false }, drawer)).toBe("notify");
+    expect(deepLinkOutcome({ isMissing: false, isFailed: true }, panel)).toBe(
+      "notifyFailed",
+    );
+    expect(deepLinkOutcome({ isMissing: false, isFailed: true }, drawer)).toBe(
+      "notifyFailed",
+    );
+  });
 });
 
 describe("action targets on a selection and on a listed row", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms",
-  "version": "0.7.13",
+  "version": "0.7.15",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/AntelopeJS/dms.git"
@@ -37,7 +37,7 @@
     "@antelopejs/interface-data-api": ">=0.2.0 <1.0.0",
     "@antelopejs/interface-database": ">=0.1.8 <1.0.0",
     "@antelopejs/interface-database-decorators": ">=0.1.7 <1.0.0",
-    "@antelopejs/interface-dms": ">=0.5.8 <0.6.0",
+    "@antelopejs/interface-dms": ">=0.5.10 <0.6.0",
     "@antelopejs/interface-email": ">=0.0.5 <1.0.0",
     "@antelopejs/interface-file-storage": ">=0.1.3 <1.0.0",
     "archiver": "^7.0.1",

package/skills/dms-module/SKILL.md

@@ -86,6 +86,9 @@ An absolute link (a public file, a snippet to copy, a mail) is built on `await G
 (`@antelopejs/interface-dms/api-base-url`, the backend) or `await GetClientBaseUrl()`
 (`/client-base-url`, the dashboard), never on `Host` / `X-Forwarded-*`: a reverse proxy may not
 forward them. Both answer the DMS config (`apiBaseUrl`, `clientBaseUrl`).
+A client address (a rate limit, an anonymous visitor) comes from `await getClientIp(context)`
+(`/client-ip`), never from `X-Forwarded-For` read by hand: it follows the DMS's
+`auth.trustedProxies`, so the operator declares the proxies once.
 
 ## Navigation & access — module pages are owner-only