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

package/src/loaders/ProductList.ts

@@ -1,102 +0,0 @@
-import type { Product } from "@decocms/apps-commerce/types";
-import { getShopifyClient } from "../client";
-import { ProductsByCollection, SearchProducts } from "../utils/storefront/queries";
-import { type ProductShopify, toProduct } from "../utils/transform";
-import type { Metafield } from "../utils/types";
-import {
-	type CollectionSortKeys,
-	type SearchSortKeys,
-	searchSortShopify,
-	sortShopify,
-} from "../utils/utils";
-
-export interface QueryProps {
-	query: string;
-	count: number;
-	sort?: SearchSortKeys;
-}
-
-export interface CollectionProps {
-	collection: string;
-	count: number;
-	sort?: CollectionSortKeys;
-}
-
-export interface FilterProps {
-	tags?: string[];
-	productTypes?: string[];
-	productVendors?: string[];
-	priceMin?: number;
-	priceMax?: number;
-	variantOptions?: { name: string; value: string }[];
-}
-
-export type Props = {
-	props: QueryProps | CollectionProps;
-	filters?: FilterProps;
-	metafields?: Metafield[];
-};
-
-const isQueryList = (p: QueryProps | CollectionProps): p is QueryProps =>
-	"query" in p && typeof p.query === "string" && typeof p.count === "number";
-
-export default async function productListLoader(
-	expandedProps: Props,
-	url?: URL,
-): Promise<Product[] | null> {
-	const client = getShopifyClient();
-
-	const props = expandedProps.props ?? (expandedProps as unknown as Props["props"]);
-
-	const count = props.count ?? 12;
-	const metafields = expandedProps.metafields || [];
-	const sort = props.sort ?? "";
-
-	const filters: Record<string, unknown>[] = [];
-	for (const tag of expandedProps.filters?.tags ?? []) {
-		filters.push({ tag });
-	}
-	for (const productType of expandedProps.filters?.productTypes ?? []) {
-		filters.push({ productType });
-	}
-	for (const productVendor of expandedProps.filters?.productVendors ?? []) {
-		filters.push({ productVendor });
-	}
-	if (expandedProps.filters?.priceMin != null)
-		filters.push({ price: { min: expandedProps.filters.priceMin } });
-	if (expandedProps.filters?.priceMax != null)
-		filters.push({ price: { max: expandedProps.filters.priceMax } });
-	for (const variantOption of expandedProps.filters?.variantOptions ?? []) {
-		filters.push({ variantOption });
-	}
-
-	let shopifyProducts: { nodes: ProductShopify[] } | undefined;
-
-	if (isQueryList(props)) {
-		const data = await client.query<{ search: { nodes: ProductShopify[] } }>(SearchProducts, {
-			first: count,
-			query: props.query,
-			productFilters: filters,
-			identifiers: metafields,
-			...searchSortShopify[sort],
-		});
-		shopifyProducts = data.search;
-	} else {
-		const data = await client.query<{
-			collection?: { products: { nodes: ProductShopify[] } };
-		}>(ProductsByCollection, {
-			first: count,
-			handle: (props as CollectionProps).collection,
-			filters,
-			identifiers: metafields,
-			...sortShopify[sort],
-		});
-		shopifyProducts = data.collection?.products;
-	}
-
-	const baseUrl = url ?? new URL("https://localhost");
-
-	const products = shopifyProducts?.nodes.map((p) => toProduct(p, p.variants.nodes[0], baseUrl));
-
-	return products ?? [];
-}

package/src/loaders/ProductListingPage.ts

