@antelopejs/dms 0.9.2 → 0.9.4

package/frontend-vue/tests/table-view-card-props.test.ts

@@ -1,215 +0,0 @@
-// @vitest-environment jsdom
-import { computed, createApp, defineComponent, h, ref, type App } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import CardsDisplay from "../layers/dms-ui/app/build/components/table-view/CardsDisplay.vue";
-import {
-  buildCardProps,
-  cardFieldColumns,
-} from "../layers/dms-ui/app/build/composables/table-view/utils/card";
-import type { TableViewColumn } from "../layers/dms-ui/app/composables/table-view/types/column";
-import type {
-  TableViewCardProps,
-  TableViewDisplayContext,
-} from "../layers/dms-ui/app/composables/table-view/types/display";
-
-vi.mock("../layers/dms-ui/app/build/components/table/Pagination.vue", () => ({
-  default: { render: () => null },
-}));
-vi.mock("../layers/dms-ui/app/build/components/table/Empty.vue", () => ({
-  default: { render: () => null },
-}));
-
-const rows = [
-  { _id: "t1", name: "Write the docs" },
-  { _id: "t2", name: "Ship it" },
-];
-
-function createContext() {
-  const selected = ref<string[]>(["t2"]);
-  const opened: unknown[] = [];
-  const context = {
-    items: rows,
-    columns: [],
-    loading: false,
-    rowIdKey: "_id",
-    labelKey: "name",
-    options: { card: { component: { componentName: "TaskCard" } } },
-    pagination: { pageIndex: 0, pageSize: 10, total: 2 },
-    selection: {
-      ids: selected.value,
-      isSelected: (id: string) => selected.value.includes(id),
-      toggle: (id: string, value?: boolean) => {
-        const on = value ?? !selected.value.includes(id);
-        selected.value = on
-          ? [...selected.value, id]
-          : selected.value.filter((entry) => entry !== id);
-      },
-    },
-    actions: {
-      canAdd: false,
-      open: (item: unknown) => opened.push(item),
-    },
-  } as unknown as TableViewDisplayContext<(typeof rows)[number]>;
-  return { context, selected, opened };
-}
-
-describe("table view card props", () => {
-  it("hands a card its row, selection and default action", () => {
-    const { context, selected, opened } = createContext();
-    const props = buildCardProps(rows[0]!, context);
-    expect(props).toMatchObject({
-      row: rows[0],
-      rowId: "t1",
-      labelKey: "name",
-      selected: false,
-    });
-    props.select(true);
-    expect(selected.value).toContain("t1");
-    props.open();
-    expect(opened).toEqual([rows[0]]);
-    expect(buildCardProps(rows[1]!, context).selected).toBe(true);
-  });
-});
-
-describe("cards display with a custom card", () => {
-  let app: App | undefined;
-  const received: TableViewCardProps[] = [];
-
-  const TaskCard = defineComponent({
-    props: {
-      row: Object,
-      rowId: String,
-      columns: Array,
-      labelKey: String,
-      actions: Object,
-      selected: Boolean,
-      select: Function,
-      open: Function,
-    },
-    setup: (props) => () => {
-      received.push({ ...props } as unknown as TableViewCardProps);
-      return h("button", { onClick: () => props.open?.() }, props.rowId);
-    },
-  });
-
-  beforeEach(() => {
-    received.length = 0;
-    vi.stubGlobal("computed", computed);
-    vi.stubGlobal("h", h);
-    vi.stubGlobal("useI18n", () => ({
-      locale: ref("en"),
-      t: (key: string) => key,
-    }));
-    vi.stubGlobal("useTranslation", () => ({ processI18n: (t: string) => t }));
-    vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
-    vi.stubGlobal("resolveDmsComponent", (name: string) =>
-      name === "TaskCard" ? TaskCard : undefined,
-    );
-  });
-
-  afterEach(() => {
-    app?.unmount();
-    app = undefined;
-    vi.unstubAllGlobals();
-  });
-
-  it("draws every row with the card component and its props", () => {
-    const { context, opened } = createContext();
-    app = createApp({ render: () => h(CardsDisplay, { context }) });
-    const container = document.createElement("div");
-    app.mount(container);
-
-    const buttons = [...container.querySelectorAll("button")];
-    expect(buttons.map((button) => button.textContent)).toEqual(["t1", "t2"]);
-    expect(received.map((props) => props.selected)).toEqual([false, true]);
-    buttons[0]!.click();
-    expect(opened).toEqual([rows[0]]);
-  });
-});
-
-describe("the default cards", () => {
-  let app: App | undefined;
-
-  beforeEach(() => {
-    vi.stubGlobal("computed", computed);
-    vi.stubGlobal("useI18n", () => ({
-      locale: ref("en"),
-      t: (key: string) => key,
-    }));
-    vi.stubGlobal("useTranslation", () => ({ processI18n: (t: string) => t }));
-    vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
-  });
-
-  afterEach(() => {
-    app?.unmount();
-    app = undefined;
-    vi.unstubAllGlobals();
-  });
-
-  it("open from the keyboard, but not through their checkbox", () => {
-    const { context, opened } = createContext();
-    context.options = {};
-    app = createApp({ render: () => h(CardsDisplay, { context }) });
-    app.component(
-      "UCheckbox",
-      defineComponent({ render: () => h("button", { type: "button" }) }),
-    );
-    const container = document.createElement("div");
-    app.mount(container);
-
-    const cards = [...container.querySelectorAll("article")];
-    expect(cards.map((card) => card.tabIndex)).toEqual([0, 0]);
-    const enter = () =>
-      new KeyboardEvent("keydown", { key: "Enter", bubbles: true });
-    cards[1]!.dispatchEvent(enter());
-    expect(opened).toEqual([rows[1]]);
-    cards[0]!.querySelector("button")!.dispatchEvent(enter());
-    expect(opened).toEqual([rows[1]]);
-  });
-});
-
-describe("card fields", () => {
-  const columns = [
-    "_id",
-    "name",
-    "status",
-    "owner",
-    "due",
-    "hidden",
-    "size",
-    "tags",
-  ].map(
-    (key) =>
-      ({
-        id: key,
-        accessorKey: key,
-        listable: key !== "hidden",
-      }) as TableViewColumn,
-  );
-  const keys = (picked: TableViewColumn[]) =>
-    picked.map((column) => column.accessorKey);
-
-  it("shows the declared fields, in their order", () => {
-    expect(
-      keys(
-        cardFieldColumns(columns, ["due", "name", "gone"], { rowIdKey: "_id" }),
-      ),
-    ).toEqual(["due", "name"]);
-  });
-
-  it("falls back to the first listable columns besides the title and the id, on the board too", () => {
-    const shown = { labelKey: "name", rowIdKey: "_id" };
-    expect(keys(cardFieldColumns(columns, undefined, shown))).toEqual([
-      "status",
-      "owner",
-      "due",
-      "size",
-    ]);
-    // A kanban card sits in its group's column: the group is not repeated.
-    expect(
-      keys(
-        cardFieldColumns(columns, undefined, { ...shown, others: ["status"] }),
-      ),
-    ).toEqual(["owner", "due", "size", "tags"]);
-  });
-});

