@decocms/apps-wake 7.66.0

package/src/actions/wishlist/addProduct.ts

@@ -0,0 +1,43 @@
+import { getWakeClient } from "../../client";
+import authenticate from "../../utils/authenticate";
+import { WishlistAddProduct } from "../../utils/graphql/queries";
+import type {
+  ProductFragment,
+  WishlistAddProductMutation,
+  WishlistReducedProductFragment,
+} from "../../utils/graphql/storefront.graphql.gen";
+import { forwardedHeaders } from "../../utils/requestCtx";
+
+export interface Props {
+  productId: number;
+}
+
+const action = async (props: Props): Promise<WishlistReducedProductFragment[] | null> => {
+  const storefront = getWakeClient();
+  const { productId } = props;
+  const customerAccessToken = await authenticate();
+  const headers = forwardedHeaders();
+
+  if (!customerAccessToken) return [];
+
+  const data = await storefront.query<WishlistAddProductMutation>(
+    WishlistAddProduct,
+    { customerAccessToken, productId },
+    headers,
+  );
+
+  const products = data.wishlistAddProduct;
+
+  if (!Array.isArray(products)) {
+    return null;
+  }
+
+  return products
+    .filter((node): node is ProductFragment => Boolean(node))
+    .map(({ productId, productName }) => ({
+      productId,
+      productName,
+    }));
+};
+
+export default action;

package/src/actions/wishlist/removeProduct.ts

@@ -0,0 +1,45 @@
+import { getWakeClient } from "../../client";
+import authenticate from "../../utils/authenticate";
+import { WishlistRemoveProduct } from "../../utils/graphql/queries";
+import type {
+  ProductFragment,
+  WishlistReducedProductFragment,
+  WishlistRemoveProductMutation,
+} from "../../utils/graphql/storefront.graphql.gen";
+import { forwardedHeaders } from "../../utils/requestCtx";
+
+export interface Props {
+  productId: number;
+}
+
+const action = async (props: Props): Promise<WishlistReducedProductFragment[] | null> => {
+  const storefront = getWakeClient();
+  const { productId } = props;
+
+  const headers = forwardedHeaders();
+
+  const customerAccessToken = await authenticate();
+
+  if (!customerAccessToken) return [];
+
+  const data = await storefront.query<WishlistRemoveProductMutation>(
+    WishlistRemoveProduct,
+    { customerAccessToken, productId },
+    headers,
+  );
+
+  const products = data.wishlistRemoveProduct;
+
+  if (!Array.isArray(products)) {
+    return null;
+  }
+
+  return products
+    .filter((node): node is ProductFragment => Boolean(node))
+    .map(({ productId, productName }) => ({
+      productId,
+      productName,
+    }));
+};
+
+export default action;

package/src/client.ts