@@ -1,172 +0,0 @@
-import type { ProductListingPage } from "@decocms/apps-commerce/types";
-import { getShopifyClient } from "../client";
-import { ProductsByCollection, SearchProducts } from "../utils/storefront/queries";
-import { type ProductShopify, toFilter, toProduct } from "../utils/transform";
-import type { Metafield } from "../utils/types";
-import {
-	getFiltersByUrl,
-	searchSortOptions,
-	searchSortShopify,
-	sortOptions,
-	sortShopify,
-} from "../utils/utils";
-
-interface PageInfo {
-	hasNextPage: boolean;
-	hasPreviousPage: boolean;
-	endCursor?: string;
-	startCursor?: string;
-}
-
-interface FilterNode {
-	id: string;
-	label: string;
-	type: string;
-	values: Array<{ id: string; label: string; count: number; input: string }>;
-}
-
-interface ProductConnection {
-	nodes: ProductShopify[];
-	pageInfo: PageInfo;
-	filters?: FilterNode[];
-}
-
-export interface Props {
-	query?: string;
-	collectionName?: string;
-	count: number;
-	metafields?: Metafield[];
-	pageOffset?: number;
-	page?: number;
-	startCursor?: string;
-	endCursor?: string;
-	pageHref?: string;
-}
-
-export default async function productListingPageLoader(
-	props: Props,
-	url?: URL,
-): Promise<ProductListingPage | null> {
-	const pageUrl = url ?? new URL(props.pageHref || "https://localhost");
-	const client = getShopifyClient();
-
-	const count = props.count ?? 12;
-	const query = props.query || pageUrl.searchParams.get("q") || "";
-	const currentPageoffset = props.pageOffset ?? 1;
-	const pageParam = pageUrl.searchParams.get("page")
-		? Number(pageUrl.searchParams.get("page")) - currentPageoffset
-		: 0;
-	const page = props.page || pageParam;
-	const endCursor = props.endCursor || pageUrl.searchParams.get("endCursor") || "";
-	const startCursor = props.startCursor || pageUrl.searchParams.get("startCursor") || "";
-	const metafields = props.metafields || [];
-
-	const isSearch = Boolean(query);
-	let hasNextPage = false;
-	let hasPreviousPage = false;
-	let shopifyProducts: ProductConnection | undefined;
-	let shopifyFilters: FilterNode[] | undefined;
-	let records: number | undefined;
-	let collectionTitle: string | undefined;
-	let collectionDescription: string | undefined;
-
-	const sort = pageUrl.searchParams.get("sort") ?? "";
-
-	if (isSearch) {
-		const data = await client.query<{
-			search: ProductConnection & { totalCount?: number; productFilters?: FilterNode[] };
-		}>(SearchProducts, {
-			...(!endCursor && { first: count }),
-			...(endCursor && { last: count }),
-			...(startCursor && { after: startCursor }),
-			...(endCursor && { before: endCursor }),
-			query,
-			productFilters: getFiltersByUrl(pageUrl),
-			identifiers: metafields,
-			...searchSortShopify[sort],
-		});
-
-		shopifyProducts = data.search;
-		shopifyFilters = data.search?.productFilters;
-		records = data.search?.totalCount;
-		hasNextPage = Boolean(data.search?.pageInfo.hasNextPage);
-		hasPreviousPage = Boolean(data.search?.pageInfo.hasPreviousPage);
-	} else {
-		const pathname = props.collectionName || pageUrl.pathname.split("/")[1];
-
-		const data = await client.query<{
-			collection?: {
-				title?: string;
-				description?: string;
-				products: ProductConnection;
-			};
-		}>(ProductsByCollection, {
-			...(!endCursor && { first: count }),
-			...(endCursor && { last: count }),
-			...(startCursor && { after: startCursor }),
-			...(endCursor && { before: endCursor }),
-			identifiers: metafields,
-			handle: pathname,
-			filters: getFiltersByUrl(pageUrl),
-			...sortShopify[sort],
-		});
-
-		shopifyProducts = data.collection?.products;
-		shopifyFilters = data.collection?.products?.filters;
-		hasNextPage = Boolean(data.collection?.products.pageInfo.hasNextPage);
-		hasPreviousPage = Boolean(data.collection?.products.pageInfo.hasPreviousPage);
-		collectionTitle = data.collection?.title;
-		collectionDescription = data.collection?.description;
-	}
-
-	const products = shopifyProducts?.nodes?.map((p) => toProduct(p, p.variants.nodes[0], pageUrl));
-
-	const nextPage = new URLSearchParams(pageUrl.searchParams);
-	const previousPage = new URLSearchParams(pageUrl.searchParams);
-
-	if (hasNextPage) {
-		nextPage.set("page", (page + currentPageoffset + 1).toString());
-		nextPage.set("startCursor", shopifyProducts?.pageInfo.endCursor ?? "");
-		nextPage.delete("endCursor");
-	}
-
-	if (hasPreviousPage) {
-		previousPage.set("page", (page + currentPageoffset - 1).toString());
-		previousPage.set("endCursor", shopifyProducts?.pageInfo.startCursor ?? "");
-		previousPage.delete("startCursor");
-	}
-
-	const filters = shopifyFilters?.map((filter) => toFilter(filter, pageUrl));
-	const currentPage = page + currentPageoffset;
-
-	return {
-		"@type": "ProductListingPage",
-		breadcrumb: {
-			"@type": "BreadcrumbList",
-			itemListElement: [
-				{
-					"@type": "ListItem" as const,
-					name: isSearch ? query : pageUrl.pathname.split("/")[1],
-					item: isSearch ? pageUrl.href : pageUrl.pathname,
-					position: 2,
-				},
-			],
-			numberOfItems: 1,
-		},
-		filters: filters ?? [],
-		products: products ?? [],
-		pageInfo: {
-			nextPage: hasNextPage ? `?${nextPage}` : undefined,
-			previousPage: hasPreviousPage ? `?${previousPage}` : undefined,
-			currentPage,
-			records,
-			recordPerPage: count,
-		},
-		sortOptions: isSearch ? searchSortOptions : sortOptions,
-		seo: {
-			title: collectionTitle || "",
-			description: collectionDescription || "",
-			canonical: `${pageUrl.origin}${pageUrl.pathname}${page >= 1 ? `?page=${page}` : ""}`,
-		},
-	};
-}