package/frontend-vue/tests/table-view-cards-reorder.test.ts

@@ -1,234 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  reactive,
-  ref,
-  type App,
-  type PropType,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import CardsDisplay from "../layers/dms-ui/app/build/components/table-view/CardsDisplay.vue";
-import { useTableReorder } from "../layers/dms-ui/app/build/composables/table-view/useTableReorder";
-import { moveRow } from "../layers/dms-ui/app/build/composables/table-view/utils/reorder";
-import type {
-  TableViewCardReorder,
-  TableViewDisplayContext,
-} from "../layers/dms-ui/app/composables/table-view/types/display";
-
-vi.mock("../layers/dms-ui/app/build/components/table/Pagination.vue", () => ({
-  default: { render: () => null },
-}));
-vi.mock("../layers/dms-ui/app/build/components/table/Empty.vue", () => ({
-  default: { render: () => null },
-}));
-
-type Row = { _id: string; name: string };
-type Api = Parameters<typeof useTableReorder>[0]["api"];
-
-const TaskCard = defineComponent({
-  props: {
-    rowId: String,
-    selected: Boolean,
-    reorder: Object as PropType<TableViewCardReorder>,
-  },
-  setup: (props) => () =>
-    h("article", { "data-selected": String(props.selected) }, [
-      props.rowId,
-      props.reorder ? h("button", props.reorder.handle) : null,
-    ]),
-});
-
-function createContext(enabled = true, componentName?: string) {
-  const items = ref<Row[]>(
-    ["t0", "t1", "t2"].map((id) => ({ _id: id, name: `Task ${id}` })),
-  );
-  const moves: [number, number][] = [];
-  const opened: unknown[] = [];
-  const selected = ref<string[]>(["t1"]);
-  const reorder = {
-    enabled,
-    move: (from: number, to: number) => {
-      moves.push([from, to]);
-      items.value = moveRow(items.value, from, to);
-    },
-  };
-  const context = reactive({
-    items,
-    columns: [],
-    loading: false,
-    rowIdKey: "_id",
-    labelKey: "name",
-    options: componentName ? { card: { component: { componentName } } } : {},
-    pagination: { pageIndex: 0, pageSize: 10, total: 3 },
-    selection: {
-      isSelected: (id: string) => selected.value.includes(id),
-      toggle: (id: string, value?: boolean) => {
-        const on = value ?? !selected.value.includes(id);
-        selected.value = on
-          ? [...selected.value, id]
-          : selected.value.filter((entry) => entry !== id);
-      },
-    },
-    actions: { canAdd: false, open: (item: unknown) => opened.push(item) },
-    reorder,
-  }) as unknown as TableViewDisplayContext<Row>;
-  return { context, items, moves, opened, selected };
-}
-
-const dragEvent = (type: string) => new Event(type, { bubbles: true });
-const key = (name: string) =>
-  new KeyboardEvent("keydown", { key: name, bubbles: true });
-
-describe("the cards display of a hand-ordered table", () => {
-  let app: App | undefined;
-  let container: HTMLElement;
-
-  const mount = (context: TableViewDisplayContext<Row>) => {
-    app = createApp({ render: () => h(CardsDisplay, { context }) });
-    app.component(
-      "UCheckbox",
-      defineComponent({
-        emits: ["update:modelValue"],
-        setup:
-          (_, { emit }) =>
-          () =>
-            h("input", {
-              type: "checkbox",
-              onChange: () => emit("update:modelValue", true),
-            }),
-      }),
-    );
-    app.component("UIcon", defineComponent({ render: () => h("i") }));
-    container = document.createElement("div");
-    document.body.append(container);
-    app.mount(container);
-  };
-  const handles = () => [
-    ...container.querySelectorAll<HTMLButtonElement>("button[draggable]"),
-  ];
-  const cards = () => [...container.querySelectorAll("article")];
-
-  beforeEach(() => {
-    vi.stubGlobal("computed", computed);
-    vi.stubGlobal("h", h);
-    vi.stubGlobal("useI18n", () => ({
-      locale: ref("en"),
-      t: (text: string) => text,
-    }));
-    vi.stubGlobal("useTranslation", () => ({ processI18n: (t: string) => t }));
-    vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
-    vi.stubGlobal("resolveDmsComponent", (name: string) =>
-      name === "TaskCard" ? TaskCard : undefined,
-    );
-  });
-
-  afterEach(() => {
-    app?.unmount();
-    app = undefined;
-    container.remove();
-    vi.unstubAllGlobals();
-  });
-
-  it("moves a card dragged by its handle onto the card it is dropped on", async () => {
-    const { context, moves, items } = createContext();
-    mount(context);
-    expect(handles()).toHaveLength(3);
-    expect(handles()[0]!.getAttribute("aria-label")).toBe(
-      "dms.table.reorder.move",
-    );
-    handles()[2]!.dispatchEvent(dragEvent("dragstart"));
-    await nextTick();
-    expect(cards()[2]!.classList.contains("opacity-50")).toBe(true);
-    cards()[0]!.dispatchEvent(dragEvent("drop"));
-    expect(moves).toEqual([[2, 0]]);
-    expect(items.value.map((row) => row._id)).toEqual(["t2", "t0", "t1"]);
-  });
-
-  it("moves a card by one with the arrow keys and keeps the focus on its handle", async () => {
-    const { context, moves, items } = createContext();
-    mount(context);
-    const handle = handles()[1]!;
-    handle.focus();
-    handle.dispatchEvent(key("ArrowLeft"));
-    await nextTick();
-    await nextTick();
-    expect(items.value.map((row) => row._id)).toEqual(["t1", "t0", "t2"]);
-    expect(document.activeElement).toBe(handle);
-    handles()[2]!.dispatchEvent(key("ArrowDown"));
-    handles()[0]!.dispatchEvent(key("ArrowUp"));
-    expect(moves).toEqual([[1, 0]]);
-  });
-
-  it("keeps its selection and its default action beside the handle", () => {
-    const { context, opened, selected } = createContext();
-    mount(context);
-    handles()[0]!.click();
-    handles()[0]!.dispatchEvent(key("Enter"));
-    expect(opened).toEqual([]);
-    container.querySelectorAll("input")[0]!.dispatchEvent(new Event("change"));
-    expect(selected.value).toEqual(["t1", "t0"]);
-    cards()[2]!.click();
-    expect(opened).toEqual([context.items[2]]);
-  });
-
-  it("disables the handle while moving is off, saying how to turn it on", () => {
-    const { context, moves } = createContext(false);
-    mount(context);
-    const handle = container.querySelector("header button")!;
-    expect(handle.hasAttribute("disabled")).toBe(true);
-    expect(handle.getAttribute("title")).toBe("dms.table.reorder.disabled");
-    handle.dispatchEvent(dragEvent("dragstart"));
-    cards()[0]!.dispatchEvent(dragEvent("drop"));
-    expect(moves).toEqual([]);
-  });
-
-  it("draws no handle on a table not ordered by hand", () => {
-    const { context } = createContext();
-    (context as { reorder?: unknown }).reorder = undefined;
-    mount(context);
-    expect(container.querySelector("header button")).toBe(null);
-  });
-
-  it("hands a custom card its handle, its selection, and drops on it", () => {
-    const { context, moves } = createContext(true, "TaskCard");
-    mount(context);
-    expect(cards().map((card) => card.dataset.selected)).toEqual([
-      "false",
-      "true",
-      "false",
-    ]);
-    handles()[0]!.dispatchEvent(dragEvent("dragstart"));
-    cards()[2]!.dispatchEvent(dragEvent("drop"));
-    expect(moves).toEqual([[0, 2]]);
-    handles()[1]!.dispatchEvent(key("ArrowRight"));
-    expect(moves).toEqual([
-      [0, 2],
-      [1, 2],
-    ]);
-  });
-});
-
-describe("which displays move rows", () => {
-
-  it("draws no handle on a display that does not draw the rows in their order", () => {
-    vi.stubGlobal("computed", computed);
-    const { reorderState } = useTableReorder({
-      reorder: { field: "position" },
-      data: ref(null),
-      rowIdKey: "_id",
-      location: "/api/features",
-      api: vi.fn() as unknown as Api,
-      canEdit: computed(() => true),
-      isNarrowed: computed(() => false),
-      isOrderedDisplay: computed(() => false),
-      refresh: vi.fn(),
-      onError: vi.fn(),
-    });
-    expect(reorderState.value).toBe(undefined);
-    vi.unstubAllGlobals();
-  });
-});

