@decocms/apps 0.23.3 → 0.24.0

package/vtex/loaders/logistics.ts

@@ -18,22 +18,22 @@ import { vtexFetch } from "../client";
 // ---------------------------------------------------------------------------
 
 export interface ProductBalance {
-  warehouseId: string;
-  warehouseName: string;
-  totalQuantity: number;
-  reservedQuantity: number;
-  hasUnlimitedQuantity: boolean;
+	warehouseId: string;
+	warehouseName: string;
+	totalQuantity: number;
+	reservedQuantity: number;
+	hasUnlimitedQuantity: boolean;
 }
 
 export interface PickupPointsByLocationOpts {
-  geoCoordinates?: number[];
-  postalCode?: string;
-  countryCode?: string;
+	geoCoordinates?: number[];
+	postalCode?: string;
+	countryCode?: string;
 }
 
 export interface PickupPointsResponse<T = any> {
-  paging: { page: number; pageSize: number; total: number; pages: number };
-  items: Array<{ distance: number; pickupPoint: T }>;
+	paging: { page: number; pageSize: number; total: number; pages: number };
+	items: Array<{ distance: number; pickupPoint: T }>;
 }
 
 // ---------------------------------------------------------------------------
@@ -45,7 +45,7 @@ export interface PickupPointsResponse<T = any> {
  * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/saleschannel/-salesChannelId-
  */
 export async function getSalesChannelById<T = any>(id: string): Promise<T> {
-  return vtexFetch<T>(`/api/catalog_system/pub/saleschannel/${id}`);
+	return vtexFetch<T>(`/api/catalog_system/pub/saleschannel/${id}`);
 }
 
 /**
@@ -53,7 +53,7 @@ export async function getSalesChannelById<T = any>(id: string): Promise<T> {
  * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pvt/saleschannel/list
  */
 export async function listSalesChannels<T = any>(): Promise<T[]> {
-  return vtexFetch<T[]>("/api/catalog_system/pvt/saleschannel/list");
+	return vtexFetch<T[]>("/api/catalog_system/pvt/saleschannel/list");
 }
 
 // ---------------------------------------------------------------------------
@@ -65,7 +65,7 @@ export async function listSalesChannels<T = any>(): Promise<T[]> {
  * @see https://developers.vtex.com/docs/api-reference/logistics-api#get-/api/logistics/pvt/configuration/pickuppoints
  */
 export async function listPickupPoints<T = any>(): Promise<T[]> {
-  return vtexFetch<T[]>("/api/logistics/pvt/configuration/pickuppoints");
+	return vtexFetch<T[]>("/api/logistics/pvt/configuration/pickuppoints");
 }
 
 /**
@@ -75,19 +75,17 @@ export async function listPickupPoints<T = any>(): Promise<T[]> {
  * @see https://developers.vtex.com/docs/api-reference/checkout-api#get-/api/checkout/pub/pickup-points
  */
 export async function listPickupPointsByLocation<T = any>(
-  opts: PickupPointsByLocationOpts,
+	opts: PickupPointsByLocationOpts,
 ): Promise<PickupPointsResponse<T>> {
-  const params = new URLSearchParams();
-  if (opts.geoCoordinates) {
-    params.set("geoCoordinates", opts.geoCoordinates.join(","));
-  } else {
-    if (opts.postalCode) params.set("postalCode", opts.postalCode);
-    if (opts.countryCode) params.set("countryCode", opts.countryCode);
-  }
+	const params = new URLSearchParams();
+	if (opts.geoCoordinates) {
+		params.set("geoCoordinates", opts.geoCoordinates.join(","));
+	} else {
+		if (opts.postalCode) params.set("postalCode", opts.postalCode);
+		if (opts.countryCode) params.set("countryCode", opts.countryCode);
+	}
 
-  return vtexFetch<PickupPointsResponse<T>>(
-    `/api/checkout/pub/pickup-points?${params}`,
-  );
+	return vtexFetch<PickupPointsResponse<T>>(`/api/checkout/pub/pickup-points?${params}`);
 }
 
 // ---------------------------------------------------------------------------
@@ -98,18 +96,16 @@ export async function listPickupPointsByLocation<T = any>(
  * List inventory balances for a SKU across all warehouses.
  * @see https://developers.vtex.com/docs/api-reference/logistics-api#get-/api/logistics/pvt/inventory/skus/-skuId-
  */
-export async function listStockByStore(
-  skuId: number,
-): Promise<ProductBalance[]> {
-  try {
-    const result = await vtexFetch<{
-      skuId?: string;
-      balance?: ProductBalance[];
-    }>(`/api/logistics/pvt/inventory/skus/${skuId}`);
+export async function listStockByStore(skuId: number): Promise<ProductBalance[]> {
+	try {
+		const result = await vtexFetch<{
+			skuId?: string;
+			balance?: ProductBalance[];
+		}>(`/api/logistics/pvt/inventory/skus/${skuId}`);
 
-    return result.balance ?? [];
-  } catch (error) {
-    console.error("[listStockByStore]", error);
-    return [];
-  }
+		return result.balance ?? [];
+	} catch (error) {
+		console.error("[listStockByStore]", error);
+		return [];
+	}
 }

package/vtex/loaders/navbar.ts

@@ -7,10 +7,11 @@
  *
  * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/category/tree/-categoryLevels-
  */
+
+import type { SiteNavigationElement } from "../../commerce/types/commerce";
 import { vtexFetch } from "../client";
 import { categoryTreeToNavbar } from "../utils/transform";
 import type { Category } from "../utils/types";
-import type { SiteNavigationElement } from "../../commerce/types/commerce";
 
 /**
  * Fetch the category tree and transform it into an array of
@@ -18,12 +19,8 @@ import type { SiteNavigationElement } from "../../commerce/types/commerce";
  *
  * @param levels - Depth of the category tree (default: 2)
  */
-export async function getNavbar(
-  levels: number = 2,
-): Promise<SiteNavigationElement[]> {
-  const tree = await vtexFetch<Category[]>(
-    `/api/catalog_system/pub/category/tree/${levels}`,
-  );
+export async function getNavbar(levels: number = 2): Promise<SiteNavigationElement[]> {
+	const tree = await vtexFetch<Category[]>(`/api/catalog_system/pub/category/tree/${levels}`);
 
-  return categoryTreeToNavbar(tree);
+	return categoryTreeToNavbar(tree);
 }

package/vtex/loaders/orders.ts

@@ -20,13 +20,10 @@ import { vtexFetch } from "../client";
  *
  * @see https://developers.vtex.com/docs/api-reference/orders-api#get-/api/oms/user/orders/-orderId-
  */
-export async function getOrderById<T = any>(
-  orderId: string,
-  authCookie: string,
-): Promise<T> {
-  return vtexFetch<T>(`/api/oms/user/orders/${orderId}`, {
-    headers: { cookie: authCookie },
-  });
+export async function getOrderById<T = any>(orderId: string, authCookie: string): Promise<T> {
+	return vtexFetch<T>(`/api/oms/user/orders/${orderId}`, {
+		headers: { cookie: authCookie },
+	});
 }
 
 // ---------------------------------------------------------------------------
@@ -34,9 +31,9 @@ export async function getOrderById<T = any>(
 // ---------------------------------------------------------------------------
 
 export interface ListOrdersOpts {
-  clientEmail: string;
-  page?: string;
-  perPage?: string;
+	clientEmail: string;
+	page?: string;
+	perPage?: string;
 }
 
 /**
@@ -45,20 +42,17 @@ export interface ListOrdersOpts {
  *
  * @see https://developers.vtex.com/docs/api-reference/orders-api#get-/api/oms/user/orders
  */
-export async function listOrders<T = any>(
-  opts: ListOrdersOpts,
-  authCookie: string,
-): Promise<T> {
-  const { clientEmail, page = "0", perPage = "15" } = opts;
-  const params = new URLSearchParams({
-    clientEmail,
-    page,
-    per_page: perPage,
-  });
+export async function listOrders<T = any>(opts: ListOrdersOpts, authCookie: string): Promise<T> {
+	const { clientEmail, page = "0", perPage = "15" } = opts;
+	const params = new URLSearchParams({
+		clientEmail,
+		page,
+		per_page: perPage,
+	});
 
-  return vtexFetch<T>(`/api/oms/user/orders?${params}`, {
-    headers: { cookie: authCookie },
-  });
+	return vtexFetch<T>(`/api/oms/user/orders?${params}`, {
+		headers: { cookie: authCookie },
+	});
 }
 
 // ---------------------------------------------------------------------------
@@ -81,23 +75,18 @@ export async function listOrders<T = any>(
  *
  * @see https://developers.vtex.com/docs/api-reference/checkout-api#get-/api/checkout/pub/orders/order-group/-orderGroupId-
  */
-export async function getOrderPlaced<T = any>(
-  orderId: string,
-  authCookie: string,
-): Promise<T[]> {
-  const isOrderGroup = !orderId.includes("-");
+export async function getOrderPlaced<T = any>(orderId: string, authCookie: string): Promise<T[]> {
+	const isOrderGroup = !orderId.includes("-");
 
-  if (isOrderGroup) {
-    return vtexFetch<T[]>(
-      `/api/checkout/pub/orders/order-group/${orderId}`,
-      { headers: { cookie: authCookie } },
-    );
-  }
+	if (isOrderGroup) {
+		return vtexFetch<T[]>(`/api/checkout/pub/orders/order-group/${orderId}`, {
+			headers: { cookie: authCookie },
+		});
+	}
 
-  const order = await vtexFetch<T>(
-    `/api/checkout/pub/orders/${orderId}`,
-    { headers: { cookie: authCookie } },
-  );
+	const order = await vtexFetch<T>(`/api/checkout/pub/orders/${orderId}`, {
+		headers: { cookie: authCookie },
+	});
 
-  return [order];
+	return [order];
 }

package/vtex/loaders/pageType.ts

@@ -6,20 +6,20 @@
  *
  * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/portal/pagetype/-path-
  */
-import { vtexFetch, type PageType } from "../client";
+import { type PageType, vtexFetch } from "../client";
 
 export type { PageType };
 
 export type VtexPageKind =
-  | "product"
-  | "category"
-  | "department"
-  | "subcategory"
-  | "brand"
-  | "collection"
-  | "search"
-  | "fulltext"
-  | "notfound";
+	| "product"
+	| "category"
+	| "department"
+	| "subcategory"
+	| "brand"
+	| "collection"
+	| "search"
+	| "fulltext"
+	| "notfound";
 
 /**
  * Resolve a URL path to a VTEX page type.
@@ -28,35 +28,41 @@ export type VtexPageKind =
  * @returns The page type with kind normalization, or null on error
  */
 export async function resolvePageType(
-  urlPath: string,
+	urlPath: string,
 ): Promise<{ pageType: PageType; kind: VtexPageKind } | null> {
-  const cleanPath = urlPath.replace(/^\//, "").replace(/\/$/, "");
-  if (!cleanPath) return null;
+	const cleanPath = urlPath.replace(/^\//, "").replace(/\/$/, "");
+	if (!cleanPath) return null;
 
-  try {
-    const pt = await vtexFetch<PageType>(
-      `/api/catalog_system/pub/portal/pagetype/${cleanPath}`,
-    );
+	try {
+		const pt = await vtexFetch<PageType>(`/api/catalog_system/pub/portal/pagetype/${cleanPath}`);
 
-    const kind = normalizeKind(pt.pageType);
-    return { pageType: pt, kind };
-  } catch {
-    return null;
-  }
+		const kind = normalizeKind(pt.pageType);
+		return { pageType: pt, kind };
+	} catch {
+		return null;
+	}
 }
 
 function normalizeKind(pageType: PageType["pageType"]): VtexPageKind {
-  switch (pageType) {
-    case "Product": return "product";
-    case "Category": return "category";
-    case "Department": return "department";
-    case "SubCategory": return "subcategory";
-    case "Brand": return "brand";
-    case "Collection":
-    case "Cluster": return "collection";
-    case "Search": return "search";
-    case "FullText": return "fulltext";
-    case "NotFound":
-    default: return "notfound";
-  }
+	switch (pageType) {
+		case "Product":
+			return "product";
+		case "Category":
+			return "category";
+		case "Department":
+			return "department";
+		case "SubCategory":
+			return "subcategory";
+		case "Brand":
+			return "brand";
+		case "Collection":
+		case "Cluster":
+			return "collection";
+		case "Search":
+			return "search";
+		case "FullText":
+			return "fulltext";
+		default:
+			return "notfound";
+	}
 }

package/vtex/loaders/payment.ts

@@ -13,26 +13,26 @@ import { vtexIOGraphQL } from "../client";
 // ---------------------------------------------------------------------------
 
 export interface PaymentSystem {
-  name: string;
-  groupName: string;
-  requiresDocument: boolean;
-  displayDocument: boolean;
-  validator: {
-    regex: string | null;
-    mask: string | null;
-    cardCodeMask: string | null;
-    cardCodeRegex: string | null;
-  };
+	name: string;
+	groupName: string;
+	requiresDocument: boolean;
+	displayDocument: boolean;
+	validator: {
+		regex: string | null;
+		mask: string | null;
+		cardCodeMask: string | null;
+		cardCodeRegex: string | null;
+	};
 }
 
 export interface Payment {
-  accountStatus: string | null;
-  cardNumber: string;
-  expirationDate: string;
-  id: string;
-  isExpired: boolean;
-  paymentSystem: string;
-  paymentSystemName: string;
+	accountStatus: string | null;
+	cardNumber: string;
+	expirationDate: string;
+	id: string;
+	isExpired: boolean;
+	paymentSystem: string;
+	paymentSystemName: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -58,17 +58,12 @@ const PAYMENT_SYSTEMS_QUERY = `query getPaymentSystems {
  * List available payment systems for the authenticated user.
  * Requires a valid VTEX auth cookie.
  */
-export async function getPaymentSystems(
-  authCookie: string,
-): Promise<PaymentSystem[]> {
-  const { paymentSystems } = await vtexIOGraphQL<{
-    paymentSystems: PaymentSystem[];
-  }>(
-    { query: PAYMENT_SYSTEMS_QUERY },
-    { cookie: authCookie },
-  );
+export async function getPaymentSystems(authCookie: string): Promise<PaymentSystem[]> {
+	const { paymentSystems } = await vtexIOGraphQL<{
+		paymentSystems: PaymentSystem[];
+	}>({ query: PAYMENT_SYSTEMS_QUERY }, { cookie: authCookie });
 
-  return paymentSystems;
+	return paymentSystems;
 }
 
 // ---------------------------------------------------------------------------
@@ -93,15 +88,10 @@ const USER_PAYMENTS_QUERY = `query getUserPayments {
  * List saved payment methods for the authenticated user.
  * Requires a valid VTEX auth cookie.
  */
-export async function getUserPayments(
-  authCookie: string,
-): Promise<Payment[]> {
-  const data = await vtexIOGraphQL<{
-    profile: { payments: Payment[] } | null;
-  }>(
-    { query: USER_PAYMENTS_QUERY },
-    { cookie: authCookie },
-  );
+export async function getUserPayments(authCookie: string): Promise<Payment[]> {
+	const data = await vtexIOGraphQL<{
+		profile: { payments: Payment[] } | null;
+	}>({ query: USER_PAYMENTS_QUERY }, { cookie: authCookie });
 
-  return data.profile?.payments ?? [];
+	return data.profile?.payments ?? [];
 }

package/vtex/loaders/profile.ts

@@ -31,26 +31,26 @@ const ADDRESS_FIELDS = `
 `;
 
 export interface Profile {
-  id: string;
-  cacheId: string;
-  email: string;
-  firstName: string;
-  lastName: string;
-  document: string;
-  userId: string;
-  birthDate: string;
-  gender: string;
-  homePhone: string;
-  businessPhone: string;
-  addresses: Record<string, unknown>[];
-  isCorporate: boolean;
-  tradeName: string;
-  corporateName: string;
-  corporateDocument: string;
-  stateRegistration: string;
-  payments: Record<string, unknown>[];
-  customFields: Array<{ key: string; value: string }>;
-  passwordLastUpdate: string;
+	id: string;
+	cacheId: string;
+	email: string;
+	firstName: string;
+	lastName: string;
+	document: string;
+	userId: string;
+	birthDate: string;
+	gender: string;
+	homePhone: string;
+	businessPhone: string;
+	addresses: Record<string, unknown>[];
+	isCorporate: boolean;
+	tradeName: string;
+	corporateName: string;
+	corporateDocument: string;
+	stateRegistration: string;
+	payments: Record<string, unknown>[];
+	customFields: Array<{ key: string; value: string }>;
+	passwordLastUpdate: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -100,18 +100,18 @@ const PROFILE_QUERY = `query getUserProfile($customFields: String) {
  * Requires a valid VTEX auth cookie.
  */
 export async function getCurrentProfile(
-  authCookie: string,
-  customFields?: string[],
+	authCookie: string,
+	customFields?: string[],
 ): Promise<Profile> {
-  const { profile } = await vtexIOGraphQL<{ profile: Profile }>(
-    {
-      query: PROFILE_QUERY,
-      variables: { customFields: customFields?.join(",") },
-    },
-    { cookie: authCookie },
-  );
+	const { profile } = await vtexIOGraphQL<{ profile: Profile }>(
+		{
+			query: PROFILE_QUERY,
+			variables: { customFields: customFields?.join(",") },
+		},
+		{ cookie: authCookie },
+	);
 
-  return profile;
+	return profile;
 }
 
 // ---------------------------------------------------------------------------
@@ -125,14 +125,14 @@ export async function getCurrentProfile(
  * @see https://developers.vtex.com/docs/api-reference/checkout-api#get-/api/checkout/pub/profiles
  */
 export async function getProfileByEmail<T = any>(
-  email: string,
-  authCookie: string,
-  ensureComplete?: boolean,
+	email: string,
+	authCookie: string,
+	ensureComplete?: boolean,
 ): Promise<T> {
-  const params = new URLSearchParams({ email });
-  if (ensureComplete) params.set("ensureComplete", "true");
+	const params = new URLSearchParams({ email });
+	if (ensureComplete) params.set("ensureComplete", "true");
 
-  return vtexFetch<T>(`/api/checkout/pub/profiles?${params}`, {
-    headers: { cookie: authCookie },
-  });
+	return vtexFetch<T>(`/api/checkout/pub/profiles?${params}`, {
+		headers: { cookie: authCookie },
+	});
 }

package/vtex/loaders/promotion.ts

@@ -20,14 +20,11 @@ import type { Document } from "../utils/types";
  * @param authCookie  - Optional cookie string for authenticated requests
  */
 export async function getPromotionById(
-  promotionId: string,
-  authCookie?: string,
+	promotionId: string,
+	authCookie?: string,
 ): Promise<Document[]> {
-  const headers: Record<string, string> = {};
-  if (authCookie) headers.cookie = authCookie;
+	const headers: Record<string, string> = {};
+	if (authCookie) headers.cookie = authCookie;
 
-  return vtexFetch<Document[]>(
-    `/api/rnb/pvt/calculatorconfiguration/${promotionId}`,
-    { headers },
-  );
+	return vtexFetch<Document[]>(`/api/rnb/pvt/calculatorconfiguration/${promotionId}`, { headers });
 }