Skip to content

The complete open source platform to run your entire marketplace. Storefront, vendor panel, admin console, and integrations in one enterprise-grade platform you own.

15.6 KB
Raw Blame
import {
  BuildingStorefront,
  Buildings,
  CogSixTooth,
  CreditCardRefresh,
  CurrencyDollar,
  EllipsisHorizontal,
  MagnifyingGlass,
  MinusMini,
  OpenRectArrowOut,
  ReceiptPercent,
  ShoppingCart,
  Tag,
  Users,
} from "@medusajs/icons";
import {
  Avatar,
  Divider,
  DropdownMenu,
  IconButton,
  Text,
  clx,
} from "@medusajs/ui";

import { Fragment, useMemo } from "react";
import { Collapsible as RadixCollapsible } from "radix-ui";
import { useTranslation } from "react-i18next";
import { Link, useLocation, useNavigate } from "react-router-dom";

import { useLogout } from "../../../hooks/api";
import { useStore } from "../../../hooks/api/store";
import { useDocumentDirection } from "../../../hooks/use-document-direction";
import { queryClient } from "../../../lib/query-client";
import { useSearch } from "../../../providers/search-provider";
import {
  SIDEBAR_MENU_CONTENT,
  SIDEBAR_RAIL_FADE,
  useSidebarMenuPlacement,
} from "../../../providers/sidebar-provider";
import { Skeleton } from "../../common/skeleton";
import { INavItem, NavItem } from "../../layout/nav-item";
import { Shell } from "../../layout/shell";
import { UserMenu } from "../user-menu";
import menuItemsModule from "virtual:mercur/menu-items";
import {
  applyNavOverrides,
  groupNavItems,
  type NavItemGroup,
  useExtension,
  usePermissions,
  type CoreNavItem,
} from "@mercurjs/dashboard-shared";

const navId = (to: string) => to.replace(/^\//, "");

const toCoreNavItem = (route: Omit<INavItem, "pathname">): CoreNavItem => ({
  id: navId(route.to),
  label: route.label,
  to: route.to,
  icon: route.icon,
  items: route.items?.map((item) => ({
    id: navId(item.to),
    label: item.label,
    to: item.to,
  })),
});
import {
  filterMenuItemsByPermissions,
  getMenuItemsByType,
  getNestedMenuItems,
} from "../../../utils/routes";
import { canReachRoute } from "../../../lib/permissions/can-reach-route";

export const MainLayout = () => {
  return (
    <Shell>
      <MainSidebar />
    </Shell>
  );
};

const allMenuItems = menuItemsModule.menuItems ?? [];

const addNestedItems = (
  to: string,
  menuItems: typeof allMenuItems,
  items?: { label: string; to: string; translationNs?: string }[],
) => {
  const nestedItems = getNestedMenuItems(menuItems, to);
  if (nestedItems.length === 0) {
    return items;
  }

  const nestedNavItems = nestedItems.map((item) => ({
    label: item.label,
    to: item.path,
    translationNs: item.translationNs,
  }));

  return [...(items ?? []), ...nestedNavItems];
};

type SidebarRoute = Omit<INavItem, "pathname"> & { group?: string };

const useSidebarRoutes = () => {
  const coreRoutes = useCoreRoutes();
  const extension = useExtension();
  const navOverrides = extension.getNavOverrides();
  const permissions = usePermissions();
  const { hasAnyPermission, hasAllPermissions } = permissions;

  // Hides links the actor can't open. `RoutePermissionGuard` is what actually
  // refuses the route; this only keeps the sidebar honest.
  const canReach = ({ to }: { to: string }) => canReachRoute(permissions, to);

  const visibleMenuItems = useMemo(
    () =>
      filterMenuItemsByPermissions(allMenuItems, {
        hasAnyPermission,
        hasAllPermissions,
      }),
    [hasAnyPermission, hasAllPermissions],
  );

  const customMenuItems = getMenuItemsByType(visibleMenuItems, "main");

  const routesWithNested = applyNavOverrides(
    coreRoutes.map(toCoreNavItem),
    navOverrides,
  )
    .filter(canReach)
    .map((route) => ({
      ...route,
      items: addNestedItems(route.to, visibleMenuItems, route.items)?.filter(
        canReach,
      ),
    }));

  const customRoutesWithNested = customMenuItems
    .sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0))
    .map((item) => ({
      label: item.label,
      to: item.path,
      icon: item.icon ? <item.icon /> : undefined,
      translationNs: item.translationNs,
      group: item.group,
      type: "extension" as const,
      items: addNestedItems(item.path, visibleMenuItems),
    }));

  const groupById = new Map<string, string | undefined>(
    navOverrides.map((o) => [o.id, o.group]),
  );

  return groupNavItems<SidebarRoute>(
    [
      ...routesWithNested.map((route) => ({
        ...route,
        group: groupById.get(route.id),
      })),
      ...customRoutesWithNested,
    ],
    extension.getNavGroups(),
  );
};

