@decocms/apps-vtex 7.2.0

package/src/actions/address.ts

@@ -0,0 +1,250 @@
+/**
+ * VTEX Address management actions (store-graphql).
+ * Ported from deco-cx/apps:
+ *   - vtex/actions/address/create.ts
+ *   - vtex/actions/address/delete.ts
+ *   - vtex/actions/address/update.ts
+ * @see https://developers.vtex.com/docs/guides/profile-system
+ */
+import { getVtexConfig, vtexFetch } from "../client";
+import { buildAuthCookieHeader } from "../utils/vtexId";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface AddressInput {
+	addressName: string;
+	addressType?: string;
+	city?: string;
+	complement?: string;
+	country?: string;
+	geoCoordinates?: number[];
+	neighborhood?: string;
+	number?: string;
+	postalCode?: string;
+	receiverName?: string;
+	reference?: string;
+	state?: string;
+	street?: string;
+}
+
+export interface SavedAddress {
+	id: string;
+	cacheId: string;
+	addressId: string;
+	userId?: string;
+	addressName: string;
+	addressType: string | null;
+	city: string | null;
+	complement: string | null;
+	country: string | null;
+	geoCoordinates: number[] | null;
+	neighborhood: string | null;
+	number: string | null;
+	postalCode: string | null;
+	receiverName: string | null;
+	reference: string | null;
+	state: string | null;
+	street: string | null;
+	name?: string;
+}
+
+export interface DeleteAddressResult {
+	cacheId: string;
+	addresses: SavedAddress[];
+}
+
+export interface UpdateAddressResult {
+	cacheId: string;
+	addresses: SavedAddress;
+}
+
+// ---------------------------------------------------------------------------
+// GraphQL helper (myvtex.com private graphql)
+// ---------------------------------------------------------------------------
+
+interface GqlResponse<T> {
+	data: T;
+	errors?: Array<{ message: string }>;
+}
+
+async function gql<T>(
+	query: string,
+	variables: Record<string, unknown>,
+	authCookie: string,
+): Promise<T> {
+	const { account } = getVtexConfig();
+	const result = await vtexFetch<GqlResponse<T>>(
+		`https://${account}.myvtex.com/_v/private/graphql/v1`,
+		{
+			method: "POST",
+			body: JSON.stringify({ query, variables }),
+			headers: { Cookie: buildAuthCookieHeader(authCookie, account) },
+		},
+	);
+	if (result.errors?.length) {
+		throw new Error(`GraphQL error: ${result.errors[0].message}`);
+	}
+	return result.data;
+}
+
+// ---------------------------------------------------------------------------
+// Mutations
+// ---------------------------------------------------------------------------
+
+const SAVE_ADDRESS = `mutation SaveAddress($address: AddressInput!) {
+  saveAddress(address: $address) @context(provider: "vtex.store-graphql") {
+    addressId
+    cacheId
+    id
+    userId
+    receiverName
+    complement
+    neighborhood
+    country
+    state
+    number
+    street
+    geoCoordinates
+    postalCode
+    city
+    name
+    addressName
+    addressType
+  }
+}`;
+
+const DELETE_ADDRESS = `mutation DeleteAddress($addressId: String) {
+  deleteAddress(id: $addressId) {
+    cacheId
+    addresses {
+      addressId: id
+      addressType
+      addressName
+      city
+      complement
+      country
+      neighborhood
+      number
+      postalCode
+      geoCoordinates
+      receiverName
+      reference
+      state
+      street
+    }
+  }
+}`;
+
+const UPDATE_ADDRESS = `mutation UpdateAddress($addressId: String!, $addressFields: AddressInput) {
+  updateAddress(id: $addressId, fields: $addressFields) @context(provider: "vtex.store-graphql") {
+    cacheId
+    addresses: address {
+      addressId: id
+      addressType
+      addressName
+      city
+      complement
+      country
+      neighborhood
+      number
+      postalCode
+      geoCoordinates
+      receiverName
+      reference
+      state
+      street
+    }
+  }
+}`;
+
+// ---------------------------------------------------------------------------
+// Actions
+// ---------------------------------------------------------------------------
+
+/** Create a new user address. Requires the user's VtexIdclientAutCookie token. */
+export async function createAddress(
+	input: AddressInput,
+	authCookie: string,
+): Promise<SavedAddress> {
+	const { saveAddress } = await gql<{ saveAddress: SavedAddress }>(
+		SAVE_ADDRESS,
+		{ address: input },
+		authCookie,
+	);
+	return saveAddress;
+}
+
+/** Delete an address by its ID. Returns remaining addresses. */
+export async function deleteAddress(
+	addressId: string,
+	authCookie: string,
+): Promise<DeleteAddressResult> {
+	const { deleteAddress: result } = await gql<{ deleteAddress: DeleteAddressResult }>(
+		DELETE_ADDRESS,
+		{ addressId },
+		authCookie,
+	);
+	return result;
+}
+
+/** Update an existing address. Returns the updated address. */
+export async function updateAddress(
+	addressId: string,
+	fields: Partial<AddressInput>,
+	authCookie: string,
+): Promise<UpdateAddressResult> {
+	const { updateAddress: result } = await gql<{ updateAddress: UpdateAddressResult }>(
+		UPDATE_ADDRESS,
+		{
+			addressId,
+			addressFields: {
+				...fields,
+				receiverName: fields.receiverName ?? null,
+				complement: fields.complement ?? null,
+			},
+		},
+		authCookie,
+	);
+	return result;
+}
+
+// ---------------------------------------------------------------------------
+// Request-aware wrappers (for COMMERCE_LOADERS / invoke proxy)
+// Handle cookie extraction, postalCode sanitization, and field defaults.
+// ---------------------------------------------------------------------------
+
+import { ensureUnsuffixedAuthCookie, getVtexCookies } from "../utils/cookies";
+
+function sanitizeAddressInput(props: Record<string, any>): Record<string, any> {
+	if (props.postalCode) props.postalCode = props.postalCode.replace(/\D/g, "");
+	if (!props.addressName) props.addressName = props.receiverName || `Address ${Date.now()}`;
+	if (!props.addressType) props.addressType = "residential";
+	return props;
+}
+
+export async function createAddressFromRequest(
+	props: Record<string, any>,
+	request: Request,
+): Promise<SavedAddress> {
+	const cookie = ensureUnsuffixedAuthCookie(getVtexCookies(request));
+	return createAddress(sanitizeAddressInput(props) as AddressInput, cookie);
+}
+
+export async function updateAddressFromRequest(
+	props: Record<string, any>,
+	request: Request,
+): Promise<UpdateAddressResult> {
+	const cookie = ensureUnsuffixedAuthCookie(getVtexCookies(request));
+	const { addressId, ...fields } = props;
+	return updateAddress(addressId, fields, cookie);
+}
+
+export async function deleteAddressFromRequest(
+	props: Record<string, any>,
+	request: Request,
+): Promise<DeleteAddressResult> {
+	const cookie = ensureUnsuffixedAuthCookie(getVtexCookies(request));
+	return deleteAddress(props.addressId, cookie);
+}

