shopify_storefront_sdk 1.0.4 → 2.0.0

package/dist/cjs/tests/unit/cache.test.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_js_1 = require("../../index.js");
+const cache_js_1 = require("../../utils/cache.js");
+const fetchMock = vitest_1.vi.fn();
+vitest_1.vi.stubGlobal("fetch", fetchMock);
+(0, vitest_1.describe)("Caching System", () => {
+    const MOCK_DOMAIN = "test-store.myshopify.com";
+    const MOCK_TOKEN = "mock-token-123";
+    let cache;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+        cache = new cache_js_1.InMemoryCache();
+    });
+    (0, vitest_1.it)("should cache successful queries and prevent subsequent network requests", async () => {
+        const client = new index_js_1.default({
+            storeUrl: MOCK_DOMAIN,
+            storefrontToken: MOCK_TOKEN,
+            cache,
+            defaultCacheTtl: 60,
+        });
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                data: { shop: { name: "First Fetch" } },
+            }),
+        });
+        // 1st call: Should hit the network (fetchMock called)
+        const result1 = await client.customQuery("query { shop { name } }", {});
+        (0, vitest_1.expect)(result1.shop.name).toBe("First Fetch");
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(1);
+        // 2nd call: Should return from cache (fetchMock NOT called again)
+        const result2 = await client.customQuery("query { shop { name } }", {});
+        (0, vitest_1.expect)(result2.shop.name).toBe("First Fetch");
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)("should NOT cache mutations", async () => {
+        const client = new index_js_1.default({
+            storeUrl: MOCK_DOMAIN,
+            storefrontToken: MOCK_TOKEN,
+            cache,
+            defaultCacheTtl: 60,
+        });
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                data: { customerCreate: { customer: { id: "123" } } },
+            }),
+        });
+        // 1st call
+        await client.customQuery("mutation { customerCreate(input: {}) { customer { id } } }", {});
+        // 2nd call with exactly the same mutation
+        await client.customQuery("mutation { customerCreate(input: {}) { customer { id } } }", {});
+        // Mutations should bypass the cache entirely
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(2);
+    });
+    (0, vitest_1.it)("should expire cache entries after the TTL", async () => {
+        // Override Date.now for time travel
+        const originalDateNow = Date.now;
+        let mockedTime = 1000000;
+        vitest_1.vi.spyOn(Date, "now").mockImplementation(() => mockedTime);
+        const client = new index_js_1.default({
+            storeUrl: MOCK_DOMAIN,
+            storefrontToken: MOCK_TOKEN,
+            cache,
+            defaultCacheTtl: 1, // 1 second TTL
+        });
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                data: { data: "mocked" },
+            }),
+        });
+        // Initial fetch
+        await client.customQuery("query { something }", {});
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(1);
+        // Fast forward time by 2 seconds (exceeding 1s TTL)
+        mockedTime += 2000;
+        // Subsequent fetch should hit network again because cache expired
+        await client.customQuery("query { something }", {});
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(2);
+        // Restore Date.now
+        vitest_1.vi.restoreAllMocks();
+    });
+});