// First sidebar entry the actor can open, in sidebar order. Falls back to the
// profile page, which needs no permission.
export const useLandingRoute = () => {
  const { ungrouped, groups } = useSidebarRoutes();
  const first = [...ungrouped, ...groups.flatMap((group) => group.items)][0];
  return first?.to ?? "/settings/profile";
};

const MainSidebar = () => {
  const { ungrouped, groups } = useSidebarRoutes();

  return (
    <aside
      className="flex flex-1 flex-col justify-between overflow-y-auto overflow-x-hidden"
      data-testid="sidebar"
    >
      <div className="flex flex-1 flex-col">
        <div
          className="sticky top-0 bg-ui-bg-subtle"
          data-testid="sidebar-header-section"
        >
          <Header />
          <div className="px-3">
            <Divider variant="dashed" />
          </div>
        </div>
        <div className="flex flex-1 flex-col justify-between">
          <div className="flex flex-1 flex-col">
            <nav
              className="flex flex-col gap-y-1 py-3"
              data-testid="sidebar-core-routes"
            >
              <Searchbar />
              {ungrouped.map((route) => (
                <NavItem key={route.to} {...route} />
              ))}
            </nav>
            {groups.map((group) => (
              <Fragment key={group.id}>
                <div className="px-3">
                  <Divider variant="dashed" />
                </div>
                <SidebarGroup group={group} />
              </Fragment>
            ))}
          </div>
          <UtilitySection />
        </div>
        <div
          className="sticky bottom-0 bg-ui-bg-subtle"
          data-testid="sidebar-user-section"
        >
          <UserSection />
        </div>
      </div>
    </aside>
  );
};

const SidebarGroup = ({ group }: { group: NavItemGroup<SidebarRoute> }) => {
  const { t } = useTranslation(group.translationNs);

  return (
    <RadixCollapsible.Root
      defaultOpen
      className="py-3"
      data-testid={`sidebar-group-${group.id}`}
    >
      <div className="px-3">
        <div
          className={clx(
            "flex h-7 items-center justify-between overflow-hidden whitespace-nowrap px-2 text-ui-fg-muted",
            SIDEBAR_RAIL_FADE,
          )}
        >
          <Text size="small" leading="compact">
            {group.translationNs ? t(group.label) : group.label}
          </Text>
          <RadixCollapsible.Trigger asChild>
            <IconButton
              size="2xsmall"
              variant="transparent"
              className="static"
              data-testid={`sidebar-group-${group.id}-toggle`}
            >
              <MinusMini className="text-ui-fg-muted" />
            </IconButton>
          </RadixCollapsible.Trigger>
        </div>
      </div>
      <RadixCollapsible.Content>
        <div className="pt-0.5">
          <nav className="flex flex-col gap-y-1">
            {group.items.map((route) => (
              <NavItem key={route.to} {...route} />
            ))}
          </nav>
        </div>
      </RadixCollapsible.Content>
    </RadixCollapsible.Root>
  );
};

