@decocms/apps-nuvemshop 7.75.0 → 7.77.0

package/src/actions/createCheckout.ts

@@ -1,4 +1,4 @@
-import { nuvemshopPost } from "../client";
+import { NuvemshopApiError, nuvemshopPost } from "../client";
 import type { NuvemshopCheckout, NuvemshopLineItem } from "../utils/types";
 
 export interface CartItem {
@@ -12,25 +12,53 @@ export interface Props {
   coupon?: string;
 }
 
+export type CheckoutErrorCode =
+  | "coupon_rejected"
+  | "out_of_stock"
+  | "unavailable"
+  | "invalid"
+  | "unknown";
+
+export type CreateCheckoutResult =
+  | { checkoutUrl: string }
+  | { error: CheckoutErrorCode; message: string };
+
+// API error code → what the buyer can act on.
+const ERRORS: Record<string, CheckoutErrorCode> = {
+  coupon_rejected: "coupon_rejected",
+  checkout_rejected: "out_of_stock", // returned when a line exceeds the variant's stock
+  resource_not_found: "unavailable",
+  invalid_request: "invalid",
+};
+
 /**
  * @title Nuvemshop - Create Checkout
  * @description Opens a Nuvemshop cart with the items (and coupon) and returns the hosted checkout URL.
+ * Failures come back as `{ error, message }` (rejected coupon, stock, removed variant) instead of throwing.
  */
 export default async function createCheckout(
   props: Props,
   req?: Request,
-): Promise<{ checkoutUrl: string }> {
-  if (!props.items?.length) throw new Error("Cannot checkout an empty cart");
+): Promise<CreateCheckoutResult> {
+  if (!props?.items?.length) return { error: "invalid", message: "Cannot checkout an empty cart" };
   const line_items: NuvemshopLineItem[] = props.items.map((i) => ({
     product_id: i.productId,
     variant_id: i.variantId,
     quantity: i.quantity,
   }));
   const coupon_code = props.coupon?.trim() || undefined;
-  const res = await nuvemshopPost<NuvemshopCheckout>(
-    "/checkouts",
-    { line_items, coupon_code },
-    { buyerIp: req?.headers.get("cf-connecting-ip") },
-  );
-  return { checkoutUrl: res.checkout_url };
+  try {
+    const res = await nuvemshopPost<NuvemshopCheckout>(
+      "/checkouts",
+      { line_items, coupon_code },
+      { buyerIp: req?.headers.get("cf-connecting-ip") },
+    );
+    return { checkoutUrl: res.checkout_url };
+  } catch (e) {
+    if (!(e instanceof NuvemshopApiError)) throw e;
+    return {
+      error: ERRORS[e.code] ?? "unknown",
+      message: e.message.replace(/^Nuvemshop \d+ [\w-]*: /, ""),
+    };
+  }
 }

package/src/admin.ts

@@ -0,0 +1,23 @@
+/**
+ * Nuvemshop Admin API (`api.nuvemshop.com.br/v1/<store>`) — server-only.
+ * Authenticated with a custom-app token (`adminToken`); used for what the
+ * Storefront API lacks: customer registration (no reCAPTCHA) and account data.
+ */
+import { getNuvemshopConfig, nuvemshopFetch } from "./client";
+
+const ADMIN_BASE = "https://api.nuvemshop.com.br/v1";
+
+export async function nuvemshopAdmin(path: string, init: { method?: string; body?: unknown } = {}) {
+  const { storeId, adminToken } = getNuvemshopConfig();
+  if (!adminToken) throw new Error("Nuvemshop adminToken is not configured (custom app token)");
+  return nuvemshopFetch(`${ADMIN_BASE}/${storeId}${path}`, {
+    method: init.method ?? "GET",
+    headers: {
+      authentication: `bearer ${adminToken}`,
+      // Nuvemshop requires an identifying User-Agent on Admin API calls.
+      "user-agent": "deco.cx storefront (https://deco.cx)",
+      ...(init.body !== undefined && { "content-type": "application/json" }),
+    },
+    body: init.body === undefined ? undefined : JSON.stringify(init.body),
+  });
+}

package/src/client.ts

@@ -32,6 +32,21 @@ export interface NuvemshopConfig {
    * category's configured sort and returns oldest-first. Default "created-descending".
    */
   defaultSort?: string;
+  /**
+   * The store's own domain (e.g. https://demodeco.lojavirtualnuvem.com.br).
+   * Needed for the session endpoints the API doesn't cover (login/logout/account).
+   */
+  storeUrl?: string;
+  /**
+   * Admin API token from a custom app (Configurações → Aplicativos sob medida).
+   * Server-only: used for customer registration and account data. It is NOT a
+   * Storefront token (the Storefront API rejects it).
+   */
+  adminToken?: string;
+  /** Cloudflare Turnstile secret, verified before registering a customer. */
+  turnstileSecret?: string;
+  /** Skip bot verification on registration (demos only — the Admin API has no captcha). */
+  allowUnverifiedRegistration?: boolean;
 }
 
 /**
@@ -100,6 +115,9 @@ export function clearNuvemshopCache() {
 
 const transport = () => (_fetch ??= createNuvemshopFetch() as FetchFn);
 
+/** The instrumented transport shared by every Nuvemshop egress (Storefront, store, Admin). */
+export const nuvemshopFetch: FetchFn = (input, init) => transport()(input, init);
+
 function storeUrl(path: string, params: Record<string, string | number | undefined> = {}) {
   const {
     storeId,
@@ -123,12 +141,26 @@ function headers(extra?: Record<string, string>) {
   };
 }
 
+/** A non-2xx Storefront API response, with the API's `error.code` (e.g. `coupon_rejected`). */
+export class NuvemshopApiError extends Error {
+  constructor(
+    readonly status: number,
+    readonly code: string,
+    message: string,
+  ) {
+    super(`Nuvemshop ${status} ${code}: ${message}`);
+    this.name = "NuvemshopApiError";
+  }
+}
+
 async function errorFrom(res: Response) {
   const body = (await res.json().catch(() => null)) as {
     error?: { code?: string; message?: string };
   } | null;
-  return new Error(
-    `Nuvemshop ${res.status} ${body?.error?.code ?? ""}: ${body?.error?.message ?? res.statusText}`,
+  return new NuvemshopApiError(
+    res.status,
+    body?.error?.code ?? "",
+    body?.error?.message ?? res.statusText,
   );
 }
 

package/src/hooks/__tests__/useCart.test.ts

@@ -2,8 +2,10 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 import {
   addItem,
   CART_STORAGE_KEY,
+  CheckoutError,
   cartStore,
   checkout,
+  fetchCartDetails,
   removeItem,
   setQuantity,
 } from "../useCart";
@@ -69,6 +71,20 @@ describe("checkout", () => {
     fetchSpy.mockRestore();
   });
 
+  it("throws a typed CheckoutError (e.g. rejected coupon) instead of navigating", async () => {
+    const fetchSpy = vi
+      .spyOn(globalThis, "fetch")
+      .mockResolvedValue(
+        new Response(JSON.stringify({ error: "coupon_rejected", message: "nope" })),
+      );
+    const navigate = vi.fn();
+    const err = await checkout([shirt], "BAD", navigate).catch((e) => e);
+    expect(err).toBeInstanceOf(CheckoutError);
+    expect(err.code).toBe("coupon_rejected");
+    expect(navigate).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+
   it("throws the server error instead of navigating", async () => {
     const fetchSpy = vi
       .spyOn(globalThis, "fetch")
@@ -79,3 +95,24 @@ describe("checkout", () => {
     fetchSpy.mockRestore();
   });
 });
+
+describe("fetchCartDetails", () => {
+  it("invokes the cart loader with the items and returns its result", async () => {
+    const details = { lines: [], itemCount: 0, subtotal: 0 };
+    const fetchSpy = vi
+      .spyOn(globalThis, "fetch")
+      .mockResolvedValue(new Response(JSON.stringify(details)));
+    expect(await fetchCartDetails([shirt])).toEqual(details);
+    const [url, init] = fetchSpy.mock.calls[0];
+    expect(url).toBe("/deco/invoke/nuvemshop/loaders/cart");
+    expect(JSON.parse(String(init!.body))).toEqual({ items: [shirt] });
+    fetchSpy.mockRestore();
+  });
+
+  it("skips the request for an empty cart", async () => {
+    const fetchSpy = vi.spyOn(globalThis, "fetch");
+    expect(await fetchCartDetails([])).toBeNull();
+    expect(fetchSpy).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+});

package/src/hooks/useCart.ts

@@ -14,10 +14,22 @@
  * <button onClick={() => addItem({ productId, variantId, quantity: 1 })}>Comprar</button>
  * ```
  */
-import { useSyncExternalStore } from "react";
-import type { CartItem } from "../actions/createCheckout";
+import { useEffect, useState, useSyncExternalStore } from "react";
+import type { CartItem, CheckoutErrorCode, CreateCheckoutResult } from "../actions/createCheckout";
+import type { Cart } from "../loaders/cart";
 
-export type { CartItem };
+export type { Cart, CartItem, CheckoutErrorCode };
+
+/** A checkout the buyer can fix: rejected coupon, stock changed, variant removed… */
+export class CheckoutError extends Error {
+  constructor(
+    readonly code: CheckoutErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "CheckoutError";
+  }
+}
 
 export const CART_STORAGE_KEY = "nuvemshop:cart";
 /** The API sums repeated variants up to 99. */
@@ -96,8 +108,42 @@ export async function checkout(
     body: JSON.stringify({ items, coupon }),
   });
   if (!res.ok) throw new Error(`Checkout failed (${res.status}): ${await res.text()}`);
-  const { checkoutUrl } = (await res.json()) as { checkoutUrl: string };
-  navigate(checkoutUrl);
+  const result = (await res.json()) as CreateCheckoutResult;
+  if ("error" in result) throw new CheckoutError(result.error, result.message);
+  navigate(result.checkoutUrl);
+}
+
+/** Minicart data (names, images, prices, totals) for the given items, from the `cart` loader. */
+export async function fetchCartDetails(items: CartItem[]): Promise<Cart | null> {
+  if (!items.length) return null;
+  const res = await fetch("/deco/invoke/nuvemshop/loaders/cart", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ items }),
+  });
+  if (!res.ok) throw new Error(`Cart failed (${res.status})`);
+  return (await res.json()) as Cart;
+}
+
+/** `useCart()` items resolved into minicart data; refetches when the items change. */
+export function useCartDetails() {
+  const items = useSyncExternalStore(cartStore.subscribe, cartStore.get, () => EMPTY);
+  const [state, setState] = useState<{ cart: Cart | null; loading: boolean; error?: Error }>({
+    cart: null,
+    loading: false,
+  });
+  useEffect(() => {
+    let live = true;
+    setState((s) => ({ ...s, loading: true }));
+    fetchCartDetails(items).then(
+      (cart) => live && setState({ cart, loading: false }),
+      (error: Error) => live && setState((s) => ({ ...s, loading: false, error })),
+    );
+    return () => {
+      live = false;
+    };
+  }, [items]);
+  return state;
 }
 
 export function useCart() {

package/src/index.ts

@@ -1,14 +1,19 @@
+export { default as login } from "./actions/account/login";
+export { default as logout } from "./actions/account/logout";
+export { default as register } from "./actions/account/register";
 export { default as createCheckout } from "./actions/createCheckout";
 export {
   clearNuvemshopCache,
   configureNuvemshop,
   getNuvemshopConfig,
+  NuvemshopApiError,
   type NuvemshopConfig,
   nuvemshopGet,
   nuvemshopPost,
   PRODUCT_FIELDS,
   setNuvemshopFetch,
 } from "./client";
+export { default as cart } from "./loaders/cart";
 export { default as categories } from "./loaders/categories";
 export { default as productDetailsPage } from "./loaders/productDetailsPage";
 export { default as productList } from "./loaders/productList";
@@ -16,8 +21,10 @@ export { default as productListingPage } from "./loaders/productListingPage";
 export { default as relatedProducts } from "./loaders/relatedProducts";
 export { default as shippingOptions } from "./loaders/shippingOptions";
 export { default as suggestions } from "./loaders/suggestions";
+export { default as user } from "./loaders/user";
 export { configure } from "./mod";
 export { NUVEMSHOP_REGISTRY_ENTRY } from "./registry";
 export { createNuvemshopFetch } from "./utils/instrumentedFetch";
 export { nuvemshopOperationRouter } from "./utils/operationRouter";
+export { nuvemshopSitemap } from "./utils/sitemap";
 export type * from "./utils/types";

package/src/loaders/cart.ts

@@ -0,0 +1,108 @@
+import type { CartItem } from "../actions/createCheckout";
+import { getNuvemshopConfig, nuvemshopGet } from "../client";
+import { originOf, type PageProps } from "../utils/request";
+import { isAvailable, productPath, variantPrices } from "../utils/transform";
+import type { NuvemshopList, NuvemshopProduct } from "../utils/types";
+
+export interface Props extends PageProps {
+  /** Items held by the client cart (`useCart`). */
+  items: CartItem[];
+}
+
+export interface CartLine extends CartItem {
+  name: string;
+  variantName: string;
+  image?: string;
+  url: string;
+  price: number;
+  listPrice: number;
+  subtotal: number;
+  /** Most the checkout will accept for this variant (stock, capped at 99). */
+  maxQuantity: number;
+  /** `quantity` was lowered to `maxQuantity`. */
+  adjusted?: boolean;
+}
+
+export interface Cart {
+  lines: CartLine[];
+  unavailable: (CartItem & { reason: "not_found" | "out_of_stock" })[];
+  itemCount: number;
+  subtotal: number;
+  listSubtotal: number;
+  savings: number;
+  currency: string;
+}
+
+const MAX_PER_VARIANT = 99;
+const IDS_PER_REQUEST = 30; // API limit for `ids`
+const cents = (n: number) => Math.round(n * 100) / 100;
+
+/**
+ * @title Nuvemshop - Cart
+ * @description Minicart data for the client-held items: names, images, prices, totals and savings,
+ * fresh from the Storefront API. Quantities are clamped to stock so the checkout won't reject them.
+ * No coupon preview (the API has none) — the coupon is validated when the checkout is created.
+ */
+export default async function cart(props: Props, req?: Request): Promise<Cart> {
+  const { currency = "BRL" } = getNuvemshopConfig();
+  const items = props?.items ?? [];
+  const ids = [...new Set(items.map((i) => i.productId))];
+  const products = new Map<number, NuvemshopProduct>();
+  for (let i = 0; i < ids.length; i += IDS_PER_REQUEST) {
+    const list = await nuvemshopGet<NuvemshopList<NuvemshopProduct>>("/products", {
+      ids: ids.slice(i, i + IDS_PER_REQUEST).join(","),
+      per_page: IDS_PER_REQUEST,
+    });
+    for (const p of list?.data ?? []) products.set(p.id, p);
+  }
+
+  const origin = originOf(props, req);
+  const lines: CartLine[] = [];
+  const unavailable: Cart["unavailable"] = [];
+  for (const item of items) {
+    const product = products.get(item.productId);
+    const variant = product?.variants?.find((v) => v.id === item.variantId);
+    if (!product || !variant || variant.visible === false) {
+      unavailable.push({ ...item, reason: "not_found" });
+      continue;
+    }
+    if (!isAvailable(variant)) {
+      unavailable.push({ ...item, reason: "out_of_stock" });
+      continue;
+    }
+    const maxQuantity = Math.min(
+      variant.stock_management && variant.stock != null ? variant.stock : MAX_PER_VARIANT,
+      MAX_PER_VARIANT,
+    );
+    const quantity = Math.min(Math.max(1, item.quantity), maxQuantity);
+    const { price, listPrice } = variantPrices(variant);
+    const image = product.images?.find((i) => i.id === variant.image_id) ?? product.images?.[0];
+    lines.push({
+      ...item,
+      quantity,
+      maxQuantity,
+      ...(quantity !== item.quantity && { adjusted: true }),
+      name: product.name,
+      variantName: variant.values.join(" / "),
+      image: image?.src,
+      url: `${origin}${productPath(product.handle)}?variant=${variant.id}`,
+      price,
+      listPrice,
+      subtotal: cents(price * quantity),
+    });
+  }
+
+  const subtotal = cents(lines.reduce((s, l) => s + l.subtotal, 0));
+  const listSubtotal = cents(lines.reduce((s, l) => s + l.listPrice * l.quantity, 0));
+  return {
+    lines,
+    unavailable,
+    itemCount: lines.reduce((n, l) => n + l.quantity, 0),
+    subtotal,
+    listSubtotal,
+    savings: cents(listSubtotal - subtotal),
+    currency,
+  };
+}
+
+export const cache = "no-store";

package/src/loaders/user.ts

@@ -0,0 +1,30 @@
+import { nuvemshopAdmin } from "../admin";
+import { getNuvemshopConfig } from "../client";
+import { storeCookies, storeFetch } from "../store";
+
+export interface NuvemshopUser {
+  id: number;
+  name?: string;
+  email?: string;
+  phone?: string | null;
+}
+
+/**
+ * @title Nuvemshop - Logged-in customer
+ * @description The buyer's account from the store session (null when logged out).
+ * Reads the customer id from the store's account page and the profile from the Admin API.
+ */
+export default async function user(_props: unknown): Promise<NuvemshopUser | null> {
+  if (!storeCookies()) return null;
+  const page = await storeFetch("/account/");
+  if (page.status !== 200) return null;
+  const id = Number((await page.text()).match(/LS\.customer\s*=\s*(\d+)/)?.[1]);
+  if (!id) return null;
+  if (!getNuvemshopConfig().adminToken) return { id };
+  const res = await nuvemshopAdmin(`/customers/${id}`);
+  if (!res.ok) return { id };
+  const c = (await res.json()) as NuvemshopUser;
+  return { id: c.id, name: c.name, email: c.email, phone: c.phone };
+}
+
+export const cache = "no-store";

package/src/manifest.gen.ts

@@ -1,7 +1,11 @@
 // Hand-maintained (the generate-manifests script referenced by other apps doesn't exist).
 // Keys are the `__resolveType` / `/deco/invoke/<key>` names.
 
+import * as actions_account_login from "./actions/account/login";
+import * as actions_account_logout from "./actions/account/logout";
+import * as actions_account_register from "./actions/account/register";
 import * as actions_createCheckout from "./actions/createCheckout";
+import * as loaders_cart from "./loaders/cart";
 import * as loaders_categories from "./loaders/categories";
 import * as loaders_productDetailsPage from "./loaders/productDetailsPage";
 import * as loaders_productList from "./loaders/productList";
@@ -9,10 +13,12 @@ import * as loaders_productListingPage from "./loaders/productListingPage";
 import * as loaders_relatedProducts from "./loaders/relatedProducts";
 import * as loaders_shippingOptions from "./loaders/shippingOptions";
 import * as loaders_suggestions from "./loaders/suggestions";
+import * as loaders_user from "./loaders/user";
 
 const manifest = {
   name: "nuvemshop",
   loaders: {
+    "nuvemshop/loaders/cart": loaders_cart,
     "nuvemshop/loaders/categories": loaders_categories,
     "nuvemshop/loaders/productDetailsPage": loaders_productDetailsPage,
     "nuvemshop/loaders/productList": loaders_productList,
@@ -20,8 +26,12 @@ const manifest = {
     "nuvemshop/loaders/relatedProducts": loaders_relatedProducts,
     "nuvemshop/loaders/shippingOptions": loaders_shippingOptions,
     "nuvemshop/loaders/suggestions": loaders_suggestions,
+    "nuvemshop/loaders/user": loaders_user,
   },
   actions: {
+    "nuvemshop/actions/account/login": actions_account_login,
+    "nuvemshop/actions/account/logout": actions_account_logout,
+    "nuvemshop/actions/account/register": actions_account_register,
     "nuvemshop/actions/createCheckout": actions_createCheckout,
   },
   sections: {},

package/src/mod.ts

@@ -47,6 +47,27 @@ export interface Props {
    * @default v2026-11
    */
   apiVersion?: string;
+  /**
+   * @title Store URL
+   * @description The store's own domain (e.g. https://minhaloja.lojavirtualnuvem.com.br). Required for login/logout/account.
+   */
+  storeUrl?: string;
+  /**
+   * @title Admin API token
+   * @description Custom app token (Configurações → Aplicativos sob medida). Server-only; enables registration and account data.
+   */
+  adminToken?: Secret;
+  /**
+   * @title Turnstile secret
+   * @description Cloudflare Turnstile secret verified before registering customers (the Admin API has no captcha).
+   */
+  turnstileSecret?: Secret;
+  /**
+   * @title Allow registration without bot verification
+   * @description Demos only.
+   * @default false
+   */
+  allowUnverifiedRegistration?: boolean;
 }
 
 export interface NuvemshopState {
@@ -64,9 +85,19 @@ export async function configure(
     (await resolveSecret(block.token, "NUVEMSHOP_STOREFRONT_TOKEN")) ??
     (typeof block.token === "string" ? block.token : undefined);
 
+  const secret = async (key: string, env: string) =>
+    (await resolveSecret(block[key], env)) ??
+    (typeof block[key] === "string" ? (block[key] as string) : undefined);
+  const adminToken = await secret("adminToken", "NUVEMSHOP_ADMIN_TOKEN");
+  const turnstileSecret = await secret("turnstileSecret", "NUVEMSHOP_TURNSTILE_SECRET");
+
   const config: NuvemshopConfig = {
     storeId,
     token: token || undefined,
+    storeUrl: block.storeUrl as string | undefined,
+    adminToken: adminToken || undefined,
+    turnstileSecret: turnstileSecret || undefined,
+    allowUnverifiedRegistration: block.allowUnverifiedRegistration === true,
     apiVersion: block.apiVersion as string | undefined,
     currency: block.currency as string | undefined,
     defaultSort: block.defaultSort as string | undefined,

package/src/store.ts

@@ -0,0 +1,88 @@
+/**
+ * The store's own (theme) session endpoints — the parts the Storefront API
+ * doesn't cover: login, logout and the logged-in account page.
+ *
+ * The session lives in the store's cookies (`store_session_payload_<id>`,
+ * `store_login_session`, …). We forward only those (`store_*`) upstream —
+ * never the site's own cookies — and re-emit the store's `Set-Cookie` on our
+ * domain through `RequestContext.responseHeaders`, so the browser keeps one
+ * session that follows it across our pages.
+ */
+import { RequestContext } from "@decocms/blocks/sdk/requestContext";
+import { getNuvemshopConfig, nuvemshopFetch } from "./client";
+
+const STORE_COOKIE = /^store_/;
+
+export function storeOrigin(): string {
+  const { storeUrl } = getNuvemshopConfig();
+  if (!storeUrl) throw new Error("Nuvemshop storeUrl is not configured (the store's own domain)");
+  return new URL(storeUrl).origin;
+}
+
+/** `store_*` cookies of the current request, as a Cookie header ("" when none). */
+export function storeCookies(): string {
+  const raw = RequestContext.current?.request.headers.get("cookie") ?? "";
+  return raw
+    .split(/;\s*/)
+    .filter((c) => STORE_COOKIE.test(c))
+    .join("; ");
+}
+
+function rewriteDomain(cookie: string, host: string | null) {
+  return host
+    ? cookie.replace(/(;\s*)domain=[^;]*/i, `$1Domain=${host}`)
+    : cookie.replace(/;\s*domain=[^;]*/gi, "");
+}
+
+/** Merge upstream Set-Cookie values into a Cookie header (for follow-up calls in the same action). */
+function mergeCookies(header: string, setCookies: string[]) {
+  const jar = new Map(header ? header.split(/;\s*/).map((c) => [c.split("=")[0], c] as const) : []);
+  for (const s of setCookies) {
+    const kv = s.split(";")[0];
+    const name = kv.split("=")[0];
+    if (STORE_COOKIE.test(name)) jar.set(name, kv);
+  }
+  return [...jar.values()].join("; ");
+}
+
+export interface StoreResponse {
+  status: number;
+  location: string | null;
+  text: () => Promise<string>;
+}
+
+/**
+ * Calls the store with the buyer's store session and forwards any new
+ * session cookies to the browser. `cookie` overrides the request's cookies
+ * (used to chain calls inside one action). Redirects are not followed.
+ */
+export async function storeFetch(
+  path: string,
+  init: { method?: "GET" | "POST"; form?: Record<string, string>; cookie?: string } = {},
+): Promise<StoreResponse & { cookie: string }> {
+  const origin = storeOrigin();
+  const cookie = init.cookie ?? storeCookies();
+  const headers: Record<string, string> = { origin, referer: `${origin}${path}` };
+  if (init.form) headers["content-type"] = "application/x-www-form-urlencoded";
+  if (cookie) headers.cookie = cookie;
+  const res = await nuvemshopFetch(`${origin}${path}`, {
+    method: init.method ?? "GET",
+    headers,
+    body: init.form ? new URLSearchParams(init.form).toString() : undefined,
+    redirect: "manual",
+  });
+  const setCookies = res.headers.getSetCookie();
+  const ctx = RequestContext.current;
+  if (ctx) {
+    const host = new URL(ctx.request.url).hostname;
+    for (const c of setCookies) {
+      if (STORE_COOKIE.test(c)) ctx.responseHeaders.append("set-cookie", rewriteDomain(c, host));
+    }
+  }
+  return {
+    status: res.status,
+    location: res.headers.get("location"),
+    text: () => res.text(),
+    cookie: mergeCookies(cookie, setCookies),
+  };
+}