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

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.20] - 2026-08-12
+
+### Added
+
+- Analytics events now include a derived `metadata.actor_type` (`internal` | `external`) based on the logged-in user's email domain (`@vtex.com` → internal), with no email or identity fields in the payload ([B2BTEAM-3639](https://vtex-dev.atlassian.net/browse/B2BTEAM-3639))
+
 ## [2.0.19] - 2026-08-04
 
 ### Changed
@@ -821,7 +827,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add CHANGELOG file
 - Add README file
 
-[unreleased]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v2.0.19...HEAD
+[unreleased]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v2.0.20...HEAD
 [1.3.55]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v1.3.54...v1.3.55
 [1.3.54]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v1.3.53...v1.3.54
 [1.3.53]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v1.3.52...v1.3.53
@@ -919,6 +925,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [2.0.10]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v2.0.9...v2.0.10
 [2.0.9]: https://github.com/vtex/faststore-plugin-buyer-portal/releases/tag/2.0.9
 
+[2.0.20]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v2.0.19...v2.0.20
 [2.0.19]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v2.0.18...v2.0.19
 [2.0.18]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v2.0.17...v2.0.18
 [2.0.17]: https://github.com/vtex/faststore-plugin-buyer-portal/compare/v2.0.16...v2.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtex/faststore-plugin-buyer-portal",