@@ -0,0 +1,123 @@
+import type { FetchFn } from "@decocms/blocks/sdk/fetchTimeout";
+import { createGraphqlClient, type GraphQLClient } from "./utils/graphql";
+
+export interface WakeConfig {
+  /** Wake account name, e.g. "erploja2". */
+  account: string;
+  /**
+   * Checkout/login domain, e.g. "https://secure.sprint55.com.br". Used only for
+   * the checkout REST API (login/cart) and proxy — NOT for the storefront
+   * GraphQL, which is a fixed multi-tenant endpoint resolved by the token.
+   */
+  checkoutUrl: string;
+  /** Wake Storefront API token (sent as `TCS-Access-Token`). */
+  storefrontToken: string;
+  /**
+   * Storefront GraphQL endpoint. Defaults to Wake's canonical multi-tenant
+   * endpoint; override only for a custom storefront host.
+   */
+  storefrontEndpoint?: string;
+  /** Wake Admin API token (Basic auth). Currently unused by the loaders/actions. */
+  token?: string;
+}
+
+const STOREFRONT_ENDPOINT = "https://storefront-api.fbits.net/graphql";
+
+/**
+ * Read an env var. Wake's tokens are provided ONLY via environment variables
+ * (no CMS secret / `resolveSecret`): `WAKE_TOKEN` (storefront) and, if ever
+ * needed, `WAKE_KEY` (admin). `process.env` is populated in Node and in
+ * Cloudflare Workers via `nodejs_compat` — the same source the framework's
+ * own `getEnvVar()` reads first.
+ */
+function readEnv(name: string): string | undefined {
+  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process
+    ?.env;
+  const value = env?.[name];
+  return value && value.length > 0 ? value : undefined;
+}
+
+/** Wake Storefront API token from `WAKE_TOKEN`. */
+export function getWakeStorefrontTokenFromEnv(): string | undefined {
+  return readEnv("WAKE_TOKEN");
+}
+
+/** Wake Admin API token from `WAKE_KEY` (currently unused by loaders/actions). */
+export function getWakeAdminTokenFromEnv(): string | undefined {
+  return readEnv("WAKE_KEY");
+}
+
+let _client: GraphQLClient | null = null;
+let _config: WakeConfig | null = null;
+let _fetch: FetchFn | undefined;
+
+/**
+ * Override the fetch function used by the Wake GraphQL client. Use this to plug
+ * in an instrumented fetch for logging/tracing.
+ *
+ * @example
+ * ```ts
+ * import { createInstrumentedFetch } from "@decocms/blocks/sdk/instrumentedFetch";
+ * import { setWakeFetch } from "@decocms/apps-wake";
+ * setWakeFetch(createInstrumentedFetch("wake"));
+ * ```
+ */
+export function setWakeFetch(fetchFn: FetchFn) {
+  _fetch = fetchFn;
+  if (_config) configureWake(_config);
+}
+
+export function configureWake(config: WakeConfig) {
+  _config = config;
+  const endpoint = config.storefrontEndpoint || STOREFRONT_ENDPOINT;
+  _client = createGraphqlClient(
+    endpoint,
+    {
+      "TCS-Access-Token": config.storefrontToken,
+    },
+    _fetch,
+  );
+}
+
+export function getWakeClient(): GraphQLClient {
+  if (!_client || !_config) {
+    throw new Error(
+      "Wake not configured. Call configureWake() first or check deco-wake.json block.",
+    );
+  }
+  return _client;
+}
+
+export function getWakeConfig(): WakeConfig {
+  if (!_config) {
+    throw new Error("Wake not configured.");
+  }
+  return _config;
+}
+
+/** Base URL of the checkout REST API (`GET /api/Login/Get`, proxied paths). */
+export function getCheckoutUrl(): string {
+  const config = getWakeConfig();
+  return config.checkoutUrl || `https://${config.account}.checkout.fbits.store`;
+}
+
+export function getBaseUrl(): string {
+  return _config?.checkoutUrl || "";
+}
+
+/**
+ * Convenience initializer used by the site setup: reads the Wake app block from
+ * the generated blocks map and configures the singleton.
+ */
+export function initWakeFromBlocks(blocks: Record<string, unknown>) {
+  const block = (blocks.wake ?? blocks["deco-wake"]) as Partial<WakeConfig> | undefined;
+  if (!block?.account) return;
+  configureWake({
+    account: block.account as string,
+    checkoutUrl: (block.checkoutUrl as string) ?? "",
+    // Tokens come from env only (WAKE_TOKEN / WAKE_KEY), never the CMS block.
+    storefrontToken: getWakeStorefrontTokenFromEnv() ?? "",
+    storefrontEndpoint: block.storefrontEndpoint as string | undefined,
+    token: getWakeAdminTokenFromEnv(),
+  });
+}

package/src/commerceLoaders.ts

