@decocms/apps-vtex 8.0.0 → 8.1.0-next.1

package/src/actions/masterData.ts

@@ -1,168 +0,0 @@
-/**
- * VTEX MasterData v2 API actions.
- * Generic CRUD operations on data entities.
- */
-import { getVtexConfig, getVtexFetch, vtexFetch, vtexFetchResponse } from "../client";
-
-function removeEmptyFields(obj: Record<string, any>): Record<string, any> {
-	return Object.fromEntries(
-		Object.entries(obj).filter(
-			([_, value]) => value !== "" && value !== undefined && value !== null,
-		),
-	);
-}
-
-export interface CreateDocumentResult {
-	DocumentId: string;
-}
-
-export interface CreateDocumentProps {
-	entity: string;
-	data: Record<string, any>;
-}
-
-export async function createDocument(props: CreateDocumentProps): Promise<CreateDocumentResult> {
-	const { entity, data } = props;
-	return vtexFetch<CreateDocumentResult>(`/api/dataentities/${entity}/documents`, {
-		method: "POST",
-		body: JSON.stringify(removeEmptyFields(data)),
-	});
-}
-
-export interface GetDocumentProps {
-	entity: string;
-	documentId: string;
-}
-
-export async function getDocument<T = unknown>(props: GetDocumentProps): Promise<T> {
-	const { entity, documentId } = props;
-	return vtexFetch<T>(`/api/dataentities/${entity}/documents/${documentId}`);
-}
-
-export interface PatchDocumentProps {
-	entity: string;
-	documentId: string;
-	data: Record<string, any>;
-}
-
-export async function patchDocument(props: PatchDocumentProps): Promise<void> {
-	const { entity, documentId, data } = props;
-	await vtexFetch<any>(`/api/dataentities/${entity}/documents/${documentId}`, {
-		method: "PATCH",
-		body: JSON.stringify(removeEmptyFields(data)),
-	});
-}
-
-export interface MasterDataSearchResult {
-	id: string;
-	accountId: string;
-	accountName: string;
-	dataEntityId: string;
-	[key: string]: any;
-}
-
-export interface SearchDocumentsProps {
-	entity: string;
-	filter: string;
-}
-
-/**
- * Simple search — kept for backward compat.
- */
-export async function searchDocuments<T = MasterDataSearchResult>(
-	props: SearchDocumentsProps,
-): Promise<T[]> {
-	const { entity, filter } = props;
-	return vtexFetch<T[]>(`/api/dataentities/${entity}/search?_where=${encodeURIComponent(filter)}`);
-}
-
-/**
- * Full MasterData search with pagination, field selection, and sorting.
- * Ported from deco-cx/apps vtex/loaders/masterdata/searchDocuments.ts
- *
- * @see https://developers.vtex.com/docs/api-reference/masterdata-api#get-/api/dataentities/-acronym-/search
- */
-export interface SearchDocumentsFullProps {
-	acronym: string;
-	fields?: string;
-	where?: string;
-	sort?: string;
-	/** @default 10 (max 100) */
-	take?: number;
-	/** @default 0 */
-	skip?: number;
-}
-
-export async function searchDocumentsFull<T = Record<string, unknown>>(
-	props: SearchDocumentsFullProps,
-): Promise<T[]> {
-	const { acronym, fields, where, sort, skip = 0, take = 10 } = props;
-	const from = Math.max(skip, 0);
-	const to = from + Math.min(100, take);
-
-	const params = new URLSearchParams();
-	if (fields) params.set("_fields", fields);
-	if (where) params.set("_where", where);
-	if (sort) params.set("_sort", sort);
-
-	const headers: Record<string, string> = {
-		accept: "application/vnd.vtex.ds.v10+json",
-		"content-type": "application/json",
-		"REST-Range": `resources=${from}-${to}`,
-	};
-
-	return vtexFetchResponse(`/api/dataentities/${acronym}/search?${params}`, {
-		headers,
-	}).then((res) => res.json());
-}
-
-// ---------------------------------------------------------------------------
-// Attachments (file upload)
-// ---------------------------------------------------------------------------
-
-export interface UploadAttachmentOpts {
-	entity: string;
-	documentId: string;
-	field: string;
-	fileName: string;
-	/** Base64-encoded file content */
-	fileBase64: string;
-	contentType: string;
-}
-
-/**
- * Upload a file attachment to a MasterData document.
- * Uses the VTEX MasterData attachment API with appKey/appToken auth.
- */
-export async function uploadAttachment(opts: UploadAttachmentOpts): Promise<{ ok: true }> {
-	const { entity, documentId, field, fileName, fileBase64, contentType } = opts;
-	const config = getVtexConfig();
-	const url = `https://${config.account}.vtexcommercestable.${config.domain ?? "com.br"}/api/dataentities/${entity}/documents/${documentId}/${field}/attachments`;
-
-	const binary = atob(fileBase64);
-	const bytes = new Uint8Array(binary.length);
-	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-
-	const blob = new Blob([bytes], { type: contentType });
-	const formData = new FormData();
-	formData.append("file", blob, fileName);
-
-	const headers: Record<string, string> = {};
-	if (config.appKey && config.appToken) {
-		headers["X-VTEX-API-AppKey"] = config.appKey;
-		headers["X-VTEX-API-AppToken"] = config.appToken;
-	}
-
-	const response = await getVtexFetch()(url, {
-		method: "POST",
-		headers,
-		body: formData,
-		operation: "masterdata.attachment.upload",
-	});
-
-	if (!response.ok) {
-		throw new Error(`VTEX attachment upload failed: ${response.status} ${response.statusText}`);
-	}
-
-	return { ok: true };
-}