package/dist/cjs/tests/unit/cartManager.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_js_1 = require("../../index.js");
+(0, vitest_1.describe)("CartManager", () => {
+    const MOCK_DOMAIN = "test-store.myshopify.com";
+    const MOCK_TOKEN = "mock-token-123";
+    let shopify;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+        shopify = new index_js_1.default({ storeUrl: MOCK_DOMAIN, storefrontToken: MOCK_TOKEN });
+    });
+    (0, vitest_1.it)("should initialize with an existing cart ID", () => {
+        const cart = shopify.cart("existing-cart-123");
+        (0, vitest_1.expect)(cart.id).toBe("existing-cart-123");
+    });
+    (0, vitest_1.it)("should lazily create a cart if no ID is provided", async () => {
+        const cart = shopify.cart();
+        (0, vitest_1.expect)(cart.id).toBeNull();
+        // Mock createCart on the SDK instance
+        const createCartSpy = vitest_1.vi.spyOn(shopify, "createCart").mockResolvedValueOnce({
+            cartCreate: { cart: { id: "new-cart-456" } }
+        });
+        // Mock addCartLines
+        const addCartLinesSpy = vitest_1.vi.spyOn(shopify, "addCartLines").mockResolvedValueOnce({});
+        await cart.addLines([{ merchandiseId: "variant-1", quantity: 1 }]);
+        (0, vitest_1.expect)(createCartSpy).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(addCartLinesSpy).toHaveBeenCalledWith({
+            cartId: "new-cart-456",
+            lines: [{ merchandiseId: "variant-1", quantity: 1 }]
+        });
+        (0, vitest_1.expect)(cart.id).toBe("new-cart-456");
+    });
+    (0, vitest_1.it)("should reuse the cart ID for subsequent operations", async () => {
+        const cart = shopify.cart("existing-cart-123");
+        const createCartSpy = vitest_1.vi.spyOn(shopify, "createCart");
+        const getCartSpy = vitest_1.vi.spyOn(shopify, "getCart").mockResolvedValueOnce({});
+        await cart.get();
+        // Should NOT have called createCart since an ID was provided
+        (0, vitest_1.expect)(createCartSpy).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(getCartSpy).toHaveBeenCalledWith({ cartId: "existing-cart-123", first: 250 });
+    });
+});

