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

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__/instrumentedFetch.test.ts

@@ -1,84 +0,0 @@
-/**
- * Smoke tests for the pre-wired Shopify fetch factory. Same wiring
- * assertions as `vtex/utils/__tests__/instrumentedFetch.test.ts`.
- */
-
-import { configureMeter, type MeterAdapter } from "@decocms/blocks/sdk/observability";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { createShopifyFetch } from "../instrumentedFetch";
-
-type Labels = Record<string, string | number | boolean>;
-
-function captureHistogram(): {
-	calls: { name: string; value: number; attrs: Labels }[];
-	meter: MeterAdapter;
-} {
-	const calls: { name: string; value: number; attrs: Labels }[] = [];
-	const meter: MeterAdapter = {
-		counterInc: vi.fn(),
-		gaugeSet: vi.fn(),
-		histogramRecord: (name, value, attrs) => {
-			calls.push({ name, value, attrs: attrs ?? {} });
-		},
-	};
-	return { calls, meter };
-}
-
-describe("createShopifyFetch", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-		configureMeter({
-			counterInc: () => {},
-			gaugeSet: () => {},
-			histogramRecord: () => {},
-		});
-	});
-
-	it("emits http.client.request.duration with provider=shopify on success", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async () => new Response("{}", { status: 200 }));
-		const fetchFn = createShopifyFetch({ baseFetch: baseFetch as typeof fetch });
-
-		await fetchFn("https://store.myshopify.com/api/2025-04/graphql.json", { method: "POST" });
-
-		expect(calls).toHaveLength(1);
-		expect(calls[0].name).toBe("http.client.request.duration");
-		expect(calls[0].attrs).toMatchObject({
-			provider: "shopify",
-			operation: "storefront.graphql",
-			status_class: "2xx",
-		});
-	});
-
-	it("honors init.operation (used by the GraphQL client to stamp <OperationName>)", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async () => new Response("{}", { status: 200 }));
-		const fetchFn = createShopifyFetch({ baseFetch: baseFetch as typeof fetch });
-
-		await fetchFn("https://store.myshopify.com/api/2025-04/graphql.json", {
-			method: "POST",
-			operation: "ProductBySlug",
-		});
-
-		expect(calls[0].attrs.operation).toBe("ProductBySlug");
-	});
-
-	it("skips histogram emission when disableHistogram is true", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async () => new Response("{}", { status: 200 }));
-		const fetchFn = createShopifyFetch({
-			baseFetch: baseFetch as typeof fetch,
-			disableHistogram: true,
-		});
-
-		await fetchFn("https://store.myshopify.com/api/2025-04/graphql.json", { method: "POST" });
-
-		expect(calls).toHaveLength(0);
-	});
-});

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

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { shopifyOperationRouter } from "../operationRouter";
-
-describe("shopifyOperationRouter", () => {
-	const store = "https://acme.myshopify.com";
-
-	it("recognizes the storefront GraphQL endpoint", () => {
-		expect(shopifyOperationRouter(`${store}/api/2025-04/graphql.json`, "POST")).toBe(
-			"storefront.graphql",
-		);
-	});
-
-	it("recognizes the admin GraphQL endpoint", () => {
-		expect(shopifyOperationRouter(`${store}/admin/api/2025-04/graphql.json`, "POST")).toBe(
-			"admin.graphql",
-		);
-	});
-
-	it("maps admin REST product / order / customer / inventory endpoints", () => {
-		expect(shopifyOperationRouter(`${store}/admin/api/2025-04/products.json`, "GET")).toBe(
-			"admin.products",
-		);
-		expect(shopifyOperationRouter(`${store}/admin/api/2025-04/orders/123.json`, "GET")).toBe(
-			"admin.orders",
-		);
-		expect(shopifyOperationRouter(`${store}/admin/api/2025-04/customers.json`, "GET")).toBe(
-			"admin.customers",
-		);
-		expect(shopifyOperationRouter(`${store}/admin/api/2025-04/inventory_levels.json`, "GET")).toBe(
-			"admin.inventory",
-		);
-	});
-
-	it("maps storefront checkout + cart endpoints", () => {
-		expect(shopifyOperationRouter(`${store}/api/2025-04/checkouts/abc.json`, "POST")).toBe(
-			"storefront.checkout",
-		);
-		expect(shopifyOperationRouter(`${store}/cart.js`, "GET")).toBe("storefront.cart");
-		expect(shopifyOperationRouter(`${store}/cart/add.js`, "POST")).toBe("storefront.cart");
-	});
-
-	it("returns undefined for unrecognized paths", () => {
-		expect(shopifyOperationRouter(`${store}/random/path`, "GET")).toBeUndefined();
-	});
-
-	it("does not throw on unparseable URLs", () => {
-		expect(shopifyOperationRouter("not-a-url", "GET")).toBeUndefined();
-		expect(shopifyOperationRouter("/api/2025-04/graphql.json", "POST")).toBe("storefront.graphql");
-	});
-
-	it("is case-insensitive on method (no behavioral impact today; future-proofing)", () => {
-		expect(shopifyOperationRouter(`${store}/api/2025-04/graphql.json`, "post")).toBe(
-			"storefront.graphql",
-		);
-	});
-});

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