package/src/actions/misc.ts

@@ -1,188 +0,0 @@
-/**
- * Miscellaneous VTEX actions that don't warrant their own module.
- * Ported from deco-cx/apps:
- *   - vtex/actions/notifyme.ts
- *   - vtex/actions/analytics/sendEvent.ts
- *   - vtex/actions/review/submit.ts
- *   - vtex/actions/payment/deletePaymentToken.ts
- * @see https://developers.vtex.com/docs/api-reference
- */
-import { getVtexConfig, getVtexFetch, vtexFetch } from "../client";
-import { buildAuthCookieHeader, VTEX_AUTH_COOKIE } from "../utils/vtexId";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface NotifyMeProps {
-	email: string;
-	skuId: string;
-	name?: string;
-}
-
-export interface ReviewData {
-	productId: string;
-	rating: number;
-	title: string;
-	text: string;
-	reviewerName: string;
-	approved: boolean;
-}
-
-export type AnalyticsEvent =
-	| {
-			type: "session.ping";
-			url: string;
-	  }
-	| {
-			type: "page.cart";
-			products: { productId: string; quantity: number }[];
-	  }
-	| {
-			type: "page.empty_cart";
-			products: Record<string, never>;
-	  }
-	| {
-			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;
-	  };
-
-export interface ISCookies {
-	anonymous: string;
-	session: string;
-}
-
-export interface DeletePaymentTokenResult {
-	deletePaymentToken: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// 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;
-}
-
-// ---------------------------------------------------------------------------
-// Mutation
-// ---------------------------------------------------------------------------
-
-const DELETE_PAYMENT_TOKEN = `mutation DeleteCreditCardToken($tokenId: ID!) {
-  deletePaymentToken(tokenId: $tokenId) @context(provider: "vtex.my-cards-graphql@2.x")
-}`;
-
-// ---------------------------------------------------------------------------
-// Actions
-// ---------------------------------------------------------------------------
-
-/**
- * Register a "notify me when back in stock" request.
- * Uses the legacy VTEX .aspx form endpoint (FormData, not JSON).
- */
-export async function notifyMe(props: NotifyMeProps): Promise<void> {
-	const { account } = getVtexConfig();
-	const { email, skuId, name = "" } = props;
-
-	const form = new FormData();
-	form.append("notifymeClientName", name);
-	form.append("notifymeClientEmail", email);
-	form.append("notifymeIdSku", skuId);
-
-	await getVtexFetch()(`https://${account}.vtexcommercestable.com.br/no-cache/AviseMe.aspx`, {
-		method: "POST",
-		body: form,
-		operation: "notifyme",
-	});
-}
-
-/**
- * Send an Intelligent Search analytics event to sp.vtex.com.
- *
- * @param event     - The typed event payload.
- * @param isCookies - IS session tracking IDs (anonymous + session).
- *                    In the original, these came from getISCookiesFromBag(ctx).
- * @param userAgent - Forwarded user-agent string.
- */
-export async function sendEvent(
-	event: AnalyticsEvent,
-	isCookies: ISCookies,
-	userAgent?: string,
-): Promise<void> {
-	const { account } = getVtexConfig();
-
-	await getVtexFetch()(`https://sp.vtex.com/event-api/v1/${account}/event`, {
-		method: "POST",
-		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify({
-			...event,
-			...isCookies,
-			agent: userAgent || "deco-sites/apps",
-		}),
-		operation: "analytics.event",
-	});
-}
-
-/**
- * Submit a product review via the Reviews & Ratings API.
- * Hits POST https://{account}.myvtex.com/reviews-and-ratings/api/review.
- * Auth is passed via the `VtexIdclientAutCookie` header (not a Cookie header).
- */
-export async function submitReview(data: ReviewData, authCookie: string): Promise<unknown> {
-	const { account } = getVtexConfig();
-
-	return vtexFetch<unknown>(`https://${account}.myvtex.com/reviews-and-ratings/api/review`, {
-		method: "POST",
-		body: JSON.stringify(data),
-		headers: { [VTEX_AUTH_COOKIE]: authCookie },
-	});
-}
-
-/**
- * Delete a saved payment token (credit card) for the authenticated user.
- * Uses the my-cards-graphql VTEX IO app.
- */
-export async function deletePaymentToken(
-	tokenId: string,
-	authCookie: string,
-): Promise<DeletePaymentTokenResult> {
-	return gql<DeletePaymentTokenResult>(DELETE_PAYMENT_TOKEN, { tokenId }, authCookie);
-}

