@shopify/hydrogen 0.14.0 → 0.16.1

package/dist/esnext/framework/cache.js

@@ -1,14 +1,20 @@
 import { getCache } from './runtime';
 import { CacheSeconds, generateCacheControlHeader, } from '../framework/CachingStrategy';
-export function generateSubRequestCacheControlHeader(userCacheOptions) {
-    return generateCacheControlHeader(userCacheOptions || CacheSeconds());
+import { hashKey } from '../utilities/hash';
+import { logCacheApiStatus } from '../utilities/log';
+function getCacheControlSetting(userCacheOptions, options) {
+    if (userCacheOptions && options) {
+        return {
+            ...userCacheOptions,
+            ...options,
+        };
+    }
+    else {
+        return userCacheOptions || CacheSeconds();
+    }
 }
-export function hashKey(key) {
-    const rawKey = key instanceof Array ? key : [key];
-    /**
-     * TODO: Smarter hash
-     */
-    return rawKey.map((k) => JSON.stringify(k)).join('');
+export function generateSubRequestCacheControlHeader(userCacheOptions) {
+    return generateCacheControlHeader(getCacheControlSetting(userCacheOptions));
 }
 /**
  * Cache API is weird. We just need a full URL, so we make one up.
@@ -29,8 +35,11 @@ export async function getItemFromCache(key) {
     const url = getKeyUrl(hashKey(key));
     const request = new Request(url);
     const response = await cache.match(request);
-    if (!response)
+    if (!response) {
+        logCacheApiStatus('MISS', url);
         return;
+    }
+    logCacheApiStatus('HIT', url);
     return [await response.json(), response];
 }
 /**
@@ -43,14 +52,53 @@ export async function setItemInCache(key, value, userCacheOptions) {
     }
     const url = getKeyUrl(hashKey(key));
     const request = new Request(url);
+    /**
+     * We are manually managing staled request by adding this workaround.
+     * Why? cache control header support is dependent on hosting platform
+     *
+     * For example:
+     *
+     * Cloudflare's Cache API does not support `stale-while-revalidate`.
+     * Cloudflare cache control header has a very odd behaviour.
+     * Say we have the following cache control header on a request:
+     *
+     *   public, max-age=15, stale-while-revalidate=30
+     *
+     * When there is a cache.match HIT, the cache control header would become
+     *
+     *   public, max-age=14400, stale-while-revalidate=30
+     *
+     * == `stale-while-revalidate` workaround ==
+     * Update response max-age so that:
+     *
+     *   max-age = max-age + stale-while-revalidate
+     *
+     * For example:
+     *
+     *   public, max-age=1, stale-while-revalidate=9
+     *                    |
+     *                    V
+     *   public, max-age=10, stale-while-revalidate=9
+     *
+     * Store the following information in the response header:
+     *
+     *   cache-put-date   - UTC time string of when this request is PUT into cache
+     *
+     * Note on `cache-put-date`: The `response.headers.get('date')` isn't static. I am
+     * not positive what date this is returning but it is never over 500 ms
+     * after subtracting from the current timestamp.
+     *
+     * `isStale` function will use the above information to test for stale-ness of a cached response
+     */
+    const cacheControl = getCacheControlSetting(userCacheOptions);
     const headers = new Headers({
-        'cache-control': generateSubRequestCacheControlHeader(userCacheOptions),
+        'cache-control': generateSubRequestCacheControlHeader(getCacheControlSetting(cacheControl, {
+            maxAge: (cacheControl.maxAge || 0) + (cacheControl.staleWhileRevalidate || 0),
+        })),
+        'cache-put-date': new Date().toUTCString(),
     });
     const response = new Response(JSON.stringify(value), { headers });
-    /**
-     * WARNING: Cloudflare's Cache API does not support `stale-while-revalidate`
-     * so this implementation will not work as expected on that platform.
-     */
+    logCacheApiStatus('PUT', url);
     await cache.put(request, response);
 }
 export async function deleteItemFromCache(key) {
@@ -59,20 +107,17 @@ export async function deleteItemFromCache(key) {
         return;
     const url = getKeyUrl(hashKey(key));
     const request = new Request(url);
+    logCacheApiStatus('DELETE', url);
     await cache.delete(request);
 }
 /**
  * Manually check the response to see if it's stale.
  */
-export function isStale(response) {
-    const responseDate = response.headers.get('date');
-    const responseCacheControl = response.headers.get('cache-control');
-    if (!responseDate || !responseCacheControl)
-        return false;
-    const responseMaxAgeMatch = responseCacheControl.match(/max-age=(\d+)/);
-    if (!responseMaxAgeMatch)
+export function isStale(response, userCacheOptions) {
+    const responseMaxAge = getCacheControlSetting(userCacheOptions).maxAge || 0;
+    const responseDate = response.headers.get('cache-put-date');
+    if (!responseDate)
         return false;
-    const responseMaxAge = parseInt(responseMaxAgeMatch[1]);
     const ageInMs = new Date().valueOf() - new Date(responseDate).valueOf();
     const age = ageInMs / 1000;
     return age > responseMaxAge;

package/dist/esnext/framework/plugin.js

@@ -12,6 +12,15 @@ import react from '@vitejs/plugin-react';
 import path from 'path';
 import cssModulesRsc from './plugins/vite-plugin-css-modules-rsc';
 export default (shopifyConfig, pluginOptions = {}) => {
+    let hydrogenUiPath;
+    try {
+        hydrogenUiPath = path.join(
+        // eslint-disable-next-line node/no-missing-require
+        path.dirname(require.resolve('@shopify/hydrogen-ui/client')));
+    }
+    catch (error) {
+        // hydrogen-ui isn't installed, so don't worry about it
+    }
     return [
         process.env.VITE_INSPECT && inspect(),
         hydrogenConfig(),
@@ -24,6 +33,7 @@ export default (shopifyConfig, pluginOptions = {}) => {
         rsc({
             clientComponentPaths: [
                 path.join(path.dirname(require.resolve('@shopify/hydrogen/package.json'))),
+                ...[hydrogenUiPath].filter(Boolean),
             ],
             isServerComponentImporterAllowed(importer, source) {
                 // Always allow the entry server (e.g. App.server.jsx) to be imported

package/dist/esnext/framework/plugins/vite-plugin-css-modules-rsc.js

@@ -20,7 +20,7 @@ export default function cssModulesRsc() {
             enforce: 'post',
             transform(code, id) {
                 if (id.includes('.module.') && cssMap.has(id)) {
-                    return code.replace(/export default .*$/gms, `import React from 'react'; export const StyleTag = () => React.createElement('style', {}, \`${cssMap.get(id)}\`);`);
+                    return code.replace(/export default .*$/gms, `import React from 'react'; export const StyleTag = () => React.createElement('style', {dangerouslySetInnerHTML: {__html: ${JSON.stringify(cssMap.get(id))}}});`);
                 }
             },
         },

package/dist/esnext/framework/plugins/vite-plugin-hydrogen-config.js

@@ -36,11 +36,18 @@ export default () => {
                 // Reload when updating local Hydrogen lib
                 server: process.env.LOCAL_DEV && {
                     watch: {
-                        ignored: ['!**/node_modules/@shopify/hydrogen/**'],
+                        ignored: [
+                            '!**/node_modules/@shopify/hydrogen/**',
+                            '!**/node_modules/@shopify/hydrogen-ui/**',
+                        ],
                     },
                 },
                 optimizeDeps: {
-                    exclude: ['@shopify/hydrogen/client', '@shopify/hydrogen/entry-client'],
+                    exclude: [
+                        '@shopify/hydrogen/client',
+                        '@shopify/hydrogen/entry-client',
+                        '@shopify/hydrogen-ui',
+                    ],
                     include: [
                         /**
                          * Additionally, the following dependencies have trouble loading the
@@ -57,6 +64,8 @@ export default () => {
                         'react',
                         'react-dom/client',
                         'react-server-dom-vite/client-proxy',
+                        // https://github.com/vitejs/vite/issues/6215
+                        'react/jsx-runtime',
                     ],
                 },
                 define: {

package/dist/esnext/hooks/useShopQuery/hooks.js

@@ -1,31 +1,51 @@
 import { useShop } from '../../foundation/useShop';
 import { getLoggerWithContext } from '../../utilities/log';
-import { useQuery } from '../../foundation/useQuery';
-import { fetchBuilder, graphqlRequestBody } from '../../utilities';
+import { graphqlRequestBody } from '../../utilities';
 import { getConfig } from '../../framework/config';
 import { useServerRequest } from '../../foundation/ServerRequestProvider';
 import { injectGraphQLTracker } from '../../utilities/graphql-tracker';
 import { sendMessageToClient } from '../../utilities/devtools';
+import { fetchSync } from '../../foundation/fetchSync/server/fetchSync';
 import { META_ENV_SSR } from '../../foundation/ssr-interop';
+import { getStorefrontApiRequestHeaders } from '../../utilities/storefrontApi';
 // Check if the response body has GraphQL errors
 // https://spec.graphql.org/June2018/#sec-Response-Format
-const shouldCacheResponse = (body) => !(body === null || body === void 0 ? void 0 : body.errors);
+const shouldCacheResponse = ([body]) => { var _a; return !((_a = JSON.parse(body)) === null || _a === void 0 ? void 0 : _a.errors); };
 /**
  * The `useShopQuery` hook allows you to make server-only GraphQL queries to the Storefront API. It must be a descendent of a `ShopifyProvider` component.
  */
 export function useShopQuery({ query, variables = {}, cache, preload = false, }) {
     var _a;
+    /**
+     * If no query is passed, we no-op here to allow developers to obey the Rules of Hooks.
+     */
+    if (!query) {
+        return { data: undefined, errors: undefined };
+    }
     if (!META_ENV_SSR) {
         throw new Error('Shopify Storefront API requests should only be made from the server.');
     }
     const serverRequest = useServerRequest();
     const log = getLoggerWithContext(serverRequest);
     const body = query ? graphqlRequestBody(query, variables) : '';
-    const { key, url, requestInit } = useCreateShopRequest(body);
-    const { data, error: useQueryError } = useQuery(key, query
-        ? fetchBuilder(url, requestInit)
-        : // If no query, avoid calling SFAPI & return nothing
-            async () => ({ data: undefined, errors: undefined }), { cache, shouldCacheResponse, preload });
+    const { url, requestInit } = useCreateShopRequest(body);
+    let data;
+    let useQueryError;
+    try {
+        data = fetchSync(url, {
+            ...requestInit,
+            cache,
+            preload,
+            shouldCacheResponse,
+        }).json();
+    }
+    catch (error) {
+        // Pass-through thrown promise for Suspense functionality
+        if (error === null || error === void 0 ? void 0 : error.then) {
+            throw error;
+        }
+        useQueryError = error;
+    }
     /**
      * The fetch request itself failed, so we handle that differently than a GraphQL error
      */
@@ -95,26 +115,13 @@ export function useShopQuery({ query, variables = {}, cache, preload = false, })
     return data;
 }
 function useCreateShopRequest(body) {
-    var _a;
     const { storeDomain, storefrontToken, storefrontApiVersion } = useShop();
     const request = useServerRequest();
-    const secretToken = typeof Oxygen !== 'undefined'
-        ? (_a = Oxygen === null || Oxygen === void 0 ? void 0 : Oxygen.env) === null || _a === void 0 ? void 0 : _a.SHOPIFY_STOREFRONT_API_SECRET_TOKEN
-        : null;
     const buyerIp = request.getBuyerIp();
-    const extraHeaders = {};
-    /**
-     * Only pass one type of storefront token at a time.
-     */
-    if (secretToken) {
-        extraHeaders['Shopify-Storefront-Private-Token'] = secretToken;
-    }
-    else {
-        extraHeaders['X-Shopify-Storefront-Access-Token'] = storefrontToken;
-    }
-    if (buyerIp) {
-        extraHeaders['Shopify-Storefront-Buyer-IP'] = buyerIp;
-    }
+    const extraHeaders = getStorefrontApiRequestHeaders({
+        buyerIp,
+        storefrontToken,
+    });
     return {
         key: [storeDomain, storefrontApiVersion, body],
         url: `https://${storeDomain}/api/${storefrontApiVersion}/graphql.json`,

package/dist/esnext/index.d.ts

@@ -13,3 +13,5 @@ export * from './hooks/useShopQuery/hooks';
 export * from './foundation/useQuery/hooks';
 export { CartQuery } from './components/CartProvider/cart-queries';
 export { generateCacheControlHeader, NoStore, CacheSeconds, CacheMinutes, CacheHours, CacheDays, CacheWeeks, CacheMonths, CacheCustom, } from './framework/CachingStrategy';
+export { fetchSync } from './foundation/fetchSync/server/fetchSync';
+export { useServerAnalytics } from './foundation/Analytics';

package/dist/esnext/index.js

@@ -17,3 +17,5 @@ export * from './foundation/useQuery/hooks';
 // it from being bundled with other client components
 export { CartQuery } from './components/CartProvider/cart-queries';
 export { generateCacheControlHeader, NoStore, CacheSeconds, CacheMinutes, CacheHours, CacheDays, CacheWeeks, CacheMonths, CacheCustom, } from './framework/CachingStrategy';
+export { fetchSync } from './foundation/fetchSync/server/fetchSync';
+export { useServerAnalytics } from './foundation/Analytics';

package/dist/esnext/types.d.ts

@@ -35,14 +35,19 @@ export declare type Hook = (params: {
     url: URL;
 } & Record<string, any>) => any | Promise<any>;
 export declare type ImportGlobEagerOutput = Record<string, Record<'default' | 'api', any>>;
+export declare type ServerAnalyticsConnector = {
+    request: (request: Request, data?: any, contentType?: 'json' | 'text') => void;
+};
 export declare type ServerHandlerConfig = {
     routes?: ImportGlobEagerOutput;
     shopifyConfig: ShopifyConfig;
+    serverAnalyticsConnectors?: Array<ServerAnalyticsConnector>;
 };
 export declare type ClientHandlerConfig = {
     shopifyConfig: ShopifyConfig;
     /** React's StrictMode is on by default for your client side app; if you want to turn it off (not recommended), you can pass `false` */
     strictMode?: boolean;
+    showDevTools?: boolean;
 };
 export declare type ClientHandler = (App: React.ElementType, config: ClientHandlerConfig) => Promise<void>;
 export interface GraphQLConnection<T> {
@@ -74,7 +79,7 @@ export interface AllCacheOptions {
     sMaxAge?: number;
     staleIfError?: number;
 }
-export declare type CachingStrategy = NoStoreStrategy | AllCacheOptions;
+export declare type CachingStrategy = AllCacheOptions;
 export interface HydrogenVitePluginOptions {
     devCache?: boolean;
     purgeQueryCacheOnBuild?: boolean;

package/dist/esnext/utilities/apiRoutes.d.ts

@@ -1,4 +1,5 @@
 import { ImportGlobEagerOutput, ShopifyConfig } from '../types';
+import type { ServerComponentRequest } from '../framework/Hydration/ServerComponentRequest.server';
 import type { ASTNode } from 'graphql';
 declare type RouteParams = Record<string, string>;
 declare type RequestOptions = {
@@ -29,8 +30,6 @@ interface QueryShopArgs {
     query: ASTNode | string;
     /** An object of the variables for the GraphQL query. */
     variables?: Record<string, any>;
-    /** A string corresponding to a valid locale identifier like `en-us` used to make the request. */
-    locale?: string;
 }
-export declare function renderApiRoute(request: Request, route: ApiRouteMatch, shopifyConfig: ShopifyConfig): Promise<Response>;
+export declare function renderApiRoute(request: ServerComponentRequest, route: ApiRouteMatch, shopifyConfig: ShopifyConfig): Promise<Response | Request>;
 export {};

package/dist/esnext/utilities/apiRoutes.js

@@ -1,6 +1,7 @@
 import { matchPath } from './matchPath';
 import { getLoggerWithContext, logServerResponse } from '../utilities/log/';
 import { fetchBuilder, graphqlRequestBody } from './fetch';
+import { getStorefrontApiRequestHeaders } from './storefrontApi';
 let memoizedRoutes = [];
 let memoizedPages = {};
 export function getApiRoutes(pages, topLevelPath = '*') {
@@ -64,31 +65,35 @@ export function getApiRouteFromURL(url, routes) {
         hasServerComponent: foundRoute.hasServerComponent,
     };
 }
-function queryShopBuilder(shopifyConfig) {
-    return async function queryShop({ query, variables, locale, }) {
-        var _a;
-        const { storeDomain, storefrontApiVersion, storefrontToken, defaultLocale } = shopifyConfig;
+function queryShopBuilder(shopifyConfig, request) {
+    return async function queryShop({ query, variables, }) {
+        const { storeDomain, storefrontApiVersion, storefrontToken } = shopifyConfig;
+        const buyerIp = request.getBuyerIp();
+        const extraHeaders = getStorefrontApiRequestHeaders({
+            buyerIp,
+            storefrontToken,
+        });
         const fetcher = fetchBuilder(`https://${storeDomain}/api/${storefrontApiVersion}/graphql.json`, {
             method: 'POST',
             body: graphqlRequestBody(query, variables),
             headers: {
-                'X-Shopify-Storefront-Access-Token': storefrontToken,
-                'Accept-Language': (_a = locale) !== null && _a !== void 0 ? _a : defaultLocale,
                 'Content-Type': 'application/json',
+                ...extraHeaders,
             },
         });
         return await fetcher();
     };
 }
 export async function renderApiRoute(request, route, shopifyConfig) {
+    var _a;
     let response;
     const log = getLoggerWithContext(request);
     try {
         response = await route.resource(request, {
             params: route.params,
-            queryShop: queryShopBuilder(shopifyConfig),
+            queryShop: queryShopBuilder(shopifyConfig, request),
         });
-        if (!(response instanceof Response)) {
+        if (!(response instanceof Response || response instanceof Request)) {
             if (typeof response === 'string' || response instanceof String) {
                 response = new Response(response);
             }
@@ -105,6 +110,6 @@ export async function renderApiRoute(request, route, shopifyConfig) {
         log.error(e);
         response = new Response('Error processing: ' + request.url, { status: 500 });
     }
-    logServerResponse('api', request, response.status);
+    logServerResponse('api', request, (_a = response.status) !== null && _a !== void 0 ? _a : 200);
     return response;
 }

package/dist/esnext/utilities/hash.d.ts

@@ -0,0 +1,2 @@
+import { QueryKey } from '../types';
+export declare function hashKey(key: QueryKey): string;

package/dist/esnext/utilities/hash.js

@@ -0,0 +1,7 @@
+export function hashKey(key) {
+    const rawKey = key instanceof Array ? key : [key];
+    /**
+     * TODO: Smarter hash
+     */
+    return rawKey.map((k) => JSON.stringify(k)).join('');
+}

package/dist/esnext/utilities/log/log-cache-api-status.js

@@ -5,5 +5,5 @@ export function logCacheApiStatus(status, url) {
     if (!log.options().showCacheApiStatus) {
         return;
     }
-    log.debug(gray(`[Cache] ${status === null || status === void 0 ? void 0 : status.padEnd(6)} query ${findQueryName(url)}`));
+    log.debug(gray(`[Cache] ${status === null || status === void 0 ? void 0 : status.padEnd(8)} query ${findQueryName(url)}`));
 }

package/dist/esnext/utilities/log/log-cache-header.js

@@ -1,4 +1,4 @@
-import { hashKey } from '../../framework/cache';
+import { hashKey } from '../hash';
 import { findQueryName, parseUrl } from './utils';
 import { gray } from 'kolorist';
 import { getLoggerWithContext } from './log';

package/dist/esnext/utilities/log/log-query-timeline.js

@@ -1,4 +1,4 @@
-import { hashKey } from '../../framework/cache';
+import { hashKey } from '../hash';
 import { findQueryName, parseUrl } from './utils';
 import { gray, red, yellow, green } from 'kolorist';
 import { getLoggerWithContext } from './log';

package/dist/esnext/utilities/storefrontApi.d.ts

@@ -0,0 +1,4 @@
+export declare function getStorefrontApiRequestHeaders({ buyerIp, storefrontToken, }: {
+    buyerIp?: string | null;
+    storefrontToken: string;
+}): Record<string, any>;

package/dist/esnext/utilities/storefrontApi.js

@@ -0,0 +1,21 @@
+import { OXYGEN_SECRET_TOKEN_ENVIRONMENT_VARIABLE, STOREFRONT_API_SECRET_TOKEN_HEADER, STOREFRONT_API_PUBLIC_TOKEN_HEADER, STOREFRONT_API_BUYER_IP_HEADER, } from '../constants';
+export function getStorefrontApiRequestHeaders({ buyerIp, storefrontToken, }) {
+    var _a;
+    const headers = {};
+    const secretToken = typeof Oxygen !== 'undefined'
+        ? (_a = Oxygen === null || Oxygen === void 0 ? void 0 : Oxygen.env) === null || _a === void 0 ? void 0 : _a[OXYGEN_SECRET_TOKEN_ENVIRONMENT_VARIABLE]
+        : null;
+    /**
+     * Only pass one type of storefront token at a time.
+     */
+    if (secretToken) {
+        headers[STOREFRONT_API_SECRET_TOKEN_HEADER] = secretToken;
+    }
+    else {
+        headers[STOREFRONT_API_PUBLIC_TOKEN_HEADER] = storefrontToken;
+    }
+    if (buyerIp) {
+        headers[STOREFRONT_API_BUYER_IP_HEADER] = buyerIp;
+    }
+    return headers;
+}

package/dist/esnext/utilities/suspense.d.ts

@@ -1,3 +1,4 @@
+import { QueryKey } from '../types';
 /**
  * Wrap the fetch promise in a way that React Suspense understands.
  * Essentially, keep throwing something until you have legit data.
@@ -5,3 +6,7 @@
 export declare function wrapPromise<T>(promise: Promise<T>): {
     read: () => T;
 };
+declare type Await<T> = T extends Promise<infer V> ? V : never;
+export declare const suspendFunction: <Fn extends () => Promise<unknown>>(key: QueryKey, fn: Fn) => Await<ReturnType<Fn>>;
+export declare const preloadFunction: (key: QueryKey, fn: () => Promise<unknown>) => unknown;
+export {};

package/dist/esnext/utilities/suspense.js

@@ -1,3 +1,4 @@
+import { hashKey } from './hash';
 /**
  * Wrap the fetch promise in a way that React Suspense understands.
  * Essentially, keep throwing something until you have legit data.
@@ -24,3 +25,34 @@ export function wrapPromise(promise) {
     };
     return { read };
 }
+const browserCache = {};
+/**
+ * Perform an async function in a synchronous way for Suspense support.
+ * To be used only in the client.
+ * Inspired by https://github.com/pmndrs/suspend-react
+ */
+function query(key, fn, preload = false) {
+    const stringKey = hashKey(key);
+    if (browserCache[stringKey]) {
+        const entry = browserCache[stringKey];
+        if (preload)
+            return undefined;
+        if (entry.error)
+            throw entry.error;
+        if (entry.response)
+            return entry.response;
+        if (!preload)
+            throw entry.promise;
+    }
+    const entry = {
+        promise: fn()
+            .then((response) => (entry.response = response))
+            .catch((error) => (entry.error = error)),
+    };
+    browserCache[stringKey] = entry;
+    if (!preload)
+        throw entry.promise;
+    return undefined;
+}
+export const suspendFunction = (key, fn) => query(key, fn);
+export const preloadFunction = (key, fn) => query(key, fn, true);

package/dist/esnext/utilities/template.js

@@ -6,7 +6,7 @@ export function stripScriptsFromTemplate(template) {
     var _a;
     const bootstrapScripts = [];
     const bootstrapModules = [];
-    const scripts = template.matchAll(/<script.+?src="(?<script>([^"]+?))".*?><\/script>/g);
+    const scripts = template.matchAll(/<script\n*?.+?src="(?<script>([^"]+?))"\n*.*?><\/script>/g);
     for (const match of scripts) {
         const scriptName = (_a = match.groups) === null || _a === void 0 ? void 0 : _a.script;
         if (!scriptName)

package/dist/esnext/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "0.14.0";
+export declare const LIB_VERSION = "0.16.1";

package/dist/esnext/version.js

@@ -1 +1 @@
-export const LIB_VERSION = '0.14.0';
+export const LIB_VERSION = '0.16.1';

package/dist/node/constants.d.ts

@@ -1 +1,7 @@
 export declare const RSC_PATHNAME = "/__rsc";
+export declare const EVENT_PATHNAME = "/__event";
+export declare const EVENT_PATHNAME_REGEX: RegExp;
+export declare const OXYGEN_SECRET_TOKEN_ENVIRONMENT_VARIABLE = "SHOPIFY_STOREFRONT_API_SECRET_TOKEN";
+export declare const STOREFRONT_API_SECRET_TOKEN_HEADER = "Shopify-Storefront-Private-Token";
+export declare const STOREFRONT_API_PUBLIC_TOKEN_HEADER = "X-Shopify-Storefront-Access-Token";
+export declare const STOREFRONT_API_BUYER_IP_HEADER = "Shopify-Storefront-Buyer-IP";

package/dist/node/constants.js

@@ -1,4 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RSC_PATHNAME = void 0;
+exports.STOREFRONT_API_BUYER_IP_HEADER = exports.STOREFRONT_API_PUBLIC_TOKEN_HEADER = exports.STOREFRONT_API_SECRET_TOKEN_HEADER = exports.OXYGEN_SECRET_TOKEN_ENVIRONMENT_VARIABLE = exports.EVENT_PATHNAME_REGEX = exports.EVENT_PATHNAME = exports.RSC_PATHNAME = void 0;
 exports.RSC_PATHNAME = '/__rsc';
+exports.EVENT_PATHNAME = '/__event';
+exports.EVENT_PATHNAME_REGEX = new RegExp(`^${exports.EVENT_PATHNAME}\/`);
+exports.OXYGEN_SECRET_TOKEN_ENVIRONMENT_VARIABLE = 'SHOPIFY_STOREFRONT_API_SECRET_TOKEN';
+exports.STOREFRONT_API_SECRET_TOKEN_HEADER = 'Shopify-Storefront-Private-Token';
+exports.STOREFRONT_API_PUBLIC_TOKEN_HEADER = 'X-Shopify-Storefront-Access-Token';
+exports.STOREFRONT_API_BUYER_IP_HEADER = 'Shopify-Storefront-Buyer-IP';

package/dist/node/entry-server.d.ts

@@ -19,5 +19,5 @@ interface RequestHandlerOptions {
 export interface RequestHandler {
     (request: Request | IncomingMessage, options: RequestHandlerOptions): Promise<Response | undefined>;
 }
-export declare const renderHydrogen: (App: any, { shopifyConfig, routes }: ServerHandlerConfig) => RequestHandler;
+export declare const renderHydrogen: (App: any, { shopifyConfig, routes, serverAnalyticsConnectors }: ServerHandlerConfig) => RequestHandler;
 export default renderHydrogen;