package/frontend-vue/tests/table-view-cards-reread.test.ts

@@ -1,77 +0,0 @@
-// @vitest-environment jsdom
-import { computed, createApp, h, reactive, ref, type App } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import CardsDisplay from "../layers/dms-ui/app/build/components/table-view/CardsDisplay.vue";
-import type { TableViewDisplayContext } from "../layers/dms-ui/app/composables/table-view/types/display";
-
-vi.mock("../layers/dms-ui/app/build/components/table/Pagination.vue", () => ({
-  default: { render: () => null },
-}));
-vi.mock("../layers/dms-ui/app/build/components/table/Empty.vue", () => ({
-  default: { render: () => h("p", { "data-test": "empty" }) },
-}));
-vi.mock(
-  "../layers/dms-ui/app/build/components/table-view/CardGridSkeleton.vue",
-  () => ({ default: { render: () => h("p", { "data-test": "skeleton" }) } }),
-);
-
-interface ReadState {
-  loading: boolean;
-  firstPageLoading: boolean;
-}
-
-function createContext(state: ReadState) {
-  return reactive({
-    items: [],
-    columns: [],
-    ...state,
-    rowIdKey: "_id",
-    labelKey: "name",
-    options: {},
-    pagination: { pageIndex: 0, pageSize: 10, total: 0 },
-    selection: { isSelected: () => false, toggle: () => {} },
-    actions: { canAdd: false, open: () => {} },
-  }) as unknown as TableViewDisplayContext;
-}
-
-describe("the cards display of an empty list", () => {
-  let app: App | undefined;
-  let container: HTMLElement;
-
-  const mount = (context: TableViewDisplayContext) => {
-    app = createApp({ render: () => h(CardsDisplay, { context }) });
-    container = document.createElement("div");
-    document.body.append(container);
-    app.mount(container);
-  };
-  const shown = (test: string) =>
-    container.querySelector(`[data-test="${test}"]`) !== null;
-
-  beforeEach(() => {
-    vi.stubGlobal("computed", computed);
-    vi.stubGlobal("h", h);
-    vi.stubGlobal("useI18n", () => ({ locale: ref("en"), t: (t: string) => t }));
-    vi.stubGlobal("useTranslation", () => ({ processI18n: (t: string) => t }));
-    vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
-    vi.stubGlobal("resolveDmsComponent", () => undefined);
-  });
-
-  afterEach(() => {
-    app?.unmount();
-    app = undefined;
-    container.remove();
-    vi.unstubAllGlobals();
-  });
-
-  it("draws the skeleton until the first answer arrives", () => {
-    mount(createContext({ loading: true, firstPageLoading: true }));
-    expect(shown("skeleton")).toBe(true);
-    expect(shown("empty")).toBe(false);
-  });
-
-  it("keeps the empty state on screen while the list is read again", () => {
-    mount(createContext({ loading: true, firstPageLoading: false }));
-    expect(shown("empty")).toBe(true);
-    expect(shown("skeleton")).toBe(false);
-  });
-});