@@ -1,216 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { ProductShopify, SkuShopify } from "../transform";
-import {
-	toBreadcrumbItem,
-	toBreadcrumbList,
-	toFilter,
-	toProduct,
-	toProductPage,
-} from "../transform";
-
-const makeSku = (overrides?: Partial<SkuShopify>): SkuShopify => ({
-	id: "gid://shopify/ProductVariant/12345",
-	title: "Default / Small",
-	availableForSale: true,
-	quantityAvailable: 10,
-	barcode: "123456789",
-	sku: "SKU-001",
-	image: { url: "https://cdn.shopify.com/img.jpg", altText: "Product image" },
-	price: { amount: "99.90", currencyCode: "BRL" },
-	compareAtPrice: { amount: "129.90", currencyCode: "BRL" },
-	selectedOptions: [{ name: "Size", value: "Small" }],
-	...overrides,
-});
-
-const makeProduct = (overrides?: Partial<ProductShopify>): ProductShopify => ({
-	id: "gid://shopify/Product/1",
-	handle: "test-product",
-	title: "Test Product",
-	description: "A test product",
-	descriptionHtml: "<p>A test product</p>",
-	createdAt: "2024-01-01",
-	tags: ["sale", "new"],
-	vendor: "TestBrand",
-	productType: "Clothing",
-	seo: { title: "Test Product SEO", description: "SEO description" },
-	images: { nodes: [{ url: "https://cdn.shopify.com/img.jpg", altText: "Product" }] },
-	media: { nodes: [] },
-	variants: { nodes: [makeSku()] },
-	collections: {
-		nodes: [{ handle: "clothing", title: "Clothing", id: "col1" }],
-	},
-	...overrides,
-});
-
-describe("toBreadcrumbItem", () => {
-	it("creates breadcrumb item", () => {
-		const result = toBreadcrumbItem({ name: "Home", position: 1, item: "/" });
-		expect(result).toEqual({
-			"@type": "ListItem",
-			name: "Home",
-			position: 1,
-			item: "/",
-		});
-	});
-
-	it("decodes URI-encoded names", () => {
-		const result = toBreadcrumbItem({ name: "Cal%C3%A7ados", position: 1, item: "/calcados" });
-		expect(result.name).toBe("Calçados");
-	});
-});
-
-describe("toBreadcrumbList", () => {
-	it("includes collection in breadcrumb when present", () => {
-		const product = makeProduct();
-		const sku = makeSku();
-		const result = toBreadcrumbList(product, sku);
-		expect(result.itemListElement).toHaveLength(2);
-		expect(result.itemListElement[0].name).toBe("Clothing");
-		expect(result.itemListElement[1].name).toBe("Test Product");
-		expect(result.numberOfItems).toBe(2);
-	});
-
-	it("omits collection when not present", () => {
-		const product = makeProduct({ collections: undefined });
-		const sku = makeSku();
-		const result = toBreadcrumbList(product, sku);
-		expect(result.itemListElement).toHaveLength(1);
-		expect(result.itemListElement[0].name).toBe("Test Product");
-	});
-});
-
-describe("toProduct", () => {
-	it("transforms Shopify product to schema.org Product", () => {
-		const product = makeProduct();
-		const sku = makeSku();
-		const url = new URL("https://example.com/products/test-product-12345");
-		const result = toProduct(product, sku, url);
-
-		expect(result["@type"]).toBe("Product");
-		expect(result.productID).toBe("gid://shopify/ProductVariant/12345");
-		expect(result.name).toBe("Default / Small");
-		expect(result.description).toBe("A test product");
-		expect(result.brand).toEqual({ "@type": "Brand", name: "TestBrand" });
-		expect(result.offers?.priceCurrency).toBe("BRL");
-		expect(result.offers?.lowPrice).toBe(99.9);
-		expect(result.offers?.highPrice).toBe(129.9);
-	});
-
-	it("sets availability based on availableForSale", () => {
-		const product = makeProduct();
-		const sku = makeSku({ availableForSale: false });
-		const url = new URL("https://example.com");
-		const result = toProduct(product, sku, url);
-		expect(result.offers?.offers[0]?.availability).toBe("https://schema.org/OutOfStock");
-	});
-
-	it("uses sale price as high price when no compare at price", () => {
-		const product = makeProduct();
-		const sku = makeSku({ compareAtPrice: null });
-		const url = new URL("https://example.com");
-		const result = toProduct(product, sku, url);
-		expect(result.offers?.highPrice).toBe(99.9);
-	});
-
-	it("includes variants at level 0", () => {
-		const product = makeProduct();
-		const sku = makeSku();
-		const url = new URL("https://example.com");
-		const result = toProduct(product, sku, url, 0);
-		expect(result.isVariantOf?.hasVariant).toHaveLength(1);
-	});
-
-	it("does not include variants at level 1", () => {
-		const product = makeProduct();
-		const sku = makeSku();
-		const url = new URL("https://example.com");
-		const result = toProduct(product, sku, url, 1);
-		expect(result.isVariantOf?.hasVariant).toEqual([]);
-	});
-});
-
-describe("toProductPage", () => {
-	it("creates a full ProductDetailsPage", () => {
-		const product = makeProduct();
-		const url = new URL("https://example.com/products/test-product-12345");
-		const result = toProductPage(product, url);
-
-		expect(result["@type"]).toBe("ProductDetailsPage");
-		expect(result.breadcrumbList["@type"]).toBe("BreadcrumbList");
-		expect(result.product["@type"]).toBe("Product");
-		expect(result.seo?.title).toBe("Test Product SEO");
-		expect(result.seo?.description).toBe("SEO description");
-	});
-
-	it("falls back to product title/description for SEO", () => {
-		const product = makeProduct({ seo: { title: null, description: null } });
-		const url = new URL("https://example.com");
-		const result = toProductPage(product, url);
-		expect(result.seo?.title).toBe("Test Product");
-		expect(result.seo?.description).toBe("A test product");
-	});
-
-	it("selects specified variant by ID", () => {
-		const sku1 = makeSku({ id: "gid://shopify/ProductVariant/111", title: "Red" });
-		const sku2 = makeSku({ id: "gid://shopify/ProductVariant/222", title: "Blue" });
-		const product = makeProduct({ variants: { nodes: [sku1, sku2] } });
-		const url = new URL("https://example.com");
-		const result = toProductPage(product, url, 222);
-		expect(result.product.name).toBe("Blue");
-	});
-});
-
-describe("toFilter", () => {
-	it("creates toggle filter", () => {
-		const filter = {
-			id: "filter.v.color",
-			label: "Color",
-			type: "LIST",
-			values: [
-				{ id: "1", label: "Red", count: 5, input: '{"productVendor":"Red"}' },
-				{ id: "2", label: "Blue", count: 3, input: '{"productVendor":"Blue"}' },
-			],
-		};
-		const url = new URL("https://example.com/collections/all");
-		const result = toFilter(filter, url);
-
-		expect(result["@type"]).toBe("FilterToggle");
-		expect(result.label).toBe("Color");
-		if (result["@type"] === "FilterToggle") {
-			expect(result.values).toHaveLength(2);
-			expect(result.values[0].label).toBe("Red");
-			expect(result.values[0].selected).toBe(false);
-		}
-	});
-
-	it("creates range filter for PRICE_RANGE type", () => {
-		const filter = {
-			id: "filter.v.price",
-			label: "Price",
-			type: "PRICE_RANGE",
-			values: [{ id: "1", label: "0-100", count: 10, input: '{"min":0,"max":100}' }],
-		};
-		const url = new URL("https://example.com");
-		const result = toFilter(filter, url);
-
-		expect(result["@type"]).toBe("FilterRange");
-		if (result["@type"] === "FilterRange") {
-			expect(result.values.min).toBe(0);
-			expect(result.values.max).toBe(100);
-		}
-	});
-
-	it("marks filter as selected when URL contains it", () => {
-		const filter = {
-			id: "filter.v.vendor",
-			label: "Brand",
-			type: "LIST",
-			values: [{ id: "1", label: "Nike", count: 5, input: '{"productVendor":"Nike"}' }],
-		};
-		const url = new URL("https://example.com?filter.v.vendor=Nike");
-		const result = toFilter(filter, url);
-		if (result["@type"] === "FilterToggle") {
-			expect(result.values[0].selected).toBe(true);
-		}
-	});
-});

