@antelopejs/dms 0.9.2 → 0.9.4

package/frontend-vue/tests/field-errors.test.ts

@@ -1,247 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  apiErrorText,
-  describeApiError,
-  resolveFieldErrors,
-} from "../layers/dms-core/app/composables/useFieldErrors";
-import { resolveApiMessage } from "../layers/dms-core/app/composables/translation/useTranslation";
-
-const FIELDS = ["name", "email", "password"] as const;
-
-/** What `assertValidation` answers: the ZodError's issues, as plain text. */
-const zodBody = (issues: unknown[]) => JSON.stringify(issues, null, 2);
-
-describe("resolveFieldErrors", () => {
-  it("ties a mapped API code to its field, with the code as message", () => {
-    expect(
-      resolveFieldErrors(
-        { statusCode: 400, data: "error.invalid_current_password" },
-        {
-          fields: ["currentPassword"],
-          codes: { "error.invalid_current_password": "currentPassword" },
-        },
-      ),
-    ).toEqual({
-      fields: [
-        {
-          field: "currentPassword",
-          message: "error.invalid_current_password",
-        },
-      ],
-      hasUnmatched: false,
-    });
-  });
-
-  it("matches a code with or without its $ prefix and can reword it", () => {
-    const resolution = resolveFieldErrors(
-      { statusCode: 409, data: "$page.settings.roles.error.name_taken" },
-      {
-        fields: ["name"],
-        codes: {
-          "page.settings.roles.error.name_taken": {
-            field: "name",
-            message: "own.key",
-          },
-        },
-      },
-    );
-    expect(resolution.fields).toEqual([{ field: "name", message: "own.key" }]);
-  });
-
-  it("accepts a mapped code on a 401, as a refused two-factor code is", () => {
-    expect(
-      resolveFieldErrors(
-        { statusCode: 401, data: "error.invalid_2fa_code" },
-        { fields: ["code"], codes: { "error.invalid_2fa_code": "code" } },
-      ).fields,
-    ).toEqual([{ field: "code", message: "error.invalid_2fa_code" }]);
-  });
-
-  it("reads the zod issues of a 400, generic messages for zod's prose", () => {
-    const error = {
-      statusCode: 400,
-      data: zodBody([
-        {
-          validation: "email",
-          code: "invalid_string",
-          message: "Invalid email",
-          path: ["email", 0],
-        },
-        {
-          code: "custom",
-          message: "$page.settings.members.invite.roles_required",
-          path: ["roles"],
-        },
-        {
-          code: "too_small",
-          minimum: 1,
-          type: "string",
-          message: "String must contain at least 1 character(s)",
-          path: ["name"],
-        },
-      ]),
-    };
-    expect(
-      resolveFieldErrors(error, { fields: ["email", "roles", "name"] }),
-    ).toEqual({
-      fields: [
-        {
-          field: "email",
-          message: "$dms.field_errors.invalid_email",
-          path: "email.0",
-        },
-        {
-          field: "roles",
-          message: "$page.settings.members.invite.roles_required",
-        },
-        { field: "name", message: "$dms.field_errors.required" },
-      ],
-      hasUnmatched: false,
-    });
-  });
-
-  it("keeps the first issue of a field and flags issues on unknown keys", () => {
-    const error = {
-      statusCode: 400,
-      data: [
-        { code: "too_big", message: "Too long", path: ["name"] },
-        { code: "custom", message: "$second", path: ["name"] },
-        { code: "custom", message: "$hidden", path: ["internal"] },
-      ],
-    };
-    expect(resolveFieldErrors(error, { fields: FIELDS })).toEqual({
-      fields: [{ field: "name", message: "$dms.field_errors.too_long" }],
-      hasUnmatched: true,
-    });
-  });
-
-  it("reads a { field, message, values } body", () => {
-    const error = {
-      statusCode: 409,
-      data: {
-        message: "$page.settings.members.invite.already_member",
-        field: "emails",
-        values: ["a@test.local", 3],
-      },
-    };
-    expect(resolveFieldErrors(error, { fields: ["emails"] }).fields).toEqual([
-      {
-        field: "emails",
-        message: "$page.settings.members.invite.already_member",
-        values: ["a@test.local"],
-      },
-    ]);
-  });
-
-  it("reads the params of a { field, message, params } body", () => {
-    const error = {
-      statusCode: 400,
-      data: {
-        message: "$page.campaigns.error.budget_max",
-        field: "budget",
-        params: { max: 5000, currency: "EUR", nested: { no: 1 } },
-      },
-    };
-    expect(resolveFieldErrors(error, { fields: ["budget"] }).fields).toEqual([
-      {
-        field: "budget",
-        message: "$page.campaigns.error.budget_max",
-        values: undefined,
-        params: { max: 5000, currency: "EUR" },
-      },
-    ]);
-  });
-
-  it("reads the data API's missing and invalid field lists", () => {
-    expect(
-      resolveFieldErrors(
-        { statusCode: 400, data: "Missing mandatory fields: name, email" },
-        { fields: FIELDS },
-      ).fields,
-    ).toEqual([
-      { field: "name", message: "$dms.field_errors.required" },
-      { field: "email", message: "$dms.field_errors.required" },
-    ]);
-    expect(
-      resolveFieldErrors(
-        { statusCode: 400, data: "Invalid field type(s): password" },
-        { fields: FIELDS },
-      ).fields,
-    ).toEqual([{ field: "password", message: "$dms.field_errors.invalid" }]);
-  });
-
-  it("reads a `field: message` text", () => {
-    expect(
-      resolveFieldErrors(
-        { statusCode: 400, data: "name: String must contain 1 character(s)" },
-        { fields: FIELDS },
-      ).fields,
-    ).toEqual([{ field: "name", message: "$dms.field_errors.invalid" }]);
-  });
-
-  it.each([
-    ["a network failure", new Error("fetch failed")],
-    ["a 403", { statusCode: 403, data: "error.forbidden" }],
-    ["a 429", { status: 429, data: "error.rate_limited" }],
-    ["a 500", { statusCode: 500, data: "error.invalid_current_password" }],
-  ])("never ties %s to a field", (_label, error) => {
-    expect(
-      resolveFieldErrors(error, {
-        fields: ["currentPassword"],
-        codes: { "error.invalid_current_password": "currentPassword" },
-      }),
-    ).toEqual({ fields: [], hasUnmatched: true });
-  });
-
-  it("leaves an unmapped code to the toast", () => {
-    expect(
-      resolveFieldErrors(
-        { statusCode: 409, data: "$page.settings.roles.error.in_use" },
-        { fields: ["name"] },
-      ),
-    ).toEqual({ fields: [], hasUnmatched: true });
-  });
-
-  it("ignores a field the form does not show", () => {
-    expect(
-      resolveFieldErrors(
-        { statusCode: 400, data: { field: "secret", message: "$x" } },
-        { fields: FIELDS },
-      ),
-    ).toEqual({ fields: [], hasUnmatched: true });
-  });
-});
-
-describe("describeApiError", () => {
-  it("words a toast from the body, its message or its first issue", () => {
-    expect(describeApiError({ data: "error.rate_limited" })).toBe(
-      "error.rate_limited",
-    );
-    expect(describeApiError({ data: { message: "$key" } })).toBe("$key");
-    expect(
-      describeApiError({
-        data: zodBody([{ code: "custom", message: "$first", path: ["x"] }]),
-      }),
-    ).toBe("$first");
-  });
-
-  it("falls back to the generic server error without a body", () => {
-    expect(describeApiError(new Error("down"))).toBe("error.500.description");
-    expect(apiErrorText(new Error("down"))).toBeUndefined();
-  });
-});
-
-describe("resolveApiMessage", () => {
-  const translate = (key: string, params: Record<string, unknown>) =>
-    key === "page.error.budget_max" ? `At most ${String(params.max)}` : key;
-
-  it("fills the translation's placeholders with the params", () => {
-    expect(
-      resolveApiMessage(translate, "$page.error.budget_max", { max: 5000 }),
-    ).toBe("At most 5000");
-  });
-
-  it("keeps an untranslated message as it came", () => {
-    expect(resolveApiMessage(translate, "Too big", { max: 1 })).toBe("Too big");
-  });
-});