const Logout = () => {
  const { t } = useTranslation();
  const navigate = useNavigate();

  const { mutateAsync: logoutMutation } = useLogout();

  const handleLogout = async () => {
    await logoutMutation(undefined, {
      onSuccess: () => {
        /**
         * When the user logs out, we want to clear the query cache
         */
        queryClient.clear();
        navigate("/login");
      },
    });
  };

  return (
    <DropdownMenu.Item
      onClick={handleLogout}
      data-testid="sidebar-header-dropdown-logout"
    >
      <div className="flex items-center gap-x-2">
        <OpenRectArrowOut className="text-ui-fg-subtle" />
        <span>{t("app.menus.actions.logout")}</span>
      </div>
    </DropdownMenu.Item>
  );
};

const Header = () => {
  const { t } = useTranslation();
  const { store, isPending, isError, error } = useStore();
  const direction = useDocumentDirection();
  const menuPlacement = useSidebarMenuPlacement("start");
  const name = store?.name;
  const fallback = store?.name?.slice(0, 1).toUpperCase();

  const isLoaded = !isPending && !!store && !!name && !!fallback;

  if (isError) {
    throw error;
  }

  return (
    <div className="w-full p-3" data-testid="sidebar-header-dropdown">
      <DropdownMenu dir={direction} data-testid="sidebar-header-dropdown-menu">
        <DropdownMenu.Trigger
          disabled={!isLoaded}
          className={clx(
            "grid w-full grid-cols-[24px_1fr_15px] items-center gap-x-3 rounded-md bg-ui-bg-subtle p-0.5 pe-2 outline-none transition-fg",
            "hover:bg-ui-bg-subtle-hover",
            "data-[state=open]:bg-ui-bg-subtle-hover",
            "focus-visible:shadow-borders-focus",
          )}
          data-testid="sidebar-header-dropdown-trigger"
        >
          {fallback ? (
            <Avatar
              variant="squared"
              size="xsmall"
              fallback={fallback}
              data-testid="sidebar-header-dropdown-avatar"
            />
          ) : (
            <Skeleton className="h-6 w-6 rounded-md" />
          )}
          <div
            className={clx("block overflow-hidden whitespace-nowrap text-start", SIDEBAR_RAIL_FADE)}
            data-testid="sidebar-header-dropdown-store-name"
          >
            {name ? (
              <Text
                size="small"
                weight="plus"
                leading="compact"
                className="truncate"
              >
                {store.name}
              </Text>
            ) : (
              <Skeleton className="h-[9px] w-[120px]" />
            )}
          </div>
          <EllipsisHorizontal className={clx("text-ui-fg-muted", SIDEBAR_RAIL_FADE)} />
        </DropdownMenu.Trigger>
        {isLoaded && (
          <DropdownMenu.Content
            {...menuPlacement}
            className={SIDEBAR_MENU_CONTENT}
            data-testid="sidebar-header-dropdown-content"
          >
            <div
              className="flex items-center gap-x-3 px-2 py-1"
              data-testid="sidebar-header-dropdown-user-info"
            >
              <Avatar
                variant="squared"
                size="small"
                fallback={fallback}
                data-testid="sidebar-header-dropdown-user-avatar"
              />
              <div
                className="flex flex-col overflow-hidden"
                data-testid="sidebar-header-dropdown-user-details"
              >
                <Text
                  size="small"
                  weight="plus"
                  leading="compact"
                  className="truncate"
                  data-testid="sidebar-header-dropdown-user-name"
                >
                  {name}
                </Text>
                <Text
                  size="xsmall"
                  leading="compact"
                  className="text-ui-fg-subtle"
                  data-testid="sidebar-header-dropdown-store-label"
                >
                  {t("app.nav.main.marketplace")}
                </Text>
              </div>
            </div>
            <DropdownMenu.Separator data-testid="sidebar-header-dropdown-separator-1" />
            <DropdownMenu.Item
              className="gap-x-2"
              asChild
              data-testid="sidebar-header-dropdown-store-settings"
            >
              <Link to="/settings/marketplace">
                <BuildingStorefront className="text-ui-fg-subtle" />
                {t("app.nav.main.marketplaceSettings")}
              </Link>
            </DropdownMenu.Item>
            <DropdownMenu.Separator data-testid="sidebar-header-dropdown-separator-2" />
            <Logout />
          </DropdownMenu.Content>
        )}
      </DropdownMenu>
    </div>
  );
};