package/src/utils/admin/admin.ts

@@ -1,57 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file no-explicit-any ban-types ban-unused-ignore
-// biome-ignore-all lint/suspicious/noExplicitAny: generated GraphQL scalar types
-
-export type Maybe<T> = T | null;
-
-export type Scalars = {
-	ID: { input: string; output: string };
-	String: { input: string; output: string };
-	Boolean: { input: boolean; output: boolean };
-	Int: { input: number; output: number };
-	Float: { input: number; output: number };
-	ARN: { input: any; output: any };
-	Date: { input: any; output: any };
-	DateTime: { input: any; output: any };
-	Decimal: { input: any; output: any };
-	FormattedString: { input: any; output: any };
-	HTML: { input: any; output: any };
-	JSON: { input: any; output: any };
-	Money: { input: any; output: any };
-	StorefrontID: { input: any; output: any };
-	URL: { input: any; output: any };
-	UnsignedInt64: { input: any; output: any };
-	UtcOffset: { input: any; output: any };
-};
-
-/** Return type for `draftOrderCalculate` mutation. */
-export type DraftOrderCalculatePayload = {
-	/** The calculated properties for a draft order. */
-	calculatedDraftOrder?: Maybe<CalculatedDraftOrder>;
-};
-
-export interface CalculatedDraftOrder {
-	/** The available shipping rates for the draft order. Requires a customer with a valid shipping address and at least one line item. */
-	availableShippingRates: Array<ShippingRate>;
-}
-
-export type ShippingRate = {
-	/** Human-readable unique identifier for this shipping rate. */
-	handle: Scalars["String"]["output"];
-	/** The cost associated with the shipping rate. */
-	price: MoneyV2;
-	/** The name of the shipping rate. */
-	title: Scalars["String"]["output"];
-};
-
-export type MoneyV2 = {
-	/** Decimal money amount. */
-	amount: Scalars["Decimal"]["output"];
-	/** Currency of the money. */
-	currencyCode: CurrencyCode;
-};
-
-export enum CurrencyCode {
-	CAD = "CAD",
-	Usd = "USD",
-}