package/frontend-vue/tests/field-options-i18n.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { processFieldI18n } from "../layers/dms-ui/app/build/utils/fieldOptionsI18n";
-
-const translate = (key: string) => (key.startsWith("$") ? `t(${key})` : key);
-
-describe("processFieldI18n", () => {
-  it("translates the texts of the options, their items and columns", () => {
-    const field = processFieldI18n(
-      {
-        id: "f",
-        component: {
-          componentName: "dms-repeater",
-          options: {
-            placeholder: "$p",
-            label: "$l",
-            description: "plain",
-            addLabel: "$add",
-            items: [{ label: "$a", description: "$d", value: 1 }],
-            columns: [{ id: "name", label: "$name" }],
-            min: 1,
-          },
-        },
-      },
-      translate,
-    );
-    expect(field.component.options).toEqual({
-      placeholder: "t($p)",
-      label: "t($l)",
-      description: "plain",
-      addLabel: "t($add)",
-      items: [{ label: "t($a)", description: "t($d)", value: 1 }],
-      columns: [{ id: "name", label: "t($name)" }],
-      min: 1,
-    });
-  });
-
-  it("leaves a field without options as it is", () => {
-    const field = { id: "f", component: {} };
-    expect(processFieldI18n(field, translate)).toBe(field);
-  });
-});

