@vtex/faststore 0.0.7 → 0.0.8

package/dist/sdk/address/use-address-actions.js

@@ -0,0 +1,247 @@
+"use client";
+import { defineActions } from "../../core/dist/actions/registry.js";
+import "../../core/dist/index.js";
+import { loggableErrorName } from "../../utils/loggable-error-name.js";
+import { CUSTOMER_ADDRESS_BOOK_IDENTITY, CUSTOMER_ADDRESS_CREATE, CUSTOMER_ADDRESS_DELETE, CUSTOMER_ADDRESS_UPDATE } from "./operations.js";
+import { useMutation } from "@apollo/client/react";
+import { useCallback, useMemo } from "react";
+import { CombinedGraphQLErrors } from "@apollo/client/errors";
+//#region src/sdk/address/use-address-actions.ts
+const NETWORK_ERROR = {
+	code: "NETWORK_ERROR",
+	message: "Unable to complete the request. Please try again.",
+	field: null
+};
+const UNAUTHORIZED_ERROR = {
+	code: "UNAUTHORIZED",
+	message: "Your session has expired. Please sign in again.",
+	field: null
+};
+/**
+* The writes answer an expired session with a top-level `UNAUTHORIZED`, never a `userError`.
+* Collapsing it into `NETWORK_ERROR` would offer a retry that cannot succeed, so it keeps its own
+* code and the caller can send the shopper back to sign-in.
+*/
+function toUserError(error) {
+	if (CombinedGraphQLErrors.is(error) && error.errors.some(({ extensions }) => extensions?.code === "UNAUTHORIZED")) return UNAUTHORIZED_ERROR;
+	return NETWORK_ERROR;
+}
+/**
+* Takes the address out of the cached address book, then evicts its entity. Apollo hides a dangling
+* reference when it reads a list, so the evict alone would empty the visible list; the explicit edit
+* keeps the stored array free of references to an entity that is gone. With no book cached, only the
+* evict runs.
+*/
+function dropAddress(cache, id) {
+	const book = cache.readQuery({ query: CUSTOMER_ADDRESS_BOOK_IDENTITY })?.customerAddressBook;
+	if (book) cache.modify({
+		id: cache.identify(book),
+		fields: { addresses(existing, { readField }) {
+			return existing.filter((reference) => readField("id", reference) !== id);
+		} }
+	});
+	cache.evict({ id: cache.identify({
+		__typename: "CustomerAddress",
+		id
+	}) });
+}
+/** True when the server says the address is not among the shopper's own: gone, or never theirs. */
+function isNotFound(userErrors) {
+	return userErrors?.some(({ code }) => code === "NOT_FOUND") ?? false;
+}
+/**
+* The `address` namespace hook. Registered with the first-party action registry via `addressActions`
+* below; the compiler-emitted `AddressActionProvider` calls it and threads the narrowed methods into
+* each consumer's `$actions.address`.
+*/
+function useAddressActions() {
+	const [createMutation] = useMutation(CUSTOMER_ADDRESS_CREATE, { update(cache, { data }) {
+		const address = data?.customerAddressCreate.customerAddress;
+		if (!address) return;
+		const book = cache.readQuery({ query: CUSTOMER_ADDRESS_BOOK_IDENTITY })?.customerAddressBook;
+		if (!book) return;
+		cache.modify({
+			id: cache.identify(book),
+			fields: { addresses(existing, { readField, toReference }) {
+				if (existing.some((reference) => readField("id", reference) === address.id)) return existing;
+				const created = toReference(address);
+				return created ? [...existing, created] : existing;
+			} }
+		});
+	} });
+	const [updateMutation] = useMutation(CUSTOMER_ADDRESS_UPDATE, { update(cache, { data }, { variables }) {
+		if (variables && isNotFound(data?.customerAddressUpdate.userErrors)) dropAddress(cache, variables.id);
+	} });
+	const [removeMutation] = useMutation(CUSTOMER_ADDRESS_DELETE, { update(cache, { data }, { variables }) {
+		const payload = data?.customerAddressDelete;
+		if (!payload) return;
+		if (payload.userErrors.length === 0 && payload.deletedCustomerAddressId) dropAddress(cache, payload.deletedCustomerAddressId);
+		else if (variables && isNotFound(payload.userErrors)) dropAddress(cache, variables.id);
+	} });
+	const create = useCallback(async (payload) => {
+		try {
+			return (await createMutation({ variables: { input: payload } })).data?.customerAddressCreate.userErrors ?? [];
+		} catch (error) {
+			console.error("[address.create] customerAddressCreate failed", loggableErrorName(error));
+			return [toUserError(error)];
+		}
+	}, [createMutation]);
+	const update = useCallback(async ({ id, ...input }) => {
+		try {
+			return (await updateMutation({ variables: {
+				id,
+				input
+			} })).data?.customerAddressUpdate.userErrors ?? [];
+		} catch (error) {
+			console.error("[address.update] customerAddressUpdate failed", loggableErrorName(error));
+			return [toUserError(error)];
+		}
+	}, [updateMutation]);
+	const remove = useCallback(async ({ id }) => {
+		try {
+			return (await removeMutation({ variables: { id } })).data?.customerAddressDelete.userErrors ?? [];
+		} catch (error) {
+			console.error("[address.remove] customerAddressDelete failed", loggableErrorName(error));
+			return [toUserError(error)];
+		}
+	}, [removeMutation]);
+	return useMemo(() => ({
+		create,
+		update,
+		remove
+	}), [
+		create,
+		update,
+		remove
+	]);
+}
+defineActions({
+	namespace: "address",
+	description: "Mutation-backed writes against the shopper's saved addresses (create, update, remove).",
+	provider: {
+		name: "AddressActionProvider",
+		importPath: "@vtex/faststore/internal/client"
+	},
+	methods: {
+		create: {
+			description: "Save a new address and add it to the cached address book (async/pessimistic). Resolves the payload userErrors.",
+			payload: [
+				{
+					name: "country",
+					type: "string"
+				},
+				{
+					name: "recipientName",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "street",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "number",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "complement",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "neighborhood",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "city",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "state",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "postalCode",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "reference",
+					type: "string",
+					optional: true
+				}
+			]
+		},
+		update: {
+			description: "Change a saved address (async/pessimistic). Omitted fields are kept; an empty string erases. Resolves the payload userErrors.",
+			payload: [
+				{
+					name: "id",
+					type: "string"
+				},
+				{
+					name: "recipientName",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "street",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "number",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "complement",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "neighborhood",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "city",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "state",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "postalCode",
+					type: "string",
+					optional: true
+				},
+				{
+					name: "reference",
+					type: "string",
+					optional: true
+				}
+			]
+		},
+		remove: {
+			description: "Remove a saved address once the server confirms (async/pessimistic). Resolves the payload userErrors.",
+			payload: [{
+				name: "id",
+				type: "string"
+			}]
+		}
+	},
+	use: useAddressActions
+});
+//#endregion
+export { useAddressActions };
+
+//# sourceMappingURL=use-address-actions.js.map

