@shop-on/theme-server 0.4.0 → 0.6.0

package/dist/marketing-cookies.js

@@ -1,26 +1,47 @@
 //#region src/marketing-cookies.ts
 const MAX_LENGTH = 256;
-const COOKIE_NAMES = {
-	fbp: "_fbp",
-	fbc: "_fbc"
-};
-function readCookie(cookie, name) {
-	const value = new RegExp(`(?:^|;\\s*)${name}=([^;]*)`).exec(cookie)?.[1]?.trim();
-	if (!value || value.length > MAX_LENGTH) return void 0;
-	return value;
+const MAX_COOKIES_LENGTH = 2048;
+const ALLOWED_NAMES = /* @__PURE__ */ new Set([
+	"_fbp",
+	"_fbc",
+	"_ga",
+	"_gcl_aw",
+	"_gcl_au",
+	"_ttp"
+]);
+const GA_STREAM_NAME = /^_ga_[A-Za-z0-9]+$/;
+function isAllowed(name) {
+	return ALLOWED_NAMES.has(name) || GA_STREAM_NAME.test(name);
 }
 /**
-* Parse `_fbp` / `_fbc` out of a raw `Cookie` header. Returns `{}` when the
-* header is missing or carries neither — the caller then sends no attribution at
-* all rather than a hash of nulls.
+* Parse the attribution cookies out of a raw `Cookie` header. Returns `{}` when
+* the header is missing or carries none — the caller then sends no attribution
+* at all rather than a hash of nulls.
 */
 function parseMarketingCookies(cookie) {
 	if (!cookie) return {};
+	const found = /* @__PURE__ */ new Map();
+	for (const pair of cookie.split(";")) {
+		const separator = pair.indexOf("=");
+		if (separator === -1) continue;
+		const name = pair.slice(0, separator).trim();
+		const value = pair.slice(separator + 1).trim();
+		if (!isAllowed(name) || found.has(name)) continue;
+		if (!value || value.length > MAX_LENGTH) continue;
+		found.set(name, value);
+	}
 	const result = {};
-	for (const [key, name] of Object.entries(COOKIE_NAMES)) {
-		const value = readCookie(cookie, name);
-		if (value) result[key] = value;
+	const fbp = found.get("_fbp");
+	const fbc = found.get("_fbc");
+	if (fbp) result.fbp = fbp;
+	if (fbc) result.fbc = fbc;
+	let cookies = "";
+	for (const [name, value] of found) {
+		const next = cookies ? `${cookies}; ${name}=${value}` : `${name}=${value}`;
+		if (next.length > MAX_COOKIES_LENGTH) break;
+		cookies = next;
 	}
+	if (cookies) result.cookies = cookies;
 	return result;
 }
 //#endregion

package/dist/metafields.d.ts

@@ -0,0 +1,7 @@
+//#region src/metafields.d.ts
+/** A resource's storefront metafields keyed `"namespace.key"`. */
+export type MetafieldMap = Record<string, {
+  type: string;
+  value: string;
+}>;
+//#endregion

package/dist/metafields.js

@@ -0,0 +1,33 @@
+import { memoTTL } from "./cache.js";
+import { getContentVersion } from "./content-version.js";
+//#region src/metafields.ts
+/** Metafield nodes as the `"namespace.key"`-keyed map every reader uses. */
+function toMetafieldMap(nodes) {
+	return Object.fromEntries(nodes.map((m) => [`${m.namespace}.${m.key}`, {
+		type: m.type,
+		value: m.value
+	}]));
+}
+/** The cached metafield read behind each route resource's `*_metafield`
+* dynamic source. `read` returns the resource's metafield nodes, or `null`
+* when the resource is missing. A resource with no published fields is `{}`
+* and IS cached; a missing resource or a failed read is retried next time.
+* Either way the caller gets `{}`, so the template renders its literal. */
+function metafieldsReader(name, read) {
+	const cached = memoTTL(async (ref, locale) => {
+		try {
+			const nodes = await read(ref, locale);
+			return nodes ? toMetafieldMap(nodes) : null;
+		} catch (err) {
+			console.warn(`[${name}] failed:`, err);
+			return null;
+		}
+	}, {
+		key: (ref, locale) => `${name}|${ref}|${locale ?? ""}`,
+		shouldCache: (v) => v !== null,
+		version: getContentVersion
+	});
+	return async (ref, locale) => await cached(ref, locale) ?? {};
+}
+//#endregion
+export { metafieldsReader, toMetafieldMap };

package/dist/page.d.ts

@@ -1,3 +1,4 @@
+import { MetafieldMap } from "./metafields.js";
 //#region src/page.d.ts
 export type PageData = {
   id: string;
@@ -25,4 +26,18 @@ export type PageRef = {
  *  `page(id:)` applies the same `public_visible` gate as the handle path, so a
  *  missing/draft/cross-shop page returns null — the caller falls back. */
 export declare const fetchPageById: (id: string, locale?: string) => Promise<PageRef | null>;
+/** The page's storefront metafields keyed `"namespace.key"` — the
+ * `page_metafield` dynamic source. Its own read, not a field on `fetchPage`,
+ * so a page whose template binds none never asks for them. `{}` on a miss or
+ * a failure, so the literal renders. */
+export declare const fetchPageMetafields: (ref: string, locale?: string) => Promise<MetafieldMap>;
+/** The route CMS page as the theme loader's dynamic sources read it
+ * (`DynamicSourcePage` in `@shop-on/theme-loader`): the title off the page
+ * read the theme already made, and a lazy provider the loader calls only when
+ * a template binds a page field. One builder so a theme picks up a new
+ * provider on upgrade instead of re-listing them. */
+export declare function routePageSource(page: Pick<PageData, "handle" | "title">, locale?: string): {
+  title: string;
+  getMetafields: () => Promise<MetafieldMap>;
+};
 //#endregion

package/dist/page.js

@@ -1,6 +1,7 @@
 import { memoTTL } from "./cache.js";
 import { graphql, request } from "./graphql.js";
 import { getContentVersion } from "./content-version.js";
+import { metafieldsReader } from "./metafields.js";
 //#region src/page.ts
 function parseRef(ref) {
 	return ref.startsWith("gid://") ? { id: ref } : { handle: ref };
@@ -90,5 +91,38 @@ const fetchPageById = async (id, locale) => {
 		return null;
 	}
 };
+const FetchPageMetafieldsQuery = graphql(`
+  query FetchPageMetafields($handle: String, $id: ID) {
+    page(handle: $handle, id: $id) {
+      # Storefront-visible only (the API gates on the storefront scope).
+      metafields(first: 50) {
+        nodes {
+          namespace
+          key
+          type
+          value
+        }
+      }
+    }
+  }
+`);
+/** The page's storefront metafields keyed `"namespace.key"` — the
+* `page_metafield` dynamic source. Its own read, not a field on `fetchPage`,
+* so a page whose template binds none never asks for them. `{}` on a miss or
+* a failure, so the literal renders. */
+const fetchPageMetafields = metafieldsReader("fetchPageMetafields", async (handle, locale) => {
+	return (await request(FetchPageMetafieldsQuery, parseRef(handle), locale ? { acceptLanguage: locale } : void 0)).page?.metafields.nodes ?? null;
+});
+/** The route CMS page as the theme loader's dynamic sources read it
+* (`DynamicSourcePage` in `@shop-on/theme-loader`): the title off the page
+* read the theme already made, and a lazy provider the loader calls only when
+* a template binds a page field. One builder so a theme picks up a new
+* provider on upgrade instead of re-listing them. */
+function routePageSource(page, locale) {
+	return {
+		title: page.title,
+		getMetafields: () => fetchPageMetafields(page.handle, locale)
+	};
+}
 //#endregion
-export { fetchPage, fetchPageById };
+export { fetchPage, fetchPageById, fetchPageMetafields, routePageSource };

package/dist/product.d.ts

@@ -48,6 +48,21 @@ export declare const BadgeTagsFragment: import("gql.tada").TadaDocumentNode<{
   on: "ShopProduct";
   masked: false;
 }>;
+/** `"namespace.key"` names as the card queries' metafield variables. Nothing
+ * named ⇒ the selection stays `@include`d out and the variables at their
+ * defaults, so a caller naming no keys sends exactly the query it always did.
+ * A name without a dot (or with an empty side) names no key and is dropped. */
+export declare function metafieldKeysVariables(keys: readonly string[] | undefined): {
+  withMetafields?: true;
+  metafieldFirst?: number;
+  metafieldKeys?: Array<{
+    namespace: string;
+    key: string;
+  }>;
+};
+/** The cache-key segment for a key list: sorted, so two callers naming the
+ * same keys in a different order share one entry. */
+export declare function metafieldKeysKey(keys: readonly string[] | undefined): string;
 /** Lean fetch for product cards (collection grids, social tiles, shop-the-look).
  * Skips description and caps media at 5. Used by the `product_list` resolver.
  * `includeOptions` (default true) gates the variant-options payload — pass
@@ -55,7 +70,7 @@ export declare const BadgeTagsFragment: import("gql.tada").TadaDocumentNode<{
 export declare function fetchProduct(ref: string, opts?: {
   includeOptions?: boolean;
   locale?: string;
-  metafield?: string;
+  metafieldKeys?: readonly string[];
 }): Promise<ProductData | null>;
 /** Lean card fetch with a plain-text description — same footprint as
  * {@link fetchProduct}, plus `descriptionPlain`; no options/variants. For cards

package/dist/product.js

@@ -2,6 +2,7 @@ import { memoTTL } from "./cache.js";
 import { graphql, request } from "./graphql.js";
 import { getContentVersion } from "./content-version.js";
 import { fetchFileById, toFileInfo } from "./files.js";
+import { toMetafieldMap } from "./metafields.js";
 //#region src/product.ts
 const BadgeTagsFragment = graphql(`
   fragment BadgeTags on ShopProduct @_unmask {
@@ -127,9 +128,9 @@ const FetchProductCardQuery = graphql(`
       $handle: String
       $id: ID
       $includeOptions: Boolean!
-      $includeMetafield: Boolean!
-      $metafieldNamespace: String!
-      $metafieldKey: String!
+      $withMetafields: Boolean = false
+      $metafieldFirst: Int = 0
+      $metafieldKeys: [MetafieldKeyInput!] = []
     ) {
       product(handle: $handle, id: $id) {
         id
@@ -162,14 +163,16 @@ const FetchProductCardQuery = graphql(`
         options @include(if: $includeOptions) {
           ...ProductOptionNode
         }
-        # One storefront-visible metafield a card names, for a caller that
-        # labels each product by it (a theme's product-variations swatches).
-        metafield(namespace: $metafieldNamespace, key: $metafieldKey)
-          @include(if: $includeMetafield) {
-          namespace
-          key
-          type
-          value
+        # The storefront-visible metafields a card names and no more (a
+        # theme's product-variations swatches name one; a closest product
+        # metafield source bound in the picker's scope names each it reads).
+        metafields(first: $metafieldFirst, keys: $metafieldKeys) @include(if: $withMetafields) {
+          nodes {
+            namespace
+            key
+            type
+            value
+          }
         }
         media(first: 5) {
           nodes {
@@ -306,25 +309,38 @@ function toMoney(m) {
 		currencyCode: m.currencyCode
 	};
 }
-/** `namespace.key` as the metafield lookup's two arguments, or null when it
-* names no key. */
-function metafieldRef(ref) {
-	const dot = ref?.indexOf(".") ?? -1;
-	if (!ref || dot <= 0 || dot === ref.length - 1) return null;
+/** `"namespace.key"` names as the card queries' metafield variables. Nothing
+* named ⇒ the selection stays `@include`d out and the variables at their
+* defaults, so a caller naming no keys sends exactly the query it always did.
+* A name without a dot (or with an empty side) names no key and is dropped. */
+function metafieldKeysVariables(keys) {
+	const parsed = [];
+	for (const ref of keys ?? []) {
+		const dot = ref.indexOf(".");
+		if (dot <= 0 || dot === ref.length - 1) continue;
+		parsed.push({
+			namespace: ref.slice(0, dot),
+			key: ref.slice(dot + 1)
+		});
+	}
+	if (parsed.length === 0) return {};
 	return {
-		namespace: ref.slice(0, dot),
-		key: ref.slice(dot + 1)
+		withMetafields: true,
+		metafieldFirst: parsed.length,
+		metafieldKeys: parsed
 	};
 }
-const fetchProductCardCached = memoTTL(async (ref, includeOptions, locale, metafield) => {
-	const lookup = metafieldRef(metafield);
+/** The cache-key segment for a key list: sorted, so two callers naming the
+* same keys in a different order share one entry. */
+function metafieldKeysKey(keys) {
+	return keys?.length ? [...keys].sort().join(",") : "";
+}
+const fetchProductCardCached = memoTTL(async (ref, includeOptions, locale, metafieldKeys) => {
 	try {
 		const p = (await request(FetchProductCardQuery, {
 			...parseRef(ref),
 			includeOptions,
-			includeMetafield: lookup !== null,
-			metafieldNamespace: lookup?.namespace ?? "",
-			metafieldKey: lookup?.key ?? ""
+			...metafieldKeysVariables(metafieldKeys)
 		}, locale ? { acceptLanguage: locale } : void 0)).product;
 		if (!p) return null;
 		return {
@@ -343,17 +359,14 @@ const fetchProductCardCached = memoTTL(async (ref, includeOptions, locale, metaf
 			compare_at: p.defaultVariant.compareAtV2 ? toMoney(p.defaultVariant.compareAtV2) : null,
 			media: toMedia(p.media.nodes, 480),
 			...p.options ? { options: p.options.map(toOption) } : {},
-			...p.metafield ? { metafields: { [`${p.metafield.namespace}.${p.metafield.key}`]: {
-				type: p.metafield.type,
-				value: p.metafield.value
-			} } } : {}
+			...p.metafields ? { metafields: toMetafieldMap(p.metafields.nodes) } : {}
 		};
 	} catch (err) {
 		console.warn("[fetchProduct] failed:", err);
 		return null;
 	}
 }, {
-	key: (ref, includeOptions, locale, metafield) => `card|${ref}|${includeOptions}|${locale ?? ""}|${metafield ?? ""}`,
+	key: (ref, includeOptions, locale, metafieldKeys) => `card|${ref}|${includeOptions}|${locale ?? ""}|${metafieldKeysKey(metafieldKeys)}`,
 	shouldCache: (v) => v !== null,
 	version: getContentVersion
 });
@@ -362,7 +375,7 @@ const fetchProductCardCached = memoTTL(async (ref, includeOptions, locale, metaf
 * `includeOptions` (default true) gates the variant-options payload — pass
 * false when the consuming cards render no swatches. */
 function fetchProduct(ref, opts) {
-	return fetchProductCardCached(ref, opts?.includeOptions ?? true, opts?.locale, opts?.metafield);
+	return fetchProductCardCached(ref, opts?.includeOptions ?? true, opts?.locale, opts?.metafieldKeys);
 }
 const FetchProductShowcaseQuery = graphql(`
     query FetchProductShowcase($handle: String, $id: ID) {
@@ -464,10 +477,7 @@ async function loadProductFull(handle, locale) {
 				title: p.seo.title,
 				description: p.seo.description
 			},
-			metafields: Object.fromEntries(p.metafields.nodes.map((m) => [`${m.namespace}.${m.key}`, {
-				type: m.type,
-				value: m.value
-			}]))
+			metafields: toMetafieldMap(p.metafields.nodes)
 		};
 	} catch (err) {
 		console.warn("[fetchProductFull] failed:", err);
@@ -657,4 +667,4 @@ const fetchProductShowcaseMedia = memoTTL(async ({ handle, namespace, imageKey,
 	version: getContentVersion
 });
 //#endregion
-export { BadgeTagsFragment, fetchProduct, fetchProductFull, fetchProductListDetail, fetchProductShowcase, fetchProductShowcaseMedia, fetchVariantMediaMap };
+export { BadgeTagsFragment, fetchProduct, fetchProductFull, fetchProductListDetail, fetchProductShowcase, fetchProductShowcaseMedia, fetchVariantMediaMap, metafieldKeysKey, metafieldKeysVariables };

package/dist/recommendations.d.ts

@@ -22,5 +22,8 @@ export declare const fetchProductRecommendations: (data: {
    * swatches switch the card to it. Needs `includeOptions`. */
   includeVariants?: boolean;
   locale?: string;
+  /** Storefront-visible metafields (`"namespace.key"`) each card carries, for
+   * the `closest_product_metafield` sources bound on it. Omitted ⇒ none. */
+  metafieldKeys?: readonly string[];
 }) => Promise<RecommendationsData>;
 //#endregion

package/dist/recommendations.js

@@ -1,6 +1,7 @@
 import { memoTTL } from "./cache.js";
 import { graphql, request } from "./graphql.js";
 import { getContentVersion } from "./content-version.js";
+import { metafieldKeysKey, metafieldKeysVariables } from "./product.js";
 import { CollectionProductNodeFragment, toCollectionProduct } from "./collection.js";
 //#region src/recommendations.ts
 const FetchProductRecommendationsQuery = graphql(`
@@ -10,6 +11,9 @@ const FetchProductRecommendationsQuery = graphql(`
       $includeOptions: Boolean!
       $includeVariants: Boolean!
       $mediaFirst: Int!
+      $withMetafields: Boolean = false
+      $metafieldFirst: Int = 0
+      $metafieldKeys: [MetafieldKeyInput!] = []
     ) {
       reference: product(handle: $productHandle) {
         id
@@ -21,13 +25,14 @@ const FetchProductRecommendationsQuery = graphql(`
   `, [CollectionProductNodeFragment]);
 /** A recommendation card's media: its image and the ones a hover gallery shows. */
 const MEDIA_FIRST = 5;
-const fetchRecommendationsCached = memoTTL(async ({ productHandle, intent, includeOptions, includeVariants, locale }) => {
+const fetchRecommendationsCached = memoTTL(async ({ productHandle, intent, includeOptions, includeVariants, locale, metafieldKeys }) => {
 	const res = await request(FetchProductRecommendationsQuery, {
 		productHandle,
 		intent,
 		includeOptions,
 		includeVariants,
-		mediaFirst: MEDIA_FIRST
+		mediaFirst: MEDIA_FIRST,
+		...metafieldKeysVariables(metafieldKeys)
 	}, locale ? { acceptLanguage: locale } : void 0);
 	const products = res.productRecommendations.map(toCollectionProduct);
 	return {
@@ -37,7 +42,7 @@ const fetchRecommendationsCached = memoTTL(async ({ productHandle, intent, inclu
 		products
 	};
 }, {
-	key: ({ productHandle, intent, includeOptions, includeVariants, locale }) => `${intent}|${productHandle}|${includeOptions}|${includeVariants}|${locale ?? ""}`,
+	key: ({ productHandle, intent, includeOptions, includeVariants, locale, metafieldKeys }) => `${intent}|${productHandle}|${includeOptions}|${includeVariants}|${locale ?? ""}|${metafieldKeysKey(metafieldKeys)}`,
 	version: getContentVersion
 });
 /** Server fetch for the storefront `productRecommendations` field. Returns an