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

package/src/utils/utils.ts

@@ -1,159 +0,0 @@
-import type {
-	InputMaybe,
-	ProductCollectionSortKeys,
-	ProductFilter,
-	SearchSortKeys as SearchSortKeysShopify,
-} from "../utils/storefront/storefront.graphql.gen";
-
-export const sortOptions = [
-	{ value: "", label: "relevance:desc" },
-	{ value: "price-ascending", label: "price:asc" },
-	{ value: "price-descending", label: "price:desc" },
-	{ value: "best-selling", label: "orders:desc" },
-	{ value: "title-ascending", label: "name:asc" },
-	{ value: "title-descending", label: "name:desc" },
-	{ value: "created-descending", label: "release:desc" },
-];
-
-// only these sorts work for search at shopify
-export const searchSortOptions = [
-	{ value: "", label: "relevance:desc" },
-	{ value: "price-ascending", label: "price:asc" },
-	{ value: "price-descending", label: "price:desc" },
-];
-
-export type CollectionSortKeys =
-	| ""
-	| "price-descending"
-	| "price-ascending"
-	| "best-selling"
-	| "title-descending"
-	| "title-ascending"
-	| "created-descending";
-
-export type SearchSortKeys = "" | "price-descending" | "price-ascending";
-
-export const searchSortShopify: Record<
-	string,
-	{ sortKey: SearchSortKeysShopify; reverse: boolean }
-> = {
-	"": {
-		sortKey: "RELEVANCE",
-		reverse: false,
-	},
-	"price-descending": {
-		sortKey: "PRICE",
-		reverse: true,
-	},
-	"price-ascending": {
-		sortKey: "PRICE",
-		reverse: false,
-	},
-};
-
-export const sortShopify: Record<
-	string,
-	{
-		sortKey: ProductCollectionSortKeys | SearchSortKeysShopify;
-		reverse: boolean;
-	}
-> = {
-	"": {
-		sortKey: "RELEVANCE",
-		reverse: false,
-	},
-	"price-descending": {
-		sortKey: "PRICE",
-		reverse: true,
-	},
-	"price-ascending": {
-		sortKey: "PRICE",
-		reverse: false,
-	},
-	"best-selling": {
-		sortKey: "BEST_SELLING",
-		reverse: false,
-	},
-	"title-descending": {
-		sortKey: "TITLE",
-		reverse: true,
-	},
-	"title-ascending": {
-		sortKey: "TITLE",
-		reverse: false,
-	},
-	"created-descending": {
-		sortKey: "CREATED",
-		reverse: true,
-	},
-};
-
-export const filterToObject = (type: string, filter: InputMaybe<ProductFilter>) => {
-	if (type === "tag") {
-		return { tag: filter?.tag };
-	}
-	if (type === "productType") {
-		return { productType: filter?.productType };
-	}
-	if (type === "productVendor") {
-		return { productVendor: filter?.productVendor };
-	}
-	if (type === "priceMin") {
-		return { price: { min: filter?.price?.min } };
-	}
-	if (type === "priceMax") {
-		return { price: { max: filter?.price?.max } };
-	}
-	if (type === "variantOption") {
-		return { variantOption: filter?.variantOption };
-	}
-	return undefined;
-};
-
-export const getFiltersByUrl = (url: URL) => {
-	const filters: InputMaybe<ProductFilter[]> | undefined = [];
-	url.searchParams.forEach((value, key) => {
-		if (key.startsWith("filter.v.option")) {
-			filters.push({
-				variantOption: { name: key.split(".")[3], value: value },
-			});
-		} else if (key.startsWith("filter.p.tag")) {
-			filters.push({ tag: value });
-		} else if (key.startsWith("filter.p.type")) {
-			filters.push({ productType: value });
-		} else if (key.startsWith("filter.p.product_type")) {
-			filters.push({ productType: value });
-		} else if (key.startsWith("filter.p.vendor")) {
-			filters.push({ productVendor: value });
-		} else if (key.startsWith("filter.v.availability")) {
-			filters.push({ available: value.toLowerCase() === "in stock" });
-		} else if (key.startsWith("filter.v.price.gte")) {
-			filters.push({ price: { min: Number(value) } });
-		} else if (key.startsWith("filter.v.price.lte")) {
-			filters.push({ price: { max: Number(value) } });
-		} else if (key.startsWith("filter.p.m.custom")) {
-			filters.push({
-				productMetafield: {
-					namespace: "custom",
-					key: key.replace("filter.p.m.custom.", ""),
-					value: value,
-				},
-			});
-		} else if (key.startsWith("filter.v.t.shopify")) {
-			filters.push({
-				taxonomyMetafield: {
-					namespace: "shopify",
-					key: key.replace("filter.v.t.shopify.", ""),
-					value: value,
-				},
-			});
-		} else if (key.startsWith("filter.p.t.category")) {
-			filters.push({
-				category: {
-					id: value,
-				},
-			});
-		}
-	});
-	return filters;
-};

