@vtex/faststore-plugin-buyer-portal 2.0.19 → 2.0.21

package/src/features/shared/hooks/analytics/useAnalytics.ts

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef } from "react";
 
-import { useDataIngestionApi } from "../../services/logger/analytics/analytics";
+import { useDataIngestionApi } from "../../services/logger/analytics/useDataIngestionApi";
 
 import type {
   AnalyticsTimer,

package/src/features/shared/services/logger/analytics/__tests__/deriveActorType.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+
+import { deriveActorType } from "../deriveActorType";
+
+describe("deriveActorType", () => {
+  it("returns internal for exact @vtex.com domain", () => {
+    expect(deriveActorType("rodrigo.tavares@vtex.com")).toBe("internal");
+  });
+
+  it("returns internal for case-insensitive and plus-tagged vtex.com emails", () => {
+    expect(deriveActorType("Name+qa@VTEX.COM")).toBe("internal");
+  });
+
+  it("returns external for non-vtex.com domains", () => {
+    expect(deriveActorType("buyer@acme.com")).toBe("external");
+  });
+
+  it("returns external for vtex.com.br and subdomain lookalikes", () => {
+    expect(deriveActorType("user@vtex.com.br")).toBe("external");
+    expect(deriveActorType("user@corp.vtex.com")).toBe("external");
+  });
+
+  it("returns external when email is missing, empty, or malformed", () => {
+    expect(deriveActorType(undefined)).toBe("external");
+    expect(deriveActorType(null)).toBe("external");
+    expect(deriveActorType("")).toBe("external");
+    expect(deriveActorType("   ")).toBe("external");
+    expect(deriveActorType("not-an-email")).toBe("external");
+  });
+});

package/src/features/shared/services/logger/analytics/__tests__/mergeActorTypeIntoEvent.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from "vitest";
+
+import * as deriveActorTypeModule from "../deriveActorType";
+import { mergeActorTypeIntoEvent } from "../mergeActorTypeIntoEvent";
+
+import type { DataIngestionApiFields } from "../types";
+
+describe("mergeActorTypeIntoEvent", () => {
+  it("attaches internal actor_type into metadata from a vtex.com email", () => {
+    const result = mergeActorTypeIntoEvent(
+      { event_name: "budget_created" },
+      "alice@vtex.com"
+    );
+
+    expect(result.metadata?.actor_type).toBe("internal");
+    expect(result).not.toHaveProperty("actor_type");
+    expect(result).not.toHaveProperty("email");
+    expect(result).not.toHaveProperty("login");
+    expect(result).not.toHaveProperty("userId");
+    expect(result).not.toHaveProperty("sub");
+  });
+
+  it("attaches external actor_type into metadata from a non-vtex email", () => {
+    const result = mergeActorTypeIntoEvent(
+      { event_name: "budget_created" },
+      "buyer@acme.com"
+    );
+
+    expect(result.metadata?.actor_type).toBe("external");
+  });
+
+  it("defaults to external when email is unavailable", () => {
+    expect(
+      mergeActorTypeIntoEvent({ event_name: "budget_created" }, null).metadata
+        ?.actor_type
+    ).toBe("external");
+    expect(
+      mergeActorTypeIntoEvent({ event_name: "budget_created" }, undefined)
+        .metadata?.actor_type
+    ).toBe("external");
+  });
+
+  it("preserves other metadata fields while attaching actor_type", () => {
+    const fields: DataIngestionApiFields = {
+      event_name: "budget_created",
+      metadata: { foo: "bar" },
+    };
+
+    const result = mergeActorTypeIntoEvent(fields, "buyer@acme.com");
+
+    expect(result.metadata).toEqual({ foo: "bar", actor_type: "external" });
+  });
+
+  it("falls back to external when deriveActorType throws", () => {
+    vi.spyOn(deriveActorTypeModule, "deriveActorType").mockImplementation(
+      () => {
+        throw new Error("unexpected");
+      }
+    );
+
+    expect(
+      mergeActorTypeIntoEvent(
+        { event_name: "budget_created" },
+        "alice@vtex.com"
+      ).metadata?.actor_type
+    ).toBe("external");
+
+    vi.restoreAllMocks();
+  });
+
+  it("does not put the source email into the event payload", () => {
+    const email = "alice@vtex.com";
+    const result = mergeActorTypeIntoEvent(
+      { event_name: "address_edited", event_category: "edition" },
+      email
+    );
+    const serialized = JSON.stringify(result);
+
+    expect(serialized).not.toContain(email);
+    expect(serialized).not.toContain("alice");
+    expect(result.metadata?.actor_type).toBe("internal");
+  });
+});

package/src/features/shared/services/logger/analytics/analytics.ts

@@ -2,7 +2,7 @@ import storeConfig from "discovery.config";
 
 import { isDevelopment } from "../../../utils/environment";
 
-import type { DataIngestionApiFields, DataIngestionApiParams } from "./types";
+import type { DataIngestionApiParams } from "./types";
 
 /**
  * VTEX Data Ingestion API for Analytics
@@ -50,7 +50,7 @@ export async function dataIngestionApi(
 /**
  * Get common analytics context
  */
-function getCommonAnalyticsContext() {
+export function getCommonAnalyticsContext() {
   const account = storeConfig?.api?.storeId || "unknown";
   const locale =
     typeof window !== "undefined"
@@ -77,25 +77,3 @@ function getCommonAnalyticsContext() {
     device,
   };
 }
-
-/**
- * Hook to send analytics events
- * This is a simple version that will be extended by useAnalytics hook
- */
-export function useDataIngestionApi() {
-  const commonFields = getCommonAnalyticsContext();
-
-  const sendEvent = (fields: DataIngestionApiFields) => {
-    // Get workspace from environment
-    const workspace = isDevelopment() ? "dev" : "master";
-
-    dataIngestionApi({
-      ...commonFields,
-      event_category: fields.event_category || "click",
-      ...fields,
-      workspace,
-    });
-  };
-
-  return { sendEvent };
-}

package/src/features/shared/services/logger/analytics/deriveActorType.ts

@@ -0,0 +1,24 @@
+import type { ActorType } from "./types";
+
+const INTERNAL_EMAIL_DOMAIN = "vtex.com";
+
+/**
+ * Derive analytics actor_type from the logged-in user's email domain.
+ * Never logs or returns the input email — only the enum.
+ */
+export function deriveActorType(email?: string | null): ActorType {
+  if (!email) {
+    return "external";
+  }
+
+  const trimmed = email.trim().toLowerCase();
+  const atIndex = trimmed.lastIndexOf("@");
+
+  if (atIndex < 0 || atIndex === trimmed.length - 1) {
+    return "external";
+  }
+
+  const domain = trimmed.slice(atIndex + 1);
+
+  return domain === INTERNAL_EMAIL_DOMAIN ? "internal" : "external";
+}

package/src/features/shared/services/logger/analytics/mergeActorTypeIntoEvent.ts

@@ -0,0 +1,29 @@
+import { deriveActorType } from "./deriveActorType";
+
+import type { ActorType, DataIngestionApiFields } from "./types";
+
+/**
+ * Attach derived actor_type to analytics fields' metadata.
+ * Caller-supplied actor_type is ignored — derivation always wins.
+ * Never copies email or other identity into the payload.
+ */
+export function mergeActorTypeIntoEvent(
+  fields: DataIngestionApiFields,
+  email?: string | null
+): DataIngestionApiFields {
+  let actorType: ActorType;
+
+  try {
+    actorType = deriveActorType(email);
+  } catch {
+    actorType = "external";
+  }
+
+  return {
+    ...fields,
+    metadata: {
+      ...fields.metadata,
+      actor_type: actorType,
+    },
+  };
+}

package/src/features/shared/services/logger/analytics/types.ts

@@ -1,3 +1,8 @@
+/**
+ * Actor classification for analytics events (internal VTEX vs external).
+ */
+export type ActorType = "internal" | "external";
+
 /**
  * Analytics event categories
  */

package/src/features/shared/services/logger/analytics/useDataIngestionApi.ts

@@ -0,0 +1,32 @@
+import { useContext } from "react";
+
+import { BuyerPortalContext } from "../../../components/BuyerPortalProvider/BuyerPortalProvider";
+import { isDevelopment } from "../../../utils/environment";
+
+import { dataIngestionApi, getCommonAnalyticsContext } from "./analytics";
+import { mergeActorTypeIntoEvent } from "./mergeActorTypeIntoEvent";
+
+import type { DataIngestionApiFields } from "./types";
+
+/**
+ * Hook to send analytics events with actor_type derived from the logged-in user.
+ */
+export function useDataIngestionApi() {
+  const buyerPortalContext = useContext(BuyerPortalContext);
+  const commonFields = getCommonAnalyticsContext();
+  const email = buyerPortalContext?.currentUser?.email;
+
+  const sendEvent = (fields: DataIngestionApiFields) => {
+    const workspace = isDevelopment() ? "dev" : "master";
+    const enrichedFields = mergeActorTypeIntoEvent(fields, email);
+
+    dataIngestionApi({
+      ...commonFields,
+      event_category: enrichedFields.event_category || "click",
+      ...enrichedFields,
+      workspace,
+    });
+  };
+
+  return { sendEvent };
+}

package/src/features/shared/utils/constants.ts

@@ -22,4 +22,4 @@ export const SCOPE_KEYS = {
   CREDIT_CARDS: "creditCards",
 } as const;
 
-export const CURRENT_VERSION = "2.0.19";
+export const CURRENT_VERSION = "2.0.21";

package/src/features/users/components/RolesMultiSelect/RolesMultiSelect.tsx

@@ -13,6 +13,7 @@ import { Skeleton, Tag as RemovableTag } from "@faststore/ui";
 import { Tag } from "../../../shared/components";
 import { useAutocompletePosition } from "../../../shared/components/AutocompleteDropdown/useAutocompletePosition";
 import { useDropdownFlipPosition } from "../../../shared/components/AutocompleteDropdown/useDropdownFlipPosition";
+import { useLocalization } from "../../../shared/localization/LocalizationContext";
 
 import {
   filterRoleOptions,
@@ -43,6 +44,7 @@ export const RolesMultiSelect = ({
   isLoading = false,
   mode,
 }: RolesMultiSelectProps) => {
+  const { t } = useLocalization();
   const listboxId = useId();
   const roleOptions = useMemo(() => options ?? [], [options]);
 
@@ -236,11 +238,9 @@ export const RolesMultiSelect = ({
           onKeyDown={handleKeyDown}
         />
 
-        {/* No CMS localization key exists yet for this floating label (see
-        Decision 6 in the spec) — hardcoded for the same reason as "Custom"
-        and "No matching roles" below: t() has no fallback and would render
-        the raw key string if missing. */}
-        <label data-fs-bp-roles-multi-select-label>Roles</label>
+        <label data-fs-bp-roles-multi-select-label>
+          {t("users.forms.roles")}
+        </label>
       </div>
 
       {isOpen && (
@@ -254,10 +254,9 @@ export const RolesMultiSelect = ({
           style={{ width: positionStyle.width }}
         >
           {filteredOptions.length === 0 ? (
-            // "No matching roles" has no CMS localization key yet (like the
-            // "Custom" tag below) — hardcoded for the same reason: t() has no
-            // fallback and would render the raw key string if missing.
-            <li data-fs-bp-roles-multi-select-empty>No matching roles</li>
+            <li data-fs-bp-roles-multi-select-empty>
+              {t("users.rolesMultiSelect.noMatchingRoles")}
+            </li>
           ) : (
             filteredOptions.map((role, index) => {
               const isChecked = selected.includes(role.roleId);
@@ -297,7 +296,7 @@ export const RolesMultiSelect = ({
                     </span>
                     {role.isCustom && (
                       <Tag data-fs-bp-roles-multi-select-option-custom-tag>
-                        Custom
+                        {t("users.rolesMultiSelect.customTag")}
                       </Tag>
                     )}
                   </div>