@antelopejs/dms 0.0.1

package/frontend-vue/tests/form-required-fields.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { jsonSchemaToZod, type JsonSchema } from "json-schema-to-zod";
+import {
+  buildValidationSchema,
+  makeFieldSchemaRequired,
+} from "../layers/dms-ui/app/composables/form/useForm";
+
+// Rebuild the exact client-side schema the form uses: the backend serializes an
+// optional field as `nullable().optional()`, `zodToJsonSchema` emits
+// `{"type":["string","null"]}`, and `json-schema-to-zod` reconstructs it as
+// `z.union([z.string(), z.null()]).optional()`.
+function roundTrippedOptionalString(): z.ZodTypeAny {
+  const source = z.object({ value: z.string().nullable().optional() });
+  const json = zodToJsonSchema(source) as unknown as JsonSchema;
+  const code = jsonSchemaToZod(json, { module: "none" }).replace(
+    /\.strict\(\)$/,
+    ".passthrough()",
+  );
+  const reconstructed = new Function("z", `"use strict"; return (${code})`)(
+    z,
+  ) as z.ZodObject<{ value: z.ZodTypeAny }>;
+  return reconstructed.shape.value;
+}
+
+describe("makeFieldSchemaRequired", () => {
+  it("enforces a non-empty value through the nullable+optional round-trip", () => {
+    const required = makeFieldSchemaRequired(roundTrippedOptionalString());
+
+    expect(required.safeParse(undefined).success).to.equal(false);
+    expect(required.safeParse("").success).to.equal(false);
+    expect(required.safeParse(null).success).to.equal(false);
+    expect(required.safeParse("Ada").success).to.equal(true);
+  });
+
+  it("requires a non-empty array for an optional array field", () => {
+    const required = makeFieldSchemaRequired(z.array(z.string()).optional());
+
+    expect(required.safeParse([]).success).to.equal(false);
+    expect(required.safeParse(["role"]).success).to.equal(true);
+  });
+
+  it("leaves a union it cannot reduce to a single type untouched", () => {
+    const union = z.union([z.string(), z.number()]);
+    expect(makeFieldSchemaRequired(union)).to.equal(union);
+  });
+});
+
+describe("buildValidationSchema", () => {
+  const baseSchema = z.object({
+    firstname: roundTrippedOptionalString(),
+    lastname: roundTrippedOptionalString(),
+  }) as z.ZodObject<Record<string, z.ZodTypeAny>>;
+
+  it("returns the base schema when nothing is toggled", () => {
+    expect(
+      buildValidationSchema(baseSchema, undefined, undefined, undefined),
+    ).to.equal(baseSchema);
+  });
+
+  it("makes only the required fields non-empty", () => {
+    const schema = buildValidationSchema(
+      baseSchema,
+      undefined,
+      undefined,
+      new Set(["firstname"]),
+    );
+
+    expect(schema.safeParse({ firstname: "", lastname: "" }).success).to.equal(
+      false,
+    );
+    expect(
+      schema.safeParse({ firstname: "Ada", lastname: "" }).success,
+    ).to.equal(true);
+  });
+
+  it("keeps a hidden field optional even when also required", () => {
+    const schema = buildValidationSchema(
+      baseSchema,
+      undefined,
+      new Set(["firstname"]),
+      new Set(["firstname"]),
+    );
+
+    expect(schema.safeParse({ firstname: "" }).success).to.equal(true);
+  });
+});

