@vtex/faststore-plugin-buyer-portal 2.0.25 → 2.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtex/faststore-plugin-buyer-portal",
-  "version": "2.0.25",
+  "version": "2.0.27",
   "description": "A plugin for faststore with buyer portal",
   "main": "index.js",
   "files": [

package/src/features/contracts/components/ContractListItem/ContractListItem.tsx

@@ -29,10 +29,12 @@ export const ContractListItem = ({
   const displayName = contract.name ?? contract.email;
   const { pushToast } = useUI();
   const { switchContract, loading } = useSwitchContract();
+  const isRemovable = contract.isAttached !== false;
 
   const handleCheckboxClick = (event: React.MouseEvent) => {
     event.stopPropagation();
     event.preventDefault();
+    if (!isRemovable) return;
     onSelect(contract.id, event);
   };
 
@@ -59,10 +61,14 @@ export const ContractListItem = ({
     >
       <div
         data-fs-bp-contract-list-item-checkbox
+        data-fs-bp-contract-list-item-checkbox-disabled={
+          !isRemovable || undefined
+        }
         role="checkbox"
         aria-checked={isSelected}
+        aria-disabled={!isRemovable}
         aria-label={`Select ${displayName ?? "contract"}`}
-        tabIndex={0}
+        tabIndex={isRemovable ? 0 : -1}
         onClick={handleCheckboxClick}
         onKeyDown={(e) =>
           e.key === " " && handleCheckboxClick(e as unknown as React.MouseEvent)
@@ -91,7 +97,7 @@ export const ContractListItem = ({
         <Dropdown>
           <BasicDropdownMenu.Trigger />
           <BasicDropdownMenu>
-            {contract.isDefault ? (
+            {contract.isDefault || !isRemovable ? (
               <DropdownItem disabled>
                 <Icon name="Star" width={16} height={16} />
                 {t("contracts.actions.setAsDefault")}
@@ -105,7 +111,8 @@ export const ContractListItem = ({
             <BasicDropdownMenu.Separator />
             <DropdownItem
               data-fs-bp-dropdown-menu-item-mode="danger"
-              onClick={onRemove}
+              disabled={!isRemovable}
+              onClick={isRemovable ? onRemove : undefined}
             >
               <Icon name="CircleRemove" width={16} height={16} />
               {t("shared.buttons.remove")}

package/src/features/contracts/layouts/ContractListingLayout/ContractListingLayout.tsx

@@ -23,6 +23,7 @@ import { GlobalLayout } from "../../../shared/layouts";
 import { SumaSidebar } from "../../../shared/layouts/SumaPageLayout/SumaSidebar";
 import { useLocalization } from "../../../shared/localization/LocalizationContext";
 import { buyerPortalRoutes } from "../../../shared/utils/buyerPortalRoutes";
+import { contractScopedLink } from "../../../shared/utils/contractScopedLink";
 import { AddContractsDrawer } from "../../components/AddContractsDrawer/AddContractsDrawer";
 import { ConfirmRemoveDrawer } from "../../components/ConfirmRemoveDrawer/ConfirmRemoveDrawer";
 import { ContractSelectAllRow } from "../../components/ContractSelectAllRow";
@@ -169,9 +170,14 @@ export const ContractListingLayout = ({
     },
   });
 
+  const removableIds = new Set(
+    contracts.filter((c) => c.isAttached !== false).map((c) => c.id)
+  );
+
   const handleRequestRemove = (overrideIds?: Set<string>) => {
     const targetIds = overrideIds ?? selectedIds;
-    if (targetIds.size === contracts.length) {
+    if (targetIds.size === 0) return;
+    if (targetIds.size === removableIds.size) {
       openUnableToRemoveDrawer();
       return;
     }
@@ -180,6 +186,7 @@ export const ContractListingLayout = ({
   };
 
   const handleItemRemove = (id: string) => {
+    if (!removableIds.has(id)) return;
     handleRequestRemove(new Set([id]));
   };
 
@@ -215,6 +222,7 @@ export const ContractListingLayout = ({
   });
 
   const handleSetDefault = (contractId: string) => {
+    if (!removableIds.has(contractId)) return;
     setDefaultContract({ orgUnitId: orgUnit.id, contractId })?.catch(() => {});
   };
 
@@ -267,9 +275,14 @@ export const ContractListingLayout = ({
     selectedIds.has(id)
   ).length;
 
+  // Contracts sourced from the legacy fallback (never attached) can't be
+  // selected for bulk removal — the BFF has no attach relation to detach.
+  const removableFilteredIds = filteredIds.filter((id) => removableIds.has(id));
+
   const handleSelect = (id: string, event: React.MouseEvent) => {
+    if (!removableIds.has(id)) return;
     if (event.shiftKey) {
-      handleShiftClick(id, filteredIds);
+      handleShiftClick(id, removableFilteredIds);
     } else {
       handleModifierClick(id);
     }
@@ -279,14 +292,14 @@ export const ContractListingLayout = ({
     if (selectedInFiltered > 0) {
       clearSelection();
     } else {
-      handleSelectAll(filteredIds);
+      handleSelectAll(removableFilteredIds);
     }
   };
 
   const handleKeyDown = (event: React.KeyboardEvent) => {
     if ((event.metaKey || event.ctrlKey) && event.key === "a") {
       event.preventDefault();
-      handleSelectAll(filteredIds);
+      handleSelectAll(removableFilteredIds);
     }
   };
 
@@ -342,7 +355,7 @@ export const ContractListingLayout = ({
             <BasicCard
               data-fs-bp-contracts-settings-card
               footerMessage={t("orgUnitDetails.links.manageContractSettings")}
-              footerLink={buyerPortalRoutes.profileDetails({
+              footerLink={contractScopedLink(buyerPortalRoutes.profileDetails, {
                 orgUnitId: orgUnit.id,
                 contractId: defaultContractId,
               })}

package/src/features/contracts/layouts/ContractListingLayout/ContractSettingsNav.tsx

@@ -4,6 +4,7 @@ import { AccountingFieldDropdown } from "../../../accounting-fields/components";
 import { checkAccountingFieldIsEmpty } from "../../../accounting-fields/utils";
 import { Icon } from "../../../shared/components";
 import { buyerPortalRoutes } from "../../../shared/utils/buyerPortalRoutes";
+import { contractScopedLink } from "../../../shared/utils/contractScopedLink";
 
 import type { AccountingField } from "../../../accounting-fields/types";
 import type { LocalizeFn } from "../../../shared/localization/types";
@@ -35,23 +36,23 @@ export const buildContractSettingsNavItems = ({
   return [
     {
       name: t("contracts.nav.basicInformation"),
-      link: buyerPortalRoutes.profileDetails(linkParams),
+      link: contractScopedLink(buyerPortalRoutes.profileDetails, linkParams),
     },
     {
       name: t("layouts.navigation.addresses"),
-      link: buyerPortalRoutes.addresses(linkParams),
+      link: contractScopedLink(buyerPortalRoutes.addresses, linkParams),
     },
     {
       name: t("layouts.navigation.paymentMethods"),
-      link: buyerPortalRoutes.paymentMethods(linkParams),
+      link: contractScopedLink(buyerPortalRoutes.paymentMethods, linkParams),
     },
     {
       name: t("layouts.navigation.creditCards"),
-      link: buyerPortalRoutes.creditCards(linkParams),
+      link: contractScopedLink(buyerPortalRoutes.creditCards, linkParams),
     },
     {
       name: t("contracts.nav.assortment"),
-      link: buyerPortalRoutes.productAssortment(linkParams),
+      link: contractScopedLink(buyerPortalRoutes.productAssortment, linkParams),
     },
     {
       name: t("layouts.navigation.accountingFields"),
@@ -59,10 +60,14 @@ export const buildContractSettingsNavItems = ({
       submenu: {
         items: accountingFields.map((field) => ({
           name: field.name,
-          link: buyerPortalRoutes.accountingFields({
-            ...linkParams,
-            accountingFieldId: field.id,
-          }),
+          link: contractScopedLink(
+            (params) =>
+              buyerPortalRoutes.accountingFields({
+                ...params,
+                accountingFieldId: field.id,
+              }),
+            linkParams
+          ),
           hasNotification: checkAccountingFieldIsEmpty(field),
           actions: (
             <AccountingFieldDropdown

package/src/features/contracts/layouts/ContractListingLayout/contract-listing-layout.scss

@@ -89,6 +89,14 @@
         flex-shrink: 0;
         color: var(--fs-bp-color-brand);
       }
+
+      [data-fs-bp-suma-sidebar-identity-contract] {
+        @include text-style("body");
+        color: var(--fs-bp-color-neutral-8);
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
     }
   }
 
@@ -437,6 +445,11 @@
         outline: 2px solid var(--fs-bp-color-brand);
         outline-offset: 2px;
       }
+
+      &[data-fs-bp-contract-list-item-checkbox-disabled] {
+        cursor: not-allowed;
+        opacity: 0.4;
+      }
     }
 
     [data-fs-bp-letter-highlight] {

package/src/features/contracts/services/__tests__/list-unit-contracts.service.test.ts

@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../list-attached-contracts.service", () => ({
+  listAttachedContractsService: vi.fn(),
+}));
+
+vi.mock("../get-contracts-org-by-unit-id.service", () => ({
+  getContractsByOrgUnitIdService: vi.fn(),
+}));
+
+import { getContractsByOrgUnitIdService } from "../get-contracts-org-by-unit-id.service";
+import { listAttachedContractsService } from "../list-attached-contracts.service";
+import { listUnitContractsService } from "../list-unit-contracts.service";
+
+import type { ContractData } from "../../types";
+
+const listAttachedContractsMock = vi.mocked(listAttachedContractsService);
+const getContractsByOrgUnitIdMock = vi.mocked(getContractsByOrgUnitIdService);
+
+const cookie = "VtexIdclientAutCookie=test-token";
+const orgUnitId = "unit-123";
+
+function contract(id: string, isDefault = false): ContractData {
+  return {
+    id,
+    name: id,
+    email: `${id}@b.com`,
+    isActive: true,
+    creationDate: "2026-01-01",
+    isDefault,
+  };
+}
+
+describe("listUnitContractsService", () => {
+  beforeEach(() => {
+    listAttachedContractsMock.mockReset();
+    getContractsByOrgUnitIdMock.mockReset();
+  });
+
+  it("returns the attached listing when the unit has attached contracts", async () => {
+    listAttachedContractsMock.mockResolvedValue([
+      contract("a", true),
+      contract("b"),
+    ]);
+
+    const result = await listUnitContractsService({ orgUnitId, cookie });
+
+    expect(result.map((c) => c.id)).toEqual(["a", "b"]);
+    expect(getContractsByOrgUnitIdMock).not.toHaveBeenCalled();
+  });
+
+  it("flags attached contracts as isAttached: true", async () => {
+    listAttachedContractsMock.mockResolvedValue([contract("a", true)]);
+
+    const result = await listUnitContractsService({ orgUnitId, cookie });
+
+    expect(result.map((c) => c.isAttached)).toEqual([true]);
+  });
+
+  it("falls back to the legacy unit-contracts listing when nothing is attached", async () => {
+    listAttachedContractsMock.mockResolvedValue([]);
+    getContractsByOrgUnitIdMock.mockResolvedValue([
+      contract("legacy-1"),
+      contract("legacy-2"),
+    ]);
+
+    const result = await listUnitContractsService({ orgUnitId, cookie });
+
+    expect(result.map((c) => c.id)).toEqual(["legacy-1", "legacy-2"]);
+    expect(getContractsByOrgUnitIdMock).toHaveBeenCalledWith({
+      orgUnitId,
+      cookie,
+    });
+  });
+
+  it("flags legacy fallback contracts as isAttached: false", async () => {
+    listAttachedContractsMock.mockResolvedValue([]);
+    getContractsByOrgUnitIdMock.mockResolvedValue([contract("legacy-1")]);
+
+    const result = await listUnitContractsService({ orgUnitId, cookie });
+
+    expect(result.map((c) => c.isAttached)).toEqual([false]);
+  });
+
+  it("flags the first fallback contract as default when none is flagged", async () => {
+    listAttachedContractsMock.mockResolvedValue([]);
+    getContractsByOrgUnitIdMock.mockResolvedValue([
+      contract("legacy-1"),
+      contract("legacy-2"),
+    ]);
+
+    const result = await listUnitContractsService({ orgUnitId, cookie });
+
+    expect(result.map((c) => c.isDefault)).toEqual([true, false]);
+  });
+
+  it("honors an explicit default in the fallback listing", async () => {
+    listAttachedContractsMock.mockResolvedValue([]);
+    getContractsByOrgUnitIdMock.mockResolvedValue([
+      contract("legacy-1"),
+      contract("legacy-2", true),
+    ]);
+
+    const result = await listUnitContractsService({ orgUnitId, cookie });
+
+    expect(result.map((c) => c.isDefault)).toEqual([false, true]);
+  });
+
+  it("returns an empty list when both listings are empty", async () => {
+    listAttachedContractsMock.mockResolvedValue([]);
+    getContractsByOrgUnitIdMock.mockResolvedValue([]);
+
+    const result = await listUnitContractsService({ orgUnitId, cookie });
+
+    expect(result).toEqual([]);
+  });
+});

package/src/features/contracts/services/__tests__/resolve-attached-contract.service.test.ts

@@ -0,0 +1,118 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../list-unit-contracts.service", () => ({
+  listUnitContractsService: vi.fn(),
+}));
+
+vi.mock("../../../shared/services/logger", () => ({
+  logError: vi.fn(),
+}));
+
+import { logError } from "../../../shared/services/logger";
+import { listUnitContractsService } from "../list-unit-contracts.service";
+import { resolveAttachedContractService } from "../resolve-attached-contract.service";
+
+import type { ContractData } from "../../types";
+
+const listUnitContractsMock = vi.mocked(listUnitContractsService);
+const logErrorMock = vi.mocked(logError);
+
+const cookie = "VtexIdclientAutCookie=test-token";
+const orgUnitId = "unit-123";
+
+function contract(id: string, isDefault = false): ContractData {
+  return {
+    id,
+    name: id,
+    email: `${id}@b.com`,
+    isActive: true,
+    creationDate: "2026-01-01",
+    isDefault,
+  };
+}
+
+describe("resolveAttachedContractService", () => {
+  beforeEach(() => {
+    listUnitContractsMock.mockReset();
+    logErrorMock.mockReset();
+  });
+
+  it("returns the URL's contract when it belongs to the unit", async () => {
+    listUnitContractsMock.mockResolvedValue([
+      contract("a", true),
+      contract("b"),
+    ]);
+
+    const result = await resolveAttachedContractService({
+      orgUnitId,
+      contractId: "b",
+      cookie,
+    });
+
+    expect(result?.id).toBe("b");
+  });
+
+  it("returns the unit's default contract when no contractId is given", async () => {
+    listUnitContractsMock.mockResolvedValue([
+      contract("a"),
+      contract("b", true),
+    ]);
+
+    const result = await resolveAttachedContractService({ orgUnitId, cookie });
+
+    expect(result?.id).toBe("b");
+  });
+
+  it("falls back to the unit's default when the URL's contract belongs to another unit", async () => {
+    listUnitContractsMock.mockResolvedValue([
+      contract("a", true),
+      contract("b"),
+    ]);
+
+    const result = await resolveAttachedContractService({
+      orgUnitId,
+      contractId: "foreign-contract",
+      cookie,
+    });
+
+    expect(result?.id).toBe("a");
+  });
+
+  it("falls back to the first contract when none is flagged as default", async () => {
+    listUnitContractsMock.mockResolvedValue([contract("a"), contract("b")]);
+
+    const result = await resolveAttachedContractService({ orgUnitId, cookie });
+
+    expect(result?.id).toBe("a");
+  });
+
+  it("returns null when the unit has no contracts", async () => {
+    listUnitContractsMock.mockResolvedValue([]);
+
+    const result = await resolveAttachedContractService({ orgUnitId, cookie });
+
+    expect(result).toBeNull();
+  });
+
+  it("returns null when the lookup fails instead of breaking the page", async () => {
+    listUnitContractsMock.mockRejectedValue(new Error("BFF unavailable"));
+
+    const result = await resolveAttachedContractService({ orgUnitId, cookie });
+
+    expect(result).toBeNull();
+  });
+
+  it("logs the error when the lookup fails", async () => {
+    listUnitContractsMock.mockRejectedValue(new Error("BFF unavailable"));
+
+    await resolveAttachedContractService({ orgUnitId, cookie });
+
+    expect(logErrorMock).toHaveBeenCalledWith(
+      "Failed to resolve attached contract",
+      expect.objectContaining({
+        orgUnitId,
+        error_message: "BFF unavailable",
+      })
+    );
+  });
+});

package/src/features/contracts/services/index.ts

@@ -12,6 +12,16 @@ export { getContractDetailsService } from "./get-contract-details.service";
 
 export { listAttachedContractsService } from "./list-attached-contracts.service";
 
+export {
+  listUnitContractsService,
+  type ListUnitContractsServiceProps,
+} from "./list-unit-contracts.service";
+
+export {
+  resolveAttachedContractService,
+  type ResolveAttachedContractServiceProps,
+} from "./resolve-attached-contract.service";
+
 export { listAvailableContractsService } from "./list-available-contracts.service";
 
 export {

package/src/features/contracts/services/list-unit-contracts.service.ts

@@ -0,0 +1,44 @@
+import { getContractsByOrgUnitIdService } from "./get-contracts-org-by-unit-id.service";
+import { listAttachedContractsService } from "./list-attached-contracts.service";
+
+import type { ContractData } from "../types";
+
+export type ListUnitContractsServiceProps = {
+  orgUnitId: string;
+  cookie: string;
+};
+
+/**
+ * Lists the contracts a unit operates under. The SUMA attach listing is the
+ * source of truth, but units that predate the attach flow have nothing
+ * explicitly attached — for those, fall back to the legacy unit-contracts
+ * endpoint (`units/<id>/contracts`), which is what the pre-SUMA portal
+ * displayed. Never fall back to the unit's `customerGroup.customerIds`:
+ * those mirror the session's customer group, not the unit's own contracts.
+ * The first fallback contract is flagged as default when none is, mirroring
+ * what listAttachedContractsService does for an unflagged BFF response.
+ * Fallback contracts are flagged `isAttached: false` — callers must treat
+ * them as read-only (no attach/detach actions), since the BFF has no
+ * attach relation to operate on for them.
+ */
+export const listUnitContractsService = async ({
+  orgUnitId,
+  cookie,
+}: ListUnitContractsServiceProps): Promise<ContractData[]> => {
+  const attached = await listAttachedContractsService({ orgUnitId, cookie });
+
+  if (attached?.length) {
+    return attached.map((contract) => ({ ...contract, isAttached: true }));
+  }
+
+  const contracts =
+    (await getContractsByOrgUnitIdService({ orgUnitId, cookie })) ?? [];
+
+  const hasExplicitDefault = contracts.some((contract) => contract.isDefault);
+
+  return contracts.map((contract, index) => ({
+    ...contract,
+    isDefault: hasExplicitDefault ? Boolean(contract.isDefault) : index === 0,
+    isAttached: false,
+  }));
+};

package/src/features/contracts/services/resolve-attached-contract.service.ts

@@ -0,0 +1,53 @@
+import { logError } from "../../shared/services/logger";
+
+import { listUnitContractsService } from "./list-unit-contracts.service";
+
+import type { ContractData } from "../types";
+
+export type ResolveAttachedContractServiceProps = {
+  orgUnitId: string;
+  /** contractId carried in the URL — may be absent or belong to another unit */
+  contractId?: string;
+  cookie: string;
+};
+
+/**
+ * Resolves which contract the sidebar of an org-unit-scoped page should link
+ * to: the URL's contractId when it belongs to the unit, otherwise the unit's
+ * default contract. Contracts come from listUnitContractsService (attached
+ * listing, legacy unit contracts as fallback). Returns null when the unit has
+ * no resolvable contract (or the lookup fails) — callers must then avoid
+ * building contract-scoped URLs, since an empty contractId segment makes the
+ * path fall into the home catch-all route and 302 the user to their root org
+ * unit.
+ */
+export const resolveAttachedContractService = async ({
+  orgUnitId,
+  contractId,
+  cookie,
+}: ResolveAttachedContractServiceProps): Promise<ContractData | null> => {
+  let contracts: ContractData[];
+
+  try {
+    contracts = await listUnitContractsService({ orgUnitId, cookie });
+  } catch (error) {
+    // The contract only feeds sidebar links/identity; the page's own data
+    // must still render if this lookup fails. Log it though — otherwise a
+    // transient BFF 5xx is indistinguishable from "unit has no contract".
+    logError("Failed to resolve attached contract", {
+      orgUnitId,
+      error_message: error instanceof Error ? error.message : String(error),
+    });
+    return null;
+  }
+
+  if (!contracts.length) {
+    return null;
+  }
+
+  return (
+    contracts.find((contract) => contract.id === contractId) ??
+    contracts.find((contract) => contract.isDefault) ??
+    contracts[0]
+  );
+};

package/src/features/contracts/types/ContractData.ts

@@ -4,6 +4,8 @@ export type ContractData = {
   email: string;
   isActive: boolean;
   isDefault?: boolean;
+  /** False when sourced from the legacy unit-contracts fallback (never explicitly attached) — undefined/true means attached. */
+  isAttached?: boolean;
   creationDate: string;
   salesRepresentative?: string;
   imageUrl?: string;

package/src/features/org-units/components/CreateOrgUnitDrawer/CreateOrgUnitDrawer.tsx

@@ -104,7 +104,8 @@ export const CreateOrgUnitDrawer = ({
 
       trackEntityCreateError(ANALYTICS_EVENTS.ORG_UNIT_CREATE_ERROR, err, {
         parent_org_unit_id: parentOrgUnit?.id,
-        error_type: error.code || "unknown",
+        errorType:
+          error.code === "InvalidOrganizationUnitName" ? "conflict" : undefined,
       });
 
       if (error.code === "InvalidOrganizationUnitName") {

package/src/features/org-units/layouts/OrgUnitDetailsLayout/OrgUnitDetailsLayout.tsx

@@ -28,6 +28,7 @@ import { useMediaQuery } from "../../../shared/hooks/useMediaQuery";
 import { GlobalLayout } from "../../../shared/layouts";
 import { useLocalization } from "../../../shared/localization/LocalizationContext";
 import {
+  contractScopedLink,
   getContractSettingsLinks,
   getFinanceSettingsLinks,
   getOrganizationSettingsLinks,
@@ -127,10 +128,14 @@ export const OrgUnitsDetailsLayout = ({
     submenu: {
       items: (listAccountingFieldData ?? []).map((item) => ({
         name: item.name,
-        link: buyerPortalRoutes.accountingFields({
-          ...linkParams,
-          accountingFieldId: item.id,
-        }),
+        link: contractScopedLink(
+          (params) =>
+            buyerPortalRoutes.accountingFields({
+              ...params,
+              accountingFieldId: item.id,
+            }),
+          linkParams
+        ),
         hasNotification: checkAccountingFieldIsEmpty(item),
         actions: (
           <AccountingFieldDropdown
@@ -261,7 +266,7 @@ export const OrgUnitsDetailsLayout = ({
             <BasicCard
               data-fs-bp-contracts-settings-card
               footerMessage={t("orgUnitDetails.links.manageContractSettings")}
-              footerLink={buyerPortalRoutes.profileDetails({
+              footerLink={contractScopedLink(buyerPortalRoutes.profileDetails, {
                 orgUnitId: orgUnit.id,
                 contractId: singleContract?.id ?? "",
               })}
@@ -345,9 +350,9 @@ export const OrgUnitsDetailsLayout = ({
             footerMessage={t(
               "orgUnitDetails.links.manageFinanceAndComplianceSettings"
             )}
-            footerLink={buyerPortalRoutes.buyingPolicies({
+            footerLink={contractScopedLink(buyerPortalRoutes.buyingPolicies, {
               orgUnitId: orgUnit.id,
-              contractId: contracts[0]?.id,
+              contractId: contracts[0]?.id ?? "",
             })}
             enableFooter
           >