package/src/loaders/RelatedProducts.ts

@@ -1,42 +0,0 @@
-import type { Product } from "@decocms/apps-commerce/types";
-import { getShopifyClient } from "../client";
-import { GetProduct, ProductRecommendations } from "../utils/storefront/queries";
-import { type ProductShopify, toProduct } from "../utils/transform";
-import type { Metafield } from "../utils/types";
-
-export interface Props {
-	slug: string;
-	count?: number;
-	metafields?: Metafield[];
-}
-
-export default async function relatedProductsLoader(
-	props: Props,
-	url?: URL,
-): Promise<Product[] | null> {
-	const client = getShopifyClient();
-	const { slug, count = 10, metafields = [] } = props;
-
-	const splitted = slug?.split("-") ?? [];
-	const maybeSkuId = Number(splitted[splitted.length - 1]);
-	const handle = splitted.slice(0, maybeSkuId ? -1 : undefined).join("-");
-
-	const productData = await client.query<{ product?: ProductShopify }>(GetProduct, {
-		handle,
-		identifiers: metafields,
-	});
-
-	if (!productData?.product) return [];
-
-	const data = await client.query<{
-		productRecommendations?: ProductShopify[];
-	}>(ProductRecommendations, { productId: productData.product.id, identifiers: metafields });
-
-	if (!data?.productRecommendations) return [];
-
-	const baseUrl = url ?? new URL("https://localhost");
-
-	return data.productRecommendations
-		.map((p) => toProduct(p, p.variants.nodes[0], baseUrl))
-		.slice(0, count);
-}

package/src/loaders/cart.ts