const useCoreRoutes = (): Omit<INavItem, "pathname">[] => {
  const { t } = useTranslation();

  return [
    {
      icon: <ShoppingCart />,
      label: t("orders.domain"),
      to: "/orders",
      items: [
        // TODO: Enable when domin is introduced
        // {
        //   label: t("draftOrders.domain"),
        //   to: "/draft-orders",
        // },
      ],
    },
    {
      icon: <Tag />,
      label: t("products.domain"),
      to: "/products",
      items: [
        {
          label: t("offers.domain"),
          to: "/offers",
        },
        {
          label: t("collections.domain"),
          to: "/collections",
        },
        {
          label: t("categories.domain"),
          to: "/categories",
        },
        // TODO: Enable when domin is introduced
        // {
        //   label: t("giftCards.domain"),
        //   to: "/gift-cards",
        // },
      ],
    },
    {
      icon: <Buildings />,
      label: t("inventory.domain"),
      to: "/inventory",
      items: [
        {
          label: t("reservations.domain"),
          to: "/reservations",
        },
      ],
    },
    {
      icon: <Users />,
      label: t("customers.domain"),
      to: "/customers",
      items: [
        {
          label: t("customerGroups.domain"),
          to: "/customer-groups",
        },
      ],
    },
    {
      icon: <ReceiptPercent />,
      label: t("promotions.domain"),
      to: "/promotions",
      items: [
        {
          label: t("campaigns.domain"),
          to: "/campaigns",
        },
      ],
    },
    {
      icon: <CurrencyDollar />,
      label: t("priceLists.domain"),
      to: "/price-lists",
    },
    {
      icon: <BuildingStorefront />,
      label: t("stores.domain"),
      to: "/stores",
      items: [
        {
          label: t("reviews.domain"),
          to: "/reviews",
        },
      ],
    },
    {
      icon: <CreditCardRefresh />,
      label: t("payouts.domain"),
      to: "/payouts",
      items: [
        {
          label: t("payoutAccounts.domain"),
          to: "/payout-accounts",
        },
      ],
    },
  ];
};

const Searchbar = () => {
  const { t } = useTranslation();
  const { toggleSearch } = useSearch();

  return (
    <div className="px-3" data-testid="sidebar-search">
      <button
        onClick={toggleSearch}
        className={clx(
          "flex w-full items-center gap-x-2.5 rounded-md bg-ui-bg-subtle px-2 py-1 text-ui-fg-subtle outline-none transition-[padding] duration-200 ease-sidebar motion-reduce:transition-none group-data-[state=collapsed]/sidebar:px-1",
          "hover:bg-ui-bg-subtle-hover",
          "focus-visible:shadow-borders-focus",
        )}
        data-testid="sidebar-search-button"
      >
        <MagnifyingGlass className="shrink-0" />
        <div className={clx("flex-1 whitespace-nowrap text-start", SIDEBAR_RAIL_FADE)}>
          <Text size="small" leading="compact" weight="plus">
            {t("app.search.label")}
          </Text>
        </div>
        <Text size="small" leading="compact" className={clx("text-ui-fg-muted", SIDEBAR_RAIL_FADE)}>
          ⌘K
        </Text>
      </button>
    </div>
  );
};

const UtilitySection = () => {
  const location = useLocation();
  const { t } = useTranslation();

  return (
    <div className="flex flex-col gap-y-0.5 py-3">
      <NavItem
        label={t("app.nav.settings.header")}
        to="/settings"
        from={location.pathname}
        icon={<CogSixTooth />}
      />
    </div>
  );
};

const UserSection = () => {
  return (
    <div>
      <div className="px-3">
        <Divider variant="dashed" />
      </div>
      <UserMenu />
    </div>
  );
};