package/frontend-vue/tests/form-reset.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import {
+  computeResetState,
+  snapshotFormState,
+} from "../layers/dms-ui/app/composables/form/useForm";
+
+describe("computeResetState", () => {
+  it("restores every field to its initial value", () => {
+    const state = { title: "edited", count: 5 };
+    const initialValues = { title: "original", count: 1 };
+
+    expect(computeResetState(state, initialValues)).toEqual({
+      title: "original",
+      count: 1,
+    });
+  });
+
+  it("skips internal watch state keys instead of throwing", () => {
+    const state = {
+      disabledFields: new Set<string>(),
+      hiddenFields: new Set<string>(),
+      title: "edited",
+    };
+    const initialValues = { title: "original" };
+
+    expect(computeResetState(state, initialValues)).toEqual({
+      title: "original",
+    });
+  });
+
+  it("clears fields that have no initial value", () => {
+    const state = { title: "typed into a blank form" };
+
+    expect(computeResetState(state, {})).toEqual({ title: undefined });
+  });
+
+  it("returns deep clones detached from the initial values", () => {
+    const initialValues = { tags: ["a", "b"] };
+    const result = computeResetState({ tags: ["c"] }, initialValues);
+
+    expect(result.tags).toEqual(["a", "b"]);
+    expect(result.tags).not.toBe(initialValues.tags);
+  });
+});
+
+describe("snapshotFormState", () => {
+  it("captures current values without the internal watch keys", () => {
+    const state = {
+      disabledFields: new Set<string>(["a"]),
+      hiddenFields: new Set<string>(),
+      title: "saved",
+    };
+
+    expect(snapshotFormState(state)).toEqual({ title: "saved" });
+  });
+
+  it("detaches the snapshot from mutable state values", () => {
+    const localized = { fr: "Bonjour", en: "Hello" };
+    const snapshot = snapshotFormState({ title: localized });
+
+    localized.fr = "Salut";
+
+    expect(snapshot.title).toEqual({ fr: "Bonjour", en: "Hello" });
+    expect(snapshot.title).not.toBe(localized);
+  });
+});

package/frontend-vue/tests/image-reference-preservation.test.ts