package/dist/cjs/tests/unit/client.test.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_js_1 = require("../../index.js");
+const errors_js_1 = require("../../utils/errors.js");
+const fetchMock = vitest_1.vi.fn();
+vitest_1.vi.stubGlobal("fetch", fetchMock);
+(0, vitest_1.describe)("Shopify SDK Unit Tests", () => {
+    const MOCK_DOMAIN = "test-store.myshopify.com";
+    const MOCK_TOKEN = "mock-token-123";
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.describe)("Initialization", () => {
+        (0, vitest_1.it)("should throw ShopifyInvalidRequestError if domain is missing", () => {
+            (0, vitest_1.expect)(() => {
+                new index_js_1.default({ storeUrl: "", storefrontToken: MOCK_TOKEN });
+            }).toThrow(errors_js_1.ShopifyInvalidRequestError);
+        });
+        (0, vitest_1.it)("should throw ShopifyInvalidRequestError if domain is invalid", () => {
+            (0, vitest_1.expect)(() => {
+                new index_js_1.default({ storeUrl: "invalid-url.com", storefrontToken: MOCK_TOKEN });
+            }).toThrow(errors_js_1.ShopifyInvalidRequestError);
+        });
+        (0, vitest_1.it)("should throw ShopifyInvalidRequestError if token is missing", () => {
+            (0, vitest_1.expect)(() => {
+                new index_js_1.default({ storeUrl: MOCK_DOMAIN, storefrontToken: "" });
+            }).toThrow(errors_js_1.ShopifyInvalidRequestError);
+        });
+        (0, vitest_1.it)("should initialize successfully with valid config", () => {
+            const client = new index_js_1.default({ storeUrl: MOCK_DOMAIN, storefrontToken: MOCK_TOKEN });
+            (0, vitest_1.expect)(client).toBeDefined();
+        });
+    });
+    (0, vitest_1.describe)("API Versioning", () => {
+        (0, vitest_1.it)("should default to the 2025-01 API version if none is provided", async () => {
+            const client = new index_js_1.default({ storeUrl: MOCK_DOMAIN, storefrontToken: MOCK_TOKEN });
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ data: {} }),
+            });
+            await client.customQuery("query { shop { name } }", {});
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith(`https://${MOCK_DOMAIN}/api/2025-01/graphql.json`, vitest_1.expect.objectContaining({ method: "POST" }));
+        });
+        (0, vitest_1.it)("should use a custom API version if provided", async () => {
+            const client = new index_js_1.default({
+                storeUrl: MOCK_DOMAIN,
+                storefrontToken: MOCK_TOKEN,
+                apiVersion: "unstable"
+            });
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ data: {} }),
+            });
+            await client.customQuery("query { shop { name } }", {});
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith(`https://${MOCK_DOMAIN}/api/unstable/graphql.json`, vitest_1.expect.objectContaining({ method: "POST" }));
+        });
+    });
+    (0, vitest_1.describe)("Error Handling", () => {
+        let client;
+        (0, vitest_1.beforeEach)(() => {
+            // Reduce retries in tests to avoid slowing them down
+            client = new index_js_1.default({ storeUrl: MOCK_DOMAIN, storefrontToken: MOCK_TOKEN, maxRetries: 0 });
+        });
+        (0, vitest_1.it)("should throw ShopifyNetworkError when fetch fails (e.g. network down)", async () => {
+            fetchMock.mockRejectedValueOnce(new Error("Network connection lost"));
+            await (0, vitest_1.expect)(client.customQuery("query { shop { name } }", {})).rejects.toThrow(errors_js_1.ShopifyNetworkError);
+        });
+        (0, vitest_1.it)("should throw ShopifyInvalidRequestError for 400 responses", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                statusText: "Bad Request"
+            });
+            await (0, vitest_1.expect)(client.customQuery("query { shop { name } }", {})).rejects.toThrow(errors_js_1.ShopifyInvalidRequestError);
+        });
+        (0, vitest_1.it)("should throw ShopifyGraphQLError when Shopify returns top-level errors", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    errors: [{ message: "Unauthorized Request" }],
+                })
+            });
+            await (0, vitest_1.expect)(client.customQuery("query { shop { name } }", {})).rejects.toThrow(errors_js_1.ShopifyGraphQLError);
+        });
+        (0, vitest_1.it)("should throw ShopifyUserError when a mutation returns nested userErrors", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    data: {
+                        customerCreate: {
+                            customer: null,
+                            userErrors: [{ field: ["email"], message: "Email has already been taken" }],
+                        },
+                    },
+                })
+            });
+            await (0, vitest_1.expect)(client.customQuery("mutation { customerCreate { userErrors { message } } }", {})).rejects.toThrow(errors_js_1.ShopifyUserError);
+        });
+        (0, vitest_1.it)("should return the correct data on a successful response", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    data: {
+                        shop: { name: "Test Store" },
+                    },
+                })
+            });
+            const response = await client.customQuery("query { shop { name } }", {});
+            (0, vitest_1.expect)(response.shop.name).toBe("Test Store");
+        });
+    });
+    (0, vitest_1.describe)("Auto-Retries", () => {
+        (0, vitest_1.it)("should successfully retry on a 429 rate limit response", async () => {
+            const client = new index_js_1.default({ storeUrl: MOCK_DOMAIN, storefrontToken: MOCK_TOKEN, maxRetries: 2 });
+            // First attempt: Rate Limited
+            fetchMock.mockResolvedValueOnce({
+                ok: false,
+                status: 429,
+                statusText: "Too Many Requests"
+            });
+            // Second attempt: Success
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    data: { shop: { name: "Success After Retry" } },
+                })
+            });
+            const response = await client.customQuery("query { shop { name } }", {});
+            (0, vitest_1.expect)(response.shop.name).toBe("Success After Retry");
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/dist/cjs/tests/unit/customerSession.test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_js_1 = require("../../index.js");
+(0, vitest_1.describe)("CustomerSession", () => {
+    const MOCK_DOMAIN = "test-store.myshopify.com";
+    const MOCK_TOKEN = "mock-token-123";
+    let shopify;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+        shopify = new index_js_1.default({ storeUrl: MOCK_DOMAIN, storefrontToken: MOCK_TOKEN });
+    });
+    (0, vitest_1.it)("should initialize with the provided token", () => {
+        const session = shopify.customer("customer-token-123");
+        (0, vitest_1.expect)(session.token).toBe("customer-token-123");
+    });
+    (0, vitest_1.it)("should forward the token when verifying the customer", async () => {
+        const session = shopify.customer("customer-token-123");
+        const verifySpy = vitest_1.vi.spyOn(shopify, "verifyCustomerToken").mockResolvedValueOnce({});
+        await session.verify();
+        (0, vitest_1.expect)(verifySpy).toHaveBeenCalledWith({ token: "customer-token-123" });
+    });
+    (0, vitest_1.it)("should forward the token and customer payload when updating the customer", async () => {
+        const session = shopify.customer("customer-token-123");
+        const updateSpy = vitest_1.vi.spyOn(shopify, "updateCustomer").mockResolvedValueOnce({});
+        await session.update({ firstName: "John", lastName: "Doe" });
+        (0, vitest_1.expect)(updateSpy).toHaveBeenCalledWith({
+            customerAccessToken: "customer-token-123",
+            customer: { firstName: "John", lastName: "Doe" }
+        });
+    });
+    (0, vitest_1.it)("should forward the token and first argument when fetching orders", async () => {
+        const session = shopify.customer("customer-token-123");
+        const getOrdersSpy = vitest_1.vi.spyOn(shopify, "getCustomerOrders").mockResolvedValueOnce({});
+        await session.getOrders(50);
+        (0, vitest_1.expect)(getOrdersSpy).toHaveBeenCalledWith({
+            customerAccessToken: "customer-token-123",
+            first: 50
+        });
+    });
+    (0, vitest_1.it)("should default to first: 250 when fetching orders if not specified", async () => {
+        const session = shopify.customer("customer-token-123");
+        const getOrdersSpy = vitest_1.vi.spyOn(shopify, "getCustomerOrders").mockResolvedValueOnce({});
+        await session.getOrders();
+        (0, vitest_1.expect)(getOrdersSpy).toHaveBeenCalledWith({
+            customerAccessToken: "customer-token-123",
+            first: 250
+        });
+    });
+});