package/src/actions/newsletter.ts

@@ -1,105 +0,0 @@
-/**
- * VTEX Newsletter actions.
- * Ported from deco-cx/apps:
- *   - vtex/actions/newsletter/subscribe.ts
- *   - vtex/actions/newsletter/updateNewsletterOptIn.ts
- * @see https://developers.vtex.com/docs/guides/newsletter
- */
-import { getVtexConfig, getVtexFetch, vtexFetch } from "../client";
-import { buildAuthCookieHeader } from "../utils/vtexId";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface SubscribeProps {
-	email: string;
-	name?: string;
-	page?: string;
-	part?: string;
-	/** Intentionally preserving the original typo from the VTEX legacy form field. */
-	campaing?: string;
-}
-
-// ---------------------------------------------------------------------------
-// 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;
-}
-
-// ---------------------------------------------------------------------------
-// Mutation
-// ---------------------------------------------------------------------------
-
-const SUBSCRIBE_NEWSLETTER = `mutation SubscribeNewsletter($email: String!, $isNewsletterOptIn: Boolean!) {
-  subscribeNewsletter(email: $email, isNewsletterOptIn: $isNewsletterOptIn) @context(provider: "vtex.store-graphql@2.x")
-}`;
-
-// ---------------------------------------------------------------------------
-// Actions
-// ---------------------------------------------------------------------------
-
-/**
- * Subscribe to the newsletter via the legacy VTEX .aspx form endpoint.
- * Uses raw fetch because the body is FormData (not JSON).
- */
-export async function subscribe(props: SubscribeProps): Promise<void> {
-	const { account } = getVtexConfig();
-	const {
-		email,
-		name = "",
-		part = "newsletter",
-		page = "_",
-		campaing = "newsletter:opt-in",
-	} = props;
-
-	const form = new FormData();
-	form.append("newsletterClientName", name);
-	form.append("newsletterClientEmail", email);
-	form.append("newsInternalPage", page);
-	form.append("newsInternalPart", part);
-	form.append("newsInternalCampaign", campaing);
-
-	await getVtexFetch()(`https://${account}.vtexcommercestable.com.br/no-cache/Newsletter.aspx`, {
-		method: "POST",
-		body: form,
-		operation: "newsletter.subscribe",
-	});
-}
-
-/**
- * Toggle the newsletter opt-in flag for an authenticated user.
- * The original Deco action extracted `email` from the auth cookie payload.
- * Here the caller must provide it explicitly.
- */
-export async function updateNewsletterOptIn(
-	subscribed: boolean,
-	email: string,
-	authCookie: string,
-): Promise<{ subscribed: boolean }> {
-	await gql<unknown>(SUBSCRIBE_NEWSLETTER, { email, isNewsletterOptIn: subscribed }, authCookie);
-	return { subscribed };
-}