@@ -0,0 +1,234 @@
+import { readFileSync } from "node:fs";
+import { transpileModule } from "typescript";
+import {
+  computed,
+  createSSRApp,
+  defineComponent,
+  effectScope,
+  h,
+  nextTick,
+  onScopeDispose,
+  onServerPrefetch,
+  reactive,
+  ref,
+  watch,
+  type EffectScope,
+  type Ref,
+} from "vue";
+import { renderToString } from "vue/server-renderer";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import Image from "../layers/dms-ui/app/components/form/components/Image.vue";
+
+interface ImageValue {
+  key: string;
+  alt?: string;
+  principal?: boolean;
+}
+
+interface GalleryEntry {
+  id: string;
+  key: string | null;
+  status: string;
+  alt: string;
+  url: string;
+  expiresAt?: number;
+}
+
+interface ImageHarness {
+  items: Ref<GalleryEntry[]>;
+  emitValue: () => void;
+  removeItem: (id: string) => void;
+  addFiles: (files: File[]) => void;
+  fetchItemMetadata: (item: GalleryEntry, force?: boolean) => Promise<void>;
+}
+
+const emit = vi.fn();
+const authFetch = vi.fn();
+const upload = vi.fn();
+let scope: EffectScope;
+const props = reactive({ modelValue: [] as ImageValue[], multiple: true });
+const original: ImageValue = {
+  key: "legacy/private.png",
+  alt: "Original",
+  principal: true,
+};
+const sibling: ImageValue = { key: "visible/sibling.png", alt: "Sibling" };
+
+function loadImage(): ImageHarness {
+  const component = readFileSync(
+    new URL(
+      "../layers/dms-ui/app/components/form/components/Image.vue",
+      import.meta.url,
+    ),
+    "utf8",
+  );
+  const script = component
+    .split('<script setup lang="ts">')[1]!
+    .split("</script>")[0]!;
+  const source = script
+    .replace(/^import[\s\S]*?from "[^"]+";\n/gm, "")
+    .replaceAll("import.meta.env.SSR", "false")
+    .replace(/^export type /gm, "type ");
+  const { outputText } = transpileModule(source, {});
+  return scope.run(() =>
+    new Function(
+      `${outputText}; return { items, emitValue, removeItem, addFiles, fetchItemMetadata };`,
+    )(),
+  )!;
+}
+
+beforeEach(() => {
+  scope = effectScope();
+  props.modelValue = [original, sibling];
+  authFetch.mockImplementation((_url, options) =>
+    options.query?.resourceKey === original.key
+      ? Promise.reject(new Error("403"))
+      : Promise.resolve({
+          url: "https://example.test/sibling.png",
+          filename: "Sibling",
+          size: 10,
+        }),
+  );
+  vi.stubGlobal("defineProps", () => props);
+  vi.stubGlobal("defineEmits", () => emit);
+  vi.stubGlobal("ref", ref);
+  vi.stubGlobal("computed", computed);
+  vi.stubGlobal("watch", watch);
+  vi.stubGlobal("inject", () => null);
+  vi.stubGlobal("FORM_FIELD_LOADING_KEY", Symbol());
+  vi.stubGlobal("FORM_CONTENT_LANGUAGE_KEY", Symbol());
+  vi.stubGlobal("CONTENT_LANGUAGE_HEADER", "x-content-language");
+  vi.stubGlobal("onBeforeUnmount", onScopeDispose);
+  vi.stubGlobal("useAuthFetch", () => ({ $authFetch: authFetch }));
+  vi.stubGlobal("useUploadWithProgress", () => ({
+    uploadWithProgress: upload,
+  }));
+  vi.stubGlobal("useFormField", () => ({ emitFormChange: vi.fn() }));
+  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
+  vi.stubGlobal("useToast", () => ({ add: vi.fn() }));
+});
+
+afterEach(() => {
+  scope.stop();
+  vi.unstubAllGlobals();
+  vi.resetAllMocks();
+});
+
+it("preserves a denied image when another image is removed", async () => {
+  const image = loadImage();
+  await nextTick();
+  expect(image.items.value[0]!.status).toBe("error");
+  image.removeItem(image.items.value[1]!.id);
+  expect(emit).toHaveBeenLastCalledWith("update:modelValue", [original]);
+});
+
+it("preserves a denied image on value echo without reinitializing its identity", async () => {
+  const image = loadImage();
+  await nextTick();
+  const id = image.items.value[0]!.id;
+  props.modelValue = [{ ...original }, { ...sibling }];
+  await nextTick();
+  expect(image.items.value[0]!.id).toBe(id);
+  image.emitValue();
+  expect(emit).toHaveBeenLastCalledWith("update:modelValue", [
+    original,
+    sibling,
+  ]);
+});
+
+it("removes a denied reference only when explicitly removed", async () => {
+  const image = loadImage();
+  await nextTick();
+  image.removeItem(image.items.value[0]!.id);
+  expect(emit).toHaveBeenLastCalledWith("update:modelValue", [
+    { ...sibling, principal: true },
+  ]);
+});
+
+it("excludes a failed new upload while retaining existing references", async () => {
+  const image = loadImage();
+  await nextTick();
+  authFetch.mockRejectedValueOnce(new Error("Upload failed"));
+  image.addFiles([new File(["bytes"], "new.png", { type: "image/png" })]);
+  await vi.waitFor(() =>
+    expect(image.items.value.at(-1)!.status).toBe("error"),
+  );
+  expect(image.items.value.at(-1)!.key).toBeNull();
+  image.emitValue();
+  expect(emit).toHaveBeenLastCalledWith("update:modelValue", [
+    original,
+    sibling,
+  ]);
+});
+
+it("keeps the denied image and its explicit deletion control in rendered markup", async () => {
+  vi.stubGlobal("useAuthFetch", () => ({
+    $authFetch: () => {
+      const denied = Promise.reject(new Error("403"));
+      onServerPrefetch(() => denied.catch(() => undefined));
+      return denied;
+    },
+  }));
+  const app = createSSRApp({
+    render: () => h(Image, { modelValue: [original], multiple: true }),
+  });
+  app.component(
+    "UButton",
+    defineComponent({
+      props: ["label"],
+      setup: (buttonProps) => () => h("button", buttonProps.label),
+    }),
+  );
+  app.component("UIcon", defineComponent({ setup: () => () => h("span") }));
+  app.component(
+    "UTooltip",
+    defineComponent({
+      setup:
+        (_, { slots }) =>
+        () =>
+          slots.default?.(),
+    }),
+  );
+  app.component("UModal", defineComponent({ setup: () => () => null }));
+  const html = await renderToString(app);
+  expect(html).toContain("dms.form.image.upload_failed");
+  expect(html).toContain("dms.form.image.delete</button>");
+  expect(emit).not.toHaveBeenCalled();
+});
+
+it("refreshes an expiring image preview and retries a transient failure", async () => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date("2026-09-14T12:00:00Z"));
+  const contentLanguageKey = Symbol();
+  vi.stubGlobal("FORM_CONTENT_LANGUAGE_KEY", contentLanguageKey);
+  vi.stubGlobal("inject", (key: symbol) =>
+    key === contentLanguageKey ? "*" : null,
+  );
+  props.modelValue = [original];
+  authFetch
+    .mockReset()
+    .mockResolvedValueOnce({
+      url: "https://example.test/first.png",
+      filename: "First",
+      size: 10,
+      expiresAt: Date.now() + 60000,
+    })
+    .mockRejectedValueOnce(new Error("temporary"))
+    .mockResolvedValueOnce({
+      url: "https://example.test/refreshed.png",
+      filename: "Refreshed",
+      size: 10,
+      expiresAt: Date.now() + 60000,
+    });
+
+  const image = loadImage();
+  await nextTick();
+  await vi.advanceTimersByTimeAsync(55000);
+  expect(image.items.value[0]!.url).toBe("https://example.test/first.png");
+  await vi.advanceTimersByTimeAsync(1000);
+  expect(image.items.value[0]!.url).toBe("https://example.test/refreshed.png");
+  expect(authFetch.mock.calls[0]![1].headers).toEqual({
+    "x-content-language": "*",
+  });
+  vi.useRealTimers();
+});