package/dist/cjs/tests/unit/pagination.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const pagination_js_1 = require("../../utils/pagination.js");
+(0, vitest_1.describe)("Pagination Utility", () => {
+    (0, vitest_1.it)("should extract nodes and stop when hasNextPage is false", async () => {
+        // Mock a paginated API response
+        const mockResponses = [
+            {
+                data: {
+                    edges: [{ node: { id: 1 } }, { node: { id: 2 } }],
+                    pageInfo: { hasNextPage: true, endCursor: "cursor_1" },
+                },
+            },
+            {
+                data: {
+                    edges: [{ node: { id: 3 } }, { node: { id: 4 } }],
+                    pageInfo: { hasNextPage: false, endCursor: null },
+                },
+            },
+        ];
+        let requestCount = 0;
+        const fetchPage = async (cursor) => {
+            if (cursor === "cursor_1") {
+                requestCount++;
+                return mockResponses[1];
+            }
+            requestCount++;
+            return mockResponses[0];
+        };
+        const results = await (0, pagination_js_1.autoPaginate)(fetchPage, (res) => res === null || res === void 0 ? void 0 : res.data);
+        (0, vitest_1.expect)(requestCount).toBe(2);
+        (0, vitest_1.expect)(results).toHaveLength(4);
+        (0, vitest_1.expect)(results).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }]);
+    });
+    (0, vitest_1.it)("should return early if the connection is null or missing", async () => {
+        const fetchPage = async () => ({ data: null });
+        const results = await (0, pagination_js_1.autoPaginate)(fetchPage, (res) => res === null || res === void 0 ? void 0 : res.data);
+        (0, vitest_1.expect)(results).toHaveLength(0);
+    });
+});

