@decocms/apps 0.23.3 → 0.24.0

package/vtex/invoke.ts

@@ -22,210 +22,175 @@
  * ```
  */
 import { createInvokeFn } from "@decocms/start/sdk/createInvoke";
+import type { RegionResult } from "./actions/checkout";
 import {
-  getOrCreateCart,
-  addItemsToCart,
-  updateCartItems,
-  addCouponToCart,
-  simulateCart,
-  getSellersByRegion,
-  setShippingPostalCode,
-  updateOrderFormAttachment,
-  type SimulationItem,
+	addCouponToCart,
+	addItemsToCart,
+	getOrCreateCart,
+	getSellersByRegion,
+	type SimulationItem,
+	setShippingPostalCode,
+	simulateCart,
+	updateCartItems,
+	updateOrderFormAttachment,
 } from "./actions/checkout";
 import {
-  createDocument,
-  getDocument,
-  patchDocument,
-  searchDocuments,
-  uploadAttachment,
-  type UploadAttachmentOpts,
-  type CreateDocumentResult,
+	type CreateDocumentResult,
+	createDocument,
+	getDocument,
+	patchDocument,
+	searchDocuments,
+	type UploadAttachmentOpts,
+	uploadAttachment,
 } from "./actions/masterData";
+import { type NotifyMeProps, notifyMe } from "./actions/misc";
+import { type SubscribeProps, subscribe } from "./actions/newsletter";
 import { createSession, editSession, type SessionData } from "./actions/session";
-import { subscribe, type SubscribeProps } from "./actions/newsletter";
-import { notifyMe, type NotifyMeProps } from "./actions/misc";
 import type { OrderForm } from "./types";
-import type { RegionResult } from "./actions/checkout";
 
 // ---------------------------------------------------------------------------
 // invoke.vtex.actions — typed server functions callable from client
 // ---------------------------------------------------------------------------
 
 export const invoke = {
-  vtex: {
-    actions: {
-      // -- Cart (unwrap VtexFetchResult -> OrderForm) -----------------------
-
-      getOrCreateCart: createInvokeFn(
-        (input: { orderFormId?: string }) =>
-          getOrCreateCart(input.orderFormId),
-        { unwrap: true },
-      ) as unknown as (ctx: { data: { orderFormId?: string } }) => Promise<OrderForm>,
-
-      addItemsToCart: createInvokeFn(
-        (input: {
-          orderFormId: string;
-          orderItems: Array<{
-            id: string;
-            seller: string;
-            quantity: number;
-          }>;
-        }) => addItemsToCart(input.orderFormId, input.orderItems),
-        { unwrap: true },
-      ) as unknown as (ctx: {
-        data: {
-          orderFormId: string;
-          orderItems: Array<{
-            id: string;
-            seller: string;
-            quantity: number;
-          }>;
-        };
-      }) => Promise<OrderForm>,
-
-      updateCartItems: createInvokeFn(
-        (input: {
-          orderFormId: string;
-          orderItems: Array<{ index: number; quantity: number }>;
-        }) => updateCartItems(input.orderFormId, input.orderItems),
-        { unwrap: true },
-      ) as unknown as (ctx: {
-        data: {
-          orderFormId: string;
-          orderItems: Array<{ index: number; quantity: number }>;
-        };
-      }) => Promise<OrderForm>,
-
-      addCouponToCart: createInvokeFn(
-        (input: { orderFormId: string; text: string }) =>
-          addCouponToCart(input.orderFormId, input.text),
-        { unwrap: true },
-      ) as unknown as (ctx: {
-        data: { orderFormId: string; text: string };
-      }) => Promise<OrderForm>,
-
-      simulateCart: createInvokeFn(
-        (input: {
-          items: SimulationItem[];
-          postalCode: string;
-          country?: string;
-        }) => simulateCart(input.items, input.postalCode, input.country),
-      ),
-
-      // -- Shipping / Region ------------------------------------------------
-
-      getSellersByRegion: createInvokeFn(
-        (input: { postalCode: string; salesChannel?: string }) =>
-          getSellersByRegion(input.postalCode, input.salesChannel),
-      ) as (ctx: {
-        data: { postalCode: string; salesChannel?: string };
-      }) => Promise<RegionResult | null>,
-
-      setShippingPostalCode: createInvokeFn(
-        (input: {
-          orderFormId: string;
-          postalCode: string;
-          country?: string;
-        }) =>
-          setShippingPostalCode(
-            input.orderFormId,
-            input.postalCode,
-            input.country,
-          ),
-      ) as (ctx: {
-        data: {
-          orderFormId: string;
-          postalCode: string;
-          country?: string;
-        };
-      }) => Promise<boolean>,
-
-      updateOrderFormAttachment: createInvokeFn(
-        (input: {
-          orderFormId: string;
-          attachment: string;
-          body: Record<string, unknown>;
-        }) =>
-          updateOrderFormAttachment(
-            input.orderFormId,
-            input.attachment,
-            input.body,
-          ),
-        { unwrap: true },
-      ) as unknown as (ctx: {
-        data: {
-          orderFormId: string;
-          attachment: string;
-          body: Record<string, unknown>;
-        };
-      }) => Promise<OrderForm>,
-
-      // -- Session ----------------------------------------------------------
-
-      createSession: createInvokeFn(
-        (input: Record<string, any>) => createSession(input),
-        { unwrap: true },
-      ),
-
-      editSession: createInvokeFn(
-        (input: { public: Record<string, { value: string }> }) =>
-          editSession(input.public),
-        { unwrap: true },
-      ) as unknown as (ctx: {
-        data: { public: Record<string, { value: string }> };
-      }) => Promise<SessionData>,
-
-      // -- MasterData -------------------------------------------------------
-
-      createDocument: createInvokeFn(
-        (input: { entity: string; data: Record<string, any> }) =>
-          createDocument(input.entity, input.data),
-      ) as (ctx: {
-        data: { entity: string; data: Record<string, any> };
-      }) => Promise<CreateDocumentResult>,
-
-      getDocument: createInvokeFn(
-        (input: { entity: string; documentId: string }) =>
-          getDocument(input.entity, input.documentId),
-      ),
-
-      patchDocument: createInvokeFn(
-        (input: {
-          entity: string;
-          documentId: string;
-          data: Record<string, any>;
-        }) => patchDocument(input.entity, input.documentId, input.data),
-      ) as (ctx: {
-        data: {
-          entity: string;
-          documentId: string;
-          data: Record<string, any>;
-        };
-      }) => Promise<void>,
-
-      searchDocuments: createInvokeFn(
-        (input: { entity: string; filter: string }) =>
-          searchDocuments(input.entity, input.filter),
-      ),
-
-      uploadAttachment: createInvokeFn(
-        (input: UploadAttachmentOpts) => uploadAttachment(input),
-      ) as (ctx: {
-        data: UploadAttachmentOpts;
-      }) => Promise<{ ok: true }>,
-
-      // -- Newsletter -------------------------------------------------------
-
-      subscribe: createInvokeFn(
-        (input: SubscribeProps) => subscribe(input),
-      ) as (ctx: { data: SubscribeProps }) => Promise<void>,
-
-      // -- Misc -------------------------------------------------------------
-
-      notifyMe: createInvokeFn(
-        (input: NotifyMeProps) => notifyMe(input),
-      ) as (ctx: { data: NotifyMeProps }) => Promise<void>,
-    },
-  },
+	vtex: {
+		actions: {
+			// -- Cart (unwrap VtexFetchResult -> OrderForm) -----------------------
+
+			getOrCreateCart: createInvokeFn(
+				(input: { orderFormId?: string }) => getOrCreateCart(input.orderFormId),
+				{ unwrap: true },
+			) as unknown as (ctx: { data: { orderFormId?: string } }) => Promise<OrderForm>,
+
+			addItemsToCart: createInvokeFn(
+				(input: {
+					orderFormId: string;
+					orderItems: Array<{
+						id: string;
+						seller: string;
+						quantity: number;
+					}>;
+				}) => addItemsToCart(input.orderFormId, input.orderItems),
+				{ unwrap: true },
+			) as unknown as (ctx: {
+				data: {
+					orderFormId: string;
+					orderItems: Array<{
+						id: string;
+						seller: string;
+						quantity: number;
+					}>;
+				};
+			}) => Promise<OrderForm>,
+
+			updateCartItems: createInvokeFn(
+				(input: { orderFormId: string; orderItems: Array<{ index: number; quantity: number }> }) =>
+					updateCartItems(input.orderFormId, input.orderItems),
+				{ unwrap: true },
+			) as unknown as (ctx: {
+				data: {
+					orderFormId: string;
+					orderItems: Array<{ index: number; quantity: number }>;
+				};
+			}) => Promise<OrderForm>,
+
+			addCouponToCart: createInvokeFn(
+				(input: { orderFormId: string; text: string }) =>
+					addCouponToCart(input.orderFormId, input.text),
+				{ unwrap: true },
+			) as unknown as (ctx: { data: { orderFormId: string; text: string } }) => Promise<OrderForm>,
+
+			simulateCart: createInvokeFn(
+				(input: { items: SimulationItem[]; postalCode: string; country?: string }) =>
+					simulateCart(input.items, input.postalCode, input.country),
+			),
+
+			// -- Shipping / Region ------------------------------------------------
+
+			getSellersByRegion: createInvokeFn((input: { postalCode: string; salesChannel?: string }) =>
+				getSellersByRegion(input.postalCode, input.salesChannel),
+			) as (ctx: {
+				data: { postalCode: string; salesChannel?: string };
+			}) => Promise<RegionResult | null>,
+
+			setShippingPostalCode: createInvokeFn(
+				(input: { orderFormId: string; postalCode: string; country?: string }) =>
+					setShippingPostalCode(input.orderFormId, input.postalCode, input.country),
+			) as (ctx: {
+				data: {
+					orderFormId: string;
+					postalCode: string;
+					country?: string;
+				};
+			}) => Promise<boolean>,
+
+			updateOrderFormAttachment: createInvokeFn(
+				(input: { orderFormId: string; attachment: string; body: Record<string, unknown> }) =>
+					updateOrderFormAttachment(input.orderFormId, input.attachment, input.body),
+				{ unwrap: true },
+			) as unknown as (ctx: {
+				data: {
+					orderFormId: string;
+					attachment: string;
+					body: Record<string, unknown>;
+				};
+			}) => Promise<OrderForm>,
+
+			// -- Session ----------------------------------------------------------
+
+			createSession: createInvokeFn((input: Record<string, any>) => createSession(input), {
+				unwrap: true,
+			}),
+
+			editSession: createInvokeFn(
+				(input: { public: Record<string, { value: string }> }) => editSession(input.public),
+				{ unwrap: true },
+			) as unknown as (ctx: {
+				data: { public: Record<string, { value: string }> };
+			}) => Promise<SessionData>,
+
+			// -- MasterData -------------------------------------------------------
+
+			createDocument: createInvokeFn((input: { entity: string; data: Record<string, any> }) =>
+				createDocument(input.entity, input.data),
+			) as (ctx: {
+				data: { entity: string; data: Record<string, any> };
+			}) => Promise<CreateDocumentResult>,
+
+			getDocument: createInvokeFn((input: { entity: string; documentId: string }) =>
+				getDocument(input.entity, input.documentId),
+			),
+
+			patchDocument: createInvokeFn(
+				(input: { entity: string; documentId: string; data: Record<string, any> }) =>
+					patchDocument(input.entity, input.documentId, input.data),
+			) as (ctx: {
+				data: {
+					entity: string;
+					documentId: string;
+					data: Record<string, any>;
+				};
+			}) => Promise<void>,
+
+			searchDocuments: createInvokeFn((input: { entity: string; filter: string }) =>
+				searchDocuments(input.entity, input.filter),
+			),
+
+			uploadAttachment: createInvokeFn((input: UploadAttachmentOpts) =>
+				uploadAttachment(input),
+			) as (ctx: { data: UploadAttachmentOpts }) => Promise<{ ok: true }>,
+
+			// -- Newsletter -------------------------------------------------------
+
+			subscribe: createInvokeFn((input: SubscribeProps) => subscribe(input)) as (ctx: {
+				data: SubscribeProps;
+			}) => Promise<void>,
+
+			// -- Misc -------------------------------------------------------------
+
+			notifyMe: createInvokeFn((input: NotifyMeProps) => notifyMe(input)) as (ctx: {
+				data: NotifyMeProps;
+			}) => Promise<void>,
+		},
+	},
 } as const;

package/vtex/loaders/address.ts

@@ -15,34 +15,34 @@ import { vtexFetch, vtexIOGraphQL } from "../client";
 // ---------------------------------------------------------------------------
 
 export interface PostalAddress {
-  "@type": "PostalAddress";
-  postalCode?: string;
-  addressLocality?: string;
-  addressRegion?: string;
-  addressCountry?: string;
-  streetAddress?: string;
-  identifier?: string;
-  areaServed?: string;
-  description?: string;
-  disambiguatingDescription?: string;
-  latitude?: number;
-  longitude?: number;
+	"@type": "PostalAddress";
+	postalCode?: string;
+	addressLocality?: string;
+	addressRegion?: string;
+	addressCountry?: string;
+	streetAddress?: string;
+	identifier?: string;
+	areaServed?: string;
+	description?: string;
+	disambiguatingDescription?: string;
+	latitude?: number;
+	longitude?: number;
 }
 
 export interface VtexAddress {
-  addressId: string;
-  addressType: string;
-  addressName: string;
-  city: string;
-  complement: string;
-  country: string;
-  neighborhood: string;
-  number: string;
-  postalCode: string;
-  geoCoordinates: number[];
-  receiverName: string;
-  state: string;
-  street: string;
+	addressId: string;
+	addressType: string;
+	addressName: string;
+	city: string;
+	complement: string;
+	country: string;
+	neighborhood: string;
+	number: string;
+	postalCode: string;
+	geoCoordinates: number[];
+	receiverName: string;
+	state: string;
+	street: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -54,27 +54,27 @@ export interface VtexAddress {
  * @see https://developers.vtex.com/docs/api-reference/checkout-api#get-/api/checkout/pub/postal-code/-countryCode-/-postalCode-
  */
 export async function getAddressByPostalCode(
-  countryCode: string,
-  postalCode: string,
+	countryCode: string,
+	postalCode: string,
 ): Promise<PostalAddress> {
-  const data = await vtexFetch<Record<string, any>>(
-    `/api/checkout/pub/postal-code/${countryCode}/${postalCode}`,
-  );
+	const data = await vtexFetch<Record<string, any>>(
+		`/api/checkout/pub/postal-code/${countryCode}/${postalCode}`,
+	);
 
-  return {
-    "@type": "PostalAddress",
-    postalCode: data.postalCode,
-    addressLocality: data.city,
-    addressRegion: data.state,
-    addressCountry: data.country,
-    streetAddress: data.street || undefined,
-    identifier: data.number || undefined,
-    areaServed: data.neighborhood || undefined,
-    description: data.complement || undefined,
-    disambiguatingDescription: data.reference || undefined,
-    latitude: data.geoCoordinates?.[0] || undefined,
-    longitude: data.geoCoordinates?.[1] || undefined,
-  };
+	return {
+		"@type": "PostalAddress",
+		postalCode: data.postalCode,
+		addressLocality: data.city,
+		addressRegion: data.state,
+		addressCountry: data.country,
+		streetAddress: data.street || undefined,
+		identifier: data.number || undefined,
+		areaServed: data.neighborhood || undefined,
+		description: data.complement || undefined,
+		disambiguatingDescription: data.reference || undefined,
+		latitude: data.geoCoordinates?.[0] ?? undefined,
+		longitude: data.geoCoordinates?.[1] ?? undefined,
+	};
 }
 
 // ---------------------------------------------------------------------------
@@ -106,15 +106,10 @@ const USER_ADDRESSES_QUERY = `query Addresses @context(scope: "private") {
  * Fetch addresses for the currently authenticated user.
  * Requires a valid VTEX auth cookie.
  */
-export async function getUserAddresses(
-  authCookie: string,
-): Promise<VtexAddress[]> {
-  const { profile } = await vtexIOGraphQL<{
-    profile: { addresses: VtexAddress[] };
-  }>(
-    { query: USER_ADDRESSES_QUERY },
-    { cookie: authCookie },
-  );
+export async function getUserAddresses(authCookie: string): Promise<VtexAddress[]> {
+	const { profile } = await vtexIOGraphQL<{
+		profile: { addresses: VtexAddress[] };
+	}>({ query: USER_ADDRESSES_QUERY }, { cookie: authCookie });
 
-  return profile?.addresses ?? [];
+	return profile?.addresses ?? [];
 }

package/vtex/loaders/brands.ts

@@ -4,48 +4,41 @@
  *
  * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/brand/list
  */
-import { vtexFetch, getVtexConfig } from "../client";
-import { toBrand } from "../utils/transform";
+
 import type { Brand } from "../../commerce/types/commerce";
+import { getVtexConfig, vtexFetch } from "../client";
+import { toBrand } from "../utils/transform";
 import type { Brand as BrandVTEX } from "../utils/types";
 
 export interface ListBrandsOpts {
-  /** When true, only returns active brands. @default false */
-  filterInactive?: boolean;
+	/** When true, only returns active brands. @default false */
+	filterInactive?: boolean;
 }
 
 /**
  * List brands from the VTEX catalog, transformed to schema.org Brand format.
  */
-export async function listBrands(
-  opts?: ListBrandsOpts,
-): Promise<Brand[]> {
-  const config = getVtexConfig();
-  const baseUrl = `https://${config.account}.vteximg.com.br/arquivos/ids`;
+export async function listBrands(opts?: ListBrandsOpts): Promise<Brand[]> {
+	const config = getVtexConfig();
+	const baseUrl = `https://${config.account}.vteximg.com.br/arquivos/ids`;
 
-  const brands = await vtexFetch<BrandVTEX[]>(
-    "/api/catalog_system/pub/brand/list",
-  );
+	const brands = await vtexFetch<BrandVTEX[]>("/api/catalog_system/pub/brand/list");
 
-  const filtered = opts?.filterInactive
-    ? brands.filter((b) => b.isActive)
-    : brands;
+	const filtered = opts?.filterInactive ? brands.filter((b) => b.isActive) : brands;
 
-  return filtered.map((b) => toBrand(b, baseUrl));
+	return filtered.map((b) => toBrand(b, baseUrl));
 }
 
 /**
  * Get a single brand by ID, as schema.org Brand.
  */
 export async function getBrandById(brandId: number): Promise<Brand | null> {
-  try {
-    const config = getVtexConfig();
-    const baseUrl = `https://${config.account}.vteximg.com.br/arquivos/ids`;
-    const brand = await vtexFetch<BrandVTEX>(
-      `/api/catalog_system/pub/brand/${brandId}`,
-    );
-    return toBrand(brand, baseUrl);
-  } catch {
-    return null;
-  }
+	try {
+		const config = getVtexConfig();
+		const baseUrl = `https://${config.account}.vteximg.com.br/arquivos/ids`;
+		const brand = await vtexFetch<BrandVTEX>(`/api/catalog_system/pub/brand/${brandId}`);
+		return toBrand(brand, baseUrl);
+	} catch {
+		return null;
+	}
 }

package/vtex/loaders/cart.ts

@@ -7,10 +7,11 @@
  *
  * @see https://developers.vtex.com/docs/api-reference/checkout-api#get-/api/checkout/pub/orderForm
  */
-import { vtexFetch, getVtexConfig } from "../client";
-import type { OrderForm } from "../utils/types";
-import { forceHttpsOnAssets } from "../utils/transform";
+
 import { DEFAULT_EXPECTED_SECTIONS } from "../actions/checkout";
+import { getVtexConfig, vtexFetch } from "../client";
+import { forceHttpsOnAssets } from "../utils/transform";
+import type { OrderForm } from "../utils/types";
 
 /**
  * Fetch the current cart (OrderForm).
@@ -23,27 +24,29 @@ import { DEFAULT_EXPECTED_SECTIONS } from "../actions/checkout";
  * @param authCookie - Optional cookie string for authenticated requests
  */
 export async function getCart(
-  orderFormId?: string,
-  opts?: { salesChannel?: string; authCookie?: string },
+	orderFormId?: string,
+	opts?: { salesChannel?: string; authCookie?: string },
 ): Promise<OrderForm> {
-  const { salesChannel } = getVtexConfig();
-  const sc = opts?.salesChannel ?? salesChannel;
-  const headers: Record<string, string> = {};
-  if (opts?.authCookie) headers.cookie = opts.authCookie;
+	const { salesChannel } = getVtexConfig();
+	const sc = opts?.salesChannel ?? salesChannel;
+	const headers: Record<string, string> = {};
+	if (opts?.authCookie) headers.cookie = opts.authCookie;
 
-  const scParam = sc ? `?sc=${sc}` : "";
+	const scParam = sc ? `?sc=${sc}` : "";
 
-  const body = JSON.stringify({ expectedOrderFormSections: DEFAULT_EXPECTED_SECTIONS });
+	const body = JSON.stringify({ expectedOrderFormSections: DEFAULT_EXPECTED_SECTIONS });
 
-  const cart = orderFormId
-    ? await vtexFetch<OrderForm>(
-        `/api/checkout/pub/orderForm/${orderFormId}${scParam}`,
-        { method: "POST", headers, body },
-      )
-    : await vtexFetch<OrderForm>(
-        `/api/checkout/pub/orderForm${scParam}`,
-        { method: "POST", headers, body },
-      );
+	const cart = orderFormId
+		? await vtexFetch<OrderForm>(`/api/checkout/pub/orderForm/${orderFormId}${scParam}`, {
+				method: "POST",
+				headers,
+				body,
+			})
+		: await vtexFetch<OrderForm>(`/api/checkout/pub/orderForm${scParam}`, {
+				method: "POST",
+				headers,
+				body,
+			});
 
-  return forceHttpsOnAssets(cart);
+	return forceHttpsOnAssets(cart);
 }