@@ -0,0 +1,137 @@
+/**
+ * Standard Wake commerce loader map factory for CMS block resolution.
+ *
+ * Wraps the cacheable catalog loaders with `createCachedLoader` (single-flight
+ * dedup + SWR + stale-if-error via the unified cache profiles), applies the
+ * PDP slug fallback and PLP page-URL resolution, and registers both `.ts` and
+ * `.ts`-less aliases.
+ *
+ * Sites call `createWakeCommerceLoaders()` and hand the result to
+ * `registerCommerceLoaders(...)` instead of wiring each loader (and its cache
+ * policy) by hand — mirroring `createVtexCommerceLoaders()`.
+ *
+ * User-specific loaders (cart/user/wishlist) are intentionally NOT included:
+ * they are per-session and must not be cached; the app manifest registers them
+ * uncached via `autoconfigApps`.
+ */
+
+import { createCachedLoader } from "@decocms/blocks/sdk/cachedLoader";
+import type { CacheProfileName } from "@decocms/blocks/sdk/cacheHeaders";
+import { RequestContext } from "@decocms/blocks/sdk/requestContext";
+import partnersLoader from "./loaders/partners";
+import productDetailsPage from "./loaders/productDetailsPage";
+import productList from "./loaders/productList";
+import productListingPage from "./loaders/productListingPage";
+import recommendations from "./loaders/recommendations";
+import shopLoader from "./loaders/shop";
+import suggestion from "./loaders/suggestion";
+
+export type CommerceLoaderFn = (props: any) => Promise<any>;
+
+export interface WakeCommerceLoadersOptions {
+  /** Override cache profiles per loader type. */
+  cacheProfiles?: {
+    listing?: CacheProfileName;
+    product?: CacheProfileName;
+    search?: CacheProfileName;
+    static?: CacheProfileName;
+  };
+  /** Additional loaders to merge into the map (site-specific). */
+  extra?: Record<string, CommerceLoaderFn>;
+}
+
+const PAGE_URL_HEADER = "x-deco-page-url";
+
+/**
+ * Resolve the real page URL for the productListingPage loader. Wake's PLP reads
+ * the URL from `props.pageHref`; the framework injects `__pageUrl`, but on CSR
+ * home navigations that is unreliable, so an explicit `x-deco-page-url` header
+ * (set by the site) wins, then `__pageUrl`, then the worker request URL.
+ */
+function resolvePageHref(props: any): string | undefined {
+  try {
+    const headerUrl = RequestContext.request.headers.get(PAGE_URL_HEADER);
+    if (headerUrl) return new URL(headerUrl, "http://localhost").href;
+  } catch {
+    // RequestContext may be unavailable in isolated calls.
+  }
+  if (props?.__pageUrl) {
+    try {
+      return new URL(props.__pageUrl, "http://localhost").href;
+    } catch {
+      // ignore malformed injected URL
+    }
+  }
+  try {
+    return new URL(RequestContext.request.url).href;
+  } catch {
+    return props?.pageHref;
+  }
+}
+
+/** Bridge `__pagePath` → `slug` when the CMS doesn't set slug explicitly. */
+function pdpWithSlugFallback(props: any): Promise<any> {
+  if ((!props.slug || props.slug.length === 0) && props.__pagePath) {
+    props = { ...props, slug: props.__pagePath };
+  }
+  return productDetailsPage(props);
+}
+
+export function createWakeCommerceLoaders(
+  options?: WakeCommerceLoadersOptions,
+): Record<string, CommerceLoaderFn> {
+  const profiles = {
+    listing: options?.cacheProfiles?.listing ?? "listing",
+    product: options?.cacheProfiles?.product ?? "product",
+    search: options?.cacheProfiles?.search ?? "search",
+    static: options?.cacheProfiles?.static ?? "static",
+  };
+
+  const cachedPDP = createCachedLoader(
+    "wake/productDetailsPage",
+    pdpWithSlugFallback,
+    profiles.product,
+  );
+  const _cachedPLP = createCachedLoader(
+    "wake/productListingPage",
+    productListingPage,
+    profiles.listing,
+  );
+  const cachedProductList = createCachedLoader("wake/productList", productList, profiles.listing);
+  const cachedSuggestion = createCachedLoader("wake/suggestion", suggestion, profiles.search);
+  const cachedRecommendations = createCachedLoader(
+    "wake/recommendations",
+    recommendations,
+    profiles.product,
+  );
+  const cachedShop = createCachedLoader("wake/shop", shopLoader, profiles.static);
+  const cachedPartners = createCachedLoader("wake/partners", partnersLoader, profiles.static);
+
+  // PLP wrapper: forward the resolved page URL as `pageHref` before caching.
+  const cachedPLP: CommerceLoaderFn = (props) =>
+    _cachedPLP({ ...props, pageHref: resolvePageHref(props) ?? props?.pageHref });
+
+  const loaders: Record<string, CommerceLoaderFn> = {
+    "wake/loaders/productDetailsPage.ts": cachedPDP,
+    "wake/loaders/productListingPage.ts": cachedPLP,
+    "wake/loaders/productList.ts": cachedProductList,
+    "wake/loaders/suggestion.ts": cachedSuggestion,
+    "wake/loaders/recommendations.ts": cachedRecommendations,
+    "wake/loaders/shop.ts": cachedShop,
+    "wake/loaders/partners.ts": cachedPartners,
+  };
+
+  // Register .ts-less aliases for invoke compatibility.
+  const withAliases: Record<string, CommerceLoaderFn> = { ...loaders };
+  for (const key of Object.keys(loaders)) {
+    if (key.endsWith(".ts")) {
+      withAliases[key.slice(0, -3)] = loaders[key];
+    }
+  }
+
+  if (options?.extra) {
+    Object.assign(withAliases, options.extra);
+  }
+
+  return withAliases;
+}