package/dist/cjs/tests/unit/webhooks.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const webhooks_js_1 = require("../../utils/webhooks.js");
+const index_js_1 = require("../../index.js");
+const crypto = require("node:crypto");
+(0, vitest_1.describe)("Webhook Verification", () => {
+    const SECRET = "my_super_secret_key";
+    const PAYLOAD = JSON.stringify({ id: 12345, status: "created" });
+    (0, vitest_1.it)("should return true for a valid signature", () => {
+        // Generate valid HMAC
+        const validHmac = crypto
+            .createHmac("sha256", SECRET)
+            .update(PAYLOAD)
+            .digest("base64");
+        // Test standalone utility
+        (0, vitest_1.expect)((0, webhooks_js_1.verifyWebhook)(PAYLOAD, validHmac, SECRET)).toBe(true);
+        // Test SDK static method wrapper
+        (0, vitest_1.expect)(index_js_1.default.verifyWebhook(PAYLOAD, validHmac, SECRET)).toBe(true);
+    });
+    (0, vitest_1.it)("should return false for an invalid signature", () => {
+        const invalidHmac = crypto
+            .createHmac("sha256", "wrong_secret")
+            .update(PAYLOAD)
+            .digest("base64");
+        (0, vitest_1.expect)((0, webhooks_js_1.verifyWebhook)(PAYLOAD, invalidHmac, SECRET)).toBe(false);
+    });
+    (0, vitest_1.it)("should return false if payload has been tampered with", () => {
+        const validHmac = crypto
+            .createHmac("sha256", SECRET)
+            .update(PAYLOAD)
+            .digest("base64");
+        const tamperedPayload = JSON.stringify({ id: 12345, status: "deleted" });
+        (0, vitest_1.expect)((0, webhooks_js_1.verifyWebhook)(tamperedPayload, validHmac, SECRET)).toBe(false);
+    });
+    (0, vitest_1.it)("should return false if missing parameters", () => {
+        (0, vitest_1.expect)((0, webhooks_js_1.verifyWebhook)("", "hmac", SECRET)).toBe(false);
+        (0, vitest_1.expect)((0, webhooks_js_1.verifyWebhook)(PAYLOAD, "", SECRET)).toBe(false);
+        (0, vitest_1.expect)((0, webhooks_js_1.verifyWebhook)(PAYLOAD, "hmac", "")).toBe(false);
+    });
+});

package/dist/cjs/utils/cache.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryCache = void 0;
+class InMemoryCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(key) {
+        const item = this.cache.get(key);
+        if (!item)
+            return null;
+        if (Date.now() > item.expiresAt) {
+            this.cache.delete(key);
+            return null;
+        }
+        return item.value;
+    }
+    set(key, value, ttlSeconds) {
+        const expiresAt = Date.now() + ttlSeconds * 1000;
+        this.cache.set(key, { value, expiresAt });
+    }
+    /**
+     * Utility to manually clear the entire memory cache.
+     */
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.InMemoryCache = InMemoryCache;

package/dist/cjs/utils/errors.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShopifyInvalidRequestError = exports.ShopifyUserError = exports.ShopifyGraphQLError = exports.ShopifyNetworkError = exports.ShopifyError = void 0;
+class ShopifyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ShopifyError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.ShopifyError = ShopifyError;
+/**
+ * Thrown when there is an issue with the network or the Shopify API is unreachable (e.g. timeouts, 5xx responses).
+ */
+class ShopifyNetworkError extends ShopifyError {
+    constructor(message) {
+        super(message);
+        this.name = "ShopifyNetworkError";
+    }
+}
+exports.ShopifyNetworkError = ShopifyNetworkError;
+/**
+ * Thrown when the GraphQL request is successfully made but Shopify returns top-level GraphQL errors.
+ */
+class ShopifyGraphQLError extends ShopifyError {
+    constructor(message, graphqlErrors) {
+        super(message);
+        this.name = "ShopifyGraphQLError";
+        this.graphqlErrors = graphqlErrors;
+    }
+}
+exports.ShopifyGraphQLError = ShopifyGraphQLError;
+/**
+ * Thrown when a mutation returns user errors (e.g. invalid form data, missing fields)
+ */
+class ShopifyUserError extends ShopifyError {
+    constructor(message, userErrors) {
+        super(message);
+        this.name = "ShopifyUserError";
+        this.userErrors = userErrors;
+    }
+}
+exports.ShopifyUserError = ShopifyUserError;
+/**
+ * Thrown when the SDK configuration is invalid or the request is malformed (e.g. 400 Bad Request, 401 Unauthorized).
+ */
+class ShopifyInvalidRequestError extends ShopifyError {
+    constructor(message) {
+        super(message);
+        this.name = "ShopifyInvalidRequestError";
+    }
+}
+exports.ShopifyInvalidRequestError = ShopifyInvalidRequestError;