package/src/actions/analytics/sendEvent.ts

@@ -0,0 +1,86 @@
+/**
+ * VTEX Intelligent Search analytics event.
+ *
+ * Reads the IS session/anonymous cookies from the incoming request and POSTs
+ * an event to the IS event-api. The configured account is resolved via
+ * {@link getVtexConfig}.
+ *
+ * @see https://developers.vtex.com/docs/api-reference/intelligent-search-api#post-/event-api/v1/-account-/event
+ */
+
+import { getVtexConfig, getVtexFetch } from "../../client";
+import { ANONYMOUS_COOKIE, SESSION_COOKIE } from "../../utils/intelligentSearch";
+
+export type Props =
+	| {
+			type: "session.ping";
+			url: string;
+	  }
+	| {
+			type: "page.cart";
+			products: { productId: string; quantity: number }[];
+	  }
+	| {
+			type: "page.empty_cart";
+			// Empty array would serialize as an invalid JSON schema, so accept anything.
+			products: unknown;
+	  }
+	| {
+			type: "page.confirmation";
+			order: string;
+			products: { productId: string; quantity: number; price: number }[];
+	  }
+	| {
+			type: "search.click";
+			position: number;
+			text: string;
+			productId: string;
+			url: string;
+	  }
+	| {
+			type: "search.query";
+			url: string;
+			text: string;
+			misspelled: boolean;
+			match: number;
+			operator: string;
+			locale: string;
+	  };
+
+const readCookie = (cookieHeader: string, name: string): string | undefined => {
+	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${escaped}=([^;]+)`));
+	return match?.[1];
+};
+
+/**
+ * @title Send Analytics Event
+ * @description POST a VTEX Intelligent Search analytics event for the current session.
+ */
+const action = async (props: Props, req: Request): Promise<null> => {
+	const { account } = getVtexConfig();
+	const cookieHeader = req.headers.get("cookie") ?? "";
+	const session = readCookie(cookieHeader, SESSION_COOKIE);
+	const anonymous = readCookie(cookieHeader, ANONYMOUS_COOKIE);
+
+	if (!session || !anonymous) {
+		throw new Error("Missing IS Cookies");
+	}
+
+	const url = `https://sp.vtex.com/event-api/v1/${account}/event`;
+	await getVtexFetch()(url, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			...props,
+			session,
+			anonymous,
+			agent: req.headers.get("user-agent") || "deco-sites/apps",
+		}),
+		operation: "analytics.event",
+	});
+
+	return null;
+};
+
+export default action;