@@ -1,74 +0,0 @@
-import { getShopifyClient } from "../client";
-import { getCartCookie, setCartCookie } from "../utils/cart";
-import { CreateCart, GetCart } from "../utils/storefront/queries";
-
-export interface CartLine {
-	id: string;
-	quantity: number;
-	merchandise: {
-		id: string;
-		title: string;
-		image?: { url: string; altText?: string | null } | null;
-		product: { title: string; handle: string; onlineStoreUrl?: string | null };
-		price: { amount: string; currencyCode: string };
-	};
-	discountAllocations?: Array<{
-		code?: string;
-		discountedAmount?: { amount: string; currencyCode: string };
-	}>;
-	cost?: {
-		totalAmount: { amount: string; currencyCode: string };
-		subtotalAmount: { amount: string; currencyCode: string };
-		amountPerQuantity?: { amount: string; currencyCode: string };
-		compareAtAmountPerQuantity?: { amount: string; currencyCode: string } | null;
-	};
-}
-
-export interface ShopifyCart {
-	id: string;
-	checkoutUrl: string;
-	totalQuantity: number;
-	lines: { nodes: CartLine[] };
-	cost: {
-		totalTaxAmount?: { amount: string; currencyCode: string };
-		subtotalAmount: { amount: string; currencyCode: string };
-		totalAmount: { amount: string; currencyCode: string };
-		checkoutChargeAmount?: { amount: string; currencyCode: string };
-	};
-	discountCodes?: Array<{ applicable: boolean; code: string }>;
-	discountAllocations?: Array<{
-		discountedAmount: { amount: string; currencyCode: string };
-	}>;
-}
-
-export async function getCart(
-	requestHeaders: Headers,
-	responseHeaders?: Headers,
-): Promise<ShopifyCart | null> {
-	const client = getShopifyClient();
-	const maybeCartId = getCartCookie(requestHeaders);
-
-	const cartId =
-		maybeCartId ??
-		(await client
-			.query<{ payload?: { cart?: { id: string } } }>(CreateCart)
-			.then((data) => data.payload?.cart?.id));
-
-	if (!cartId) throw new Error("Missing cart id");
-
-	const cart = await client
-		.query<{ cart?: ShopifyCart }>(GetCart, { id: decodeURIComponent(cartId) })
-		.then((data) => data.cart ?? null);
-
-	if (responseHeaders) {
-		setCartCookie(responseHeaders, cartId);
-	}
-
-	return cart;
-}
-
-export async function createCart(): Promise<string | null> {
-	const client = getShopifyClient();
-	const data = await client.query<{ payload?: { cart?: { id: string } } }>(CreateCart);
-	return data?.payload?.cart?.id ?? null;
-}

package/src/loaders/shop.ts

@@ -1,35 +0,0 @@
-import { getShopifyClient } from "../client";
-import { GetShopInfo } from "../utils/storefront/queries";
-import type { Metafield } from "../utils/types";
-
-export interface Shop {
-	name: string;
-	description?: string;
-	privacyPolicy?: { title: string; body: string };
-	refundPolicy?: { title: string; body: string };
-	shippingPolicy?: { title: string; body: string };
-	subscriptionPolicy?: { title: string; body: string };
-	termsOfService?: { title: string; body: string };
-	metafields?: Array<{
-		description?: string | null;
-		key: string;
-		namespace: string;
-		type: string;
-		value: string;
-		reference?: { image?: { url: string } } | null;
-		references?: { edges: Array<{ node: { image?: { url: string } } }> } | null;
-	} | null>;
-}
-
-export interface Props {
-	metafields?: Metafield[];
-}
-
-export default async function shopLoader(props?: Props): Promise<Shop> {
-	const client = getShopifyClient();
-	const metafields = props?.metafields || [];
-
-	const data = await client.query<{ shop: Shop }>(GetShopInfo, { identifiers: metafields });
-
-	return data.shop;
-}

package/src/loaders/user.ts

@@ -1,39 +0,0 @@
-import { getShopifyClient } from "../client";
-import { FetchCustomerInfo } from "../utils/storefront/queries";
-import { getUserCookie } from "../utils/user";
-
-export interface ShopifyUser {
-	"@id": string;
-	email: string;
-	givenName: string;
-	familyName: string;
-}
-
-export default async function userLoader(requestHeaders: Headers): Promise<ShopifyUser | null> {
-	const client = getShopifyClient();
-	const customerAccessToken = getUserCookie(requestHeaders);
-
-	if (!customerAccessToken) return null;
-
-	try {
-		const data = await client.query<{
-			customer?: {
-				id: string;
-				email?: string | null;
-				firstName?: string | null;
-				lastName?: string | null;
-			};
-		}>(FetchCustomerInfo, { customerAccessToken });
-
-		if (!data.customer) return null;
-
-		return {
-			"@id": data.customer.id,
-			email: data.customer.email ?? "",
-			givenName: data.customer.firstName ?? "",
-			familyName: data.customer.lastName ?? "",
-		};
-	} catch {
-		return null;
-	}
-}

