@decocms/apps-wake 7.66.0

package/src/loaders/productListingPage.ts

@@ -0,0 +1,333 @@
+import type { ProductListingPage, SortOption } from "@decocms/apps-commerce/types";
+import partnerAssociate from "../actions/cart/partnerAssociate";
+import { getWakeClient } from "../client";
+import { handleAuthError } from "../utils/authError";
+import { capitalize } from "../utils/capitalize";
+import { getVariations, MAXIMUM_REQUEST_QUANTITY } from "../utils/getVariations";
+import { GetPartners, GetURL, Hotsite, Search } from "../utils/graphql/queries";
+import type {
+  GetPartnersQuery,
+  GetUrlQuery,
+  HotsiteQuery,
+  ProductFragment,
+  ProductSortKeys,
+  SearchQuery,
+  SortDirection,
+} from "../utils/graphql/storefront.graphql.gen";
+import { getPartnerCookie } from "../utils/partner";
+import { currentRequest, currentRequestHeaders, forwardedHeaders } from "../utils/requestCtx";
+import { FILTER_PARAM, toBreadcrumbList, toFilters, toProduct } from "../utils/transform";
+import type { RequestURLParam } from "../utils/types";
+import type { Filters } from "./productList";
+
+export type Sort =
+  | "NAME:ASC"
+  | "NAME:DESC"
+  | "RELEASE_DATE:DESC"
+  | "PRICE:ASC"
+  | "PRICE:DESC"
+  | "DISCOUNT:DESC"
+  | "SALES:DESC";
+
+export const SORT_OPTIONS: SortOption[] = [
+  { value: "NAME:ASC", label: "Nome A-Z" },
+  { value: "NAME:DESC", label: "Nome Z-A" },
+  { value: "RELEASE_DATE:DESC", label: "Lançamentos" },
+  { value: "PRICE:ASC", label: "Menores Preços" },
+  { value: "PRICE:DESC", label: "Maiores Preços" },
+  { value: "DISCOUNT:DESC", label: "Maiores Descontos" },
+  { value: "SALES:DESC", label: "Mais Vendidos" },
+];
+
+type SortValue = `${ProductSortKeys}:${SortDirection}`;
+export interface Props {
+  /**
+   * @title Count
+   * @description Number of products to display
+   * @maximum 50
+   * @default 12
+   */
+  limit?: number;
+
+  /** @description Types of operations to perform between query terms */
+  operation?: "AND" | "OR";
+
+  /**
+   * @ignore
+   */
+  page: number;
+
+  /**
+   * @title Sorting
+   */
+  sort?: Sort;
+
+  /**
+   * @description overides the query term
+   */
+  query?: string;
+
+  /**
+   * @title Only Main Variant
+   * @description Toggle the return of only main variants or all variations separeted.
+   */
+  onlyMainVariant?: boolean;
+
+  filters?: Filters;
+
+  /** @description Retrieve variantions for each product. */
+  getVariations?: boolean;
+
+  /**
+   * @title Starting page query parameter offset.
+   * @description Set the starting page offset. Default to 1.
+   */
+  pageOffset?: 0 | 1;
+
+  /**
+   * @hide true
+   * @description The URL of the page, used to override URL from request
+   */
+  pageHref?: string;
+
+  /**
+   * @title Partner Param
+   * @description page param to partners page
+   * @deprecated
+   */
+  slug?: RequestURLParam;
+
+  /**
+   * @title Partner Param
+   * @description page param to partners page
+   */
+  partnerAlias?: RequestURLParam;
+}
+
+const OUTSIDE_ATTRIBUTES_FILTERS = ["precoPor"];
+
+const filtersFromParams = (searchParams: URLSearchParams) => {
+  const filters: Array<{ field: string; values: string[] }> = [];
+
+  searchParams.getAll(FILTER_PARAM).forEach((value) => {
+    const test = /.*:.*/;
+    const [field, val] = test.test(value) ? value.split(":") : value.split("__");
+
+    if (!OUTSIDE_ATTRIBUTES_FILTERS.includes(field)) {
+      filters.push({ field, values: [val] });
+    }
+  });
+
+  return filters;
+};
+
+/**
+ * @title Wake Integration
+ * @description Product Listing Page loader
+ */
+const searchLoader = async (props: Props): Promise<ProductListingPage | null> => {
+  const req = currentRequest();
+  const reqUrl = req?.url ?? "https://localhost";
+  // get url from params
+  const url =
+    new URL(reqUrl).pathname === "/live/invoke"
+      ? new URL(props.pageHref || req?.headers.get("referer") || reqUrl)
+      : new URL(props.pageHref || reqUrl);
+
+  const storefront = getWakeClient();
+
+  const partnerAlias = props.partnerAlias ?? props.slug;
+
+  const partnerAccessTokenCookie = getPartnerCookie(currentRequestHeaders());
+
+  const headers = forwardedHeaders();
+
+  const limit = Number(url.searchParams.get("tamanho") ?? props.limit ?? 12);
+
+  const filters = filtersFromParams(url.searchParams) ?? props.filters;
+  const sort =
+    (url.searchParams.get("sort") as SortValue | null) ??
+    (url.searchParams.get("ordenacao") as SortValue | null) ??
+    props.sort ??
+    "SALES:DESC";
+  const page =
+    props.page ??
+    Number(url.searchParams.get("page")) ??
+    Number(url.searchParams.get("pagina")) ??
+    0;
+  const query = props.query ?? url.searchParams.get("busca");
+  const operation = props.operation ?? "AND";
+
+  const [sortKey, sortDirection] = sort.split(":") as [ProductSortKeys, SortDirection];
+
+  const onlyMainVariant = props.onlyMainVariant ?? true;
+  const [minimumPrice, maximumPrice] =
+    url.searchParams
+      .getAll("filtro")
+      ?.find((i) => i.startsWith("precoPor"))
+      ?.split(":")[1]
+      ?.split(";")
+      .map(Number) ??
+    url.searchParams.get("precoPor")?.split(";").map(Number) ??
+    [];
+
+  const offset = page <= 1 ? 0 : (page - 1) * limit;
+
+  const partnerData = partnerAlias
+    ? await storefront.query<GetPartnersQuery>(
+        GetPartners,
+        { first: 1, alias: [partnerAlias] },
+        headers,
+      )
+    : null;
+
+  const partnerAccessToken =
+    partnerData?.partners?.edges?.[0]?.node?.partnerAccessToken ?? partnerAccessTokenCookie;
+
+  if (partnerAccessToken) {
+    try {
+      await partnerAssociate({ partnerAccessToken });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  const urlData = await storefront.query<GetUrlQuery>(GetURL, { url: url.pathname }, headers);
+
+  const isHotsite = urlData.uri?.kind === "HOTSITE";
+
+  const commonParams = {
+    sortDirection,
+    sortKey,
+    filters,
+    limit: Math.min(limit, MAXIMUM_REQUEST_QUANTITY),
+    offset,
+    onlyMainVariant,
+    minimumPrice,
+    maximumPrice,
+    partnerAccessToken,
+  };
+
+  if (!query && !isHotsite && !partnerAccessToken) {
+    console.warn(
+      "ProductListingPage: No search query, hotsite, or partner token provided - returning null",
+    );
+    return null;
+  }
+
+  let data: SearchQuery | HotsiteQuery | undefined;
+  try {
+    data = isHotsite
+      ? await storefront.query<HotsiteQuery>(
+          Hotsite,
+          { ...commonParams, url: url.pathname },
+          headers,
+        )
+      : await storefront.query<SearchQuery>(Search, { ...commonParams, query, operation }, headers);
+  } catch (error: unknown) {
+    handleAuthError(error, "load products");
+  }
+
+  const products = data?.result?.productsByOffset?.items ?? [];
+
+  const nextPage = new URLSearchParams(url.searchParams);
+  const previousPage = new URLSearchParams(url.searchParams);
+
+  const hasNextPage = Boolean(
+    (data?.result?.productsByOffset?.totalCount ?? 0) / limit >
+      (data?.result?.productsByOffset?.page ?? 0),
+  );
+
+  const hasPreviousPage = page > 1;
+
+  const pageOffset = props.pageOffset ?? 0;
+
+  if (hasNextPage) {
+    nextPage.set("page", (page + pageOffset + 1).toString());
+  }
+
+  if (hasPreviousPage) {
+    previousPage.set("page", (page + pageOffset - 1).toString());
+  }
+
+  const productIDs = products.map((i) => i?.productId).filter((id): id is number => id != null);
+
+  const variations = props.getVariations ? await getVariations(productIDs, url, headers) : [];
+
+  const breadcrumb = toBreadcrumbList(data?.result?.breadcrumbs, {
+    base: url,
+  });
+
+  const title = isHotsite
+    ? (data as HotsiteQuery)?.result?.seo?.find((i) => i?.type === "TITLE")?.content
+    : capitalize(query || "");
+  const description = isHotsite
+    ? (data as HotsiteQuery)?.result?.seo?.find((i) => i?.name === "description")?.content
+    : capitalize(query || "");
+  const canonical = new URL(isHotsite ? `/${(data as HotsiteQuery)?.result?.url}` : url, url).href;
+
+  return {
+    "@type": "ProductListingPage",
+    filters: toFilters(data?.result?.aggregations, { base: url }),
+    pageInfo: {
+      nextPage: hasNextPage ? `?${nextPage}` : undefined,
+      previousPage: hasPreviousPage ? `?${previousPage}` : undefined,
+      currentPage: data?.result?.productsByOffset?.page ?? 1,
+      records: data?.result?.productsByOffset?.totalCount,
+      recordPerPage: limit,
+    },
+    sortOptions: SORT_OPTIONS,
+    breadcrumb,
+    seo: {
+      description: description || "",
+      title: title || "",
+      canonical,
+    },
+    products: products
+      ?.filter((p): p is ProductFragment => Boolean(p))
+      .map((variant) => {
+        const productVariations = variations?.filter(
+          (v) => v.inProductGroupWithID === variant.productId,
+        );
+
+        return toProduct(variant, { base: url }, productVariations);
+      }),
+  };
+};
+
+export const cache = "stale-while-revalidate";
+
+export const cacheKey = (props: Props): string | null => {
+  const req = currentRequest();
+  const url = new URL(props.pageHref || req?.url || "https://localhost");
+
+  // Don't cache search queries to ensure freshness
+  if (url.searchParams.get("q") || url.searchParams.get("query") || url.searchParams.get("busca")) {
+    return null;
+  }
+
+  // Avoid cross-tenant cache bleed when a partner token is present
+  if (getPartnerCookie(currentRequestHeaders())) {
+    return null;
+  }
+
+  const params = new URLSearchParams([
+    ["limit", (props.limit || 12).toString()],
+    ["page", (props.page || 0).toString()],
+    ["sort", props.sort || ""],
+    ["pageOffset", (props.pageOffset || 0).toString()],
+  ]);
+
+  // Add any filter parameters
+  url.searchParams.forEach((value, key) => {
+    if (key === "filtro" || key === "q" || key === "sort" || key === "page") {
+      params.append(key, value);
+    }
+  });
+
+  params.sort();
+  url.search = params.toString();
+  return url.href;
+};
+
+export default searchLoader;

package/src/loaders/proxy.ts

@@ -0,0 +1,79 @@
+import { getCheckoutUrl } from "../client";
+
+/**
+ * Checkout paths that must be proxied to the Wake checkout host. In the Deno
+ * runtime this loader returned deco `Route[]` consumed by the `website` router;
+ * that router does not exist in this architecture, so the loader returns a
+ * serializable descriptor list that the storefront's worker entry consumes to
+ * install its own proxy handler.
+ */
+const PATHS_TO_PROXY: Array<[string, string?]> = [
+  ["/checkout", "/checkout"],
+  ["/Fechamento"],
+  ["/Fechamento/*"],
+  ["/Login"],
+  ["/Login/*"],
+  ["/login/*"],
+  ["/Login/Authenticate"],
+  ["/Carrinho/*"],
+  ["/api/*"],
+  ["/MinhaConta"],
+  ["/MinhaConta/*"],
+];
+
+export interface Props {
+  extraPathsToProxy?: string[];
+  /**
+   * @title Other site maps to include
+   */
+  includeSiteMap?: string[];
+}
+
+export type WakeProxyRoute =
+  | {
+      type: "proxy";
+      pathTemplate: string;
+      basePath?: string;
+      /** Target host to proxy to (the Wake checkout URL). */
+      url: string;
+      /** Host header to forward. */
+      host: string;
+    }
+  | {
+      type: "sitemap";
+      pathTemplate: string;
+      include?: string[];
+      host: string;
+    };
+
+/**
+ * @title Wake Proxy Routes
+ */
+function loader(props: Props): WakeProxyRoute[] {
+  const { includeSiteMap, extraPathsToProxy = [] } = props;
+
+  const checkoutUrl = getCheckoutUrl();
+
+  const extraPathsAsArray: Array<[string, string?]> = extraPathsToProxy.map((path) => [path]);
+
+  const checkout: WakeProxyRoute[] = [...PATHS_TO_PROXY, ...extraPathsAsArray].map(
+    ([pathTemplate, basePath]) => ({
+      type: "proxy",
+      pathTemplate,
+      basePath,
+      url: checkoutUrl,
+      host: checkoutUrl,
+    }),
+  );
+
+  const sitemap: WakeProxyRoute = {
+    type: "sitemap",
+    pathTemplate: "/Sitemap.xml",
+    include: includeSiteMap,
+    host: checkoutUrl,
+  };
+
+  return [...checkout, sitemap];
+}
+
+export default loader;

package/src/loaders/recommendations.ts

@@ -0,0 +1,84 @@
+import type { Product } from "@decocms/apps-commerce/types";
+import { getWakeClient } from "../client";
+import { handleAuthError } from "../utils/authError";
+import { getVariations } from "../utils/getVariations";
+import { ProductRecommendations } from "../utils/graphql/queries";
+import type {
+  ProductFragment,
+  ProductRecommendationsQuery,
+} from "../utils/graphql/storefront.graphql.gen";
+import { getPartnerCookie } from "../utils/partner";
+import { currentRequestHeaders, currentUrl, forwardedHeaders } from "../utils/requestCtx";
+import { parseSlug, toProduct } from "../utils/transform";
+import type { RequestURLParam } from "../utils/types";
+
+export interface Props {
+  /**
+   * @default DEFAULT
+   * @description Algorithm type
+   */
+  algorithm: "DEFAULT";
+  quantity: number;
+  slug: RequestURLParam;
+  /** @description Retrieve variantions for each product. */
+  getVariations?: boolean;
+}
+
+/**
+ * @title Wake Integration - Product Recommendations
+ * @description Product Recommendations loader
+ */
+const productRecommendationsLoader = async (props: Props): Promise<Product[] | null> => {
+  const url = currentUrl();
+  const storefront = getWakeClient();
+  const { slug, quantity, algorithm = "DEFAULT" } = props;
+  const partnerAccessToken = getPartnerCookie(currentRequestHeaders());
+
+  const headers = forwardedHeaders();
+
+  const { id: productId } = parseSlug(slug);
+
+  let data: ProductRecommendationsQuery | undefined;
+  try {
+    data = await storefront.query<ProductRecommendationsQuery>(
+      ProductRecommendations,
+      { quantity, productId, algorithm, partnerAccessToken },
+      headers,
+    );
+  } catch (error: unknown) {
+    handleAuthError(error, "load product recommendations");
+  }
+
+  const products = data?.productRecommendations;
+
+  if (!Array.isArray(products)) {
+    return null;
+  }
+
+  const productIDs = products.map((i) => i?.productId).filter((id): id is number => id != null);
+
+  const variations = props.getVariations ? await getVariations(productIDs, url, headers) : [];
+
+  return products
+    ?.filter((p): p is ProductFragment => Boolean(p))
+    .map((variant) => {
+      const productVariations = variations?.filter(
+        (v) => v.inProductGroupWithID === variant.productId,
+      );
+
+      return toProduct(variant, { base: url }, productVariations);
+    });
+};
+
+export const cache = "stale-while-revalidate";
+
+export const cacheKey = (props: Props): string | null => {
+  // Avoid cross-tenant cache bleed when a partner token is present
+  if (getPartnerCookie(currentRequestHeaders())) {
+    return null;
+  }
+
+  return `wake:recommendations:${props.slug}:${props.quantity}:${props.algorithm}:${props.getVariations ?? false}`;
+};
+
+export default productRecommendationsLoader;

package/src/loaders/shop.ts

@@ -0,0 +1,37 @@
+import { getWakeClient } from "../client";
+import { handleAuthError } from "../utils/authError";
+import { Shop } from "../utils/graphql/queries";
+import type { ShopQuery } from "../utils/graphql/storefront.graphql.gen";
+import { getPartnerCookie } from "../utils/partner";
+import { currentRequestHeaders, forwardedHeaders } from "../utils/requestCtx";
+
+/**
+ * @title Wake Integration - Shop Infos
+ * @description Shop Infos loader
+ */
+const shopInfos = async (): Promise<ShopQuery["shop"] | undefined> => {
+  const storefront = getWakeClient();
+  const headers = forwardedHeaders();
+
+  let data: ShopQuery;
+  try {
+    data = await storefront.query<ShopQuery>(Shop, {}, headers);
+  } catch (error: unknown) {
+    handleAuthError(error, "load shop information");
+  }
+
+  return data?.shop ?? undefined;
+};
+
+export const cache = "stale-while-revalidate";
+
+export const cacheKey = (): string | null => {
+  // Avoid cross-tenant cache bleed when a partner token is present
+  if (getPartnerCookie(currentRequestHeaders())) {
+    return null;
+  }
+
+  return "wake:shop";
+};
+
+export default shopInfos;

package/src/loaders/suggestion.ts

@@ -0,0 +1,67 @@
+import type { Suggestion } from "@decocms/apps-commerce/types";
+import { getWakeClient } from "../client";
+import { handleAuthError } from "../utils/authError";
+import { Autocomplete } from "../utils/graphql/queries";
+import type { AutocompleteQuery, ProductFragment } from "../utils/graphql/storefront.graphql.gen";
+import { getPartnerCookie } from "../utils/partner";
+import { currentRequestHeaders, currentUrl, forwardedHeaders } from "../utils/requestCtx";
+import { toProduct } from "../utils/transform";
+
+export interface Props {
+  query: string;
+  limit?: number;
+}
+
+/**
+ * @title Wake Integration
+ * @description Product Suggestion loader
+ */
+const loader = async (props: Props): Promise<Suggestion | null> => {
+  const storefront = getWakeClient();
+  const { query, limit = 10 } = props;
+
+  const partnerAccessToken = getPartnerCookie(currentRequestHeaders());
+  const headers = forwardedHeaders();
+  const url = currentUrl();
+
+  if (!query) return null;
+
+  let data: AutocompleteQuery | undefined;
+  try {
+    data = await storefront.query<AutocompleteQuery>(
+      Autocomplete,
+      { query, limit, partnerAccessToken },
+      headers,
+    );
+  } catch (error: unknown) {
+    handleAuthError(error, "load product suggestions");
+  }
+
+  const { products: wakeProducts, suggestions = [] } = data?.autocomplete ?? {};
+
+  if (!wakeProducts?.length && !suggestions?.length) return null;
+
+  const products = wakeProducts
+    ?.filter((node): node is ProductFragment => Boolean(node))
+    .map((node) => toProduct(node, { base: url }));
+
+  return {
+    products: products,
+    searches: suggestions?.filter(Boolean)?.map((suggestion) => ({
+      term: suggestion!,
+    })),
+  };
+};
+
+export const cache = "no-cache";
+
+export const cacheKey = (props: Props): string | null => {
+  // Avoid cross-tenant cache bleed when a partner token is present
+  if (getPartnerCookie(currentRequestHeaders())) {
+    return null;
+  }
+
+  return `wake:suggestion:${props.query}:${props.limit ?? 10}`;
+};
+
+export default loader;

package/src/loaders/user.ts

@@ -0,0 +1,48 @@
+import type { Person } from "@decocms/apps-commerce/types";
+import { getWakeClient } from "../client";
+import { handleAuthError } from "../utils/authError";
+import authenticate from "../utils/authenticate";
+import { GetUser } from "../utils/graphql/queries";
+import type { GetUserQuery } from "../utils/graphql/storefront.graphql.gen";
+import { forwardedHeaders } from "../utils/requestCtx";
+
+/**
+ * @title Wake Integration
+ * @description User loader
+ */
+const userLoader = async (): Promise<Person | null> => {
+  const storefront = getWakeClient();
+  const headers = forwardedHeaders();
+
+  const customerAccessToken = await authenticate();
+
+  if (!customerAccessToken) return null;
+
+  let data: GetUserQuery | undefined;
+  try {
+    data = await storefront.query<GetUserQuery>(GetUser, { customerAccessToken }, headers);
+  } catch (error: unknown) {
+    handleAuthError(error, "load user data");
+  }
+
+  const customer = data?.customer;
+
+  if (!customer) return null;
+
+  return {
+    "@id": String(customer.id ?? customer.customerId),
+    email: customer.email ?? undefined,
+    givenName: customer.customerName ?? undefined,
+    gender:
+      customer.gender === "Masculino"
+        ? "https://schema.org/Male"
+        : customer.gender === "Feminino"
+          ? "https://schema.org/Female"
+          : undefined,
+  };
+};
+
+export default userLoader;
+
+// User-specific response; must not be cached/shared.
+export const cache = "no-store";

package/src/loaders/wishlist.ts

@@ -0,0 +1,40 @@
+import { getWakeClient } from "../client";
+import { handleAuthError } from "../utils/authError";
+import authenticate from "../utils/authenticate";
+import { GetWishlist } from "../utils/graphql/queries";
+import type {
+  GetWishlistQuery,
+  WishlistReducedProductFragment,
+} from "../utils/graphql/storefront.graphql.gen";
+import { forwardedHeaders } from "../utils/requestCtx";
+
+/**
+ * @title Wake Integration
+ * @description Product Wishlist loader
+ */
+const loader = async (): Promise<WishlistReducedProductFragment[]> => {
+  const storefront = getWakeClient();
+  const headers = forwardedHeaders();
+
+  const customerAccessToken = await authenticate();
+
+  if (!customerAccessToken) return [];
+
+  let data: GetWishlistQuery | undefined;
+  try {
+    data = await storefront.query<GetWishlistQuery>(GetWishlist, { customerAccessToken }, headers);
+  } catch (error: unknown) {
+    handleAuthError(error, "load wishlist");
+  }
+
+  return (
+    data?.customer?.wishlist?.products?.filter((p): p is WishlistReducedProductFragment =>
+      Boolean(p),
+    ) ?? []
+  );
+};
+
+export default loader;
+
+// User-specific wishlist data; must not be cached/shared.
+export const cache = "no-store";