package/frontend-vue/tests/field-row.test.ts

@@ -1,115 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  type App,
-  createApp,
-  h,
-  nextTick,
-  onMounted,
-  onUnmounted,
-  ref,
-} from "vue";
-import {
-  FORM_LAYOUT_CLASSES,
-  SECTION_LAYOUT_CLASSES,
-} from "../layers/dms-ui/app/build/composables/form/formLayout";
-
-const FORM_COLUMNS = "@min-[560px]:grid-cols-[minmax(0,240px)_minmax(0,1fr)]";
-
-let app: App | undefined;
-let host: HTMLDivElement;
-
-async function mount(
-  props: Record<string, unknown>,
-  slots: Record<string, () => unknown> = {},
-) {
-  const { default: FieldRow } = await import(
-    "../layers/dms-ui/app/components/field-row/FieldRow.vue"
-  );
-  app = createApp({ setup: () => () => h(FieldRow, props, slots) });
-  app.mount(host);
-  await nextTick();
-}
-
-const body = () => host.firstElementChild!.firstElementChild as HTMLElement;
-
-beforeEach(() => {
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("onMounted", onMounted);
-  vi.stubGlobal("onUnmounted", onUnmounted);
-  vi.stubGlobal("useDefinedFunctions", () => ({
-    getFunction: () => undefined,
-  }));
-  vi.stubGlobal("useTranslation", () => ({
-    processI18n: (text: string) => text,
-  }));
-  host = document.createElement("div");
-  document.body.append(host);
-});
-
-afterEach(() => {
-  app?.unmount();
-  host.remove();
-  vi.unstubAllGlobals();
-});
-
-describe("FieldRow", () => {
-  it("names its control with a label, and keeps the details out of it", async () => {
-    await mount(
-      { label: "Email", labelFor: "email", layout: "form" },
-      { default: () => h("input", { id: "email" }), details: () => "Saved" },
-    );
-    const label = host.querySelector("label")!;
-    expect(label.htmlFor).toBe("email");
-    expect(label.textContent).toBe("Email");
-    expect(label.parentElement!.textContent).toContain("Saved");
-    expect(body().className).toContain(FORM_COLUMNS);
-  });
-
-  it("pads itself and draws its hairline, with the card's inset", async () => {
-    await mount({ label: "Name" });
-    expect(host.querySelector("label")).toBeNull();
-    expect(host.firstElementChild!.className).toContain("border-t");
-    expect(body().className).toContain("px-[18px]");
-    expect(body().className).toContain("py-4");
-  });
-
-  it("spans both form columns with its control when it has no label", async () => {
-    await mount({ layout: "form" }, { default: () => h("input") });
-    expect(body().children).toHaveLength(1);
-    expect(body().firstElementChild!.className).toContain("col-span-full");
-  });
-
-  it("keeps a labelled control in the form's control column", async () => {
-    await mount(
-      { label: "Name", layout: "form" },
-      { default: () => h("input") },
-    );
-    expect(body().lastElementChild!.className).not.toContain("col-span-full");
-  });
-
-  it("leaves the spacing to the list of a stacked form", async () => {
-    await mount({
-      label: "Name",
-      layout: "stack",
-      inset: false,
-      spacing: "list",
-    });
-    expect(host.firstElementChild!.className).not.toContain("border-t");
-    expect(body().className).not.toContain("px-[18px]");
-    expect(body().className).not.toContain("py-4");
-  });
-});
-
-describe("form rows", () => {
-  it("draw a card's and a section's rows as FieldRow's form rows", () => {
-    expect(FORM_LAYOUT_CLASSES.horizontal.row.layout).toBe("form");
-    expect(SECTION_LAYOUT_CLASSES.row.layout).toBe("form");
-    expect(SECTION_LAYOUT_CLASSES.row.inset).toBe(true);
-    expect(FORM_LAYOUT_CLASSES.vertical.row).toEqual({
-      layout: "stack",
-      inset: false,
-      spacing: "list",
-    });
-  });
-});