package/frontend-vue/tests/table-view-chrome.test.ts

@@ -1,175 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  FULL_TABLE_CHROME,
-  resolveTableChrome,
-} from "../layers/dms-ui/app/build/composables/table-view/utils/chrome";
-import {
-  applyQuickFilter,
-  quickFilterButtonLabel,
-  quickFilterValue,
-  quickFilterMode,
-  relationQuickFilterItems,
-  relationQuickFilterSource,
-  staticQuickFilterItems,
-} from "../layers/dms-ui/app/build/composables/table-view/utils/quickFilters";
-import type { TableViewColumn } from "../layers/dms-ui/app/composables/table-view/types/column";
-
-const column = (
-  id: string,
-  options: Record<string, unknown> = {},
-): TableViewColumn =>
-  ({
-    id,
-    accessorKey: id,
-    header: id,
-    listable: true,
-    type: { id, inputComponent: { componentName: "x", options } },
-  }) as unknown as TableViewColumn;
-
-describe("TableView layout", () => {
-  const everything = {
-    hasCaption: true,
-    isSearchable: true,
-    isFilterable: true,
-  };
-
-  it("draws the full chrome by default", () => {
-    expect(resolveTableChrome(undefined, everything)).toEqual(
-      FULL_TABLE_CHROME,
-    );
-    expect(resolveTableChrome("full", everything).search).toBe("toggle");
-  });
-
-  it("reduces the compact layout to an open search field and the page size picker", () => {
-    expect(resolveTableChrome("compact", everything)).toEqual({
-      caption: false,
-      search: "field",
-      filters: false,
-      sorting: false,
-      refresh: false,
-      menu: false,
-      columnMenus: false,
-      pageSize: true,
-    });
-  });
-
-  it("draws a control only when the table has something to offer through it", () => {
-    const bare = resolveTableChrome("full", {
-      hasCaption: false,
-      isSearchable: false,
-      isFilterable: false,
-    });
-    expect(bare.caption).toBe(false);
-    expect(bare.search).toBe("none");
-    expect(bare.filters).toBe(false);
-    expect(bare.menu).toBe(true);
-    expect(
-      resolveTableChrome("compact", { ...everything, isSearchable: false })
-        .search,
-    ).toBe("none");
-  });
-});
-
-describe("TableView quick filters", () => {
-  const translate = (key: string) => key.replace(/^\$/, "t:");
-
-  it("lists a select's items and a boolean's two values", () => {
-    expect(
-      staticQuickFilterItems(
-        column("select", { items: [{ value: 1, label: "$one" }] }),
-        translate,
-      ),
-    ).toEqual([{ value: "1", label: "t:one" }]);
-    expect(
-      staticQuickFilterItems(column("boolean"), translate)?.map((i) => i.value),
-    ).toEqual(["true", "false"]);
-  });
-
-  it("reads a relation's values from its select endpoint", () => {
-    const relation = column("relation", {
-      multiple: true,
-      searchUrl: "/api/roles/select",
-      keyMapping: { label: "title", value: "_id" },
-    });
-    expect(staticQuickFilterItems(relation, translate)).toBe(undefined);
-    const source = relationQuickFilterSource(relation)!;
-    expect(source).toEqual({
-      url: "/api/roles/select",
-      labelKey: "title",
-      valueKey: "_id",
-    });
-    expect(
-      relationQuickFilterItems(
-        [{ _id: "r1", title: "Admin" }, { title: "no id" }],
-        source,
-      ),
-    ).toEqual([{ value: "r1", label: "Admin" }]);
-  });
-
-  it("matches inside a list for a multiple column, by equality otherwise", () => {
-    expect(quickFilterMode(column("relation", { multiple: true }))).toBe(
-      "array_contains_string",
-    );
-    expect(quickFilterMode(column("select"))).toBe("is");
-    expect(quickFilterMode(column("select"), "is_not")).toBe("is_not");
-  });
-
-  const roles = { field: "roleIds", mode: "array_contains_string" } as const;
-  const dueDate = {
-    accessorKey: "dueDate",
-    mode: "before",
-    value: "2026-01-01",
-    pinned: false,
-  };
-
-  it("writes the picked value as the column's own filter", () => {
-    const filters = applyQuickFilter([dueDate], roles, "r1");
-    expect(filters).toEqual([
-      dueDate,
-      {
-        accessorKey: "roleIds",
-        mode: "array_contains_string",
-        value: "r1",
-        pinned: false,
-      },
-    ]);
-    expect(quickFilterValue(filters, roles)).toBe("r1");
-    expect(applyQuickFilter(filters, roles, "r2")).toHaveLength(2);
-    expect(quickFilterValue(applyQuickFilter(filters, roles, "r2"), roles)).toBe(
-      "r2",
-    );
-  });
-
-  it("clears its filter on All, leaving the others", () => {
-    const filters = applyQuickFilter([dueDate], roles, "r1");
-    expect(applyQuickFilter(filters, roles, undefined)).toEqual([dueDate]);
-    expect(quickFilterValue([dueDate], roles)).toBe(undefined);
-  });
-
-  it("sets a default filter on the column rather than adding a second one", () => {
-    const pinned = {
-      accessorKey: "roleIds",
-      mode: "array_contains_string",
-      value: undefined,
-      pinned: true,
-      initialValue: undefined,
-    };
-    expect(applyQuickFilter([pinned], roles, "r1")).toEqual([
-      { ...pinned, value: "r1" },
-    ]);
-  });
-
-  it("names the column and its value on the button of a table without filters row", () => {
-    const role = {
-      ...roles,
-      label: "Role",
-      icon: "i-ph-funnel",
-      allLabel: "All",
-      items: [{ value: "r1", label: "Admin" }],
-    };
-    const filters = applyQuickFilter([], role, "r1");
-    expect(quickFilterButtonLabel(role, [], false)).toBe("Role");
-    expect(quickFilterButtonLabel(role, filters, true)).toBe("Admin");
-    expect(quickFilterButtonLabel(role, filters, false)).toBe("Role: Admin");
-  });
-});