@antelopejs/dms 0.7.14 → 0.7.15

package/frontend-vue/tests/control-error-path.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import * as legacy from "../layers/dms-ui/app/build/composables/form/useControlError";
+import { useControlError } from "../layers/dms-ui/app/composables/form/useControlError";
+import { FORM_CONTROL_ERRORS_KEY } from "../layers/dms-ui/app/build/composables/form/formControlErrors";
+
+describe("useControlError location", () => {
+  it("stays importable from its former build/ path", () => {
+    expect(legacy.useControlError).toBe(useControlError);
+    expect(legacy.FORM_CONTROL_ERRORS_KEY).toBe(FORM_CONTROL_ERRORS_KEY);
+  });
+});

package/frontend-vue/tests/email-layout.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it, vi } from "vitest";
+import { createSSRApp, defineComponent, h } from "vue";
+import { renderToString } from "vue/server-renderer";
+import EmailLayout from "../layers/dms-layout/app/emails/components/EmailLayout.vue";
+import { emailLogoUrl } from "../layers/dms-layout/app/emails/components/index";
+
+const PUBLIC_BASE = "https://admin.example.com";
+const ELEMENTS: Record<string, string> = {
+  EHtml: "html",
+  EHead: "head",
+  EBody: "body",
+  EContainer: "div",
+  ESection: "section",
+  EHeading: "h1",
+  EImg: "img",
+  EHr: "hr",
+  EPreview: "span",
+};
+
+function element(tag: string) {
+  return defineComponent({
+    inheritAttrs: false,
+    setup:
+      (_, { attrs, slots }) =>
+      () =>
+        h(tag, { src: attrs.src, alt: attrs.alt }, slots.default?.()),
+  });
+}
+
+async function renderLayout(
+  props: Record<string, unknown>,
+  logo = "/images/logo.png",
+  clientBaseUrl = PUBLIC_BASE,
+): Promise<string> {
+  vi.stubGlobal("useDmsAppConfig", () => ({
+    branding: { logo: { default: { light: logo } } },
+  }));
+  vi.stubGlobal("useDmsRuntimeConfig", () => ({
+    public: { dms: { clientBaseUrl } },
+  }));
+  const app = createSSRApp({
+    render: () =>
+      h(EmailLayout, props, {
+        default: () => h("p", "Body"),
+        footer: () => h("small", "Footer"),
+      }),
+  });
+  Object.entries(ELEMENTS).forEach(([name, tag]) =>
+    app.component(name, element(tag)),
+  );
+  const html = await renderToString(app);
+  vi.unstubAllGlobals();
+  return html;
+}
+
+describe("EmailLayout", () => {
+  it("keeps the heading, the separator and the logo by default", async () => {
+    const html = await renderLayout({ title: "Welcome" });
+    expect(html).toContain("<h1>Welcome</h1>");
+    expect(html).toContain("<hr>");
+    expect(html).toContain(
+      `<img src="${PUBLIC_BASE}/images/logo.png" alt="Logo">`,
+    );
+  });
+
+  it("drops the heading without a title and the separator on request", async () => {
+    const html = await renderLayout({ divider: false, preheader: "Preview" });
+    expect(html).not.toContain("<h1>");
+    expect(html).not.toContain("<hr>");
+    expect(html).toContain("<span>Preview</span>");
+    expect(html).toContain("<p>Body</p>");
+    expect(html).toContain("<small>Footer</small>");
+  });
+
+  it("keeps any logo by default", async () => {
+    expect(
+      await renderLayout({ title: "Hi" }, "/images/logo.svg", ""),
+    ).toContain('<img src="/images/logo.svg" alt="Logo">');
+  });
+
+  it("leaves out a logo a mail client cannot load with publicLogoOnly", async () => {
+    const guarded = { title: "Hi", publicLogoOnly: true };
+    expect(await renderLayout(guarded, "/images/logo.svg")).not.toContain(
+      "<img",
+    );
+    expect(
+      await renderLayout(guarded, "/logo.png", "http://localhost:3001"),
+    ).not.toContain("<img");
+    expect(await renderLayout(guarded)).toContain(
+      `<img src="${PUBLIC_BASE}/images/logo.png" alt="Logo">`,
+    );
+  });
+});
+
+describe("emailLogoUrl", () => {
+  it("resolves a root path against the public base URL", () => {
+    expect(emailLogoUrl("/logo.png", PUBLIC_BASE)).toBe(
+      `${PUBLIC_BASE}/logo.png`,
+    );
+    expect(emailLogoUrl("https://cdn.example.com/logo.png", "")).toBe(
+      "https://cdn.example.com/logo.png",
+    );
+  });
+
+  it.each([
+    [undefined, PUBLIC_BASE],
+    ["/logo.svg", PUBLIC_BASE],
+    ["https://cdn.example.com/logo.SVG?v=2", ""],
+    ["data:image/png;base64,AAAA", ""],
+    ["/logo.png", ""],
+    ["/logo.png", "http://localhost:3001"],
+    ["/logo.png", "http://dms.localhost"],
+    ["/logo.png", "http://127.0.0.1:3001"],
+    ["/logo.png", "http://10.0.0.5"],
+    ["/logo.png", "http://172.20.1.1"],
+    ["/logo.png", "http://192.168.1.10"],
+    ["/logo.png", "http://169.254.169.254"],
+    ["/logo.png", "http://[::1]:3001"],
+    ["/logo.png", "http://[fd00::1]"],
+    ["/logo.png", "http://intranet.internal"],
+  ])("leaves out %s on %s", (logo, base) => {
+    expect(emailLogoUrl(logo, base)).toBe("");
+  });
+});

package/frontend-vue/tests/input-number-range.test.ts

@@ -17,7 +17,7 @@ import {
   nextTick,
   ref,
 } from "vue";
-import { FORM_CONTROL_ERRORS_KEY } from "../layers/dms-ui/app/build/composables/form/useControlError";
+import { FORM_CONTROL_ERRORS_KEY } from "../layers/dms-ui/app/build/composables/form/formControlErrors";
 import {
   ABOVE_MAX_MESSAGE,
   BELOW_MIN_MESSAGE,

package/frontend-vue/tests/input-tags.test.ts

@@ -16,7 +16,7 @@ import {
   formErrorsInjectionKey,
   formFieldInjectionKey,
 } from "@nuxt/ui/composables/useFormField";
-import { FORM_CONTROL_ERRORS_KEY } from "../layers/dms-ui/app/build/composables/form/useControlError";
+import { FORM_CONTROL_ERRORS_KEY } from "../layers/dms-ui/app/build/composables/form/formControlErrors";
 
 const formErrors = ref<Array<Record<string, unknown>>>([]);
 const model = ref<string[]>([]);

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.14",
+  "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.9 <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",