package/frontend-vue/tests/menu-navigation.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it } from "vitest";
+import {
+  addActiveStateToMenuItems,
+  isMenuItemActive,
+} from "../layers/dms-core/app/utils/menu";
+import { buildMenuItemTarget } from "../layers/dms-ui/app/build/types/tree";
+
+type TreeNode = Parameters<typeof buildMenuItemTarget>[0];
+
+function node(overrides: Partial<TreeNode>): TreeNode {
+  return {
+    id: "project",
+    fullId: "cloud.projects.project",
+    fullSlug: "/project",
+    displayName: "Project",
+    layoutUrl: "/project/pagelayout",
+    children: {},
+    childrenOrders: [],
+    ...overrides,
+  } as TreeNode;
+}
+
+function route(path: string, query: Record<string, unknown> = {}) {
+  return { path, query };
+}
+
+describe("buildMenuItemTarget", () => {
+  it("returns the bare slug when the entry declares no query", () => {
+    expect(buildMenuItemTarget(node({}))).to.equal("/project");
+  });
+
+  it("returns a path/query target when the entry declares a query", () => {
+    expect(
+      buildMenuItemTarget(node({ query: { project: "invoicer" } })),
+    ).to.deep.equal({ path: "/project", query: { project: "invoicer" } });
+  });
+
+  it("returns no target for a category that has no page behind it", () => {
+    expect(buildMenuItemTarget(node({ layoutUrl: undefined }))).to.equal(
+      undefined,
+    );
+  });
+});
+
+describe("isMenuItemActive with query entries", () => {
+  const invoicer = {
+    fullId: "cloud.projects.invoicer",
+    to: { path: "/project", query: { project: "invoicer" } },
+  };
+  const resto = {
+    fullId: "cloud.projects.resto",
+    to: { path: "/project", query: { project: "resto" } },
+  };
+
+  it("highlights only the entry matching the current query", () => {
+    const current = route("/project", { project: "invoicer" });
+    expect(isMenuItemActive(invoicer, null, current)).to.equal(true);
+    expect(isMenuItemActive(resto, null, current)).to.equal(false);
+  });
+
+  it("ignores query parameters the entry does not declare", () => {
+    const current = route("/project", { project: "invoicer", env: "prod" });
+    expect(isMenuItemActive(invoicer, null, current)).to.equal(true);
+  });
+
+  it("stays inactive on the same path without the entry's query", () => {
+    expect(isMenuItemActive(invoicer, null, route("/project"))).to.equal(false);
+  });
+
+  it("does not let the fullId fallback override a query mismatch", () => {
+    const current = route("/project", { project: "resto" });
+    expect(
+      isMenuItemActive(invoicer, "cloud.projects.invoicer", current),
+    ).to.equal(false);
+  });
+
+  it("keeps highlighting a plain entry on its sub-routes", () => {
+    const orders = { fullId: "pages.orders", to: "/orders" };
+    expect(isMenuItemActive(orders, null, route("/orders/detail/42"))).to.equal(
+      true,
+    );
+  });
+});
+
+describe("addActiveStateToMenuItems", () => {
+  it("marks a single query entry active across a group", () => {
+    const groups = [
+      [
+        {
+          id: "invoicer",
+          to: { path: "/project", query: { project: "invoicer" } },
+        },
+        { id: "resto", to: { path: "/project", query: { project: "resto" } } },
+      ],
+    ];
+
+    const [group] = addActiveStateToMenuItems(
+      groups,
+      null,
+      route("/project", { project: "resto" }),
+    );
+
+    expect(group?.[0]?.active).to.equal(undefined);
+    expect(group?.[1]?.active).to.equal(true);
+  });
+});