package/src/v8/client.test.ts

@@ -1,136 +0,0 @@
-// @vitest-environment node
-/**
- * createShopifyClient (/next/upstream-clients#write-a-client): every request
- * goes through the instrumented fetch as provider "shopify", labeled with the
- * GraphQL operation name, and errors carry no bodies or tokens.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const seen = vi.hoisted(() => ({
-  options: [] as unknown[],
-  operations: [] as (string | undefined)[],
-}));
-
-vi.mock("@decocms/blocks/fetch", async (importOriginal) => {
-  const real = await importOriginal<typeof import("@decocms/blocks/fetch")>();
-  return {
-    createInstrumentedFetch: (options: Parameters<typeof real.createInstrumentedFetch>[0]) => {
-      seen.options.push(options);
-      const request = real.createInstrumentedFetch(options);
-      return (input: string | URL | Request, init?: RequestInit & { operation?: string }) => {
-        seen.operations.push(init?.operation);
-        return request(input, init);
-      };
-    },
-  };
-});
-
-import { createShopifyClient, ShopifyError } from "./client";
-
-function upstream(body: unknown, status = 200) {
-  return vi.fn(
-    async (_input: string | URL | Request, _init?: RequestInit) =>
-      new Response(JSON.stringify(body), { status }),
-  );
-}
-
-const config = { storeName: "acme", storefrontAccessToken: "sf-token", apiVersion: "2026-07" };
-
-beforeEach(() => {
-  seen.options.length = 0;
-  seen.operations.length = 0;
-});
-
-describe("createShopifyClient", () => {
-  it("posts to the Storefront API through the instrumented fetch, with no retries or circuit breaker", async () => {
-    const fetch = upstream({ data: { product: { id: "1" } } });
-    const shopify = createShopifyClient(config, { fetch });
-
-    const data = await shopify.storefront.query<{ product: { id: string } }>(
-      "query ProductByHandle($handle: String!) { product(handle: $handle) { id } }",
-      { handle: "linen-shirt" },
-      { headers: { "Shopify-Storefront-Buyer-IP": "203.0.113.7" } },
-    );
-
-    expect(data).toEqual({ product: { id: "1" } });
-    expect(seen.options).toEqual([{ provider: "shopify", fetch }]);
-    expect(seen.operations).toEqual(["ProductByHandle"]);
-    const [url, init] = fetch.mock.calls[0] ?? [];
-    expect(url).toBe("https://acme.myshopify.com/api/2026-07/graphql.json");
-    expect(init?.method).toBe("POST");
-    expect(init?.headers).toMatchObject({
-      "x-shopify-storefront-access-token": "sf-token",
-      "Shopify-Storefront-Buyer-IP": "203.0.113.7",
-    });
-    expect(JSON.parse(String(init?.body))).toEqual({
-      query: "query ProductByHandle($handle: String!) { product(handle: $handle) { id } }",
-      variables: { handle: "linen-shirt" },
-    });
-  });
-
-  it("labels an unnamed document by its API surface", async () => {
-    const fetch = upstream({ data: { shop: { name: "Acme" } } });
-    const shopify = createShopifyClient(
-      { ...config, adminAccessToken: "admin-token", apiVersion: "2025-07" },
-      { fetch },
-    );
-    await shopify.storefront.query("{ shop { name } }");
-    await shopify.admin.query("{ shop { name } }");
-
-    expect(seen.operations).toEqual(["storefront.graphql", "admin.graphql"]);
-    expect(fetch.mock.calls[1]?.[0]).toBe(
-      "https://acme.myshopify.com/admin/api/2025-07/graphql.json",
-    );
-    expect(fetch.mock.calls[1]?.[1]?.headers).toMatchObject({
-      "x-shopify-access-token": "admin-token",
-    });
-  });
-
-  it("refuses admin calls without an admin token, without sending anything", async () => {
-    const fetch = upstream({ data: {} });
-    const shopify = createShopifyClient(config, { fetch });
-    await expect(shopify.admin.query("{ shop { name } }")).rejects.toThrow(/adminAccessToken/);
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it("reports HTTP failures by operation and status, never the body or token", async () => {
-    const fetch = upstream({ errors: "secret upstream detail sf-token" }, 401);
-    const shopify = createShopifyClient(config, { fetch });
-    const error = (await shopify.storefront
-      .query("query Cart { cart { id } }")
-      .catch((e: unknown) => e)) as ShopifyError;
-
-    expect(error).toBeInstanceOf(ShopifyError);
-    expect(error).toMatchObject({ operation: "Cart", status: 401, codes: [] });
-    expect(error.message).toBe("shopify Cart failed with HTTP 401");
-  });
-
-  it("reports a non-JSON body as INVALID_JSON, never quoting the body", async () => {
-    const fetch = vi.fn(async () => new Response("<html>sf-token</html>", { status: 200 }));
-    const shopify = createShopifyClient(config, { fetch });
-    const error = (await shopify.storefront
-      .query("query Cart { cart { id } }")
-      .catch((e: unknown) => e)) as ShopifyError;
-
-    expect(error).toBeInstanceOf(ShopifyError);
-    expect(error).toMatchObject({ operation: "Cart", status: 200, codes: ["INVALID_JSON"] });
-    expect(error.message).not.toContain("sf-token");
-    expect(error.message).not.toContain("<html");
-  });
-
-  it("reports GraphQL errors by their codes, not their messages", async () => {
-    const fetch = upstream({
-      errors: [
-        { message: "Throttled for customer@example.com", extensions: { code: "THROTTLED" } },
-        { message: "again", extensions: { code: "THROTTLED" } },
-      ],
-    });
-    const shopify = createShopifyClient(config, { fetch });
-    const error = (await shopify.storefront
-      .query("query Cart { cart { id } }")
-      .catch((e: unknown) => e)) as ShopifyError;
-
-    expect(error).toMatchObject({ operation: "Cart", status: 200, codes: ["THROTTLED"] });
-    expect(error.message).not.toContain("customer@example.com");
-  });
-});

package/src/v8/client.ts

@@ -1,125 +0,0 @@
-/**
- * The Shopify upstream client (/next/upstream-clients): the Storefront and
- * Admin GraphQL APIs over the framework's instrumented fetch, and nothing
- * else. Converters to commerce types, cart and customer flows, hooks and
- * loaders live in the Shopify platform template and site code.
- *
- * Every request is measured as provider "shopify", labeled with the GraphQL
- * operation's own name (`query ProductByHandle { … }` → "ProductByHandle"),
- * or "storefront.graphql" / "admin.graphql" for an unnamed document. Retries
- * and the circuit breaker stay off, as for every client but VTEX's; caching
- * is the framework binding's job.
- */
-import { createInstrumentedFetch } from "@decocms/blocks/fetch";
-import { extractGraphqlOperationName } from "./graphqlOperationName";
-
-export interface ShopifyClientConfig {
-  /** The store's subdomain: "acme" for acme.myshopify.com. */
-  storeName: string;
-  /** Storefront API access token. */
-  storefrontAccessToken: string;
-  /** Admin API access token; `admin` is only available when it's set. */
-  adminAccessToken?: string;
-  /** The Shopify API version, e.g. "2026-07". The site owns it, so there is no default to go stale. */
-  apiVersion: string;
-}
-
-interface ShopifyRequestOptions {
-  /** Extra request headers, e.g. `Shopify-Storefront-Buyer-IP`. */
-  headers?: Record<string, string>;
-  signal?: AbortSignal;
-}
-
-/** One GraphQL endpoint: send a document, get its `data` back. */
-interface ShopifyGraphQL {
-  query<T, V extends Record<string, unknown> = Record<string, unknown>>(
-    document: string,
-    variables?: V,
-    options?: ShopifyRequestOptions,
-  ): Promise<T>;
-}
-
-export interface ShopifyClient {
-  storefront: ShopifyGraphQL;
-  /** Throws when called without `adminAccessToken` in the config. */
-  admin: ShopifyGraphQL;
-}
-
-/** A failed request. Carries the operation, the HTTP status and Shopify's error codes; never bodies or tokens. */
-export class ShopifyError extends Error {
-  constructor(
-    readonly operation: string,
-    readonly status: number,
-    readonly codes: string[] = [],
-  ) {
-    super(
-      codes.length > 0
-        ? `shopify ${operation} returned GraphQL errors (${codes.join(", ")})`
-        : `shopify ${operation} failed with HTTP ${status}`,
-    );
-    this.name = "ShopifyError";
-  }
-}
-
-export function createShopifyClient(
-  config: ShopifyClientConfig,
-  options: { fetch?: typeof globalThis.fetch } = {},
-): ShopifyClient {
-  const request = createInstrumentedFetch({ provider: "shopify", fetch: options.fetch });
-  const origin = `https://${config.storeName}.myshopify.com`;
-  const version = config.apiVersion;
-
-  const endpoint = (surface: "storefront" | "admin", url: string, auth: Record<string, string>) =>
-    ({
-      async query(document, variables, { headers, signal } = {}) {
-        const operation = extractGraphqlOperationName(document) ?? `${surface}.graphql`;
-        const response = await request(url, {
-          operation,
-          method: "POST",
-          headers: { "content-type": "application/json", ...headers, ...auth },
-          body: JSON.stringify({ query: document, variables }),
-          signal,
-        });
-        if (!response.ok) {
-          void response.body?.cancel().catch(() => {});
-          throw new ShopifyError(operation, response.status);
-        }
-        // A non-JSON body (an HTML error page) must not reach the error: the
-        // SyntaxError's message quotes the start of the body.
-        let body: { data?: unknown; errors?: { extensions?: { code?: unknown } }[] };
-        try {
-          body = await response.json();
-        } catch {
-          throw new ShopifyError(operation, response.status, ["INVALID_JSON"]);
-        }
-        // Partial data alongside errors is rejected as a whole, deliberately:
-        // a thin client doesn't guess which fields are still trustworthy.
-        if (body.errors?.length || body.data == null) {
-          const codes = body.errors?.length
-            ? body.errors.map((e) =>
-                typeof e.extensions?.code === "string" ? e.extensions.code : "UNKNOWN",
-              )
-            : ["MISSING_DATA"];
-          throw new ShopifyError(operation, response.status, [...new Set(codes)]);
-        }
-        return body.data as never;
-      },
-    }) satisfies ShopifyGraphQL;
-
-  const adminToken = config.adminAccessToken;
-  return {
-    storefront: endpoint("storefront", `${origin}/api/${version}/graphql.json`, {
-      "x-shopify-storefront-access-token": config.storefrontAccessToken,
-    }),
-    admin: adminToken
-      ? endpoint("admin", `${origin}/admin/api/${version}/graphql.json`, {
-          "x-shopify-access-token": adminToken,
-        })
-      : {
-          query: () =>
-            Promise.reject(
-              new Error("shopify admin: pass adminAccessToken to createShopifyClient"),
-            ),
-        },
-  };
-}

package/src/v8/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");
-  });
-});

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist"
-  },
-  "include": ["src/**/*"]
-}