package/src/utils/admin/queries.ts

@@ -1,29 +0,0 @@
-import { gql } from "../graphql";
-
-// Fixme: This is to avoid typescript generation errors
-// because it does not accept generating an empty schema
-// TODO: Remove this once you add any other query
-export const Noop = {
-	query: gql`query Noop { app(id: "") { description } }`,
-};
-
-export const draftOrderCalculate = {
-	query: gql` mutation draftOrderCalculate($input: DraftOrderInput!) {
-    calculatedDraftOrder: draftOrderCalculate(input: $input) {
-      calculatedDraftOrder {
-          availableShippingRates {
-              title
-              handle
-              price {
-                amount
-              }
-          }
-      }
-      userErrors {
-        field
-        message
-      }
-    }
-  }
-  `,
-};

package/src/utils/cart.ts

@@ -1,32 +0,0 @@
-import { getCookies, setCookie } from "./cookies";
-
-const CART_COOKIE = "cart";
-const SHOPIFY_PREFIX = "gid://shopify/Cart/";
-
-const ONE_WEEK_MS = 7 * 24 * 3600 * 1_000;
-
-export const getCartCookie = (headers: Headers): string | null => {
-	const cookies = getCookies(headers);
-
-	if (!cookies[CART_COOKIE]) {
-		return null;
-	}
-
-	try {
-		return decodeURIComponent(`${SHOPIFY_PREFIX}${cookies[CART_COOKIE]}`);
-	} catch {
-		return null;
-	}
-};
-
-export const setCartCookie = (headers: Headers, cartId: string) => {
-	setCookie(headers, {
-		name: CART_COOKIE,
-		value: cartId.replace(SHOPIFY_PREFIX, ""),
-		path: "/",
-		expires: new Date(Date.now() + ONE_WEEK_MS),
-		httpOnly: true,
-		secure: true,
-		sameSite: "Lax",
-	});
-};