package/src/handlers/sitemap.ts

@@ -0,0 +1,61 @@
+import { withFetchTimeout } from "@decocms/blocks/sdk/fetchTimeout";
+import { getWakeConfig } from "../client";
+
+const fetchSafe = withFetchTimeout();
+
+const BASE_SITEMAP_URL = "https://p-general-sitemap-public.s3.us-east-2.amazonaws.com/Sitemap";
+
+const xmlHeader = '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">';
+
+const includeSiteMaps = (currentXML: string, origin: string, includes?: string[]) => {
+  const siteMapIncludeTags: string[] = [];
+
+  for (const include of includes ?? []) {
+    siteMapIncludeTags.push(`
+      <sitemap>
+          <loc>${include.startsWith("/") ? `${origin}${include}` : include}</loc>
+          <lastmod>${new Date().toISOString().substring(0, 10)}</lastmod>
+      </sitemap>
+    `);
+  }
+
+  return siteMapIncludeTags.length > 0
+    ? currentXML.replace(xmlHeader, `${xmlHeader}\n${siteMapIncludeTags.join("\n")}`)
+    : currentXML;
+};
+
+export interface Props {
+  include?: string[];
+}
+
+/**
+ * @title Sitemap Proxy
+ *
+ * Returns a request handler that proxies the Wake public S3 sitemap for the
+ * configured account, rewriting the public URL to the current origin and
+ * optionally injecting extra `<sitemap>` entries.
+ */
+export default function Sitemap({ include }: Props = {}) {
+  return async (req: Request): Promise<Response> => {
+    const { account } = getWakeConfig();
+
+    if (!account) {
+      throw new Error("Missing account");
+    }
+
+    const publicUrl = `${BASE_SITEMAP_URL}/${encodeURIComponent(account)}/`;
+
+    const response = await fetchSafe(publicUrl);
+
+    const reqUrl = new URL(req.url);
+    const text = await response.text();
+
+    return new Response(
+      includeSiteMaps(text.replaceAll(publicUrl, `${reqUrl.origin}/`), reqUrl.origin, include),
+      {
+        headers: response.headers,
+        status: response.status,
+      },
+    );
+  };
+}

package/src/index.ts

@@ -0,0 +1,58 @@
+// App contract
+
+// Cart actions
+export { default as addItem } from "./actions/cart/addItem";
+export { type CartItem, default as addItems } from "./actions/cart/addItems";
+export { default as updateItemQuantity } from "./actions/cart/updateItemQuantity";
+// Client & Config
+export type { WakeConfig } from "./client";
+export {
+  configureWake,
+  getBaseUrl,
+  getCheckoutUrl,
+  getWakeClient,
+  getWakeConfig,
+  initWakeFromBlocks,
+  setWakeFetch,
+} from "./client";
+// Commerce loaders factory (cached, CMS-registerable map)
+export {
+  type CommerceLoaderFn,
+  createWakeCommerceLoaders,
+  type WakeCommerceLoadersOptions,
+} from "./commerceLoaders";
+// Cart / user / wishlist
+export { default as cartLoader } from "./loaders/cart";
+// Shop / partners
+export { default as partnersLoader } from "./loaders/partners";
+// Product loaders
+export { default as productDetailsPageLoader } from "./loaders/productDetailsPage";
+export { default as productListLoader } from "./loaders/productList";
+export { default as productListingPageLoader } from "./loaders/productListingPage";
+export type { WakeProxyRoute } from "./loaders/proxy";
+export { default as proxyLoader } from "./loaders/proxy";
+export { default as recommendationsLoader } from "./loaders/recommendations";
+export { default as shopLoader } from "./loaders/shop";
+export { default as suggestionLoader } from "./loaders/suggestion";
+export { default as userLoader } from "./loaders/user";
+export { default as wishlistLoader } from "./loaders/wishlist";
+export { configure, type Props, type WakeState } from "./mod";
+// Registry
+export { WAKE_REGISTRY_ENTRY } from "./registry";
+
+// Cookie utils
+export { getCartCookie, setCartCookie, setClientCookie } from "./utils/cart";
+export { getCookies, setCookie } from "./utils/cookies";
+// GraphQL client + fetch instrumentation
+export { extractGraphqlOperationName } from "./utils/graphqlOperationName";
+export { type CreateWakeFetchOptions, createWakeFetch } from "./utils/instrumentedFetch";
+export { wakeOperationRouter } from "./utils/operationRouter";
+export { getPartnerCookie } from "./utils/partner";
+// Transform helpers
+export {
+  parseSlug,
+  toBreadcrumbList,
+  toFilters,
+  toProduct,
+} from "./utils/transform";
+export { getUserCookie } from "./utils/user";

