@decocms/apps 0.23.3 → 0.25.0

package/vtex/inline-loaders/workflowProducts.ts

@@ -2,67 +2,63 @@
  * Workflow/collection products loader using Intelligent Search + shared transform.
  * Maps IS response to schema.org Product[] following deco-cx/apps pattern.
  */
-import { intelligentSearch, getVtexConfig, toFacetPath } from "../client";
-import { toProduct, pickSku } from "../utils/transform";
-import type { Product as ProductVTEX } from "../utils/types";
+
 import type { Product } from "../../commerce/types/commerce";
+import { getVtexConfig, intelligentSearch, toFacetPath } from "../client";
+import { pickSku, toProduct } from "../utils/transform";
+import type { Product as ProductVTEX } from "../utils/types";
 
 export interface WorkflowProductsProps {
-  props?: {
-    query?: string;
-    count?: number;
-    sort?: string;
-    collection?: string;
-  };
-  page?: number;
-  pagesize?: number;
+	props?: {
+		query?: string;
+		count?: number;
+		sort?: string;
+		collection?: string;
+	};
+	page?: number;
+	pagesize?: number;
 }
 
 export default async function vtexWorkflowProducts(
-  props: WorkflowProductsProps,
+	props: WorkflowProductsProps,
 ): Promise<Product[] | null> {
-  const inner = props.props ?? props;
-  const collection = (inner as any).collection;
-  const query = (inner as any).query ?? "";
-  const count = (inner as any).count ?? props.pagesize ?? 12;
-  const sort = (inner as any).sort ?? "";
+	const inner = props.props ?? props;
+	const collection = (inner as any).collection;
+	const query = (inner as any).query ?? "";
+	const count = (inner as any).count ?? props.pagesize ?? 12;
+	const sort = (inner as any).sort ?? "";
 
-  try {
-    const config = getVtexConfig();
-    const locale = config.locale ?? "pt-BR";
+	try {
+		const config = getVtexConfig();
+		const locale = config.locale ?? "pt-BR";
 
-    const params: Record<string, string> = {
-      count: String(count),
-      locale,
-      page: String((props.page ?? 0) + 1),
-    };
-    if (query) params.query = query;
-    if (sort) params.sort = sort;
+		const params: Record<string, string> = {
+			count: String(count),
+			locale,
+			page: String((props.page ?? 0) + 1),
+		};
+		if (query) params.query = query;
+		if (sort) params.sort = sort;
 
-    const facetPath = collection
-      ? toFacetPath([{ key: "productClusterIds", value: collection }])
-      : "";
+		const facetPath = collection
+			? toFacetPath([{ key: "productClusterIds", value: collection }])
+			: "";
 
-    const endpoint = facetPath
-      ? `/product_search/${facetPath}`
-      : "/product_search/";
+		const endpoint = facetPath ? `/product_search/${facetPath}` : "/product_search/";
 
-    const data = await intelligentSearch<{ products: ProductVTEX[] }>(
-      endpoint,
-      params,
-    );
+		const data = await intelligentSearch<{ products: ProductVTEX[] }>(endpoint, params);
 
-    const products = data.products ?? [];
-    const baseUrl = config.publicUrl
-      ? `https://${config.publicUrl}`
-      : `https://${config.account}.vtexcommercestable.${config.domain ?? "com.br"}`;
+		const products = data.products ?? [];
+		const baseUrl = config.publicUrl
+			? `https://${config.publicUrl}`
+			: `https://${config.account}.vtexcommercestable.${config.domain ?? "com.br"}`;
 
-    return products.map((p) => {
-      const sku = pickSku(p);
-      return toProduct(p, sku, 0, { baseUrl, priceCurrency: "BRL" });
-    });
-  } catch (error) {
-    console.error("[VTEX] Workflow products error:", error);
-    return null;
-  }
+		return products.map((p) => {
+			const sku = pickSku(p);
+			return toProduct(p, sku, 0, { baseUrl, priceCurrency: "BRL" });
+		});
+	} catch (error) {
+		console.error("[VTEX] Workflow products error:", error);
+		return null;
+	}
 }

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 ?? [];
 }