package/src/actions/orders.ts

@@ -1,34 +0,0 @@
-/**
- * VTEX Order management actions.
- * Ported from deco-cx/apps:
- *   - vtex/actions/orders/cancel.ts
- * @see https://developers.vtex.com/docs/api-reference/orders-api
- */
-import { getVtexConfig, vtexFetch } from "../client";
-import { buildAuthCookieHeader } from "../utils/vtexId";
-
-// ---------------------------------------------------------------------------
-// Action
-// ---------------------------------------------------------------------------
-
-/**
- * Cancel an order on behalf of the authenticated user.
- * Hits POST /api/checkout/pub/orders/{orderId}/user-cancel-request
- * on vtexcommercestable.com.br.
- */
-export async function cancelOrder(
-	orderId: string,
-	reason: string,
-	authCookie?: string,
-): Promise<void> {
-	const headers: Record<string, string> = {};
-	if (authCookie) {
-		headers.Cookie = buildAuthCookieHeader(authCookie, getVtexConfig().account);
-	}
-
-	await vtexFetch<unknown>(`/api/checkout/pub/orders/${orderId}/user-cancel-request`, {
-		method: "POST",
-		body: JSON.stringify({ reason }),
-		headers,
-	});
-}

package/src/actions/profile.ts

@@ -1,201 +0,0 @@
-/**
- * VTEX Profile update action (store-graphql).
- * Ported from deco-cx/apps:
- *   - vtex/actions/profile/updateProfile.ts
- * @see https://developers.vtex.com/docs/guides/profile-system
- */
-import { getVtexConfig, getVtexFetch, vtexFetch } from "../client";
-import { buildAuthCookieHeader } from "../utils/vtexId";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface ProfileInput {
-	firstName?: string;
-	lastName?: string;
-	birthDate?: string;
-	gender?: string;
-	homePhone?: string;
-	businessPhone?: string;
-	document?: string;
-	email: string;
-	tradeName?: string;
-	corporateName?: string;
-	corporateDocument?: string;
-	stateRegistration?: string;
-	isCorporate?: boolean;
-}
-
-export interface Profile {
-	cacheId: string;
-	firstName: string;
-	lastName: string;
-	birthDate: string;
-	gender: string;
-	homePhone: string;
-	businessPhone: string;
-	document: string;
-	email: string;
-	tradeName: string;
-	corporateName: string;
-	corporateDocument: string;
-	stateRegistration: string;
-	isCorporate: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// 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;
-}
-
-// ---------------------------------------------------------------------------
-// Mutation
-// ---------------------------------------------------------------------------
-
-const UPDATE_PROFILE = `mutation UpdateProfile($input: ProfileInput!) {
-  updateProfile(fields: $input) @context(provider: "vtex.store-graphql") {
-    cacheId
-    firstName
-    lastName
-    birthDate
-    gender
-    homePhone
-    businessPhone
-    document
-    email
-    tradeName
-    corporateName
-    corporateDocument
-    stateRegistration
-    isCorporate
-  }
-}`;
-
-// ---------------------------------------------------------------------------
-// Action
-// ---------------------------------------------------------------------------
-
-/**
- * Update user profile.
- * The original Deco action extracted `email` from the auth cookie payload.
- * Here the caller must provide it explicitly.
- */
-export async function updateProfile(
-	fields: Omit<ProfileInput, "email">,
-	email: string,
-	authCookie: string,
-): Promise<Profile> {
-	const { updateProfile: profile } = await gql<{ updateProfile: Profile }>(
-		UPDATE_PROFILE,
-		{ input: { ...fields, email } },
-		authCookie,
-	);
-	return profile;
-}
-
-// ---------------------------------------------------------------------------
-// Request-aware wrappers (for COMMERCE_LOADERS / invoke proxy)
-// ---------------------------------------------------------------------------
-
-import { getCurrentProfile } from "../loaders/profile";
-import { getVtexCookies } from "../utils/cookies";
-import { deletePaymentToken } from "./misc";
-import { updateNewsletterOptIn } from "./newsletter";
-
-/**
- * Normalize birthDate strings to ISO 8601.
- * Handles dd/mm/yyyy (Brazilian format), yyyy-mm-dd, and full ISO.
- */
-function normalizeBirthDate(profile: Record<string, any>): void {
-	if (!profile.birthDate || typeof profile.birthDate !== "string") return;
-	const ddmmyyyy = profile.birthDate.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
-	if (ddmmyyyy) {
-		profile.birthDate = `${ddmmyyyy[3]}-${ddmmyyyy[2]}-${ddmmyyyy[1]}T00:00:00.000Z`;
-	} else if (!profile.birthDate.includes("T")) {
-		const isoMatch = profile.birthDate.match(/(\d{4})-(\d{2})-(\d{2})/);
-		if (isoMatch) {
-			profile.birthDate = `${isoMatch[0]}T00:00:00.000Z`;
-		}
-	}
-}
-
-/**
- * Update user profile via VTEX IO GraphQL. Handles cookie extraction,
- * birthDate normalization, and undefined-key cleanup.
- */
-export async function updateProfileFromRequest(
-	props: Record<string, any>,
-	request: Request,
-): Promise<any> {
-	const { account } = getVtexConfig();
-	const cookie = getVtexCookies(request);
-	const profile = { ...props };
-	normalizeBirthDate(profile);
-	for (const key of Object.keys(profile)) {
-		if (profile[key] === undefined) delete profile[key];
-	}
-	const QUERY = `mutation UpdateProfile($profile: ProfileInput!) {
-		updateProfile(fields: $profile) @context(provider: "vtex.store-graphql@2.x") {
-			cacheId firstName lastName email document gender homePhone
-			businessPhone birthDate isCorporate corporateName
-			corporateDocument tradeName stateRegistration
-		}
-	}`;
-	const res = await getVtexFetch()(`https://${account}.myvtex.com/_v/private/graphql/v1`, {
-		method: "POST",
-		body: JSON.stringify({ query: QUERY, variables: { profile } }),
-		headers: { "Content-Type": "application/json", cookie },
-		operation: "io.graphql.UpdateProfile",
-	});
-	return res.json();
-}
-
-export async function newsletterProfileFromRequest(
-	props: Record<string, any>,
-	request: Request,
-): Promise<any> {
-	const cookie = request.headers.get("cookie") ?? "";
-	return updateNewsletterOptIn(props.isNewsletterOptIn, props.email, cookie);
-}
-
-export async function deletePaymentFromRequest(
-	props: Record<string, any>,
-	request: Request,
-): Promise<any> {
-	const cookie = getVtexCookies(request);
-	return deletePaymentToken(props.id, cookie);
-}
-
-export async function getPasswordLastUpdate(
-	_props: Record<string, any>,
-	request: Request,
-): Promise<string | null> {
-	const cookie = getVtexCookies(request);
-	const profile = await getCurrentProfile(cookie);
-	return profile?.passwordLastUpdate ?? null;
-}