package/frontend-vue/tests/field-suffix-count.test.ts

@@ -1,121 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A number field writes its unit after the box ("30 days"), and a text field
- * or a text area asked for it counts the characters typed, out of its
- * `maxLength` ("4 / 60"). Without either option, the control is unchanged.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  type App,
-  type Component,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-} from "vue";
-import { characterCountText } from "../layers/dms-ui/app/build/utils/characterCount";
-
-let app: App | undefined;
-let host: HTMLDivElement;
-
-const Control = (tag: string) =>
-  defineComponent({
-    inheritAttrs: false,
-    setup:
-      (_, { slots, attrs }) =>
-      () =>
-        h("div", { "data-control": tag }, [
-          h(tag, { ...attrs }),
-          slots.trailing?.(),
-        ]),
-  });
-
-async function mount(component: Component, props: Record<string, unknown>) {
-  app = createApp({ render: () => h(component, props) });
-  app.component("UInput", Control("input"));
-  app.component("UTextarea", Control("textarea"));
-  app.component("UInputNumber", Control("input"));
-  app.mount(host);
-  await nextTick();
-}
-
-const load = async (name: string) =>
-  (await import(`../layers/dms-ui/app/components/form/components/${name}.vue`))
-    .default as Component;
-
-beforeEach(() => {
-  vi.stubGlobal("useI18n", () => ({ locale: { value: "en" } }));
-  vi.stubGlobal("useTranslation", () => ({
-    processI18n: (text: string) => (text.startsWith("$") ? `t(${text})` : text),
-  }));
-  host = document.createElement("div");
-  document.body.append(host);
-});
-
-afterEach(() => {
-  app?.unmount();
-  host.remove();
-  vi.unstubAllGlobals();
-});
-
-describe("characterCountText", () => {
-  it("counts out of the limit, or alone", () => {
-    expect(characterCountText("Acme", 60)).toBe("4 / 60");
-    expect(characterCountText("Acme")).toBe("4");
-    expect(characterCountText(undefined, 60)).toBe("0 / 60");
-    expect(characterCountText("👋🏽", 10)).toBe("2 / 10");
-  });
-});
-
-describe("a text field's counter", () => {
-  it("shows the count in the field when asked", async () => {
-    await mount(await load("InputText"), {
-      modelValue: "Acme",
-      maxLength: 60,
-      showCount: true,
-    });
-    expect(
-      host.querySelector("[data-character-count]")?.textContent?.trim(),
-    ).toBe("4 / 60");
-    const input = host.querySelector("input")!;
-    expect(input.getAttribute("maxlength")).toBe("60");
-    expect(input.hasAttribute("showcount")).toBe(false);
-  });
-
-  it("draws no counter by default", async () => {
-    await mount(await load("InputText"), { modelValue: "Acme", maxLength: 60 });
-    expect(host.querySelector("[data-character-count]")).toBeNull();
-    expect(host.querySelector("input")!.getAttribute("maxlength")).toBe("60");
-  });
-
-  it("counts under a text area", async () => {
-    await mount(await load("Textarea"), {
-      modelValue: "Hello",
-      maxLength: 280,
-      showCount: true,
-    });
-    expect(
-      host.querySelector("[data-character-count]")?.textContent?.trim(),
-    ).toBe("5 / 280");
-    expect(host.querySelector("textarea")!.hasAttribute("showcount")).toBe(
-      false,
-    );
-  });
-});
-
-describe("a number field's unit", () => {
-  it("writes the unit after the field, translated", async () => {
-    await mount(await load("InputNumber"), {
-      modelValue: 30,
-      suffix: "$billing.days",
-    });
-    const suffix = host.querySelector("[data-field-suffix]");
-    expect(suffix?.textContent?.trim()).toBe("t($billing.days)");
-    expect(host.querySelector("input")!.hasAttribute("suffix")).toBe(false);
-  });
-
-  it("draws no unit by default", async () => {
-    await mount(await load("InputNumber"), { modelValue: 30 });
-    expect(host.querySelector("[data-field-suffix]")).toBeNull();
-  });
-});

