@shopify/hydrogen 0.11.0-experimental.1 → 0.11.1-experimental.0

package/dist/esnext/foundation/Head/Head.client.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { HelmetProps as HeadProps } from 'react-helmet-async';
+export declare function Head({ children, ...props }: HeadProps & {
+    children: React.ReactNode;
+}): JSX.Element;

package/dist/esnext/foundation/Head/Head.client.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Helmet, HelmetData as HeadData, } from 'react-helmet-async';
+import { useEnvContext } from '../ssr-interop';
+const clientHeadData = new HeadData({});
+export function Head({ children, ...props }) {
+    const headData = useEnvContext((req) => req.ctx.head, clientHeadData);
+    return (
+    // @ts-ignore
+    React.createElement(Helmet, { ...props, helmetData: headData }, children));
+}

package/dist/esnext/foundation/Head/index.d.ts

@@ -0,0 +1 @@
+export { Head } from './Head.client';

package/dist/esnext/foundation/Head/index.js

@@ -0,0 +1 @@
+export { Head } from './Head.client';

package/dist/esnext/foundation/ServerRequestProvider/ServerRequestProvider.d.ts

@@ -1,4 +1,4 @@
-import type { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+import type { PreloadQueriesByURL, ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
 import type { QueryKey } from '../../types';
 declare type ServerRequestProviderProps = {
     isRSC: boolean;
@@ -19,4 +19,5 @@ declare type RequestCacheResult<T> = {
  * It will throw the promise if data is not ready.
  */
 export declare function useRequestCacheData<T>(key: QueryKey, fetcher: () => Promise<T>): RequestCacheResult<T>;
+export declare function preloadRequestCacheData(request: ServerComponentRequest, preloadQueries?: PreloadQueriesByURL): void;
 export {};

package/dist/esnext/foundation/ServerRequestProvider/ServerRequestProvider.js

@@ -1,5 +1,7 @@
 import React, { createContext, useContext } from 'react';
+import { getTime } from '../../utilities/timing';
 import { hashKey } from '../../framework/cache';
+import { collectQueryTimings } from '../../utilities/log';
 // Context to inject current request in SSR
 const RequestContextSSR = createContext(null);
 // Cache to inject current request in RSC
@@ -49,19 +51,56 @@ export function useServerRequest() {
  * It will throw the promise if data is not ready.
  */
 export function useRequestCacheData(key, fetcher) {
-    const { cache } = useServerRequest().ctx;
+    const request = useServerRequest();
+    const cache = request.ctx.cache;
     const cacheKey = hashKey(key);
     if (!cache.has(cacheKey)) {
         let data;
         let promise;
         cache.set(cacheKey, () => {
-            if (data !== undefined)
+            if (data !== undefined) {
+                collectQueryTimings(request, key, 'rendered');
                 return data;
+            }
             if (!promise) {
-                promise = fetcher().then((r) => (data = { data: r }), (e) => (data = { error: e }));
+                const startApiTime = getTime();
+                promise = fetcher().then((r) => {
+                    data = { data: r };
+                    collectQueryTimings(request, key, 'resolved', getTime() - startApiTime);
+                }, (e) => (data = { error: e }));
             }
             throw promise;
         });
     }
-    return cache.get(cacheKey).call();
+    // Making sure the promise has returned data because it can be initated by a preload request,
+    // otherwise, we throw the promise
+    const result = cache.get(cacheKey).call();
+    if (result instanceof Promise)
+        throw result;
+    return result;
+}
+export function preloadRequestCacheData(request, preloadQueries) {
+    const cache = request.ctx.cache;
+    preloadQueries === null || preloadQueries === void 0 ? void 0 : preloadQueries.forEach((preloadQuery, cacheKey) => {
+        collectQueryTimings(request, preloadQuery.key, 'preload');
+        if (!cache.has(cacheKey)) {
+            let data;
+            let promise;
+            cache.set(cacheKey, () => {
+                if (data !== undefined) {
+                    collectQueryTimings(request, preloadQuery.key, 'rendered');
+                    return data;
+                }
+                if (!promise) {
+                    const startApiTime = getTime();
+                    promise = preloadQuery.fetcher().then((r) => {
+                        data = { data: r };
+                        collectQueryTimings(request, preloadQuery.key, 'resolved', getTime() - startApiTime);
+                    }, (e) => (data = { error: e }));
+                }
+                return promise;
+            });
+        }
+        cache.get(cacheKey).call();
+    });
 }

package/dist/esnext/foundation/useQuery/hooks.d.ts

@@ -1,6 +1,14 @@
-import type { CacheOptions, QueryKey } from '../../types';
+import type { CachingStrategy, PreloadOptions, QueryKey } from '../../types';
 export interface HydrogenUseQueryOptions {
-    cache: CacheOptions;
+    /** The [caching strategy](/custom-storefronts/hydrogen/framework/cache#caching-strategies) to help you
+     * determine which cache control header to set.
+     */
+    cache?: CachingStrategy;
+    /** Whether to [preload the query](/custom-storefronts/hydrogen/framework/preloaded-queries).
+     * Defaults to `false`. Specify `true` to preload the query for the URL or `'*'`
+     * to preload the query for all requests.
+     */
+    preload?: PreloadOptions;
 }
 /**
  * The `useQuery` hook is a wrapper around Suspense calls and
@@ -12,7 +20,7 @@ export declare function useQuery<T>(
 key: QueryKey, 
 /** An asynchronous query function like `fetch` which returns data. */
 queryFn: () => Promise<T>, 
-/** Options including `cache` to manage the cache behavior of the sub-request. */
+/** The options to manage the cache behavior of the sub-request. */
 queryOptions?: HydrogenUseQueryOptions): {
     data?: undefined;
     error: Response;

package/dist/esnext/foundation/useQuery/hooks.js

@@ -1,7 +1,7 @@
-import { log } from '../../utilities/log';
-import { deleteItemFromCache, getItemFromCache, isStale, setItemInCache, } from '../../framework/cache';
+import { getLoggerWithContext, collectQueryCacheControlHeaders, collectQueryTimings, } from '../../utilities/log';
+import { deleteItemFromCache, generateSubRequestCacheControlHeader, getItemFromCache, isStale, setItemInCache, } from '../../framework/cache';
 import { runDelayedFunction } from '../../framework/runtime';
-import { useRequestCacheData } from '../ServerRequestProvider';
+import { useRequestCacheData, useServerRequest } from '../ServerRequestProvider';
 /**
  * The `useQuery` hook is a wrapper around Suspense calls and
  * global runtime's Cache if it exists.
@@ -12,10 +12,20 @@ export function useQuery(
 key, 
 /** An asynchronous query function like `fetch` which returns data. */
 queryFn, 
-/** Options including `cache` to manage the cache behavior of the sub-request. */
+/** The options to manage the cache behavior of the sub-request. */
 queryOptions) {
+    const request = useServerRequest();
     const withCacheIdKey = ['__QUERY_CACHE_ID__', ...key];
-    return useRequestCacheData(withCacheIdKey, cachedQueryFnBuilder(withCacheIdKey, queryFn, queryOptions));
+    const fetcher = cachedQueryFnBuilder(withCacheIdKey, queryFn, queryOptions);
+    collectQueryTimings(request, withCacheIdKey, 'requested');
+    if (queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.preload) {
+        request.savePreloadQuery({
+            preload: queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.preload,
+            key: withCacheIdKey,
+            fetcher,
+        });
+    }
+    return useRequestCacheData(withCacheIdKey, fetcher);
 }
 function cachedQueryFnBuilder(key, queryFn, queryOptions) {
     const resolvedQueryOptions = {
@@ -25,12 +35,17 @@ function cachedQueryFnBuilder(key, queryFn, queryOptions) {
      * Attempt to read the query from cache. If it doesn't exist or if it's stale, regenerate it.
      */
     async function cachedQueryFn() {
+        // Call this hook before running any async stuff
+        // to prevent losing the current React cycle.
+        const request = useServerRequest();
+        const log = getLoggerWithContext(request);
         const cacheResponse = await getItemFromCache(key);
         async function generateNewOutput() {
             return await queryFn();
         }
         if (cacheResponse) {
             const [output, response] = cacheResponse;
+            collectQueryCacheControlHeaders(request, key, response.headers.get('cache-control'));
             /**
              * Important: Do this async
              */
@@ -62,6 +77,7 @@ function cachedQueryFnBuilder(key, queryFn, queryOptions) {
          * Important: Do this async
          */
         runDelayedFunction(async () => await setItemInCache(key, newOutput, resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache));
+        collectQueryCacheControlHeaders(request, key, generateSubRequestCacheControlHeader(resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache));
         return newOutput;
     }
     return cachedQueryFn;

package/dist/esnext/framework/CachingStrategy/index.d.ts

@@ -0,0 +1,10 @@
+import type { CachingStrategy, AllCacheOptions, NoStoreStrategy } from '../../types';
+export declare function generateCacheControlHeader(cacheOptions: CachingStrategy): string;
+export declare function NoStore(): NoStoreStrategy;
+export declare function CacheSeconds(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheMinutes(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheHours(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheDays(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheWeeks(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheMonths(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheCustom(overrideOptions: CachingStrategy): AllCacheOptions;

package/dist/esnext/framework/CachingStrategy/index.js

@@ -0,0 +1,96 @@
+const PUBLIC = 'public';
+const PRIVATE = 'private';
+const NO_STORE = 'no-store';
+const optionMapping = {
+    maxAge: 'max-age',
+    staleWhileRevalidate: 'stale-while-revalidate',
+    sMaxAge: 's-maxage',
+    staleIfError: 'stale-if-error',
+};
+export function generateCacheControlHeader(cacheOptions) {
+    const cacheControl = [];
+    Object.keys(cacheOptions).forEach((key) => {
+        if (key === 'mode') {
+            cacheControl.push(cacheOptions[key]);
+        }
+        else if (optionMapping[key]) {
+            cacheControl.push(`${optionMapping[key]}=${cacheOptions[key]}`);
+        }
+    });
+    return cacheControl.join(', ');
+}
+export function NoStore() {
+    return {
+        mode: NO_STORE,
+    };
+}
+function guardExpirableModeType(overrideOptions) {
+    if ((overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) &&
+        (overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) !== PUBLIC &&
+        (overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) !== PRIVATE) {
+        throw Error("'mode' must be either 'public' or 'private'");
+    }
+}
+// 10 seconds
+export function CacheSeconds(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1,
+        staleWhileRevalidate: 9,
+        ...overrideOptions,
+    };
+}
+// 30 minutes
+export function CacheMinutes(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 900,
+        staleWhileRevalidate: 900,
+        ...overrideOptions,
+    };
+}
+// 1 hour
+export function CacheHours(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1800,
+        staleWhileRevalidate: 1800,
+        ...overrideOptions,
+    };
+}
+// 1 day
+export function CacheDays(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 3600,
+        staleWhileRevalidate: 82800,
+        ...overrideOptions,
+    };
+}
+// 2 weeks
+export function CacheWeeks(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 604800,
+        staleWhileRevalidate: 604800,
+        ...overrideOptions,
+    };
+}
+// 1 month
+export function CacheMonths(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1296000,
+        staleWhileRevalidate: 1296000,
+        ...overrideOptions,
+    };
+}
+export function CacheCustom(overrideOptions) {
+    return overrideOptions;
+}

package/dist/esnext/framework/Hydration/Html.js

@@ -1,22 +1,15 @@
 /// <reference types="vite/client" />
 import React from 'react';
 export function Html({ children, template, htmlAttrs, bodyAttrs }) {
-    var _a;
-    const head = template.match(/<head>(.+?)<\/head>/s)[1] || '';
-    let devEntryPoint = '';
+    let head = template.match(/<head>(.+?)<\/head>/s)[1] || '';
     // @ts-ignore
     if (import.meta.env.DEV) {
-        devEntryPoint =
-            ((_a = template
-                .substring(template.lastIndexOf('<script type="module"'))
-                .match(/src="(.*?)">/i)) === null || _a === void 0 ? void 0 : _a[1]) || '';
-        if (!devEntryPoint) {
-            throw new Error('Could not find entry-client module in index.html');
-        }
+        // Fix React Refresh for async scripts.
+        // https://github.com/vitejs/vite/issues/6759
+        head = head.replace(/>(\s*?import[\s\w]+?['"]\/@react-refresh)/, ' async="">$1');
     }
     return (React.createElement("html", { ...htmlAttrs },
         React.createElement("head", { dangerouslySetInnerHTML: { __html: head } }),
         React.createElement("body", { ...bodyAttrs },
-            React.createElement("div", { id: "root" }, children),
-            import.meta.env.DEV && (React.createElement("script", { type: "module", src: devEntryPoint })))));
+            React.createElement("div", { id: "root" }, children))));
 }

package/dist/esnext/framework/Hydration/ServerComponentRequest.server.d.ts

@@ -1,5 +1,15 @@
 import type { ShopifyContextValue } from '../../foundation/ShopifyProvider/types';
-import type { RealHelmetData } from '../../foundation/Helmet';
+import type { QueryCacheControlHeaders } from '../../utilities/log/log-cache-header';
+import type { QueryTiming } from '../../utilities/log/log-query-timeline';
+import type { PreloadOptions, QueryKey } from '../../types';
+import { HelmetData as HeadData } from 'react-helmet-async';
+export declare type PreloadQueryEntry = {
+    key: QueryKey;
+    fetcher: () => Promise<unknown>;
+    preload?: PreloadOptions;
+};
+export declare type PreloadQueriesByURL = Map<string, PreloadQueryEntry>;
+export declare type AllPreloadQueries = Map<string, PreloadQueriesByURL>;
 /**
  * This augments the `Request` object from the Fetch API:
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
@@ -11,13 +21,21 @@ export declare class ServerComponentRequest extends Request {
     cookies: Map<string, string>;
     id: string;
     time: number;
+    preloadURL: string;
     ctx: {
         cache: Map<string, any>;
-        helmet: RealHelmetData;
+        head: HeadData;
         shopifyConfig?: ShopifyContextValue;
+        queryCacheControl: Array<QueryCacheControlHeaders>;
+        queryTimings: Array<QueryTiming>;
+        preloadQueries: PreloadQueriesByURL;
         [key: string]: any;
     };
     constructor(input: any);
     constructor(input: RequestInfo, init?: RequestInit);
     private parseCookies;
+    isRscRequest(): boolean;
+    savePreloadQuery(query: PreloadQueryEntry): void;
+    getPreloadQueries(): PreloadQueriesByURL | undefined;
+    savePreloadQueries(): void;
 }

package/dist/esnext/framework/Hydration/ServerComponentRequest.server.js

@@ -1,5 +1,7 @@
 import { getTime } from '../../utilities/timing';
-import { HelmetData } from 'react-helmet-async';
+import { hashKey } from '../cache';
+import { HelmetData as HeadData } from 'react-helmet-async';
+import { RSC_PATHNAME } from '../../constants';
 let reqCounter = 0; // For debugging
 const generateId = typeof crypto !== 'undefined' &&
     // @ts-ignore
@@ -7,6 +9,9 @@ const generateId = typeof crypto !== 'undefined' &&
     ? // @ts-ignore
         () => crypto.randomUUID()
     : () => `req${++reqCounter}`;
+// Stores queries by url or '*'
+const preloadCache = new Map();
+const PRELOAD_ALL = '*';
 /**
  * This augments the `Request` object from the Fetch API:
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
@@ -32,9 +37,15 @@ export class ServerComponentRequest extends Request {
         this.id = generateId();
         this.ctx = {
             cache: new Map(),
-            helmet: new HelmetData({}),
+            head: new HeadData({}),
+            queryCacheControl: [],
+            queryTimings: [],
+            preloadQueries: new Map(),
         };
         this.cookies = this.parseCookies();
+        const referer = this.headers.get('referer');
+        this.preloadURL =
+            this.isRscRequest() && referer && referer !== '' ? referer : this.url;
     }
     parseCookies() {
         const cookieString = this.headers.get('cookie') || '';
@@ -42,6 +53,44 @@ export class ServerComponentRequest extends Request {
             .split(';')
             .map((chunk) => chunk.trim().split(/=(.+)/)));
     }
+    isRscRequest() {
+        const url = new URL(this.url);
+        return url.pathname === RSC_PATHNAME;
+    }
+    savePreloadQuery(query) {
+        if (typeof query.preload === 'string' && query.preload === PRELOAD_ALL) {
+            saveToPreloadAllPreload(query);
+        }
+        else if (query.preload) {
+            this.ctx.preloadQueries.set(hashKey(query.key), query);
+        }
+    }
+    getPreloadQueries() {
+        if (preloadCache.has(this.preloadURL)) {
+            const combinedPreloadQueries = new Map();
+            const urlPreloadCache = preloadCache.get(this.preloadURL);
+            mergeMapEntries(combinedPreloadQueries, urlPreloadCache);
+            mergeMapEntries(combinedPreloadQueries, preloadCache.get(PRELOAD_ALL));
+            return combinedPreloadQueries;
+        }
+        else if (preloadCache.has(PRELOAD_ALL)) {
+            return preloadCache.get(PRELOAD_ALL);
+        }
+    }
+    savePreloadQueries() {
+        preloadCache.set(this.preloadURL, this.ctx.preloadQueries);
+    }
+}
+function mergeMapEntries(map1, map2) {
+    map2 && map2.forEach((v, k) => map1.set(k, v));
+}
+function saveToPreloadAllPreload(query) {
+    let setCache = preloadCache.get(PRELOAD_ALL);
+    if (!setCache) {
+        setCache = new Map();
+    }
+    setCache === null || setCache === void 0 ? void 0 : setCache.set(hashKey(query.key), query);
+    preloadCache.set(PRELOAD_ALL, setCache);
 }
 /**
  * @see https://github.com/frandiox/vitedge/blob/17f3cd943e86d7c0c71a862985ddd6caa2899425/src/node/utils.js#L19-L24

package/dist/esnext/framework/Hydration/ServerComponentResponse.server.d.ts

@@ -1,4 +1,4 @@
-import { CacheOptions } from '../../types';
+import type { CachingStrategy } from '../../types';
 export declare class ServerComponentResponse extends Response {
     private wait;
     private cacheOptions?;
@@ -16,7 +16,7 @@ export declare class ServerComponentResponse extends Response {
      */
     doNotStream(): void;
     canStream(): boolean;
-    cache(options: CacheOptions): void;
+    cache(options: CachingStrategy): void;
     get cacheControlHeader(): string;
     writeHead({ status, statusText, headers, }?: {
         status?: number;

package/dist/esnext/framework/Hydration/ServerComponentResponse.server.js

@@ -1,5 +1,5 @@
 import { renderToString } from 'react-dom/server';
-import { generateCacheControlHeader } from '../cache';
+import { CacheSeconds, generateCacheControlHeader } from '../CachingStrategy';
 export class ServerComponentResponse extends Response {
     constructor() {
         super(...arguments);
@@ -23,12 +23,7 @@ export class ServerComponentResponse extends Response {
         this.cacheOptions = options;
     }
     get cacheControlHeader() {
-        var _a;
-        const options = {
-            ...DEFAULT_CACHE_OPTIONS,
-            ...((_a = this.cacheOptions) !== null && _a !== void 0 ? _a : {}),
-        };
-        return generateCacheControlHeader(options);
+        return generateCacheControlHeader(this.cacheOptions || CacheSeconds());
     }
     writeHead({ status, statusText, headers, } = {}) {
         if (status || statusText) {
@@ -58,7 +53,3 @@ export class ServerComponentResponse extends Response {
         return null;
     }
 }
-const DEFAULT_CACHE_OPTIONS = {
-    maxAge: 60 * 60,
-    staleWhileRevalidate: 23 * 60 * 60,
-};

package/dist/esnext/framework/cache/in-memory.js

@@ -1,3 +1,4 @@
+import { logCacheApiStatus } from '../../utilities/log';
 /**
  * This is an in-memory implementation of `Cache` that *barely*
  * works and is only meant to be used during development.
@@ -7,7 +8,7 @@ export class InMemoryCache {
         this.store = new Map();
     }
     put(request, response) {
-        console.log(`[Cache] PUT ${request.url.slice(0, 100)}`);
+        logCacheApiStatus('PUT', request.url);
         this.store.set(request.url, {
             value: response,
             date: new Date(),
@@ -16,7 +17,7 @@ export class InMemoryCache {
     match(request) {
         const match = this.store.get(request.url);
         if (!match) {
-            console.log(`[Cache] MISS ${request.url.slice(0, 100)}`);
+            logCacheApiStatus('MISS', request.url);
             return;
         }
         const { value, date } = match;
@@ -26,7 +27,7 @@ export class InMemoryCache {
         const age = (new Date().valueOf() - date) / 1000;
         const isMiss = age > maxAge + swr;
         if (isMiss) {
-            console.log(`[Cache] MISS ${request.url.slice(0, 100)}`);
+            logCacheApiStatus('MISS', request.url);
             this.store.delete(request.url);
             return;
         }
@@ -34,7 +35,7 @@ export class InMemoryCache {
         const headers = new Headers(value.headers);
         headers.set('cache', isStale ? 'STALE' : 'HIT');
         headers.set('date', date.toGMTString());
-        console.log(`[Cache] ${headers.get('cache')} ${request.url.slice(0, 100)}`);
+        logCacheApiStatus(headers.get('cache'), request.url);
         const response = new Response(value.body, {
             headers,
         });
@@ -42,6 +43,6 @@ export class InMemoryCache {
     }
     delete(request) {
         this.store.delete(request.url);
-        console.log(`[Cache] DELETE ${request.url.slice(0, 100)}`);
+        logCacheApiStatus('DELETE', request.url);
     }
 }

package/dist/esnext/framework/cache.d.ts

@@ -1,5 +1,5 @@
-import type { CacheOptions, QueryKey } from '../types';
-export declare function generateCacheControlHeader(options: CacheOptions): string;
+import type { QueryKey, CachingStrategy } from '../types';
+export declare function generateSubRequestCacheControlHeader(userCacheOptions?: CachingStrategy): string;
 /**
  * Use a preview header during development.
  * TODO: Support an override of this to force the cache
@@ -18,7 +18,7 @@ export declare function getItemFromCache(key: QueryKey): Promise<undefined | [an
 /**
  * Put an item into the cache.
  */
-export declare function setItemInCache(key: QueryKey, value: any, userCacheOptions?: CacheOptions): Promise<void>;
+export declare function setItemInCache(key: QueryKey, value: any, userCacheOptions?: CachingStrategy): Promise<void>;
 export declare function deleteItemFromCache(key: QueryKey): Promise<void>;
 /**
  * Manually check the response to see if it's stale.

package/dist/esnext/framework/cache.js

@@ -1,17 +1,7 @@
 import { getCache } from './runtime';
-const DEFAULT_SUBREQUEST_CACHE_OPTIONS = {
-    maxAge: 1,
-    staleWhileRevalidate: 9,
-};
-export function generateCacheControlHeader(options) {
-    if (options.noStore) {
-        return 'no-store';
-    }
-    return [
-        options.private ? 'private' : 'public',
-        `max-age=${options.maxAge}`,
-        `stale-while-revalidate=${options.staleWhileRevalidate}`,
-    ].join(', ');
+import { CacheSeconds, generateCacheControlHeader, } from '../framework/CachingStrategy';
+export function generateSubRequestCacheControlHeader(userCacheOptions) {
+    return generateCacheControlHeader(userCacheOptions || CacheSeconds());
 }
 /**
  * Use a preview header during development.
@@ -61,12 +51,8 @@ export async function setItemInCache(key, value, userCacheOptions) {
     }
     const url = getKeyUrl(hashKey(key));
     const request = new Request(url);
-    const cacheOptions = {
-        ...DEFAULT_SUBREQUEST_CACHE_OPTIONS,
-        ...(userCacheOptions !== null && userCacheOptions !== void 0 ? userCacheOptions : {}),
-    };
     const headers = new Headers({
-        'cache-control': generateCacheControlHeader(cacheOptions),
+        'cache-control': generateSubRequestCacheControlHeader(userCacheOptions),
     });
     const response = new Response(JSON.stringify(value), { headers });
     /**

package/dist/esnext/framework/middleware.d.ts

@@ -1,22 +1,22 @@
-import { IncomingMessage, NextFunction } from 'connect';
-import http from 'http';
-import { ViteDevServer } from 'vite';
-import { ShopifyConfig } from '../types';
+import type { IncomingMessage, NextFunction } from 'connect';
+import type { ServerResponse } from 'http';
+import type { ViteDevServer } from 'vite';
+import type { ShopifyConfig } from '../types';
 declare type HydrogenMiddlewareArgs = {
     dev?: boolean;
     shopifyConfig?: ShopifyConfig;
     indexTemplate: string | ((url: string) => Promise<string>);
-    getServerEntrypoint: () => Record<string, any> | Promise<Record<string, any>>;
+    getServerEntrypoint: () => any;
     devServer?: ViteDevServer;
     cache?: Cache;
 };
 export declare function graphiqlMiddleware({ shopifyConfig, dev, }: {
     shopifyConfig: ShopifyConfig;
     dev: boolean;
-}): (request: IncomingMessage, response: http.ServerResponse, next: NextFunction) => Promise<void>;
+}): (request: IncomingMessage, response: ServerResponse, next: NextFunction) => Promise<void>;
 /**
  * Provides middleware to Node.js Express-like servers. Used by the Hydrogen
  * Vite dev server plugin as well as production Node.js implementation.
  */
-export declare function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, devServer, }: HydrogenMiddlewareArgs): (request: IncomingMessage, response: http.ServerResponse, next: NextFunction) => Promise<void>;
+export declare function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, devServer, }: HydrogenMiddlewareArgs): (request: IncomingMessage, response: ServerResponse, next: NextFunction) => Promise<void>;
 export {};