package/src/actions/auth.ts

@@ -0,0 +1,333 @@
+/**
+ * VTEX Authentication Actions
+ *
+ * Ported from deco-cx/apps vtex/actions/authentication/*.ts
+ * Cookie forwarding happens automatically via RequestContext.responseHeaders.
+ * @see https://github.com/deco-cx/apps/tree/main/vtex/actions/authentication
+ */
+
+import { getVtexConfig, vtexFetchWithCookies } from "../client";
+import { VTEX_AUTH_COOKIE } from "../utils/vtexId";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface AuthProvider {
+	providerName: string;
+	className: string;
+	expectedContext: unknown[];
+}
+
+export interface StartAuthentication {
+	authenticationToken: string | null;
+	oauthProviders: AuthProvider[];
+	showClassicAuthentication: boolean;
+	showAccessKeyAuthentication: boolean;
+	showPasskeyAuthentication: boolean;
+	authCookie: string | null;
+	isAuthenticated: boolean;
+	selectedProvider: string | null;
+	samlProviders: unknown[];
+}
+
+export interface AuthResponse {
+	authStatus: string | "WrongCredentials" | "BlockedUser" | "Success";
+	promptMFA: boolean;
+	clientToken: string | null;
+	authCookie: { Name: string; Value: string } | null;
+	accountAuthCookie: { Name: string; Value: string } | null;
+	expiresIn: number;
+	userId: string | null;
+	phoneNumber: string | null;
+	scope: string | null;
+}
+
+export interface RefreshTokenResponse {
+	status: string;
+	userId: string;
+	refreshAfter: string;
+}
+
+/**
+ * Cookies to set after a successful login.
+ * Caller (server function) should use these to set cookies on the response.
+ */
+export interface LoginCookies {
+	authCookieName: string;
+	authCookieValue: string;
+	accountAuthCookieName?: string;
+	accountAuthCookieValue?: string;
+	expiresInSeconds: number;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const FORM_HEADERS = {
+	"Content-Type": "application/x-www-form-urlencoded",
+	Accept: "application/json",
+};
+
+/**
+ * Extract login cookies from an AuthResponse.
+ * Returns null if auth failed.
+ */
+export function extractLoginCookies(response: AuthResponse): LoginCookies | null {
+	if (response.authStatus !== "Success" || !response.authCookie) {
+		return null;
+	}
+	return {
+		authCookieName: response.authCookie.Name,
+		authCookieValue: response.authCookie.Value,
+		accountAuthCookieName: response.accountAuthCookie?.Name,
+		accountAuthCookieValue: response.accountAuthCookie?.Value,
+		expiresInSeconds: response.expiresIn,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Actions
+// ---------------------------------------------------------------------------
+
+export interface StartAuthenticationProps {
+	callbackUrl?: string;
+	returnUrl?: string;
+	locale?: string;
+	appStart?: boolean;
+}
+
+export async function startAuthentication(
+	props?: StartAuthenticationProps,
+): Promise<StartAuthentication> {
+	const config = getVtexConfig();
+	const {
+		callbackUrl = "/",
+		returnUrl = "/",
+		locale = config.locale ?? "pt-BR",
+		appStart = true,
+	} = props ?? {};
+
+	const params = new URLSearchParams({
+		locale,
+		scope: config.account,
+		appStart: String(appStart),
+		callbackUrl,
+		returnUrl,
+	});
+
+	return vtexFetchWithCookies<StartAuthentication>(
+		`/api/vtexid/pub/authentication/start?${params}`,
+	);
+}
+
+export interface ClassicSignInProps {
+	email: string;
+	password: string;
+	authenticationToken?: string;
+}
+
+/**
+ * Classic email + password sign-in.
+ * Calls startAuthentication internally if no authenticationToken provided.
+ * Set-Cookie headers from both calls are forwarded via RequestContext.responseHeaders.
+ */
+export async function classicSignIn(props: ClassicSignInProps): Promise<AuthResponse> {
+	const { email, password } = props;
+	let token = props.authenticationToken;
+	if (!token) {
+		const startResult = await startAuthentication();
+		token = startResult.authenticationToken ?? undefined;
+		if (!token) throw new Error("Failed to obtain authentication token from startAuthentication");
+	}
+
+	const body = new URLSearchParams({
+		email,
+		password,
+		authenticationToken: token,
+	});
+	return vtexFetchWithCookies<AuthResponse>("/api/vtexid/pub/authentication/classic/validate", {
+		method: "POST",
+		body,
+		headers: FORM_HEADERS,
+	});
+}
+
+export interface AccessKeySignInProps {
+	email: string;
+	accessKey: string;
+	authenticationToken: string;
+}
+
+/**
+ * Passwordless sign-in via email access key.
+ */
+export async function accessKeySignIn(props: AccessKeySignInProps): Promise<AuthResponse> {
+	const { email, accessKey, authenticationToken } = props;
+	const body = new URLSearchParams({
+		login: email,
+		accessKey,
+		authenticationToken,
+	});
+
+	return vtexFetchWithCookies<AuthResponse>("/api/vtexid/pub/authentication/accesskey/validate", {
+		method: "POST",
+		body,
+		headers: FORM_HEADERS,
+	});
+}
+
+/**
+ * Logout — returns list of cookie names that must be cleared (Max-Age=0).
+ */
+export function logout(): { cookiesToClear: string[] } {
+	const { account } = getVtexConfig();
+	return {
+		cookiesToClear: [
+			VTEX_AUTH_COOKIE,
+			`${VTEX_AUTH_COOKIE}_${account}`,
+			"vid_rt",
+			`vid_rt_${account}`,
+		],
+	};
+}
+
+export interface RefreshTokenProps {
+	fingerprint?: string;
+}
+
+/**
+ * Refreshes the VTEX auth token using existing session cookies.
+ * Cookies are read automatically from RequestContext.
+ */
+export async function refreshToken(props?: RefreshTokenProps): Promise<RefreshTokenResponse> {
+	return vtexFetchWithCookies<RefreshTokenResponse>("/api/vtexid/refreshtoken/webstore", {
+		method: "POST",
+		body: JSON.stringify({ fingerprint: props?.fingerprint }),
+	});
+}
+
+export interface RecoveryPasswordProps {
+	email: string;
+	newPassword: string;
+	accessKey: string;
+	authenticationToken: string;
+	locale?: string;
+}
+
+/**
+ * Sets a new password using an email access key (password-recovery flow).
+ */
+export async function recoveryPassword(props: RecoveryPasswordProps): Promise<AuthResponse> {
+	const { email, newPassword, accessKey, authenticationToken, locale } = props;
+	const config = getVtexConfig();
+
+	const params = new URLSearchParams({
+		scope: config.account,
+		locale: locale ?? config.locale ?? "pt-BR",
+	});
+
+	const body = new URLSearchParams({
+		login: email,
+		accessKey,
+		newPassword,
+		authenticationToken,
+	});
+
+	return vtexFetchWithCookies<AuthResponse>(
+		`/api/vtexid/pub/authentication/classic/setpassword?${params}`,
+		{ method: "POST", body, headers: FORM_HEADERS },
+	);
+}
+
+export interface ResetPasswordProps {
+	email: string;
+	currentPassword: string;
+	newPassword: string;
+	authenticationToken?: string;
+	locale?: string;
+}
+
+/**
+ * Resets password for an already-authenticated user.
+ * Calls startAuthentication internally if no authenticationToken provided.
+ * Set-Cookie headers from both calls are forwarded via RequestContext.responseHeaders.
+ */
+export async function resetPassword(props: ResetPasswordProps): Promise<AuthResponse> {
+	const { email, currentPassword, newPassword, locale } = props;
+	const config = getVtexConfig();
+
+	let token = props.authenticationToken;
+	if (!token) {
+		const startResult = await startAuthentication({ locale });
+		token = startResult.authenticationToken ?? undefined;
+		if (!token) throw new Error("Failed to obtain authentication token from startAuthentication");
+	}
+
+	const params = new URLSearchParams({
+		scope: config.account,
+		locale: locale ?? config.locale ?? "pt-BR",
+	});
+
+	const body = new URLSearchParams({
+		login: email,
+		currentPassword,
+		newPassword,
+		authenticationToken: token,
+	});
+
+	return vtexFetchWithCookies<AuthResponse>(
+		`/api/vtexid/pub/authentication/classic/setpassword?${params}`,
+		{ method: "POST", body, headers: FORM_HEADERS },
+	);
+}
+
+export interface SendEmailVerificationProps {
+	email: string;
+	authenticationToken?: string;
+	locale?: string;
+	parentAppId?: string;
+}
+
+/**
+ * Sends an access-key verification email.
+ * Calls startAuthentication internally if no authenticationToken provided.
+ * Returns { success, authenticationToken }.
+ */
+export async function sendEmailVerification(props: SendEmailVerificationProps): Promise<{
+	success: boolean;
+	authenticationToken: string | null;
+}> {
+	const { email, locale, parentAppId } = props;
+	try {
+		let token = props.authenticationToken;
+
+		if (!token) {
+			const startResult = await startAuthentication({ locale });
+			token = startResult.authenticationToken ?? undefined;
+			if (!token) throw new Error("Failed to obtain authentication token");
+		}
+
+		const body = new URLSearchParams({ authenticationToken: token, email });
+		if (locale) body.append("locale", locale);
+		if (parentAppId) body.append("parentAppId", parentAppId);
+
+		const result = await vtexFetchWithCookies<Record<string, string>>(
+			"/api/vtexid/pub/authentication/accesskey/send?deliveryMethod=email",
+			{ method: "POST", body, headers: FORM_HEADERS },
+		);
+
+		if (result?.authStatus === "InvalidToken") {
+			throw new Error("Authentication token is invalid");
+		}
+
+		return {
+			success: true,
+			authenticationToken: token,
+		};
+	} catch (error) {
+		console.error("[sendEmailVerification]", error);
+		return { success: false, authenticationToken: null };
+	}
+}