package/frontend-vue/tests/file-constraints.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  checkFileConstraints,
-  type FileFieldConstraints,
-  matchMimetype,
-} from "../layers/dms-ui/app/utils/fileConstraints";
-
-function fakeFile(type: string, size: number): File {
-  return { type, size, name: "sample" } as File;
-}
-
-describe("matchMimetype", () => {
-  it("matches an exact mimetype", () => {
-    expect(matchMimetype("image/png", "image/png")).to.equal(true);
-  });
-
-  it("matches a trailing wildcard pattern", () => {
-    expect(matchMimetype("image/png", "image/*")).to.equal(true);
-  });
-
-  it("rejects a mimetype outside a wildcard pattern", () => {
-    expect(matchMimetype("application/pdf", "image/*")).to.equal(false);
-  });
-
-  it("rejects a different exact mimetype", () => {
-    expect(matchMimetype("image/png", "image/jpeg")).to.equal(false);
-  });
-});
-
-describe("checkFileConstraints", () => {
-  it("accepts any file when no constraints are configured", () => {
-    expect(
-      checkFileConstraints(fakeFile("application/x-foo", 10_000)),
-    ).to.equal(null);
-  });
-
-  it("accepts a file within size and mimetype constraints", () => {
-    const constraints: FileFieldConstraints = {
-      maxSize: 1024,
-      allowedMimetypes: ["image/*"],
-    };
-    expect(
-      checkFileConstraints(fakeFile("image/png", 512), constraints),
-    ).to.equal(null);
-  });
-
-  it("reports a size violation before a mimetype violation", () => {
-    const constraints: FileFieldConstraints = {
-      maxSize: 1024,
-      allowedMimetypes: ["image/*"],
-    };
-    expect(
-      checkFileConstraints(fakeFile("application/pdf", 4096), constraints),
-    ).to.equal("size");
-  });
-
-  it("reports a mimetype violation", () => {
-    const constraints: FileFieldConstraints = {
-      allowedMimetypes: ["image/png", "image/jpeg"],
-    };
-    expect(
-      checkFileConstraints(fakeFile("application/pdf", 512), constraints),
-    ).to.equal("mimetype");
-  });
-
-  it("accepts everything when allowedMimetypes is empty", () => {
-    const constraints: FileFieldConstraints = { allowedMimetypes: [] };
-    expect(
-      checkFileConstraints(fakeFile("application/pdf", 512), constraints),
-    ).to.equal(null);
-  });
-});

package/frontend-vue/tests/file-drop-prompt.test.ts

@@ -1,72 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  inject,
-  onScopeDispose,
-  ref,
-  watch,
-  type App,
-} from "vue";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import File from "../layers/dms-ui/app/components/form/components/File.vue";
-
-const dropZone = defineComponent({
-  inheritAttrs: false,
-  setup:
-    (_, { attrs }) =>
-    () =>
-      h("span", String(attrs.label ?? "")),
-});
-
-function mountFile(multiple: boolean): { app: App; container: HTMLElement } {
-  const app = createApp({
-    render: () => h(File, { modelValue: null, multiple }),
-  });
-  app.config.globalProperties.$t = (key: string) => key;
-  app.component("UFileUpload", dropZone);
-  const container = document.createElement("div");
-  app.mount(container);
-  return { app, container };
-}
-
-beforeEach(() => {
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("watch", watch);
-  vi.stubGlobal("inject", inject);
-  vi.stubGlobal("onScopeDispose", onScopeDispose);
-  vi.stubGlobal("FORM_FIELD_LOADING_KEY", Symbol());
-  vi.stubGlobal("FORM_CONTENT_LANGUAGE_KEY", Symbol());
-  vi.stubGlobal("CONTENT_LANGUAGE_HEADER", "x-content-language");
-  vi.stubGlobal("useAuthFetch", () => ({ $authFetch: vi.fn() }));
-  vi.stubGlobal("useUploadWithProgress", () => ({
-    uploadWithProgress: vi.fn(),
-  }));
-  vi.stubGlobal("useFormField", () => ({
-    emitFormChange: vi.fn(),
-    color: ref(undefined),
-    highlight: ref(undefined),
-    ariaAttrs: ref(undefined),
-  }));
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  vi.stubGlobal("useToast", () => ({ add: vi.fn() }));
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-it("asks for a file in its drop zone", () => {
-  const { app, container } = mountFile(false);
-  expect(container.textContent).toBe("dms.form.file.drop_prompt");
-  app.unmount();
-});
-
-it("asks for files in the drop zone of a multiple field", () => {
-  const { app, container } = mountFile(true);
-  expect(container.textContent).toBe("dms.form.file.drop_prompt_multiple");
-  app.unmount();
-});