package/src/manifest.gen.ts

@@ -1,39 +0,0 @@
-// AUTO-GENERATED by scripts/generate-manifests.ts — DO NOT EDIT
-// This file is checked into source control and updated via: npm run generate:manifests
-
-import * as actions_cart_addItems from "./actions/cart/addItems";
-import * as actions_cart_updateCoupons from "./actions/cart/updateCoupons";
-import * as actions_cart_updateItems from "./actions/cart/updateItems";
-import * as actions_user_signIn from "./actions/user/signIn";
-import * as actions_user_signUp from "./actions/user/signUp";
-import * as loaders_cart from "./loaders/cart";
-import * as loaders_ProductDetailsPage from "./loaders/ProductDetailsPage";
-import * as loaders_ProductList from "./loaders/ProductList";
-import * as loaders_ProductListingPage from "./loaders/ProductListingPage";
-import * as loaders_RelatedProducts from "./loaders/RelatedProducts";
-import * as loaders_shop from "./loaders/shop";
-import * as loaders_user from "./loaders/user";
-
-const manifest = {
-	name: "shopify",
-	loaders: {
-		"shopify/loaders/ProductDetailsPage": loaders_ProductDetailsPage,
-		"shopify/loaders/ProductList": loaders_ProductList,
-		"shopify/loaders/ProductListingPage": loaders_ProductListingPage,
-		"shopify/loaders/RelatedProducts": loaders_RelatedProducts,
-		"shopify/loaders/cart": loaders_cart,
-		"shopify/loaders/shop": loaders_shop,
-		"shopify/loaders/user": loaders_user,
-	},
-	actions: {
-		"shopify/actions/cart/addItems": actions_cart_addItems,
-		"shopify/actions/cart/updateCoupons": actions_cart_updateCoupons,
-		"shopify/actions/cart/updateItems": actions_cart_updateItems,
-		"shopify/actions/user/signIn": actions_user_signIn,
-		"shopify/actions/user/signUp": actions_user_signUp,
-	},
-	sections: {},
-} as const;
-
-export type Manifest = typeof manifest;
-export default manifest;

package/src/mod.ts

@@ -1,67 +0,0 @@
-/**
- * Shopify app module — standard autoconfig contract.
- *
- * Exports `configure` following the AppModContract pattern.
- * The framework's `autoconfigApps()` calls these generically.
- *
- * @example
- * ```ts
- * import * as shopifyApp from "@decocms/apps/shopify/mod";
- *
- * const app = await shopifyApp.configure(blocks["deco-shopify"], resolveSecret);
- * if (app) {
- *   // app.manifest, app.state are available
- * }
- * ```
- */
-
-import type { AppDefinition, ResolveSecretFn } from "@decocms/apps-commerce/app-types";
-import { configureShopify, type ShopifyConfig } from "./client";
-import manifest from "./manifest.gen";
-
-// -------------------------------------------------------------------------
-// State
-// -------------------------------------------------------------------------
-
-export interface ShopifyState {
-	config: ShopifyConfig;
-}
-
-// -------------------------------------------------------------------------
-// Configure
-// -------------------------------------------------------------------------
-
-/**
- * Configure the Shopify app from CMS block data.
- * Returns an AppDefinition or null if required fields are missing.
- */
-export async function configure(
-	block: Record<string, unknown>,
-	resolveSecret: ResolveSecretFn,
-): Promise<AppDefinition<ShopifyState> | null> {
-	if (!block?.storeName) return null;
-
-	const storefrontAccessToken =
-		(await resolveSecret(block.storefrontAccessToken, "SHOPIFY_STOREFRONT_TOKEN")) ??
-		(typeof block.storefrontAccessToken === "string" ? block.storefrontAccessToken : null);
-
-	if (!storefrontAccessToken) return null;
-
-	const config: ShopifyConfig = {
-		storeName: block.storeName as string,
-		storefrontAccessToken,
-		publicUrl: block.publicUrl as string | undefined,
-	};
-
-	// Bridge: maintain global singleton for backward compat
-	configureShopify(config);
-
-	return {
-		name: "shopify",
-		manifest,
-		state: { config },
-	};
-}
-
-/** Placeholder preview for CMS editor — evolves when admin supports it. */
-export const preview = undefined;