package/src/loaders/cart.ts

@@ -0,0 +1,46 @@
+import { getWakeClient } from "../client";
+import { handleAuthError } from "../utils/authError";
+import { getCartCookie, setCartCookie } from "../utils/cart";
+import { CreateCart, GetCart } from "../utils/graphql/queries";
+import type {
+  CheckoutFragment,
+  CreateCartMutation,
+  GetCartQuery,
+} from "../utils/graphql/storefront.graphql.gen";
+import {
+  currentRequestHeaders,
+  currentResponseHeaders,
+  forwardedHeaders,
+} from "../utils/requestCtx";
+
+/**
+ * @title Wake Integration
+ * @description Cart loader
+ */
+const loader = async (): Promise<Partial<CheckoutFragment>> => {
+  const storefront = getWakeClient();
+  const cartId = getCartCookie(currentRequestHeaders());
+  const headers = forwardedHeaders();
+
+  let data: GetCartQuery | CreateCartMutation;
+  try {
+    data = cartId
+      ? await storefront.query<GetCartQuery>(GetCart, { checkoutId: cartId }, headers)
+      : await storefront.query<CreateCartMutation>(CreateCart, {}, headers);
+  } catch (error: unknown) {
+    handleAuthError(error, "load cart");
+  }
+
+  const checkoutId = data.checkout?.checkoutId;
+
+  if (checkoutId && cartId !== checkoutId) {
+    setCartCookie(currentResponseHeaders(), checkoutId);
+  }
+
+  return data.checkout ?? {};
+};
+
+export default loader;
+
+// User-specific cart data; must not be cached/shared.
+export const cache = "no-store";

package/src/loaders/partners.ts

@@ -0,0 +1,58 @@
+import { getWakeClient } from "../client";
+import { handleAuthError } from "../utils/authError";
+import { GetPartners } from "../utils/graphql/queries";
+import type { GetPartnersQuery } from "../utils/graphql/storefront.graphql.gen";
+import { getPartnerCookie } from "../utils/partner";
+import { currentRequestHeaders, forwardedHeaders } from "../utils/requestCtx";
+import type { RequestURLParam } from "../utils/types";
+
+export interface Props {
+  slug: RequestURLParam;
+}
+
+/**
+ * @title Wake Integration - Partners
+ * @description Partners loader
+ */
+const loader = async (props: Props): Promise<GetPartnersQuery["partners"]> => {
+  const storefront = getWakeClient();
+  const { slug } = props;
+
+  const headers = forwardedHeaders();
+
+  // Guard against missing slug to prevent querying with [undefined]
+  if (!slug) {
+    return undefined;
+  }
+
+  let data: GetPartnersQuery | undefined;
+  try {
+    data = await storefront.query<GetPartnersQuery>(
+      GetPartners,
+      { first: 1, alias: [slug] },
+      headers,
+    );
+  } catch (error: unknown) {
+    handleAuthError(error, "load partner information");
+  }
+
+  return data?.partners ?? undefined;
+};
+
+export const cache = "stale-while-revalidate";
+
+export const cacheKey = (props: Props): string | null => {
+  // Don't cache if no slug is provided
+  if (!props.slug) {
+    return null;
+  }
+
+  // Don't cache if partner cookie is present - partner-specific content should not be cached
+  if (getPartnerCookie(currentRequestHeaders())) {
+    return null;
+  }
+
+  return `wake:partners:${props.slug}:1`;
+};
+
+export default loader;