-  "version": "2.0.19",
+  "version": "2.0.20",
   "description": "A plugin for faststore with buyer portal",
   "main": "index.js",
   "scripts": {

package/specs/analytics-actor-type.md

@@ -0,0 +1,243 @@
+# Analytics Actor Type (Internal vs External)
+
+> **Status**: Done
+> **Created**: 2026-07-28
+> **Jira**: [B2BTEAM-3639](https://vtex-dev.atlassian.net/browse/B2BTEAM-3639)
+> **Epic**: [B2BTEAM-3596](https://vtex-dev.atlassian.net/browse/B2BTEAM-3596) — Melhoria 1
+> **Sibling task**: [B2BTEAM-3640](https://vtex-dev.atlassian.net/browse/B2BTEAM-3640) (Redshift column + QuickSight segmentation)
+
+## 1. Business Context
+
+### Problem Statement
+
+Organization Account already emits usage analytics (create/edit/delete, timing, errors) via `useAnalytics` into the VTEX Data Ingestion API, Redshift, and QuickSight. Those numbers mix real customer usage with traffic from VTEX employees testing and supporting accounts.
+
+PMs cannot filter “real usage” without a reliable, PII-free signal on each event that says whether the actor was internal VTEX or external.
+
+### Goals
+
+1. Every Org Account analytics event includes a derived `actor_type` of `internal` or `external`.
+2. Usage metrics can exclude VTEX traffic without dropping error analysis options (filtering stays at the consumer; emission always sends the field).
+3. Zero PII in the analytics envelope: never send email, login, user id, or other identity — only the derived enum.
+
+### User Stories
+
+#### US-1: Emit actor_type on every analytics event
+
+- **Story**: As a PM analyzing Org Account usage, I want every event tagged as internal or external, so I can segment real customer usage from VTEX traffic.
+- **Acceptance Criteria**:
+  - **Given** a logged-in user whose email domain is `vtex.com`, **when** any analytics event is emitted through `useAnalytics` / `useDataIngestionApi`, **then** the payload includes `actor_type: "internal"`.
+  - **Given** a logged-in user whose email domain is not `vtex.com`, **when** any analytics event is emitted, **then** the payload includes `actor_type: "external"`.
+  - **Given** any successful emission path (`trackEvent`, `trackError`, `trackEntityCreated`, `trackEntityEdited`, `trackEntityCreateError`, `trackEntityEditError`), **when** the event is sent, **then** `actor_type` is present on the envelope (not only inside caller-supplied metadata).
+
+#### US-2: Never send identity or email in the event
+
+- **Story**: As a platform owner, I want the analytics envelope to stay free of PII, so we do not leak user identity into Redshift / QuickSight / Slack summaries.
+- **Acceptance Criteria**:
+  - **Given** a user with email `alice@vtex.com`, **when** an event is emitted, **then** the JSON body does not contain that email, login, `userId`, or session `sub`.
+  - **Given** derivation needs the email in memory, **when** building the payload, **then** only the enum `actor_type` is attached to the outgoing event.
+
+#### US-3: Safe default when identity is unavailable
+
+- **Story**: As an engineer, I want a deterministic fallback when email is missing, so every event still carries `actor_type` and the pipeline never breaks.
+- **Acceptance Criteria**:
+  - **Given** `currentUser` is null or `email` is empty/missing, **when** an event is emitted, **then** `actor_type` is `"external"`.
+  - **Given** derivation throws or email is malformed (no `@`), **when** an event is emitted, **then** `actor_type` is `"external"` and emission still succeeds.
+
+### Key Scenarios
+
+| Scenario | Pre-conditions | Steps | Expected Result |
+|---|---|---|---|
+| Happy path — VTEX employee | `currentUser.email` is `rodrigo.tavares@vtex.com` | User creates a budget; `trackEntityCreated` runs | Event has `actor_type: "internal"`; no email in payload |
+| Happy path — customer | `currentUser.email` is `buyer@acme.com` | User edits an address; `trackEntityEdited` runs | Event has `actor_type: "external"` |
+| Error case — Users API failed in loader | `currentUser` is `null` (e.g. `getUserByIdService` returned null) | User still triggers an analytics call from a mounted component | Event has `actor_type: "external"`; send does not throw |
+| Edge case — username login, email from API | Session `sub` is `everton.ataidetestdev` (not an email); Users API returns `email: "everton@vtex.com"` | Any event is emitted | Classification uses API email → `internal`; session `sub` is never sent |
+| Edge case — case / plus addressing | Email is `Name+qa@VTEX.COM` | Event emitted | Domain match is case-insensitive → `internal` |
+
+### Functional Requirements
+
+1. Derive `actor_type` at emission time from the logged-in user's email domain.
+2. Classification rule: domain equals `vtex.com` (case-insensitive) → `internal`; otherwise → `external`.
+3. Attach `actor_type` on every event sent through the shared analytics send path so callers do not need to pass it.
+4. Do not attach email, login, userId, session `sub`, or other identity fields to the event.
+5. Remain backward compatible with the existing schemaless ingestion pipeline (additive field only).
+
+### Non-Functional Requirements
+
+1. **Privacy**: envelope stays zero-PII for identity; derivation is local/ephemeral.
+2. **Reliability**: missing user context must not block or fail analytics emission.
+3. **Performance**: derivation is O(1) string work; no extra network calls at emit time.
+4. **Testability**: pure domain classifier is unit-tested; send path asserts field presence and absence of PII.
+
+### Out of Scope
+
+- Exposing `actor_type` as a Redshift column or QuickSight filter (sibling [B2BTEAM-3640](https://vtex-dev.atlassian.net/browse/B2BTEAM-3640)).
+- Melhoria 2 (`error_type` / stripping raw `error_message` / `error_stack`).
+- Rewriting the telemetry pipeline, DAG, or Slack weekly summary.
+- Classifying by session `sub` alone, account name, IP, or workspace.
+- Matching sibling domains (e.g. `vtex.com.br`) or subdomains (e.g. `corp.vtex.com`) — only exact `vtex.com`.
+
+---
+
+## 2. Arch Decisions
+
+### Proposed Solution
+
+Enrich the shared analytics send path so every event automatically receives `actor_type`, derived from `currentUser.email` already available in `BuyerPortalContext`.
+
+**Identity source (important):** the auth session JWT does **not** carry email. Example session claims:
+
+```json
+{
+  "sub": "everton.ataidetestdev",
+  "userId": "dd801513-ae2f-4ff8-b6de-dd3a2159a895",
+  "customerId": "…",
+  "unitId": "…",
+  "account": "b2bfaststoredev",
+  "type": "user"
+}
+```
+
+`sub` is a login/username, not an email. Email is loaded server-side in page loaders via `getUserByIdService` → Users API (`usersClient.getUserById`), then passed into `BuyerPortalProvider` as `currentUser.email`. Classification must use that email, never the session `sub`.
+
+```mermaid
+flowchart LR
+  Cookie["Auth cookie JWT\nuserId, sub, …"] --> Loader["Page loader\nwithAuthLoader"]
+  Loader --> UsersAPI["getUserByIdService\nUsers API"]
+  UsersAPI --> Ctx["BuyerPortalContext\ncurrentUser.email"]
+  Ctx --> Derive["deriveActorType(email)\ninternal | external"]
+  Derive --> Send["useDataIngestionApi.sendEvent\n+ actor_type"]
+  Send --> Ingest["VTEX schemaless-events"]
+```
+
+### Architecture Overview
+
+| Layer | Responsibility |
+|---|---|
+| `deriveActorType(email?)` | Pure helper: parse domain, return `internal` \| `external` |
+| `useDataIngestionApi` | Read `currentUser?.email` from `BuyerPortalContext` (optional context, like `useLogger`); merge `actor_type` into every `sendEvent` payload at top level alongside `account`, `locale`, `device`, `production` |
+| `useAnalytics` | Unchanged call sites; inherits enrichment via `sendEvent` |
+| Callers | No changes required to pass `actor_type` |
+
+### Alternatives Considered
+
+| Alternative | Pros | Cons | Verdict |
+|---|---|---|---|
+| Derive in each feature caller | Explicit per event | Easy to miss; duplicates logic | Rejected |
+| Derive only inside `useAnalytics.withDefaults` | Covers most UI tracking | Anything calling `useDataIngestionApi` / `dataIngestionApi` directly could skip it; harder to guarantee “every event” | Rejected as sole approach |
+| Classify from session `sub` | No dependency on Users API | `sub` is often not an email (e.g. `everton.ataidetestdev`); false `external` for VTEX staff | Rejected |
+| Put `actor_type` only inside `metadata` | Minimal type change | Sibling Redshift task wants a first-class column; top-level matches existing common fields | Rejected |
+| Centralize in `useDataIngestionApi` + pure helper | Single choke point; additive; testable | Hook must tolerate missing React context | **Accepted** |
+
+### Risks & Mitigations
+
+| Risk | Impact | Likelihood | Mitigation |
+|---|---|---|---|
+| `currentUser` null when analytics fires | Med (VTEX traffic mislabeled as external) | Med | Default `external`; ensure loaders keep loading user where events fire; document gap |
+| VTEX staff using non-`@vtex.com` email | Med (internal traffic still pollutes usage) | Low | Document rule; extend domain list only via explicit follow-up |
+| Customer email on `vtex.com` (unlikely) | Low | Low | Accept false `internal`; rule is domain-based by product decision |
+| Accidental PII leak via spread of user object | High | Low | Unit tests asserting outbound payload keys; helper never returns email |
+
+### Key Decisions
+
+#### Decision 1: Classification rule = exact `@vtex.com` domain
+
+- **Status**: Accepted
+- **Context**: Need a simple, privacy-safe heuristic for “VTEX employee”.
+- **Decision**: `internal` iff the email’s domain equals `vtex.com` (case-insensitive). Plus-tags (`user+tag@vtex.com`) still match. Domains like `vtex.com.br` or `*.vtex.com` are **not** internal in this iteration.
+- **Consequences**: Simple to implement and document; may miss regional VTEX domains until explicitly expanded.
+
+#### Decision 2: Fallback = `external` when email unavailable
+
+- **Status**: Accepted
+- **Context**: Ticket enum is only `internal \| external`; every event must carry the field.
+- **Decision**: Missing/invalid email → `external`.
+- **Consequences**: Some VTEX traffic without a loaded user profile remains in “external” usage until context is present; safer than inventing a third enum value for Melhoria 1.
+
+#### Decision 3: Identity source = `currentUser.email` from BuyerPortalContext
+
+- **Status**: Accepted
+- **Context**: Session JWT has `userId` / `sub` but not email; email already exists on `UserData` after loader fetch.
+- **Decision**: Read `currentUser?.email` from context at send time. Do not decode the auth cookie on the client for classification. Do not use `login` / `sub` unless it is later proven to be an email and product asks for it — out of scope for v1 (email-only).
+- **Consequences**: Correct for the common path where pages load the user; no extra network at emit time.
+
+#### Decision 4: Place `actor_type` at top level of the event envelope
+
+- **Status**: Accepted
+- **Context**: Sibling task needs a Redshift column; common context fields (`account`, `locale`, `device`, `production`) are already top-level.
+- **Decision**: Set `actor_type` as a top-level field on the object passed to `dataIngestionApi`, not buried only under `metadata`.
+- **Consequences**: Easier DAG mapping; additive and backward compatible for schemaless ingestion.
+
+### Implementation Plan
+
+1. Add `ActorType` type and pure `deriveActorType(email?: string | null): ActorType` under shared analytics (or shared utils) with unit tests.
+2. Extend `DataIngestionApiFields` / send path types with optional/required `actor_type`.
+3. Update `useDataIngestionApi` to read `BuyerPortalContext` (gracefully if undefined) and always set `actor_type` on `sendEvent`.
+4. Add tests that mock context email and assert outbound payload contains `actor_type` and does not contain email/login/userId.
+5. Manual smoke on a host store: one `@vtex.com` user and one external user; confirm events in the analytics pipeline / network tab.
+6. Hand off to [B2BTEAM-3640](https://vtex-dev.atlassian.net/browse/B2BTEAM-3640) for Redshift + QuickSight.
+
+---
+
+## 3. Technical Contract
+
+### Data Models
+
+```ts
+type ActorType = "internal" | "external";
+
+/** Pure classifier — never logs or returns the input email. */
+function deriveActorType(email?: string | null): ActorType;
+```
+
+**Rules for `deriveActorType`:**
+
+1. Trim and lowercase the email.
+2. If empty or no `@`, return `"external"`.
+3. Take the substring after the last `@` as the domain.
+4. If domain === `"vtex.com"`, return `"internal"`; else `"external"`.
+
+**Event envelope (additive):**
+
+| Field | Type | Required on emit | Notes |
+|---|---|---|---|
+| `actor_type` | `"internal" \| "external"` | Yes | Derived; top-level |
+| `email` / `login` / `userId` / `sub` | — | **Must not appear** | PII / identity ban |
+
+Existing fields (`name`, `account`, `locale`, `production`, `device`, `event_name`, `event_category`, `metadata`, …) unchanged.
+
+### Interfaces
+
+```ts
+// analytics types — additive
+interface DataIngestionApiFields {
+  // …existing fields…
+  actor_type?: ActorType; // set by send path; callers need not pass
+}
+
+// useDataIngestionApi sendEvent behavior
+sendEvent(fields: DataIngestionApiFields): void
+// always merges: { ...commonFields, ...fields, actor_type: deriveActorType(currentUser?.email) }
+// caller-supplied actor_type must not override the derived value (server of truth = derivation)
+```
+
+`useAnalytics` public API stays the same; no new required options on `UseAnalyticsConfig`.
+
+### Integration Points
+
+| System | Interaction |
+|---|---|
+| Auth cookie / session JWT | Provides `userId` only (indirectly); **not** used for domain classification |
+| Users API via `getUserByIdService` | Source of `currentUser.email` in loaders |
+| `BuyerPortalContext` | Runtime source of email for derivation in the client send hook |
+| VTEX Data Ingestion (`schemaless-events`) | Receives additive `actor_type`; no schema migration in this task |
+| Redshift / QuickSight | Consumer of the field in sibling task B2BTEAM-3640 |
+
+### Invariants & Constraints
+
+1. Every event leaving `useDataIngestionApi.sendEvent` includes `actor_type`.
+2. Outgoing analytics JSON must never include email, login, userId, or session `sub` as a result of this feature.
+3. Derivation does not perform network I/O.
+4. Callers cannot force a conflicting `actor_type` that bypasses derivation (derived value wins).
+5. Domains other than exact `vtex.com` are always `external` in this version.
+6. This feature does not change event names, categories, or existing metadata shapes beyond the additive field.

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.20";