package/src/registry.ts

@@ -1,9 +0,0 @@
-import type { AppRegistryEntry } from "@decocms/apps-commerce/registry";
-
-export const SHOPIFY_REGISTRY_ENTRY: AppRegistryEntry = {
-	blockKey: "deco-shopify",
-	module: () => import("./mod"),
-	displayName: "Shopify",
-	category: "commerce",
-	description: "Shopify Storefront API commerce integration",
-};

package/src/utils/__tests__/graphqlOperationName.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractGraphqlOperationName } from "../graphqlOperationName";
-
-describe("extractGraphqlOperationName", () => {
-	it("returns the explicit name when provided, regardless of body content", () => {
-		expect(extractGraphqlOperationName("query Whatever { x }", "ForcedName")).toBe("ForcedName");
-		expect(extractGraphqlOperationName("", "Override")).toBe("Override");
-	});
-
-	it("extracts a single named query", () => {
-		expect(
-			extractGraphqlOperationName("query ProductBySlug($slug: String!) { product { id } }"),
-		).toBe("ProductBySlug");
-	});
-
-	it("extracts a single named mutation", () => {
-		expect(
-			extractGraphqlOperationName("mutation CartLinesAdd($cartId: ID!) { cartLinesAdd { } }"),
-		).toBe("CartLinesAdd");
-	});
-
-	it("extracts a single named subscription", () => {
-		expect(extractGraphqlOperationName("subscription OrderEvents { orderUpdated { id } }")).toBe(
-			"OrderEvents",
-		);
-	});
-
-	it("returns undefined for anonymous operations", () => {
-		expect(extractGraphqlOperationName("{ product { id } }")).toBeUndefined();
-		expect(extractGraphqlOperationName("query { product { id } }")).toBeUndefined();
-	});
-
-	it("returns undefined when document has more than one named operation (caller must disambiguate)", () => {
-		const multi = `
-			query OpA { a }
-			query OpB { b }
-		`;
-		expect(extractGraphqlOperationName(multi)).toBeUndefined();
-	});
-
-	it("ignores the words query/mutation/subscription inside string literals", () => {
-		const docWithStringy = `query RealName { thing(arg: "this query mutation subscription is a string") }`;
-		expect(extractGraphqlOperationName(docWithStringy)).toBe("RealName");
-	});
-
-	it("ignores the words inside block strings (triple-quoted)", () => {
-		const doc = `
-			"""
-			This block string mentions query Inner and mutation Inner2.
-			"""
-			query OuterReal { x }
-		`;
-		expect(extractGraphqlOperationName(doc)).toBe("OuterReal");
-	});
-
-	it("ignores the words inside # comments", () => {
-		const doc = `
-			# query CommentedOut { x }
-			query Active { y }
-		`;
-		expect(extractGraphqlOperationName(doc)).toBe("Active");
-	});
-
-	it("returns undefined on an empty / nullish body", () => {
-		expect(extractGraphqlOperationName("")).toBeUndefined();
-		expect(extractGraphqlOperationName("   \n\t  ")).toBeUndefined();
-	});
-
-	it("handles a real-world Shopify storefront query shape", () => {
-		const doc = `
-			query ProductDetails($handle: String!, $country: CountryCode!) @inContext(country: $country) {
-				product(handle: $handle) {
-					id
-					title
-				}
-			}
-		`;
-		expect(extractGraphqlOperationName(doc)).toBe("ProductDetails");
-	});
-});