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

package/dist/node/framework/cache.js

@@ -1,22 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStale = exports.deleteItemFromCache = exports.setItemInCache = exports.getItemFromCache = exports.hashKey = exports.getCacheControlHeader = exports.generateCacheControlHeader = void 0;
+exports.isStale = exports.deleteItemFromCache = exports.setItemInCache = exports.getItemFromCache = exports.hashKey = exports.getCacheControlHeader = exports.generateSubRequestCacheControlHeader = void 0;
 const runtime_1 = require("./runtime");
-const DEFAULT_SUBREQUEST_CACHE_OPTIONS = {
-    maxAge: 1,
-    staleWhileRevalidate: 9,
-};
-function generateCacheControlHeader(options) {
-    if (options.noStore) {
-        return 'no-store';
-    }
-    return [
-        options.private ? 'private' : 'public',
-        `max-age=${options.maxAge}`,
-        `stale-while-revalidate=${options.staleWhileRevalidate}`,
-    ].join(', ');
+const CachingStrategy_1 = require("../framework/CachingStrategy");
+function generateSubRequestCacheControlHeader(userCacheOptions) {
+    return (0, CachingStrategy_1.generateCacheControlHeader)(userCacheOptions || (0, CachingStrategy_1.CacheSeconds)());
 }
-exports.generateCacheControlHeader = generateCacheControlHeader;
+exports.generateSubRequestCacheControlHeader = generateSubRequestCacheControlHeader;
 /**
  * Use a preview header during development.
  * TODO: Support an override of this to force the cache
@@ -68,12 +58,8 @@ 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/node/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 {};

package/dist/node/framework/middleware.js

@@ -18,13 +18,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hydrogenMiddleware = exports.graphiqlMiddleware = void 0;
 const graphiql_1 = require("./graphiql");
-const handle_event_1 = __importDefault(require("../handle-event"));
 function graphiqlMiddleware({ shopifyConfig, dev, }) {
     return async function (request, response, next) {
         const graphiqlRequest = dev && isGraphiqlRequest(request);
@@ -40,51 +36,23 @@ exports.graphiqlMiddleware = graphiqlMiddleware;
  * Vite dev server plugin as well as production Node.js implementation.
  */
 function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, devServer, }) {
+    /**
+     * We're running in the Node.js runtime without access to `fetch`,
+     * which is needed for proxy requests and server-side API requests.
+     */
+    const webPolyfills = !globalThis.fetch || !globalThis.ReadableStream
+        ? Promise.resolve().then(() => __importStar(require('../utilities/web-api-polyfill'))) : undefined;
     return async function (request, response, next) {
-        const url = new URL('http://' + request.headers.host + request.originalUrl);
+        var _a, _b, _c;
         try {
-            /**
-             * We're running in the Node.js runtime without access to `fetch`,
-             * which is needed for proxy requests and server-side API requests.
-             */
-            if (!globalThis.fetch) {
-                const fetch = await Promise.resolve().then(() => __importStar(require('node-fetch')));
-                const { default: AbortController } = await Promise.resolve().then(() => __importStar(require('abort-controller')));
-                // @ts-ignore
-                globalThis.fetch = fetch;
-                // @ts-ignore
-                globalThis.Request = fetch.Request;
-                // @ts-ignore
-                globalThis.Response = fetch.Response;
-                // @ts-ignore
-                globalThis.Headers = fetch.Headers;
-                // @ts-ignore
-                globalThis.AbortController = AbortController;
-            }
-            if (!globalThis.ReadableStream) {
-                const { ReadableStream, WritableStream, TransformStream } = await Promise.resolve().then(() => __importStar(require('web-streams-polyfill/ponyfill')));
-                Object.assign(globalThis, {
-                    ReadableStream,
-                    WritableStream,
-                    TransformStream,
-                });
-            }
-            /**
-             * Dynamically import ServerComponentResponse after the `fetch`
-             * polyfill has loaded above.
-             */
-            const { ServerComponentRequest } = await Promise.resolve().then(() => __importStar(require('./Hydration/ServerComponentRequest.server')));
-            const eventResponse = await (0, handle_event_1.default)(
-            /**
-             * Mimic a `FetchEvent`
-             */
-            {}, {
-                request: new ServerComponentRequest(request),
-                entrypoint: await getServerEntrypoint(),
-                indexTemplate,
-                streamableResponse: response,
+            await webPolyfills;
+            const entrypoint = await getServerEntrypoint();
+            const handleRequest = (_a = entrypoint.default) !== null && _a !== void 0 ? _a : entrypoint;
+            const eventResponse = await handleRequest(request, {
                 dev,
                 cache,
+                indexTemplate,
+                streamableResponse: response,
             });
             /**
              * If a `Response` was returned, that means it was not streamed.
@@ -114,7 +82,7 @@ function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, de
              */
             try {
                 const template = typeof indexTemplate === 'function'
-                    ? await indexTemplate(url.toString())
+                    ? await indexTemplate((_c = (_b = request.originalUrl) !== null && _b !== void 0 ? _b : request.url) !== null && _c !== void 0 ? _c : '')
                     : indexTemplate;
                 const html = template.replace(`<div id="root"></div>`, `<div id="root"><pre><code>${e.stack}</code></pre></div>`);
                 response.write(html);

package/dist/node/framework/plugin.js

@@ -1,14 +1,36 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const vite_plugin_hydrogen_config_1 = __importDefault(require("./plugins/vite-plugin-hydrogen-config"));
-const vite_plugin_hydrogen_middleware_1 = __importDefault(require("./plugins/vite-plugin-hydrogen-middleware"));
+const vite_plugin_hydrogen_middleware_1 = __importStar(require("./plugins/vite-plugin-hydrogen-middleware"));
+const vite_plugin_hydrogen_client_middleware_1 = __importDefault(require("./plugins/vite-plugin-hydrogen-client-middleware"));
+const vite_plugin_platform_entry_1 = __importDefault(require("./plugins/vite-plugin-platform-entry"));
 // @ts-ignore
 const plugin_1 = __importDefault(require("@shopify/hydrogen/vendor/react-server-dom-vite/plugin"));
 const vite_plugin_ssr_interop_1 = __importDefault(require("./plugins/vite-plugin-ssr-interop"));
 const vite_plugin_purge_query_cache_1 = __importDefault(require("./plugins/vite-plugin-purge-query-cache"));
+const vite_plugin_hydration_auto_import_1 = __importDefault(require("./plugins/vite-plugin-hydration-auto-import"));
 const vite_plugin_inspect_1 = __importDefault(require("vite-plugin-inspect"));
 const plugin_react_1 = __importDefault(require("@vitejs/plugin-react"));
 const path_1 = __importDefault(require("path"));
@@ -16,17 +38,25 @@ exports.default = (shopifyConfig, pluginOptions = {}) => {
     return [
         process.env.VITE_INSPECT && (0, vite_plugin_inspect_1.default)(),
         (0, vite_plugin_hydrogen_config_1.default)(),
+        (0, vite_plugin_hydrogen_client_middleware_1.default)(),
         (0, vite_plugin_hydrogen_middleware_1.default)(shopifyConfig, pluginOptions),
         (0, plugin_react_1.default)(),
+        (0, vite_plugin_hydration_auto_import_1.default)(),
         (0, vite_plugin_ssr_interop_1.default)(),
         (0, plugin_1.default)({
             clientComponentPaths: [
                 path_1.default.join(path_1.default.dirname(require.resolve('@shopify/hydrogen/package.json'))),
             ],
-            isServerComponentImporterAllowed(importer) {
-                return /(handle-worker-event|index)\.js/.test(importer);
+            isServerComponentImporterAllowed(importer, source) {
+                // Always allow the entry server (e.g. App.server.jsx) to be imported
+                // in other files such as worker.js or server.js.
+                const entryServer = process.env.HYDROGEN_SERVER_ENTRY || vite_plugin_hydrogen_middleware_1.HYDROGEN_DEFAULT_SERVER_ENTRY;
+                return (source.includes(entryServer) ||
+                    // TODO update this after handleEvent is replaced with handleRequest
+                    /(handle-worker-event|index|entry-server)\.js/.test(importer));
             },
         }),
+        (0, vite_plugin_platform_entry_1.default)(),
         pluginOptions.purgeQueryCacheOnBuild && (0, vite_plugin_purge_query_cache_1.default)(),
     ];
 };

package/dist/node/framework/plugins/vite-plugin-hydration-auto-import.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vite';
+declare const _default: () => Plugin;
+export default _default;

package/dist/node/framework/plugins/vite-plugin-hydration-auto-import.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vite_1 = require("vite");
+const path_1 = __importDefault(require("path"));
+const magic_string_1 = __importDefault(require("magic-string"));
+const HYDROGEN_ENTRY_FILE = 'hydrogen-entry-client.jsx';
+exports.default = () => {
+    let config;
+    return {
+        name: 'vite-plugin-hydration-auto-import',
+        enforce: 'pre',
+        configResolved(_config) {
+            config = _config;
+        },
+        resolveId(id, importer) {
+            if ((/^\/?@shopify\/hydrogen\/entry-client$/.test(id) ||
+                id.endsWith(path_1.default.sep + HYDROGEN_ENTRY_FILE)) &&
+                (0, vite_1.normalizePath)(importer || '').endsWith('/index.html')) {
+                // Make this virtual import look like a local project file
+                // to enable React Refresh normally.
+                return path_1.default.join(config.root, HYDROGEN_ENTRY_FILE + '?virtual');
+            }
+            return null;
+        },
+        load(id) {
+            if (id.includes(HYDROGEN_ENTRY_FILE + '?virtual')) {
+                const code = new magic_string_1.default(`import renderHydrogen from '@shopify/hydrogen/entry-client';\n` +
+                    `export default renderHydrogen((props) => props.children);`);
+                return {
+                    code: code.toString(),
+                    map: code.generateMap({
+                        file: HYDROGEN_ENTRY_FILE,
+                        source: HYDROGEN_ENTRY_FILE,
+                    }),
+                };
+            }
+            return null;
+        },
+    };
+};

package/dist/node/framework/plugins/vite-plugin-hydrogen-client-middleware.d.ts

@@ -0,0 +1,9 @@
+import { type Plugin } from 'vite';
+declare const _default: () => Plugin;
+/**
+ * This dev server middleware prevents Vite from applying immutable cache control headers to client
+ * components. These client components are part of the user's local source, but since they are
+ * referenced via import globs in the `react-dom-server-vite` NPM package, Vite assumes they
+ * are 3P deps that can be cached. This middleware responds to the requests early with `no-cache`.
+ */
+export default _default;

package/dist/node/framework/plugins/vite-plugin-hydrogen-client-middleware.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vite_1 = require("vite");
+/**
+ * This dev server middleware prevents Vite from applying immutable cache control headers to client
+ * components. These client components are part of the user's local source, but since they are
+ * referenced via import globs in the `react-dom-server-vite` NPM package, Vite assumes they
+ * are 3P deps that can be cached. This middleware responds to the requests early with `no-cache`.
+ */
+exports.default = () => {
+    return {
+        name: 'vite-plugin-hydrogen-client-middleware',
+        enforce: 'pre',
+        configureServer(server) {
+            server.middlewares.use(async (req, res, next) => {
+                const url = req.url;
+                try {
+                    if (url.includes('.client.js') &&
+                        url.includes('?v=') &&
+                        !url.includes('node_modules')) {
+                        const result = await server.transformRequest(url, { html: false });
+                        if (result) {
+                            return (0, vite_1.send)(req, res, result.code, 'js', {
+                                etag: result.etag,
+                                cacheControl: 'no-cache',
+                                headers: server.config.server.headers,
+                                map: result.map,
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    next(e);
+                }
+                next();
+            });
+        },
+    };
+};

package/dist/node/framework/plugins/vite-plugin-hydrogen-middleware.d.ts

@@ -1,10 +1,11 @@
 import { Plugin } from 'vite';
 import type { HydrogenVitePluginOptions, ShopifyConfig } from '../../types';
+export declare const HYDROGEN_DEFAULT_SERVER_ENTRY = "/src/App.server";
 declare const _default: (shopifyConfig: ShopifyConfig, pluginOptions: HydrogenVitePluginOptions) => Plugin;
 export default _default;
 declare global {
     var Oxygen: {
-        env: Record<string, string | undefined>;
+        env: any;
         [key: string]: any;
     };
 }

package/dist/node/framework/plugins/vite-plugin-hydrogen-middleware.js

@@ -3,12 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HYDROGEN_DEFAULT_SERVER_ENTRY = void 0;
 const vite_1 = require("vite");
 const body_parser_1 = __importDefault(require("body-parser"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = require("fs");
 const middleware_1 = require("../middleware");
 const in_memory_1 = require("../cache/in-memory");
+exports.HYDROGEN_DEFAULT_SERVER_ENTRY = '/src/App.server';
 exports.default = (shopifyConfig, pluginOptions) => {
     return {
         name: 'vite-plugin-hydrogen-middleware',
@@ -36,7 +38,8 @@ exports.default = (shopifyConfig, pluginOptions) => {
                 dev: true,
                 shopifyConfig,
                 indexTemplate: getIndexTemplate,
-                getServerEntrypoint: async () => await server.ssrLoadModule(process.env.HYDROGEN_SERVER_ENTRY || '/src/entry-server'),
+                getServerEntrypoint: () => server.ssrLoadModule(process.env.HYDROGEN_SERVER_ENTRY ||
+                    exports.HYDROGEN_DEFAULT_SERVER_ENTRY),
                 devServer: server,
                 cache: (pluginOptions === null || pluginOptions === void 0 ? void 0 : pluginOptions.devCache)
                     ? new in_memory_1.InMemoryCache()

package/dist/node/framework/plugins/vite-plugin-platform-entry.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vite';
+declare const _default: () => Plugin;
+export default _default;

package/dist/node/framework/plugins/vite-plugin-platform-entry.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vite_1 = require("vite");
+const vite_plugin_hydrogen_middleware_1 = require("./vite-plugin-hydrogen-middleware");
+const magic_string_1 = __importDefault(require("magic-string"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const SSR_BUNDLE_NAME = 'index.js';
+exports.default = () => {
+    let config;
+    let isESM;
+    return {
+        name: 'vite-plugin-platform-entry',
+        enforce: 'pre',
+        configResolved(_config) {
+            config = _config;
+            if (config.build.ssr) {
+                const { output = {} } = config.build.rollupOptions || {};
+                const { format = '' } = (Array.isArray(output) ? output[0] : output) || {};
+                isESM = Boolean(process.env.WORKER) || ['es', 'esm'].includes(format);
+            }
+        },
+        resolveId(source, importer) {
+            if ((0, vite_1.normalizePath)(source).includes('@shopify/hydrogen/platforms/')) {
+                const hydrogenPath = path_1.default.dirname(require.resolve('@shopify/hydrogen/package.json'));
+                const platformEntryName = source.split(path_1.default.sep).pop() || '';
+                const platformEntryPath = path_1.default.resolve(hydrogenPath, 'dist', 'esnext', 'platforms', platformEntryName);
+                return this.resolve(platformEntryPath, importer, {
+                    skipSelf: true,
+                });
+            }
+            return null;
+        },
+        transform(code, id) {
+            if ((0, vite_1.normalizePath)(id).includes('@shopify/hydrogen/dist/esnext/platforms/')) {
+                code = code
+                    .replace('__SERVER_ENTRY__', process.env.HYDROGEN_SERVER_ENTRY || vite_plugin_hydrogen_middleware_1.HYDROGEN_DEFAULT_SERVER_ENTRY)
+                    .replace('__INDEX_TEMPLATE__', (0, vite_1.normalizePath)(path_1.default.resolve(config.root, config.build.outDir, '..', 'client', 'index.html')));
+                const ms = new magic_string_1.default(code);
+                return {
+                    code: ms.toString(),
+                    map: ms.generateMap({ file: id, source: id }),
+                };
+            }
+        },
+        generateBundle(options, bundle) {
+            if (config.build.ssr) {
+                const [[key, value]] = Object.entries(bundle);
+                delete bundle[key];
+                value.fileName = SSR_BUNDLE_NAME;
+                bundle[SSR_BUNDLE_NAME] = value;
+                // This ensures the file has a proper
+                // default export instead of exporting an
+                // object containing a 'default' property.
+                if (value.type === 'chunk' && !isESM) {
+                    value.code = value.code.replace(/((^|;)[\s]*)exports\[['"]default['"]\]\s*=/m, '$1module.exports =');
+                }
+            }
+        },
+        writeBundle(options) {
+            if (config.build.ssr && options.dir) {
+                const mainFile = `./${SSR_BUNDLE_NAME}`;
+                const packageJson = {
+                    type: isESM ? 'module' : 'commonjs',
+                    main: mainFile,
+                    exports: { '.': mainFile, mainFile },
+                };
+                fs_1.default.writeFileSync(path_1.default.join(options.dir, 'package.json'), JSON.stringify(packageJson, null, 2), 'utf-8');
+            }
+        },
+    };
+};

package/dist/node/streaming.server.d.ts

@@ -0,0 +1,21 @@
+import type { Writable } from 'stream';
+export declare const rscRenderToReadableStream: (App: JSX.Element) => ReadableStream<Uint8Array>;
+export declare const createFromReadableStream: (rs: ReadableStream<Uint8Array>) => {
+    readRoot: () => JSX.Element;
+};
+declare type StreamOptions = {
+    nonce?: string;
+    onCompleteShell?: () => void;
+    onCompleteAll?: () => void;
+    onError?: (error: Error) => void;
+    bootstrapScripts?: string[];
+    bootstrapModules?: string[];
+};
+export declare const ssrRenderToPipeableStream: (App: JSX.Element, options: StreamOptions) => {
+    pipe: Writable['pipe'];
+};
+export declare const ssrRenderToReadableStream: (App: JSX.Element, options: StreamOptions) => ReadableStream<Uint8Array>;
+export declare function supportsReadableStream(): boolean;
+export declare function isStreamingSupported(): Promise<boolean>;
+export declare function bufferReadableStream(reader: ReadableStreamDefaultReader, cb?: (chunk: string) => void): Promise<string>;
+export {};

package/dist/node/streaming.server.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferReadableStream = exports.isStreamingSupported = exports.supportsReadableStream = exports.ssrRenderToReadableStream = exports.ssrRenderToPipeableStream = exports.createFromReadableStream = exports.rscRenderToReadableStream = void 0;
+const server_1 = require("react-dom/server");
+// @ts-ignore
+const writer_browser_server_1 = require("@shopify/hydrogen/vendor/react-server-dom-vite/writer.browser.server");
+// @ts-ignore
+const react_server_dom_vite_1 = require("@shopify/hydrogen/vendor/react-server-dom-vite");
+exports.rscRenderToReadableStream = writer_browser_server_1.renderToReadableStream;
+exports.createFromReadableStream = react_server_dom_vite_1.createFromReadableStream;
+exports.ssrRenderToPipeableStream = server_1.renderToPipeableStream;
+exports.ssrRenderToReadableStream = server_1.renderToReadableStream;
+function supportsReadableStream() {
+    try {
+        new ReadableStream();
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+exports.supportsReadableStream = supportsReadableStream;
+let cachedStreamingSupport;
+async function isStreamingSupported() {
+    if (cachedStreamingSupport === undefined) {
+        try {
+            const rs = new ReadableStream({
+                start(controller) {
+                    controller.close();
+                },
+            });
+            // This will throw in CFW until streaming
+            // is supported. It works in Miniflare.
+            await new Response(rs).text();
+            cachedStreamingSupport = true;
+        }
+        catch (_) {
+            cachedStreamingSupport = false;
+        }
+    }
+    return cachedStreamingSupport;
+}
+exports.isStreamingSupported = isStreamingSupported;
+async function bufferReadableStream(reader, cb) {
+    const decoder = new TextDecoder();
+    let result = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        const stringValue = typeof value === 'string' ? value : decoder.decode(value);
+        result += stringValue;
+        if (cb) {
+            cb(stringValue);
+        }
+    }
+    return result;
+}
+exports.bufferReadableStream = bufferReadableStream;

package/dist/node/types.d.ts

@@ -1,34 +1,29 @@
 /// <reference types="node" />
-import { ServerResponse } from 'http';
+import type { ServerResponse } from 'http';
+import type { Logger } from './utilities/log/log';
 import type { ServerComponentRequest } from './framework/Hydration/ServerComponentRequest.server';
+import type { ServerComponentResponse } from './framework/Hydration/ServerComponentResponse.server';
 import type { Metafield, Image, MediaContentType } from './graphql/types/types';
-import { ApiRouteMatch } from './utilities/apiRoutes';
-import { Logger } from './utilities/log/log';
-export declare type Renderer = (url: URL, options: {
+declare type CommonOptions = {
+    App: any;
+    pages?: ImportGlobEagerOutput;
     request: ServerComponentRequest;
+    componentResponse: ServerComponentResponse;
+    log: Logger;
+    dev?: boolean;
+};
+export declare type RendererOptions = CommonOptions & {
     template: string;
     nonce?: string;
-    dev?: boolean;
-}) => Promise<Response>;
-export declare type Streamer = (url: URL, options: {
-    request: ServerComponentRequest;
+};
+export declare type StreamerOptions = CommonOptions & {
     response?: ServerResponse;
     template: string;
     nonce?: string;
-    dev?: boolean;
-}) => void;
-export declare type Hydrator = (url: URL, options: {
-    request: ServerComponentRequest;
+};
+export declare type HydratorOptions = CommonOptions & {
     response?: ServerResponse;
     isStreamable: boolean;
-    dev?: boolean;
-}) => void;
-export declare type EntryServerHandler = {
-    render: Renderer;
-    stream: Streamer;
-    hydrate: Hydrator;
-    getApiRoute: (url: URL) => ApiRouteMatch | null;
-    log: Logger;
 };
 export declare type ShopifyConfig = {
     defaultLocale?: string;
@@ -47,7 +42,6 @@ export declare type ServerHandlerConfig = {
 export declare type ClientHandlerConfig = {
     shopifyConfig: ShopifyConfig;
 };
-export declare type ServerHandler = (App: any, config: ServerHandlerConfig) => EntryServerHandler;
 export declare type ClientHandler = (App: any, config: ClientHandlerConfig) => Promise<void>;
 export interface GraphQLConnection<T> {
     edges?: {
@@ -58,7 +52,7 @@ export interface MediaImage {
     __typename?: string;
     id?: string;
     mediaContentType?: MediaContentType;
-    image?: Pick<Image, 'altText' | 'url' | 'id' | 'width' | 'height'>;
+    data?: Pick<Image, 'altText' | 'url' | 'id' | 'width' | 'height'>;
 }
 interface ProductVariant {
     __typename?: string;
@@ -83,14 +77,20 @@ export interface Measurement {
     value: number;
 }
 export declare type QueryKey = string | readonly unknown[];
-export interface CacheOptions {
-    private?: boolean;
+export declare type NoStoreStrategy = {
+    mode: string;
+};
+export interface AllCacheOptions {
+    mode?: string;
     maxAge?: number;
     staleWhileRevalidate?: number;
-    noStore?: boolean;
+    sMaxAge?: number;
+    staleIfError?: number;
 }
+export declare type CachingStrategy = NoStoreStrategy | AllCacheOptions;
 export interface HydrogenVitePluginOptions {
     devCache?: boolean;
     purgeQueryCacheOnBuild?: boolean;
 }
+export declare type PreloadOptions = boolean | string;
 export {};

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

@@ -1,5 +1,4 @@
 import { ImportGlobEagerOutput } from '../types';
-import { Logger } from '../utilities/log/log';
 declare type RouteParams = Record<string, string>;
 declare type RequestOptions = {
     params: RouteParams;
@@ -17,5 +16,5 @@ export declare type ApiRouteMatch = {
 };
 export declare function getApiRoutesFromPages(pages: ImportGlobEagerOutput | undefined, topLevelPath?: string): Array<HydrogenApiRoute>;
 export declare function getApiRouteFromURL(url: URL, routes: Array<HydrogenApiRoute>): ApiRouteMatch | null;
-export declare function renderApiRoute(request: Request, route: ApiRouteMatch, log: Logger): Promise<Response>;
+export declare function renderApiRoute(request: Request, route: ApiRouteMatch): Promise<Response>;
 export {};