package/dist/cjs/utils/pagination.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoPaginate = autoPaginate;
+/**
+ * Automatically fetches all pages of a Shopify GraphQL Connection and flattens the nodes into an array.
+ *
+ * @param fetchPage A function that takes an optional cursor and returns a promise of the API response.
+ * @param getConnection A selector function that extracts the Connection object from the API response.
+ * @returns A flat array of all nodes across all pages.
+ */
+async function autoPaginate(fetchPage, getConnection) {
+    const results = [];
+    let hasNextPage = true;
+    let cursor = undefined;
+    while (hasNextPage) {
+        const response = await fetchPage(cursor);
+        const connection = getConnection(response);
+        if (!connection || !connection.edges || !connection.pageInfo) {
+            break;
+        }
+        for (const edge of connection.edges) {
+            if (edge && edge.node) {
+                results.push(edge.node);
+            }
+        }
+        hasNextPage = connection.pageInfo.hasNextPage;
+        cursor = connection.pageInfo.endCursor || undefined;
+    }
+    return results;
+}

package/dist/cjs/utils/webhooks.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyWebhook = verifyWebhook;
+const crypto = require("node:crypto");
+/**
+ * Verifies a Shopify webhook's HMAC signature.
+ *
+ * @param rawBody The raw, unparsed request body string or buffer.
+ * @param hmacHeader The `x-shopify-hmac-sha256` header provided by Shopify.
+ * @param secret Your Shopify app or storefront webhook API secret.
+ * @returns A boolean indicating whether the webhook signature is valid.
+ */
+function verifyWebhook(rawBody, hmacHeader, secret) {
+    if (!rawBody || !hmacHeader || !secret) {
+        return false;
+    }
+    try {
+        const generatedHash = crypto
+            .createHmac("sha256", secret)
+            .update(rawBody)
+            .digest("base64");
+        const generatedBuffer = Buffer.from(generatedHash);
+        const hmacBuffer = Buffer.from(hmacHeader);
+        // Use timingSafeEqual to prevent timing attacks
+        if (generatedBuffer.length !== hmacBuffer.length) {
+            return false;
+        }
+        return crypto.timingSafeEqual(generatedBuffer, hmacBuffer);
+    }
+    catch (err) {
+        return false;
+    }
+}

package/dist/client/client.d.ts

@@ -2,8 +2,19 @@ import type { StoreConfig } from "../utils/config.js";
 declare class ShopifyClient {
     private endpoint;
     private token;
-    constructor({ storeUrl, storefrontToken }: StoreConfig);
+    private maxRetries;
+    private cache;
+    private cacheTtl;
+    constructor({ storeUrl, storefrontToken, apiVersion, maxRetries, cache, defaultCacheTtl }: StoreConfig);
+    /**
+     * Generates a deterministic hash for a GraphQL query and its variables.
+     */
+    private generateCacheKey;
     query<T = any>(query: string, variables?: {}): Promise<T>;
+    /**
+     * Helper function to recursively check for `userErrors` inside the GraphQL response data.
+     */
+    private checkForUserErrors;
 }
 export default ShopifyClient;
 //# sourceMappingURL=client.d.ts.map

package/dist/client/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAGtD,cAAM,aAAa;IACjB,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,KAAK,CAAC;gBACF,EAAE,QAAQ,EAAE,eAAe,EAAE,EAAE,WAAW;IAQhD,KAAK,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC;CAsBhE;AAED,eAAe,aAAa,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAUtD,cAAM,aAAa;IACjB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,QAAQ,CAAS;gBAEb,EAAE,QAAQ,EAAE,eAAe,EAAE,UAAsB,EAAE,UAAc,EAAE,KAAK,EAAE,eAAoB,EAAE,EAAE,WAAW;IAc3H;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIlB,KAAK,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC;IA0F/D;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAsB3B;AAED,eAAe,aAAa,CAAC"}