package/dist/sdk/address/use-address-actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-address-actions.js","names":[],"sources":["../../../src/sdk/address/use-address-actions.ts"],"sourcesContent":["'use client';\n\nimport type { ApolloCache, Reference } from '@apollo/client';\nimport { CombinedGraphQLErrors } from '@apollo/client/errors';\nimport { useMutation } from '@apollo/client/react';\nimport { defineActions } from '@vtex/fs-core';\nimport { useCallback, useMemo } from 'react';\nimport { loggableErrorName } from '../../utils/loggable-error-name.js';\nimport {\n  type AddressCreatePayload,\n  type AddressRemovePayload,\n  type AddressUpdatePayload,\n  CUSTOMER_ADDRESS_BOOK_IDENTITY,\n  CUSTOMER_ADDRESS_CREATE,\n  CUSTOMER_ADDRESS_DELETE,\n  CUSTOMER_ADDRESS_UPDATE,\n  type CustomerAddressUserError,\n} from './operations.js';\n\nexport type {\n  AddressCreatePayload,\n  AddressRemovePayload,\n  AddressUpdatePayload,\n  CustomerAddressUserError,\n} from './operations.js';\n\n/**\n * The `address` action namespace: the one sanctioned client write surface for the shopper's saved\n * addresses (docs/storefront-core/adr-0010-actions-own-the-write-side.md,\n * docs/features/my-account-address-book/rfc.md § Address actions).\n *\n * Every method is async and pessimistic: the cache changes only after the server answers. Each\n * resolves to the payload's `userErrors` (empty on success), with their `field`, so the caller can\n * mark the field. None rejects for an expected outcome. ADR-0010 has handlers surface `userErrors`\n * through the `notifications` action; that action does not exist yet, so the caller presents them.\n */\nexport type AddressActions = Readonly<{\n  /** Save a new address. Appends it to the cached address book on success. Never rejects. */\n  create: (payload: AddressCreatePayload) => Promise<readonly CustomerAddressUserError[]>;\n  /**\n   * Change a saved address. Omit a field to keep it; an empty string erases it. Subscribers update\n   * through the normalized cache. Never rejects.\n   */\n  update: (payload: AddressUpdatePayload) => Promise<readonly CustomerAddressUserError[]>;\n  /**\n   * Remove a saved address. The list changes only once the server confirms. A `NOT_FOUND` answer\n   * means the server no longer has it, so it leaves the cache too. Never rejects.\n   */\n  remove: (payload: AddressRemovePayload) => Promise<readonly CustomerAddressUserError[]>;\n}>;\n\nconst NETWORK_ERROR: CustomerAddressUserError = {\n  code: 'NETWORK_ERROR',\n  message: 'Unable to complete the request. Please try again.',\n  field: null,\n};\n\nconst UNAUTHORIZED_ERROR: CustomerAddressUserError = {\n  code: 'UNAUTHORIZED',\n  message: 'Your session has expired. Please sign in again.',\n  field: null,\n};\n\n/**\n * The writes answer an expired session with a top-level `UNAUTHORIZED`, never a `userError`.\n * Collapsing it into `NETWORK_ERROR` would offer a retry that cannot succeed, so it keeps its own\n * code and the caller can send the shopper back to sign-in.\n */\nfunction toUserError(error: unknown): CustomerAddressUserError {\n  if (CombinedGraphQLErrors.is(error) && error.errors.some(({ extensions }) => extensions?.code === 'UNAUTHORIZED')) {\n    return UNAUTHORIZED_ERROR;\n  }\n  return NETWORK_ERROR;\n}\n\n/**\n * Takes the address out of the cached address book, then evicts its entity. Apollo hides a dangling\n * reference when it reads a list, so the evict alone would empty the visible list; the explicit edit\n * keeps the stored array free of references to an entity that is gone. With no book cached, only the\n * evict runs.\n */\nfunction dropAddress(cache: ApolloCache, id: string): void {\n  const book = cache.readQuery({ query: CUSTOMER_ADDRESS_BOOK_IDENTITY })?.customerAddressBook;\n  if (book) {\n    cache.modify({\n      id: cache.identify(book),\n      fields: {\n        addresses(existing: readonly Reference[], { readField }) {\n          return existing.filter((reference) => readField('id', reference) !== id);\n        },\n      },\n    });\n  }\n  cache.evict({ id: cache.identify({ __typename: 'CustomerAddress', id }) });\n}\n\n/** True when the server says the address is not among the shopper's own: gone, or never theirs. */\nfunction isNotFound(userErrors: readonly CustomerAddressUserError[] | undefined): boolean {\n  return userErrors?.some(({ code }) => code === 'NOT_FOUND') ?? false;\n}\n\n/**\n * The `address` namespace hook. Registered with the first-party action registry via `addressActions`\n * below; the compiler-emitted `AddressActionProvider` calls it and threads the narrowed methods into\n * each consumer's `$actions.address`.\n */\nexport function useAddressActions(): AddressActions {\n  const [createMutation] = useMutation(CUSTOMER_ADDRESS_CREATE, {\n    update(cache, { data }) {\n      const address = data?.customerAddressCreate.customerAddress;\n      if (!address) return;\n      // Read from the cache only: no mounted list means nothing to append to, and the entity the\n      // payload just normalized is all this write leaves behind.\n      const book = cache.readQuery({ query: CUSTOMER_ADDRESS_BOOK_IDENTITY })?.customerAddressBook;\n      if (!book) return;\n      cache.modify({\n        id: cache.identify(book),\n        fields: {\n          addresses(existing: readonly Reference[], { readField, toReference }) {\n            if (existing.some((reference) => readField('id', reference) === address.id)) {\n              return existing;\n            }\n            const created = toReference(address);\n            return created ? [...existing, created] : existing;\n          },\n        },\n      });\n    },\n  });\n\n  const [updateMutation] = useMutation(CUSTOMER_ADDRESS_UPDATE, {\n    update(cache, { data }, { variables }) {\n      if (variables && isNotFound(data?.customerAddressUpdate.userErrors)) dropAddress(cache, variables.id);\n    },\n  });\n\n  const [removeMutation] = useMutation(CUSTOMER_ADDRESS_DELETE, {\n    update(cache, { data }, { variables }) {\n      const payload = data?.customerAddressDelete;\n      if (!payload) return;\n      if (payload.userErrors.length === 0 && payload.deletedCustomerAddressId) {\n        dropAddress(cache, payload.deletedCustomerAddressId);\n      } else if (variables && isNotFound(payload.userErrors)) {\n        dropAddress(cache, variables.id);\n      }\n    },\n  });\n\n  const create = useCallback<AddressActions['create']>(\n    async (payload) => {\n      try {\n        const result = await createMutation({ variables: { input: payload } });\n        return result.data?.customerAddressCreate.userErrors ?? [];\n      } catch (error) {\n        // Log only the error name: the message can echo a submitted address value (PII).\n        console.error('[address.create] customerAddressCreate failed', loggableErrorName(error));\n        return [toUserError(error)];\n      }\n    },\n    [createMutation],\n  );\n\n  const update = useCallback<AddressActions['update']>(\n    async ({ id, ...input }) => {\n      try {\n        // Forwarded unmapped: an empty string is an explicit erase and must survive to the wire.\n        const result = await updateMutation({ variables: { id, input } });\n        return result.data?.customerAddressUpdate.userErrors ?? [];\n      } catch (error) {\n        console.error('[address.update] customerAddressUpdate failed', loggableErrorName(error));\n        return [toUserError(error)];\n      }\n    },\n    [updateMutation],\n  );\n\n  const remove = useCallback<AddressActions['remove']>(\n    async ({ id }) => {\n      try {\n        const result = await removeMutation({ variables: { id } });\n        return result.data?.customerAddressDelete.userErrors ?? [];\n      } catch (error) {\n        console.error('[address.remove] customerAddressDelete failed', loggableErrorName(error));\n        return [toUserError(error)];\n      }\n    },\n    [removeMutation],\n  );\n\n  return useMemo(() => ({ create, update, remove }), [create, update, remove]);\n}\n\n/**\n * Declares the `address` action namespace: the single source of truth for its method/payload\n * metadata, runtime provider, and `use` hook. The native catalog builder\n * (`scripts/build-catalog.mjs`) statically reads this call to emit `actions.json`; at runtime\n * `AddressActionProvider` calls `useAddressActions` directly.\n */\nexport const addressActions = defineActions({\n  namespace: 'address',\n  description: \"Mutation-backed writes against the shopper's saved addresses (create, update, remove).\",\n  provider: { name: 'AddressActionProvider', importPath: '@vtex/faststore/internal/client' },\n  methods: {\n    create: {\n      description:\n        'Save a new address and add it to the cached address book (async/pessimistic). Resolves the payload userErrors.',\n      payload: [\n        { name: 'country', type: 'string' },\n        { name: 'recipientName', type: 'string', optional: true },\n        { name: 'street', type: 'string', optional: true },\n        { name: 'number', type: 'string', optional: true },\n        { name: 'complement', type: 'string', optional: true },\n        { name: 'neighborhood', type: 'string', optional: true },\n        { name: 'city', type: 'string', optional: true },\n        { name: 'state', type: 'string', optional: true },\n        { name: 'postalCode', type: 'string', optional: true },\n        { name: 'reference', type: 'string', optional: true },\n      ],\n    },\n    update: {\n      description:\n        'Change a saved address (async/pessimistic). Omitted fields are kept; an empty string erases. Resolves the payload userErrors.',\n      payload: [\n        { name: 'id', type: 'string' },\n        { name: 'recipientName', type: 'string', optional: true },\n        { name: 'street', type: 'string', optional: true },\n        { name: 'number', type: 'string', optional: true },\n        { name: 'complement', type: 'string', optional: true },\n        { name: 'neighborhood', type: 'string', optional: true },\n        { name: 'city', type: 'string', optional: true },\n        { name: 'state', type: 'string', optional: true },\n        { name: 'postalCode', type: 'string', optional: true },\n        { name: 'reference', type: 'string', optional: true },\n      ],\n    },\n    remove: {\n      description:\n        'Remove a saved address once the server confirms (async/pessimistic). Resolves the payload userErrors.',\n      payload: [{ name: 'id', type: 'string' }],\n    },\n  },\n  use: useAddressActions,\n});\n"],"mappings":"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"}

package/dist/sdk/address/use-address-by-postal-code.js

@@ -0,0 +1,57 @@
+"use client";
+import { withRequestTimeout } from "../shipping/request-timeout.js";
+import { loggableErrorName } from "../../utils/loggable-error-name.js";
+import { ADDRESS_BY_POSTAL_CODE } from "./postal-code-lookup-operations.js";
+import { getApolloContext } from "@apollo/client/react";
+import { useCallback, useContext } from "react";
+//#region src/sdk/address/use-address-by-postal-code.ts
+const FAILED = { status: "failed" };
+/**
+* Postal-code lookup SDK hook (specs/sfs-3430-address-by-postal-code.md).
+*
+* Returns a callback that runs the `AddressByPostalCode` query once per call and never rejects. It
+* reads the client from `getApolloContext()` (a non-throwing read, like `useShippingSimulation`), and
+* skips the cache: a lookup is a shopper's postal code, so it is neither read from nor written to the
+* normalized cache. The hook does not check `hasPostalCodeLookup(country)`; the caller decides
+* whether a country is worth a request, and when to ask and which reply is stale.
+*
+* A failure logs the error's name, as the address actions do, and never the country, the postal
+* code, or a message.
+*/
+function useAddressByPostalCode() {
+	const { client } = useContext(getApolloContext());
+	return useCallback(async ({ country, postalCode }) => {
+		try {
+			if (!client) throw new Error("No Apollo client is available.");
+			const result = await withRequestTimeout((signal) => client.query({
+				query: ADDRESS_BY_POSTAL_CODE,
+				variables: {
+					country,
+					postalCode
+				},
+				fetchPolicy: "no-cache",
+				context: { fetchOptions: { signal } }
+			}));
+			if (result.error) throw result.error;
+			if (!result.data) throw new Error("The lookup returned no data.");
+			const address = result.data.addressByPostalCode;
+			if (!address) return { status: "notFound" };
+			return {
+				status: "found",
+				address: {
+					city: address.city ?? null,
+					state: address.state ?? null,
+					street: address.street ?? null,
+					neighborhood: address.neighborhood ?? null
+				}
+			};
+		} catch (error) {
+			console.error("[address.postalCodeLookup] addressByPostalCode failed", loggableErrorName(error));
+			return FAILED;
+		}
+	}, [client]);
+}
+//#endregion
+export { useAddressByPostalCode };
+
+//# sourceMappingURL=use-address-by-postal-code.js.map

package/dist/sdk/address/use-address-by-postal-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-address-by-postal-code.js","names":[],"sources":["../../../src/sdk/address/use-address-by-postal-code.ts"],"sourcesContent":["'use client';\n\nimport { getApolloContext } from '@apollo/client/react';\nimport { useCallback, useContext } from 'react';\nimport { loggableErrorName } from '../../utils/loggable-error-name.js';\nimport { withRequestTimeout } from '../shipping/request-timeout.js';\nimport { ADDRESS_BY_POSTAL_CODE } from './postal-code-lookup-operations.js';\n\n/**\n * The fields the platform resolves for a postal code. Each is `null` where the platform left it\n * blank, and the state is as the platform codes it, so it may not match a select's option values.\n */\nexport type PostalCodeLookupFields = Readonly<{\n  city: string | null;\n  state: string | null;\n  street: string | null;\n  neighborhood: string | null;\n}>;\n\n/**\n * The three things a lookup can come to. `notFound` is a code the platform does not know; `failed`\n * is a lookup that could not run (no client, a GraphQL error, a transport error, a timeout). The two\n * never look alike, so a caller can show an outage differently from a typo.\n */\nexport type PostalCodeLookupResult =\n  | Readonly<{ status: 'found'; address: PostalCodeLookupFields }>\n  | Readonly<{ status: 'notFound' }>\n  | Readonly<{ status: 'failed' }>;\n\nconst FAILED: PostalCodeLookupResult = { status: 'failed' };\n\n/**\n * Postal-code lookup SDK hook (specs/sfs-3430-address-by-postal-code.md).\n *\n * Returns a callback that runs the `AddressByPostalCode` query once per call and never rejects. It\n * reads the client from `getApolloContext()` (a non-throwing read, like `useShippingSimulation`), and\n * skips the cache: a lookup is a shopper's postal code, so it is neither read from nor written to the\n * normalized cache. The hook does not check `hasPostalCodeLookup(country)`; the caller decides\n * whether a country is worth a request, and when to ask and which reply is stale.\n *\n * A failure logs the error's name, as the address actions do, and never the country, the postal\n * code, or a message.\n */\nexport function useAddressByPostalCode(): (input: {\n  country: string;\n  postalCode: string;\n}) => Promise<PostalCodeLookupResult> {\n  const { client } = useContext(getApolloContext());\n\n  return useCallback(\n    async ({ country, postalCode }): Promise<PostalCodeLookupResult> => {\n      try {\n        if (!client) {\n          throw new Error('No Apollo client is available.');\n        }\n        const result = await withRequestTimeout((signal) =>\n          client.query({\n            query: ADDRESS_BY_POSTAL_CODE,\n            variables: { country, postalCode },\n            fetchPolicy: 'no-cache',\n            context: { fetchOptions: { signal } },\n          }),\n        );\n\n        if (result.error) {\n          throw result.error;\n        }\n        if (!result.data) {\n          throw new Error('The lookup returned no data.');\n        }\n\n        const address = result.data.addressByPostalCode;\n        if (!address) {\n          return { status: 'notFound' };\n        }\n        return {\n          status: 'found',\n          address: {\n            city: address.city ?? null,\n            state: address.state ?? null,\n            street: address.street ?? null,\n            neighborhood: address.neighborhood ?? null,\n          },\n        };\n      } catch (error) {\n        console.error('[address.postalCodeLookup] addressByPostalCode failed', loggableErrorName(error));\n        return FAILED;\n      }\n    },\n    [client],\n  );\n}\n"],"mappings":";;;;;;;AA6BA,MAAM,SAAiC,EAAE,QAAQ,SAAS;;;;;;;;;;;;;AAc1D,SAAgB,yBAGsB;CACpC,MAAM,EAAE,WAAW,WAAW,iBAAiB,CAAC;CAEhD,OAAO,YACL,OAAO,EAAE,SAAS,iBAAkD;EAClE,IAAI;GACF,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,gCAAgC;GAElD,MAAM,SAAS,MAAM,oBAAoB,WACvC,OAAO,MAAM;IACX,OAAO;IACP,WAAW;KAAE;KAAS;IAAW;IACjC,aAAa;IACb,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE;GACtC,CAAC,CACH;GAEA,IAAI,OAAO,OACT,MAAM,OAAO;GAEf,IAAI,CAAC,OAAO,MACV,MAAM,IAAI,MAAM,8BAA8B;GAGhD,MAAM,UAAU,OAAO,KAAK;GAC5B,IAAI,CAAC,SACH,OAAO,EAAE,QAAQ,WAAW;GAE9B,OAAO;IACL,QAAQ;IACR,SAAS;KACP,MAAM,QAAQ,QAAQ;KACtB,OAAO,QAAQ,SAAS;KACxB,QAAQ,QAAQ,UAAU;KAC1B,cAAc,QAAQ,gBAAgB;IACxC;GACF;EACF,SAAS,OAAO;GACd,QAAQ,MAAM,yDAAyD,kBAAkB,KAAK,CAAC;GAC/F,OAAO;EACT;CACF,GACA,CAAC,MAAM,CACT;AACF"}

package/dist/sdk/address/validate-address.js

@@ -0,0 +1,62 @@
+import { ACCOUNT_MAX_LENGTH } from "./constants.js";
+import { resolveLibraryError } from "./messages.js";
+import { declaredMaxLength, toFormValues } from "./schema.js";
+import { createFormState, getVisibleFields, resolveFieldOptions, validate } from "@vtex/country-forms";
+//#region src/sdk/address/validate-address.ts
+const REQUIRED = {
+	code: "required",
+	messageId: "fs/address.error.required"
+};
+const INVALID = {
+	code: "invalid",
+	messageId: "fs/address.error.invalid"
+};
+function isAddressField(name) {
+	return Object.hasOwn(ACCOUNT_MAX_LENGTH, name);
+}
+function isOutsideOptions(field, values, fields) {
+	const value = values[field.name] ?? "";
+	if (field.type !== "select" || value === "") return false;
+	const controller = fields.find(({ name }) => name === field.dependsOn);
+	if (controller && ((values[controller.name] ?? "") === "" || isOutsideOptions(controller, values, fields))) return false;
+	return !(resolveFieldOptions(field, values) ?? []).some((option) => option.value === value);
+}
+/**
+* Checks a draft or a stored address against its country's rules and the account's own rules, and
+* returns at most one error per field. A field's first error wins, in this order: the library's,
+* a select value outside its options, then the account's maximum length.
+*
+* The account's rules cover what the library does not: `recipientName` must not be blank,
+* `reference` and the address name may be empty, every free-text field has a maximum length, and a
+* select's value must be one of the options the library resolves. Keys outside the ten address
+* fields are ignored, so a merged record can carry `geoCoordinate` as it is.
+*/
+function validateAddress(values, rules) {
+	const text = toFormValues(values);
+	const fields = getVisibleFields(rules.schema, text);
+	const errors = {};
+	const declared = new Map(rules.schema.fields.map((field) => [field.name, field]));
+	const libraryErrors = validate(createFormState(rules.schema, text), rules.schema);
+	for (const [name, key] of Object.entries(libraryErrors)) {
+		const field = declared.get(name);
+		if (isAddressField(name) && field) errors[name] = resolveLibraryError(key, {
+			country: rules.country,
+			maxLength: declaredMaxLength(field)
+		});
+	}
+	for (const field of fields) if (isAddressField(field.name) && !errors[field.name] && isOutsideOptions(field, text, fields)) errors[field.name] = INVALID;
+	if ((values.recipientName ?? "").trim() === "" && !errors.recipientName) errors.recipientName = REQUIRED;
+	for (const name of Object.keys(ACCOUNT_MAX_LENGTH).filter(isAddressField)) {
+		const maxLength = ACCOUNT_MAX_LENGTH[name];
+		if (!errors[name] && (values[name] ?? "").length > maxLength) errors[name] = {
+			code: "tooLong",
+			messageId: "fs/address.error.too-long",
+			values: { maxLength }
+		};
+	}
+	return errors;
+}
+//#endregion
+export { validateAddress };
+
+//# sourceMappingURL=validate-address.js.map

package/dist/sdk/address/validate-address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-address.js","names":[],"sources":["../../../src/sdk/address/validate-address.ts"],"sourcesContent":["import {\n  createFormState,\n  type FieldDefinition,\n  type FormValues,\n  getVisibleFields,\n  resolveFieldOptions,\n  validate,\n} from '@vtex/country-forms';\nimport { ACCOUNT_MAX_LENGTH } from './constants.js';\nimport { resolveLibraryError } from './messages.js';\nimport { declaredMaxLength, toFormValues } from './schema.js';\nimport type { AddressErrors, AddressFieldError, AddressFieldName, AddressValues, CountryRules } from './types.js';\n\nconst REQUIRED: AddressFieldError = { code: 'required', messageId: 'fs/address.error.required' };\nconst INVALID: AddressFieldError = { code: 'invalid', messageId: 'fs/address.error.invalid' };\n\nfunction isAddressField(name: string): name is AddressFieldName {\n  return Object.hasOwn(ACCOUNT_MAX_LENGTH, name);\n}\n\nfunction isOutsideOptions(field: FieldDefinition, values: FormValues, fields: readonly FieldDefinition[]): boolean {\n  const value = values[field.name] ?? '';\n  if (field.type !== 'select' || value === '') {\n    return false;\n  }\n\n  // A dependent list exists only for a valid controller; the controller carries its own error.\n  const controller = fields.find(({ name }) => name === field.dependsOn);\n  if (controller && ((values[controller.name] ?? '') === '' || isOutsideOptions(controller, values, fields))) {\n    return false;\n  }\n\n  return !(resolveFieldOptions(field, values) ?? []).some((option) => option.value === value);\n}\n\n/**\n * Checks a draft or a stored address against its country's rules and the account's own rules, and\n * returns at most one error per field. A field's first error wins, in this order: the library's,\n * a select value outside its options, then the account's maximum length.\n *\n * The account's rules cover what the library does not: `recipientName` must not be blank,\n * `reference` and the address name may be empty, every free-text field has a maximum length, and a\n * select's value must be one of the options the library resolves. Keys outside the ten address\n * fields are ignored, so a merged record can carry `geoCoordinate` as it is.\n */\nexport function validateAddress(values: AddressValues, rules: CountryRules): AddressErrors {\n  const text = toFormValues(values);\n  const fields = getVisibleFields(rules.schema, text);\n  const errors: Partial<Record<AddressFieldName, AddressFieldError>> = {};\n\n  const declared = new Map(rules.schema.fields.map((field) => [field.name, field]));\n  const libraryErrors = validate(createFormState(rules.schema, text), rules.schema);\n  for (const [name, key] of Object.entries(libraryErrors)) {\n    const field = declared.get(name);\n    if (isAddressField(name) && field) {\n      errors[name] = resolveLibraryError(key, { country: rules.country, maxLength: declaredMaxLength(field) });\n    }\n  }\n\n  for (const field of fields) {\n    if (isAddressField(field.name) && !errors[field.name] && isOutsideOptions(field, text, fields)) {\n      errors[field.name] = INVALID;\n    }\n  }\n\n  if ((values.recipientName ?? '').trim() === '' && !errors.recipientName) {\n    errors.recipientName = REQUIRED;\n  }\n\n  for (const name of Object.keys(ACCOUNT_MAX_LENGTH).filter(isAddressField)) {\n    const maxLength = ACCOUNT_MAX_LENGTH[name];\n    if (!errors[name] && (values[name] ?? '').length > maxLength) {\n      errors[name] = { code: 'tooLong', messageId: 'fs/address.error.too-long', values: { maxLength } };\n    }\n  }\n\n  return errors;\n}\n"],"mappings":";;;;;AAaA,MAAM,WAA8B;CAAE,MAAM;CAAY,WAAW;AAA4B;AAC/F,MAAM,UAA6B;CAAE,MAAM;CAAW,WAAW;AAA2B;AAE5F,SAAS,eAAe,MAAwC;CAC9D,OAAO,OAAO,OAAO,oBAAoB,IAAI;AAC/C;AAEA,SAAS,iBAAiB,OAAwB,QAAoB,QAA6C;CACjH,MAAM,QAAQ,OAAO,MAAM,SAAS;CACpC,IAAI,MAAM,SAAS,YAAY,UAAU,IACvC,OAAO;CAIT,MAAM,aAAa,OAAO,MAAM,EAAE,WAAW,SAAS,MAAM,SAAS;CACrE,IAAI,gBAAgB,OAAO,WAAW,SAAS,QAAQ,MAAM,iBAAiB,YAAY,QAAQ,MAAM,IACtG,OAAO;CAGT,OAAO,EAAE,oBAAoB,OAAO,MAAM,KAAK,CAAC,EAAA,CAAG,MAAM,WAAW,OAAO,UAAU,KAAK;AAC5F;;;;;;;;;;;AAYA,SAAgB,gBAAgB,QAAuB,OAAoC;CACzF,MAAM,OAAO,aAAa,MAAM;CAChC,MAAM,SAAS,iBAAiB,MAAM,QAAQ,IAAI;CAClD,MAAM,SAA+D,CAAC;CAEtE,MAAM,WAAW,IAAI,IAAI,MAAM,OAAO,OAAO,KAAK,UAAU,CAAC,MAAM,MAAM,KAAK,CAAC,CAAC;CAChF,MAAM,gBAAgB,SAAS,gBAAgB,MAAM,QAAQ,IAAI,GAAG,MAAM,MAAM;CAChF,KAAK,MAAM,CAAC,MAAM,QAAQ,OAAO,QAAQ,aAAa,GAAG;EACvD,MAAM,QAAQ,SAAS,IAAI,IAAI;EAC/B,IAAI,eAAe,IAAI,KAAK,OAC1B,OAAO,QAAQ,oBAAoB,KAAK;GAAE,SAAS,MAAM;GAAS,WAAW,kBAAkB,KAAK;EAAE,CAAC;CAE3G;CAEA,KAAK,MAAM,SAAS,QAClB,IAAI,eAAe,MAAM,IAAI,KAAK,CAAC,OAAO,MAAM,SAAS,iBAAiB,OAAO,MAAM,MAAM,GAC3F,OAAO,MAAM,QAAQ;CAIzB,KAAK,OAAO,iBAAiB,GAAA,CAAI,KAAK,MAAM,MAAM,CAAC,OAAO,eACxD,OAAO,gBAAgB;CAGzB,KAAK,MAAM,QAAQ,OAAO,KAAK,kBAAkB,CAAC,CAAC,OAAO,cAAc,GAAG;EACzE,MAAM,YAAY,mBAAmB;EACrC,IAAI,CAAC,OAAO,UAAU,OAAO,SAAS,GAAA,CAAI,SAAS,WACjD,OAAO,QAAQ;GAAE,MAAM;GAAW,WAAW;GAA6B,QAAQ,EAAE,UAAU;EAAE;CAEpG;CAEA,OAAO;AACT"}

package/dist/sdk/cache/storefront-cache.js

@@ -4,11 +4,36 @@ import { InMemoryCache } from "@apollo/client";
 /**
 * Per-entity normalization and field-merge rules for the Storefront cache.
 *
-* Empty in T1. Domain entries (Product, Cart, OrderForm, …) arrive with the
-* particles that need them — see docs/storefront-core/reference-free-particle-model.md § Typed documents and the shared cache,
-* "Out of Scope".
+* The cart and the order share three types whose ids neither can scope
+* (docs/features/order-placed/rfc.md, 3.4): a totalizer's id is its category
+* ("Items"), which the cart's totalizer line selects by; an address's id is the
+* saved address itself, masked on the order and not on the cart; and a
+* customization's id is the assembly ("Engraving"), which two lines of one cart
+* already share. Normalized, one record would overwrite the other, so each is
+* stored inside the record that holds it, and replaced on every write: safe
+* while every fragment selects the same subfields of each.
+*
+* The lists that hold them are the server's whole answer, so each write
+* replaces the list (`merge: false`). Apollo does the same by default, but warns
+* that data may be lost whenever such a list shrinks, as when a discount line
+* leaves the cart's totalizers; a merge by id would keep that stale line.
+*
+* Other domain entries arrive with the particles that need them — see
+* docs/storefront-core/reference-free-particle-model.md § Typed documents and the shared cache.
 */
-const typePolicies = {};
+const replaceList = { merge: false };
+const typePolicies = {
+	CartTotalizer: { keyFields: false },
+	Address: { keyFields: false },
+	CartItemCustomization: { keyFields: false },
+	Cart: { fields: { totalizers: replaceList } },
+	CartItem: { fields: { customizations: replaceList } },
+	CartItemComposition: { fields: { customizations: replaceList } },
+	Shipping: { fields: { savedAddresses: replaceList } },
+	Order: { fields: { totals: replaceList } },
+	SellerOrder: { fields: { totals: replaceList } },
+	OrderItem: { fields: { customizations: replaceList } }
+};
 /**
 * The single source of truth for InMemoryCache configuration. Both the
 * server-side `createClient` and the client-side `StorefrontProvider`

package/dist/sdk/cache/storefront-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"storefront-cache.js","names":[],"sources":["../../../src/sdk/cache/storefront-cache.ts"],"sourcesContent":["import { InMemoryCache, type InMemoryCacheConfig, type TypePolicies } from '@apollo/client';\nimport { possibleTypes } from '../generated/fragment-types.js';\n\n/**\n * Per-entity normalization and field-merge rules for the Storefront cache.\n *\n * Empty in T1. Domain entries (Product, Cart, OrderForm, …) arrive with the\n * particles that need them — see docs/storefront-core/reference-free-particle-model.md § Typed documents and the shared cache,\n * \"Out of Scope\".\n */\nexport const typePolicies: TypePolicies = {};\n\nexport { possibleTypes };\n\n/**\n * The single source of truth for InMemoryCache configuration. Both the\n * server-side `createClient` and the client-side `StorefrontProvider`\n * consume this so SSR and CSR normalize entities identically.\n */\nexport function getCacheConfig(): InMemoryCacheConfig {\n  return {\n    typePolicies,\n    possibleTypes,\n  };\n}\n\n/**\n * The only place an `InMemoryCache` is constructed on the server path.\n * The client-side provider builds its cache from `getCacheConfig()` so the\n * config is shared verbatim without coupling to a specific InMemoryCache\n * subclass (the Next.js integration ships its own SSR-aware variant).\n */\nexport function buildCache(): InMemoryCache {\n  return new InMemoryCache(getCacheConfig());\n}\n"],"mappings":";;;;;;;;;;AAUA,MAAa,eAA6B,CAAC;;;;;;AAS3C,SAAgB,iBAAsC;CACpD,OAAO;EACL;EACA;CACF;AACF;;;;;;;AAQA,SAAgB,aAA4B;CAC1C,OAAO,IAAI,cAAc,eAAe,CAAC;AAC3C"}
+{"version":3,"file":"storefront-cache.js","names":[],"sources":["../../../src/sdk/cache/storefront-cache.ts"],"sourcesContent":["import { InMemoryCache, type InMemoryCacheConfig, type TypePolicies } from '@apollo/client';\nimport { possibleTypes } from '../generated/fragment-types.js';\n\n/**\n * Per-entity normalization and field-merge rules for the Storefront cache.\n *\n * The cart and the order share three types whose ids neither can scope\n * (docs/features/order-placed/rfc.md, 3.4): a totalizer's id is its category\n * (\"Items\"), which the cart's totalizer line selects by; an address's id is the\n * saved address itself, masked on the order and not on the cart; and a\n * customization's id is the assembly (\"Engraving\"), which two lines of one cart\n * already share. Normalized, one record would overwrite the other, so each is\n * stored inside the record that holds it, and replaced on every write: safe\n * while every fragment selects the same subfields of each.\n *\n * The lists that hold them are the server's whole answer, so each write\n * replaces the list (`merge: false`). Apollo does the same by default, but warns\n * that data may be lost whenever such a list shrinks, as when a discount line\n * leaves the cart's totalizers; a merge by id would keep that stale line.\n *\n * Other domain entries arrive with the particles that need them — see\n * docs/storefront-core/reference-free-particle-model.md § Typed documents and the shared cache.\n */\nconst replaceList = { merge: false } as const;\n\nexport const typePolicies: TypePolicies = {\n  CartTotalizer: { keyFields: false },\n  Address: { keyFields: false },\n  CartItemCustomization: { keyFields: false },\n  Cart: { fields: { totalizers: replaceList } },\n  CartItem: { fields: { customizations: replaceList } },\n  CartItemComposition: { fields: { customizations: replaceList } },\n  Shipping: { fields: { savedAddresses: replaceList } },\n  Order: { fields: { totals: replaceList } },\n  SellerOrder: { fields: { totals: replaceList } },\n  OrderItem: { fields: { customizations: replaceList } },\n};\n\nexport { possibleTypes };\n\n/**\n * The single source of truth for InMemoryCache configuration. Both the\n * server-side `createClient` and the client-side `StorefrontProvider`\n * consume this so SSR and CSR normalize entities identically.\n */\nexport function getCacheConfig(): InMemoryCacheConfig {\n  return {\n    typePolicies,\n    possibleTypes,\n  };\n}\n\n/**\n * The only place an `InMemoryCache` is constructed on the server path.\n * The client-side provider builds its cache from `getCacheConfig()` so the\n * config is shared verbatim without coupling to a specific InMemoryCache\n * subclass (the Next.js integration ships its own SSR-aware variant).\n */\nexport function buildCache(): InMemoryCache {\n  return new InMemoryCache(getCacheConfig());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,cAAc,EAAE,OAAO,MAAM;AAEnC,MAAa,eAA6B;CACxC,eAAe,EAAE,WAAW,MAAM;CAClC,SAAS,EAAE,WAAW,MAAM;CAC5B,uBAAuB,EAAE,WAAW,MAAM;CAC1C,MAAM,EAAE,QAAQ,EAAE,YAAY,YAAY,EAAE;CAC5C,UAAU,EAAE,QAAQ,EAAE,gBAAgB,YAAY,EAAE;CACpD,qBAAqB,EAAE,QAAQ,EAAE,gBAAgB,YAAY,EAAE;CAC/D,UAAU,EAAE,QAAQ,EAAE,gBAAgB,YAAY,EAAE;CACpD,OAAO,EAAE,QAAQ,EAAE,QAAQ,YAAY,EAAE;CACzC,aAAa,EAAE,QAAQ,EAAE,QAAQ,YAAY,EAAE;CAC/C,WAAW,EAAE,QAAQ,EAAE,gBAAgB,YAAY,EAAE;AACvD;;;;;;AASA,SAAgB,iBAAsC;CACpD,OAAO;EACL;EACA;CACF;AACF;;;;;;;AAQA,SAAgB,aAA4B;CAC1C,OAAO,IAAI,cAAc,eAAe,CAAC;AAC3C"}

package/dist/sdk/client/fetch-page-data.d.ts

@@ -17,6 +17,8 @@ export type FetchPageDataOptions<TVars extends OperationVariables> = {} extends
 export type FetchPageDataResult<TData> = {
   data: TData | null;
   error?: ErrorLike;
+  /** Response keys of top-level fields that resolved to null beside an error at their path. */
+  failedFields: string[];
 };
 /**
  * Runs a single query against the provided Apollo Client with the options
@@ -33,6 +35,15 @@ export type FetchPageDataResult<TData> = {
  * partial `data` the server produced. Callers who need to distinguish the
  * two can inspect `result.error` with `CombinedGraphQLErrors.is()` from
  * `@apollo/client/errors`.
+ *
+ * `failedFields` names the root fields a section cannot render from this
+ * result: `null` in `data` with an error whose `path` starts at them. A null
+ * with no error is a legitimate absence, and an error below a root that kept
+ * its data leaves that root renderable, so neither counts. With no data at
+ * all, a failed non-null root nulled the whole response, and every root an
+ * error's `path` starts at counts. The browser skips
+ * seeding a result with failed fields and asks again
+ * (docs/storefront-core/reference-data-layer-runtime.md § Page scope).
  */
 export declare function fetchPageData<TData = unknown, TVars extends OperationVariables = OperationVariables>(client: ApolloClient, document: DocumentNode | TypedDocumentNode<TData, TVars>, options?: FetchPageDataOptions<TVars>): Promise<FetchPageDataResult<TData>>;
 //#endregion

package/dist/sdk/client/fetch-page-data.js

@@ -1,3 +1,4 @@
+import { getFailedFields } from "../data/failed-fields.js";
 //#region src/sdk/client/fetch-page-data.ts
 /**
 * Runs a single query against the provided Apollo Client with the options
@@ -14,6 +15,15 @@
 * partial `data` the server produced. Callers who need to distinguish the
 * two can inspect `result.error` with `CombinedGraphQLErrors.is()` from
 * `@apollo/client/errors`.
+*
+* `failedFields` names the root fields a section cannot render from this
+* result: `null` in `data` with an error whose `path` starts at them. A null
+* with no error is a legitimate absence, and an error below a root that kept
+* its data leaves that root renderable, so neither counts. With no data at
+* all, a failed non-null root nulled the whole response, and every root an
+* error's `path` starts at counts. The browser skips
+* seeding a result with failed fields and asks again
+* (docs/storefront-core/reference-data-layer-runtime.md § Page scope).
 */
 async function fetchPageData(client, document, options = {}) {
 	const result = await client.query({
@@ -24,7 +34,8 @@ async function fetchPageData(client, document, options = {}) {
 	});
 	return {
 		data: result.data ?? null,
-		...result.error ? { error: result.error } : {}
+		...result.error ? { error: result.error } : {},
+		failedFields: getFailedFields(result.data, result.error)
 	};
 }
 //#endregion

package/dist/sdk/client/fetch-page-data.js.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-page-data.js","names":[],"sources":["../../../src/sdk/client/fetch-page-data.ts"],"sourcesContent":["import type { ApolloClient, DocumentNode, ErrorLike, OperationVariables, TypedDocumentNode } from '@apollo/client';\n\n/**\n * Options bag accepted by {@link fetchPageData}.\n *\n * Mirrors Apollo Client 4.x's own `VariablesOption<TVars>` shape: when\n * `TVars` has no required keys (the default `OperationVariables`), variables\n * are optional; when the caller supplies a concrete variables object with\n * required fields, variables become required — matching the contract of the\n * underlying `client.query` call.\n */\n// biome-ignore lint/complexity/noBannedTypes: `{} extends TVars` is the idiomatic probe for \"variables has no required keys\" — same pattern Apollo itself uses.\nexport type FetchPageDataOptions<TVars extends OperationVariables> = {} extends TVars\n  ? { variables?: TVars }\n  : { variables: TVars };\n\nexport type FetchPageDataResult<TData> = {\n  data: TData | null;\n  error?: ErrorLike;\n};\n\n/**\n * Runs a single query against the provided Apollo Client with the options\n * required for stateless RSC rendering (`errorPolicy: 'all'` — partial data\n * is returned alongside the error — and `fetchPolicy: 'no-cache'` — the\n * client's cache is never consulted, so a long-lived module-level client\n * cannot leak state across requests).\n *\n * Never constructs a client itself; callers own the client lifetime via\n * the generated `utils/query-client.ts` or a direct `createClient()` call.\n *\n * Under `errorPolicy: 'all'`, Apollo reports every failure — GraphQL errors\n * and transport-level errors alike — via the `error` field alongside any\n * partial `data` the server produced. Callers who need to distinguish the\n * two can inspect `result.error` with `CombinedGraphQLErrors.is()` from\n * `@apollo/client/errors`.\n */\nexport async function fetchPageData<TData = unknown, TVars extends OperationVariables = OperationVariables>(\n  client: ApolloClient,\n  document: DocumentNode | TypedDocumentNode<TData, TVars>,\n  options: FetchPageDataOptions<TVars> = {} as FetchPageDataOptions<TVars>,\n): Promise<FetchPageDataResult<TData>> {\n  const result = await client.query<TData, TVars>({\n    ...options,\n    query: document,\n    errorPolicy: 'all',\n    fetchPolicy: 'no-cache',\n  });\n\n  return {\n    data: result.data ?? null,\n    ...(result.error ? { error: result.error } : {}),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqCA,eAAsB,cACpB,QACA,UACA,UAAuC,CAAC,GACH;CACrC,MAAM,SAAS,MAAM,OAAO,MAAoB;EAC9C,GAAG;EACH,OAAO;EACP,aAAa;EACb,aAAa;CACf,CAAC;CAED,OAAO;EACL,MAAM,OAAO,QAAQ;EACrB,GAAI,OAAO,QAAQ,EAAE,OAAO,OAAO,MAAM,IAAI,CAAC;CAChD;AACF"}
+{"version":3,"file":"fetch-page-data.js","names":[],"sources":["../../../src/sdk/client/fetch-page-data.ts"],"sourcesContent":["import type { ApolloClient, DocumentNode, ErrorLike, OperationVariables, TypedDocumentNode } from '@apollo/client';\nimport { getFailedFields } from '../data/failed-fields.js';\n\n/**\n * Options bag accepted by {@link fetchPageData}.\n *\n * Mirrors Apollo Client 4.x's own `VariablesOption<TVars>` shape: when\n * `TVars` has no required keys (the default `OperationVariables`), variables\n * are optional; when the caller supplies a concrete variables object with\n * required fields, variables become required — matching the contract of the\n * underlying `client.query` call.\n */\n// biome-ignore lint/complexity/noBannedTypes: `{} extends TVars` is the idiomatic probe for \"variables has no required keys\" — same pattern Apollo itself uses.\nexport type FetchPageDataOptions<TVars extends OperationVariables> = {} extends TVars\n  ? { variables?: TVars }\n  : { variables: TVars };\n\nexport type FetchPageDataResult<TData> = {\n  data: TData | null;\n  error?: ErrorLike;\n  /** Response keys of top-level fields that resolved to null beside an error at their path. */\n  failedFields: string[];\n};\n\n/**\n * Runs a single query against the provided Apollo Client with the options\n * required for stateless RSC rendering (`errorPolicy: 'all'` — partial data\n * is returned alongside the error — and `fetchPolicy: 'no-cache'` — the\n * client's cache is never consulted, so a long-lived module-level client\n * cannot leak state across requests).\n *\n * Never constructs a client itself; callers own the client lifetime via\n * the generated `utils/query-client.ts` or a direct `createClient()` call.\n *\n * Under `errorPolicy: 'all'`, Apollo reports every failure — GraphQL errors\n * and transport-level errors alike — via the `error` field alongside any\n * partial `data` the server produced. Callers who need to distinguish the\n * two can inspect `result.error` with `CombinedGraphQLErrors.is()` from\n * `@apollo/client/errors`.\n *\n * `failedFields` names the root fields a section cannot render from this\n * result: `null` in `data` with an error whose `path` starts at them. A null\n * with no error is a legitimate absence, and an error below a root that kept\n * its data leaves that root renderable, so neither counts. With no data at\n * all, a failed non-null root nulled the whole response, and every root an\n * error's `path` starts at counts. The browser skips\n * seeding a result with failed fields and asks again\n * (docs/storefront-core/reference-data-layer-runtime.md § Page scope).\n */\nexport async function fetchPageData<TData = unknown, TVars extends OperationVariables = OperationVariables>(\n  client: ApolloClient,\n  document: DocumentNode | TypedDocumentNode<TData, TVars>,\n  options: FetchPageDataOptions<TVars> = {} as FetchPageDataOptions<TVars>,\n): Promise<FetchPageDataResult<TData>> {\n  const result = await client.query<TData, TVars>({\n    ...options,\n    query: document,\n    errorPolicy: 'all',\n    fetchPolicy: 'no-cache',\n  });\n\n  return {\n    data: result.data ?? null,\n    ...(result.error ? { error: result.error } : {}),\n    failedFields: getFailedFields(result.data, result.error),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,eAAsB,cACpB,QACA,UACA,UAAuC,CAAC,GACH;CACrC,MAAM,SAAS,MAAM,OAAO,MAAoB;EAC9C,GAAG;EACH,OAAO;EACP,aAAa;EACb,aAAa;CACf,CAAC;CAED,OAAO;EACL,MAAM,OAAO,QAAQ;EACrB,GAAI,OAAO,QAAQ,EAAE,OAAO,OAAO,MAAM,IAAI,CAAC;EAC9C,cAAc,gBAAgB,OAAO,MAAM,OAAO,KAAK;CACzD;AACF"}

package/dist/sdk/content/create-content-runtime.js

@@ -1,3 +1,4 @@
+import { ownValue } from "../../utils/own-value.js";
 import { cache } from "react";
 import { cookies, draftMode } from "next/headers";
 import { createHmac, timingSafeEqual } from "node:crypto";
@@ -571,14 +572,6 @@ function blobByteLength(blob) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/**
-* Own-property read. Every object keyed by an authored id here comes from `JSON.parse` or a plain
-* literal, so it carries `Object.prototype`: a key named `__proto__` or `constructor` would resolve
-* to something inherited instead of to `undefined`, and the absent-key branch would never be taken.
-*/
-function ownValue(source, key) {
-	return Object.hasOwn(source, key) ? source[key] : void 0;
-}
 /** Property check instead of `instanceof`: `AbortSignal.timeout` rejects with a `DOMException`. */
 function isTimeoutError(error) {
 	if (typeof error !== "object" || error === null) return false;