package/src/utils/cookies.ts

@@ -1,82 +0,0 @@
-/**
- * Node.js-compatible cookie helpers.
- * Replaces Deno's std/http/cookie.ts.
- */
-
-export function getCookies(headers: Headers): Record<string, string> {
-	const cookieHeader = headers.get("cookie") || "";
-	const cookies: Record<string, string> = {};
-	for (const pair of cookieHeader.split(";")) {
-		const [key, ...rest] = pair.trim().split("=");
-		if (key) {
-			cookies[key.trim()] = decodeURIComponent(rest.join("=").trim());
-		}
-	}
-	return cookies;
-}
-
-export function setCookie(
-	headers: Headers,
-	options: {
-		name: string;
-		value: string;
-		path?: string;
-		expires?: Date;
-		maxAge?: number;
-		httpOnly?: boolean;
-		secure?: boolean;
-		sameSite?: "Strict" | "Lax" | "None";
-	},
-) {
-	const parts = [`${options.name}=${encodeURIComponent(options.value)}`];
-	if (options.path) parts.push(`Path=${options.path}`);
-	if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
-	if (options.maxAge !== undefined) parts.push(`Max-Age=${options.maxAge}`);
-	if (options.httpOnly) parts.push("HttpOnly");
-	if (options.secure) parts.push("Secure");
-	if (options.sameSite) parts.push(`SameSite=${options.sameSite}`);
-
-	headers.append("Set-Cookie", parts.join("; "));
-}
-
-export interface Cookie {
-	name: string;
-	value: string;
-	path?: string;
-	expires?: Date;
-	maxAge?: number;
-	httpOnly?: boolean;
-	secure?: boolean;
-	sameSite?: "Strict" | "Lax" | "None";
-}
-
-export function getSetCookies(headers: Headers): Cookie[] {
-	const cookies: Cookie[] = [];
-	const setCookieHeaders = headers.getSetCookie?.() ?? [];
-	for (const header of setCookieHeaders) {
-		const parts = header.split(";").map((p) => p.trim());
-		const [nameValue, ...attrs] = parts;
-		const [name, ...rest] = nameValue.split("=");
-		const value = rest.join("=");
-		const cookie: Cookie = { name: name.trim(), value };
-		for (const attr of attrs) {
-			const [k, v] = attr.split("=");
-			const key = k.trim().toLowerCase();
-			if (key === "path") cookie.path = v?.trim();
-			if (key === "httponly") cookie.httpOnly = true;
-			if (key === "secure") cookie.secure = true;
-			if (key === "samesite") cookie.sameSite = v?.trim() as any;
-			if (key === "max-age") cookie.maxAge = Number(v?.trim());
-		}
-		cookies.push(cookie);
-	}
-	return cookies;
-}
-
-export function debounce<T extends (...args: any[]) => void>(fn: T, delay: number): T {
-	let timer: ReturnType<typeof setTimeout>;
-	return ((...args: any[]) => {
-		clearTimeout(timer);
-		timer = setTimeout(() => fn(...args), delay);
-	}) as T;
-}