@antelopejs/dms 0.7.12 → 0.7.14

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/scroll-to-block.test.ts

@@ -44,11 +44,24 @@ const Pair = defineComponent({
     h(Fragment, [h("h3", { class: "pair-head" }), h("p", "body")]),
 });
 
-const resolvedChild = (id: string, component: unknown) => ({
+// A list beside the item it selects, like a split layout: one child in a
+// named slot, the other in the default one.
+const Split = defineComponent({
+  setup:
+    (_, { slots }) =>
+    () =>
+      h("div", { class: "split" }, [
+        h("aside", slots.aside?.()),
+        h("article", slots.default?.()),
+      ]),
+});
+
+const resolvedChild = (id: string, component: unknown, slot?: string) => ({
   id,
   component,
   options: {},
   children: [],
+  ...(slot ? { slot } : {}),
 });
 
 async function mountPage(showSecond = ref(true)) {
@@ -69,6 +82,10 @@ async function mountPage(showSecond = ref(true)) {
         showSecond.value
           ? block("tabs", Section, [resolvedChild("statistics", Section)])
           : null,
+        block("explorer", Split, [
+          resolvedChild("tree", Section, "aside"),
+          resolvedChild("header", Pair),
+        ]),
       ]),
   });
   app.component("DmsRecursiveComponent", RecursiveComponent);
@@ -115,6 +132,18 @@ describe("scrollToBlock", () => {
     });
   });
 
+  it("finds the children of a block that places them in its slots", async () => {
+    await mountPage();
+    expect(scrollToBlock("explorer.header")).toBe(true);
+    expect(scrolled.at(-1)?.element).toBe(
+      host.querySelector(".split article .pair-head"),
+    );
+    expect(scrollToBlock("explorer.tree")).toBe(true);
+    expect(scrolled.at(-1)?.element).toBe(
+      host.querySelector(".split aside section"),
+    );
+  });
+
   it("answers false for a block that is not on screen", async () => {
     const showSecond = await mountPage();
     expect(scrollToBlock("missing")).toBe(false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "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.7 <0.6.0",
+    "@antelopejs/interface-dms": ">=0.5.9 <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