@decocms/apps 0.20.1

package/vtex/loaders/search.ts

@@ -0,0 +1,127 @@
+/**
+ * VTEX search-related loaders (Intelligent Search + Catalog).
+ * Pure async functions — require configureVtex() to have been called.
+ *
+ * Ported from deco-cx/apps:
+ *   vtex/loaders/intelligentSearch/topsearches.ts
+ *   vtex/loaders/intelligentSearch/productSearchValidator.ts
+ *   vtex/loaders/options/productIdByTerm.ts
+ *
+ * @see https://developers.vtex.com/docs/api-reference/intelligent-search-api
+ */
+import { intelligentSearch, getVtexConfig } from "../client";
+import type { Suggestion } from "../utils/types";
+
+// ---------------------------------------------------------------------------
+// getTopSearches
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch the top searches from Intelligent Search.
+ *
+ * @param locale - BCP-47 locale (defaults to the configured locale or "pt-BR")
+ */
+export async function getTopSearches(locale?: string): Promise<Suggestion> {
+  const cfg = getVtexConfig();
+  const effectiveLocale = locale ?? cfg.locale ?? "pt-BR";
+
+  return intelligentSearch<Suggestion>("/top_searches", {
+    locale: effectiveLocale,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// validateProductSearch
+// ---------------------------------------------------------------------------
+
+export interface FacetsSearchProps {
+  query?: string;
+  facets?: string;
+  sort?: string;
+  count?: number;
+  page?: number;
+  locale?: string;
+}
+
+/**
+ * Validate whether a product search returns results.
+ *
+ * Runs the given search parameters against Intelligent Search.
+ * If no results are found and the props include facets, retries
+ * the search without facets.
+ *
+ * Returns the raw IS response or `null` when nothing is found.
+ */
+export async function validateProductSearch<T = unknown>(
+  props: FacetsSearchProps,
+  fetcher: (props: FacetsSearchProps) => Promise<T[] | null>,
+): Promise<T[] | null> {
+  const results = await fetcher(props);
+  if (results !== null && results.length > 0) return results;
+
+  if (props.facets) {
+    return fetcher({ ...props, facets: "" });
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// getProductIdByTerm
+// ---------------------------------------------------------------------------
+
+interface ProductIdOption {
+  value: string;
+  label: string;
+  image?: string;
+}
+
+interface ISSuggestionProduct {
+  productId: string;
+  productName: string;
+  brand: string;
+  linkText: string;
+  items: Array<{
+    itemId: string;
+    name: string;
+    images: Array<{ imageUrl: string; imageText: string }>;
+    sellers: Array<{
+      commertialOffer: { Price: number; ListPrice: number };
+    }>;
+  }>;
+}
+
+interface ISSuggestionResponse {
+  searches: Array<{ term: string; count: number }>;
+  products: ISSuggestionProduct[];
+}
+
+/**
+ * Search for products by free-text term and return a list of
+ * `{ value (SKU ID), label, image }` options.
+ *
+ * Hits the IS autocomplete_suggestions endpoint.
+ */
+export async function getProductIdByTerm(
+  term?: string,
+): Promise<ProductIdOption[]> {
+  const query = (term ?? "").trim();
+  if (!query) return [];
+
+  const data = await intelligentSearch<ISSuggestionResponse>(
+    "/autocomplete_suggestions/",
+    { query },
+  );
+
+  if (!data.products?.length) {
+    return [{ value: "No products found", label: "No products found" }];
+  }
+
+  return data.products.flatMap((product) =>
+    (product.items ?? []).map((item) => ({
+      value: item.itemId,
+      label: `${item.itemId} - ${product.productName} ${item.name} - ${product.productId}`,
+      image: item.images?.[0]?.imageUrl,
+    })),
+  );
+}

package/vtex/loaders/session.ts

@@ -0,0 +1,91 @@
+/**
+ * VTEX Session API loaders.
+ * Pure async functions — require configureVtex() to have been called.
+ *
+ * Ported from deco-cx/apps:
+ *   vtex/loaders/session/getSession.ts
+ *   vtex/loaders/session/getUserSessions.ts
+ *
+ * @see https://developers.vtex.com/docs/api-reference/session-manager-api
+ */
+import { vtexFetch, vtexIOGraphQL } from "../client";
+
+// ---------------------------------------------------------------------------
+// getSession (REST)
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch the current session data.
+ *
+ * @param items - Keys to retrieve, e.g. `["public.variable1", "profile.email"]`.
+ *                Pass `["*"]` (or omit) to retrieve all keys.
+ * @param authCookie - The raw `cookie` header value forwarded from the user request.
+ *
+ * @see https://developers.vtex.com/docs/api-reference/session-manager-api#get-/api/sessions
+ */
+export async function getSession<T = any>(
+  items: string[] = ["*"],
+  authCookie: string,
+): Promise<T> {
+  const qs = new URLSearchParams({ items: items.join(",") });
+  return vtexFetch<T>(`/api/sessions?${qs}`, {
+    headers: { cookie: authCookie },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// getUserSessions (authenticated — VTEX IO GraphQL)
+// ---------------------------------------------------------------------------
+
+export interface LoginSession {
+  id: string;
+  cacheId: string;
+  deviceType: string;
+  city: string;
+  lastAccess: string;
+  browser: string;
+  os: string;
+  ip: string;
+  fullAddress: string;
+  firstAccess: string;
+}
+
+export interface LoginSessionsInfo {
+  currentLoginSessionId: string;
+  loginSessions: LoginSession[];
+}
+
+const USER_SESSIONS_QUERY = `query getUserSessions {
+  loginSessionsInfo {
+    currentLoginSessionId
+    loginSessions {
+      id
+      cacheId
+      deviceType
+      city
+      lastAccess
+      browser
+      os
+      ip
+      fullAddress
+      firstAccess
+    }
+  }
+}`;
+
+/**
+ * Fetch all active login sessions for the currently authenticated user.
+ * Requires a valid VTEX auth cookie.
+ */
+export async function getUserSessions(
+  authCookie: string,
+): Promise<LoginSessionsInfo> {
+  const { loginSessionsInfo } = await vtexIOGraphQL<{
+    loginSessionsInfo: LoginSessionsInfo;
+  }>(
+    { query: USER_SESSIONS_QUERY },
+    { cookie: authCookie },
+  );
+
+  return loginSessionsInfo;
+}

package/vtex/loaders/user.ts

@@ -0,0 +1,89 @@
+/**
+ * VTEX User API loader.
+ * Pure async function — requires configureVtex() to have been called.
+ *
+ * Ported from deco-cx/apps:
+ *   vtex/loaders/user.ts
+ *
+ * @see https://developers.vtex.com/docs/api-reference/checkout-api
+ */
+import { vtexIOGraphQL } from "../client";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface Person {
+  "@id": string;
+  email: string;
+  givenName?: string;
+  familyName?: string;
+  taxID?: string;
+  gender?: string;
+  telephone?: string;
+}
+
+interface VtexUser {
+  id: string;
+  userId: string;
+  email: string;
+  firstName?: string;
+  lastName?: string;
+  profilePicture?: string;
+  gender?: string;
+  document?: string;
+  homePhone?: string;
+  businessPhone?: string;
+}
+
+// ---------------------------------------------------------------------------
+// getUser (authenticated — VTEX IO GraphQL)
+// ---------------------------------------------------------------------------
+
+const USER_QUERY = `query getUserProfile {
+  profile {
+    id
+    userId
+    email
+    firstName
+    lastName
+    profilePicture
+    gender
+    document
+    homePhone
+    businessPhone
+  }
+}`;
+
+/**
+ * Fetch the authenticated user as a Schema.org-style `Person`.
+ * Returns `null` when no valid session exists or the query fails.
+ *
+ * @param authCookie - Raw `cookie` header value from the user request.
+ */
+export async function getUser(
+  authCookie: string,
+): Promise<Person | null> {
+  try {
+    const { profile: user } = await vtexIOGraphQL<{ profile: VtexUser }>(
+      { query: USER_QUERY },
+      { cookie: authCookie },
+    );
+
+    return {
+      "@id": user.userId ?? user.id,
+      email: user.email,
+      givenName: user.firstName,
+      familyName: user.lastName,
+      taxID: user.document?.replace(/[^\d]/g, ""),
+      gender: user.gender
+        ? user.gender === "f"
+          ? "https://schema.org/Female"
+          : "https://schema.org/Male"
+        : undefined,
+      telephone: user.homePhone ?? user.businessPhone,
+    };
+  } catch {
+    return null;
+  }
+}

package/vtex/loaders/wishlist.ts

@@ -0,0 +1,89 @@
+/**
+ * VTEX Wishlist API loader.
+ * Pure async function — requires configureVtex() to have been called.
+ *
+ * Ported from deco-cx/apps:
+ *   vtex/loaders/wishlist.ts
+ *
+ * @see https://developers.vtex.com/docs/guides/vtex-wish-list
+ */
+import { vtexIOGraphQL } from "../client";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface WishlistItem {
+  id: string;
+  productId: string;
+  sku: string;
+  title: string;
+}
+
+export interface GetWishlistOpts {
+  shopperId: string;
+  count?: number;
+  page?: number;
+  allRecords?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// getWishlist (authenticated — VTEX IO GraphQL)
+// ---------------------------------------------------------------------------
+
+const WISHLIST_QUERY = `query GetWishlist($shopperId: String!, $name: String!, $from: Int, $to: Int) {
+  viewList(shopperId: $shopperId, name: $name, from: $from, to: $to)
+    @context(provider: "vtex.wish-list@1.x") {
+    name
+    data {
+      id
+      productId
+      sku
+      title
+    }
+  }
+}`;
+
+/**
+ * Fetch the wishlist for a given shopper.
+ * Requires a valid VTEX auth cookie.
+ *
+ * @param authCookie - Raw `cookie` header value from the user request.
+ * @param opts.shopperId - The shopper identifier (usually the e-mail from the JWT `sub` claim).
+ * @param opts.count - Items per page (default: all).
+ * @param opts.page - Zero-based page index (default: 0).
+ * @param opts.allRecords - When true, ignores pagination and returns every item.
+ */
+export async function getWishlist(
+  authCookie: string,
+  opts: GetWishlistOpts,
+): Promise<WishlistItem[]> {
+  try {
+    const { viewList } = await vtexIOGraphQL<{
+      viewList: { name?: string; data: WishlistItem[] };
+    }>(
+      {
+        operationName: "GetWishlist",
+        query: WISHLIST_QUERY,
+        variables: {
+          name: "Wishlist",
+          shopperId: opts.shopperId,
+        },
+      },
+      { cookie: authCookie },
+    );
+
+    const data = viewList.data ?? [];
+
+    if (opts.allRecords) return data;
+
+    const count = opts.count ?? Infinity;
+    const page = opts.page ?? 0;
+    return data.slice(count * page, count * (page + 1));
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      throw error;
+    }
+    return [];
+  }
+}

package/vtex/loaders/wishlistProducts.ts

@@ -0,0 +1,81 @@
+/**
+ * Wishlist Products loader.
+ * Returns a ProductListingPage built from the user's wishlist items.
+ *
+ * Ported from deco-cx/apps vtex/loaders/product/wishlist.ts
+ */
+import type {
+	Product,
+	ProductListingPage,
+} from "../../commerce/types/commerce";
+import { getWishlist } from "./wishlist";
+
+export interface WishlistProductsProps {
+	/** Items per page @default 12 */
+	count?: number;
+	/** 1 to start from index 1 @default 0 */
+	offset?: 0 | 1;
+	/** The user's auth cookie string */
+	authCookie: string;
+	/** The user's shopper ID (email) */
+	shopperId: string;
+	/** Current page URL (for pagination links) */
+	url: string;
+}
+
+function withPage(baseUrl: string, page: number): string {
+	const url = new URL(baseUrl);
+	url.searchParams.set("page", `${page}`);
+	return `?${url.searchParams}`;
+}
+
+export async function wishlistProducts(
+	props: WishlistProductsProps,
+): Promise<ProductListingPage | null> {
+	const {
+		count: recordPerPage = 12,
+		offset = 0,
+		authCookie,
+		shopperId,
+		url: rawUrl,
+	} = props;
+
+	const url = new URL(rawUrl);
+	const page = Math.max(
+		0,
+		Number(url.searchParams.get("page") ?? offset) - offset,
+	);
+	const items = await getWishlist(authCookie, { shopperId, allRecords: true });
+	const records = items.length;
+	const start = page * recordPerPage;
+	const end = (page + 1) * recordPerPage;
+
+	const products: Product[] = items
+		.map(({ sku, productId }) => ({
+			"@type": "Product" as const,
+			inProductGroupWithID: productId,
+			productID: sku,
+			sku,
+		}))
+		.slice(start, end);
+
+	return {
+		"@type": "ProductListingPage",
+		breadcrumb: {
+			"@type": "BreadcrumbList",
+			itemListElement: [],
+			numberOfItems: 0,
+		},
+		filters: [],
+		products,
+		pageInfo: {
+			currentPage: page + offset,
+			nextPage: records > end ? withPage(rawUrl, page + 1 + offset) : undefined,
+			previousPage: page > 0 ? withPage(rawUrl, page - 1 + offset) : undefined,
+			recordPerPage,
+			records,
+		},
+		sortOptions: [],
+		seo: null,
+	};
+}