@decocms/apps-vtex 8.1.0-next.0 → 8.1.0-next.2

package/src/__tests__/schemas.test.ts

@@ -1,71 +0,0 @@
-/**
- * End-to-end guard for the acceptance criteria of "real props schemas in
- * /deco/meta": after a site wires VTEX the standard way
- * (createVtexCommerceLoaders → registerCommerceLoaders), the composed meta
- * must publish the real props of the app's loaders/actions — enums included —
- * not the `__resolveType`-only stubs.
- */
-
-import { registerCommerceLoaders } from "@decocms/blocks/cms";
-import { composeMeta, type MetaResponse } from "@decocms/blocks/cms/client";
-import { describe, expect, it } from "vitest";
-import { createVtexCommerceLoaders } from "../commerceLoaders";
-import { registerVtexSchemas } from "../schemas";
-
-const b64 = (s: string) => Buffer.from(s).toString("base64");
-
-const emptySiteMeta = (): MetaResponse => ({
-	major: 1,
-	version: "1.0.0",
-	namespace: "site",
-	site: "test",
-	manifest: { blocks: {} },
-	schema: { definitions: {}, root: {} },
-});
-
-describe("vtex schemas in the composed meta", () => {
-	// Mirrors a real site setup: build the loader map (this also registers the
-	// real schemas), then register it (which auto-registers the stubs).
-	registerCommerceLoaders(createVtexCommerceLoaders());
-	registerVtexSchemas();
-	const meta = composeMeta(emptySiteMeta());
-	const def = (key: string) => meta.schema.definitions[b64(key)];
-
-	it("publishes real props for the intelligent-search PDP loader (both key forms)", () => {
-		for (const key of [
-			"vtex/loaders/intelligentSearch/productDetailsPage.ts",
-			"vtex/loaders/intelligentSearch/productDetailsPage",
-		]) {
-			const d = def(key);
-			expect(d, key).toBeDefined();
-			expect(d.properties.slug, key).toMatchObject({ type: "string" });
-			expect(d.properties.__resolveType.enum, key).toEqual([key]);
-			expect(d.additionalProperties, key).toBeUndefined();
-		}
-	});
-
-	it("publishes the legacy PLP loader with its sort enum preserved", () => {
-		const d = def("vtex/loaders/legacy/productListingPage.ts");
-		expect(d).toBeDefined();
-		expect(d.properties.sort.enum).toContain("OrderByPriceDESC");
-		expect(d.properties.sort.enum).toContain("OrderByPriceASC");
-		expect(d.properties.count).toMatchObject({ type: "number" });
-		expect(d.properties.fq).toMatchObject({ type: "string" });
-	});
-
-	it("publishes real props for a checkout action", () => {
-		const d = def("vtex/actions/checkout/addItemsToCart.ts");
-		expect(d).toBeDefined();
-		expect(d.properties.orderItems).toMatchObject({ type: "array" });
-		expect(d.additionalProperties).toBeUndefined();
-	});
-
-	it("keeps the JSON-editor stub shape for keys without a generated schema", () => {
-		// Registered by createVtexCommerceLoaders but owned by another namespace —
-		// no schemas.gen entry, so the stub (additionalProperties: true) survives.
-		const d = def("commerce/loaders/navbar.ts");
-		expect(d).toBeDefined();
-		expect(d.additionalProperties).toBe(true);
-		expect(Object.keys(d.properties)).toEqual(["__resolveType"]);
-	});
-});

package/src/actions/address.ts

@@ -1,250 +0,0 @@
-/**
- * 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

@@ -1,86 +0,0 @@
-/**
- * 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;