package/frontend-vue/tests/multi-account-validate.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { validateAccount } from "../layers/dms-core/app/composables/auth/useMultiAccount";
+import type { StoredAccount } from "../layers/dms-core/app/types/auth";
+
+function makeAccount(overrides: Partial<StoredAccount> = {}): StoredAccount {
+  return {
+    accountId: "account-1",
+    userId: "user-1",
+    email: "user@example.com",
+    name: "User",
+    lastUsed: new Date(0),
+    ...overrides,
+  };
+}
+
+function stubFetch(implementation: () => Promise<unknown>) {
+  const fetchMock = vi.fn(implementation);
+  (globalThis as Record<string, unknown>).$fetch = fetchMock;
+  return fetchMock;
+}
+
+afterEach(() => {
+  delete (globalThis as Record<string, unknown>).$fetch;
+});
+
+describe("validateAccount", () => {
+  it("posts only the opaque account identifier to the validate endpoint", async () => {
+    const fetchMock = stubFetch(async () => ({ valid: true }));
+
+    await validateAccount(makeAccount());
+
+    expect(fetchMock).toHaveBeenCalledWith("/auth/validate-account", {
+      method: "POST",
+      body: { accountId: "account-1" },
+    });
+  });
+
+  it("keeps the account expired when the endpoint answers 200 { valid: false }", async () => {
+    stubFetch(async () => ({ valid: false }));
+
+    const account = makeAccount({ isExpired: true });
+    await validateAccount(account);
+
+    expect(account.isExpired).toBe(true);
+  });
+
+  it("marks a previously valid account expired when validation fails", async () => {
+    stubFetch(async () => ({ valid: false }));
+
+    const account = makeAccount({ isExpired: false });
+    await validateAccount(account);
+
+    expect(account.isExpired).toBe(true);
+  });
+
+  it("clears the expired flag when the token is valid", async () => {
+    stubFetch(async () => ({ valid: true }));
+
+    const account = makeAccount({ isExpired: true });
+    await validateAccount(account);
+
+    expect(account.isExpired).toBe(false);
+  });
+
+  it("ignores token-shaped data from a failed validation", async () => {
+    stubFetch(async () => ({
+      valid: false,
+      refresh_token: "should-not-be-used",
+    }));
+
+    const account = makeAccount();
+    await validateAccount(account);
+
+    expect(account.isExpired).toBe(true);
+    expect(account).not.toHaveProperty("refreshToken");
+  });
+
+  it("leaves the stored state untouched on an indeterminate verdict", async () => {
+    stubFetch(async () => ({ valid: null }));
+
+    const account = makeAccount({ isExpired: true });
+    await validateAccount(account);
+
+    expect(account.isExpired).toBe(true);
+    expect(account).not.toHaveProperty("refreshToken");
+  });
+
+  it("leaves the stored state untouched when the request itself throws", async () => {
+    stubFetch(async () => {
+      throw new Error("network down");
+    });
+
+    const account = makeAccount({ isExpired: false });
+    await validateAccount(account);
+
+    expect(account.isExpired).toBe(false);
+    expect(account).not.toHaveProperty("refreshToken");
+  });
+});