@shopify/hydrogen 0.8.3 → 0.9.0

package/dist/node/framework/middleware.js

@@ -42,32 +42,24 @@ exports.graphiqlMiddleware = graphiqlMiddleware;
 function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, devServer, }) {
     return async function (request, response, next) {
         const url = new URL('http://' + request.headers.host + request.originalUrl);
-        const isReactHydrationRequest = url.pathname === '/react';
-        /**
-         * If it's a dev environment, it's assumed that Vite's dev server is handling
-         * any static or JS requests, so we need to ensure that we don't try to handle them.
-         *
-         * If it's a product environment, it's assumed that the developer is handling
-         * static requests with e.g. static middleware.
-         */
-        if (dev && !shouldInterceptRequest(request, isReactHydrationRequest)) {
-            return next();
-        }
         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 { fetch, Request, Response, Headers } = await Promise.resolve().then(() => __importStar(require('undici')));
+                const { default: AbortController } = await Promise.resolve().then(() => __importStar(require('abort-controller')));
+                // @ts-ignore
+                globalThis.fetch = fetch;
                 // @ts-ignore
-                globalThis.fetch = fetch.default;
+                globalThis.Request = Request;
                 // @ts-ignore
-                globalThis.Request = fetch.Request;
+                globalThis.Response = Response;
                 // @ts-ignore
-                globalThis.Response = fetch.Response;
+                globalThis.Headers = Headers;
                 // @ts-ignore
-                globalThis.Headers = fetch.Headers;
+                globalThis.AbortController = AbortController;
             }
             /**
              * Dynamically import ServerComponentResponse after the `fetch`
@@ -95,7 +87,18 @@ function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, de
                     response.setHeader(key, value);
                 });
                 response.statusCode = eventResponse.status;
-                response.end(eventResponse.body);
+                if (eventResponse.body) {
+                    const reader = eventResponse.body.getReader();
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            return response.end();
+                        response.write(value);
+                    }
+                }
+                else {
+                    response.end();
+                }
             }
         }
         catch (e) {
@@ -126,11 +129,6 @@ function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, de
     };
 }
 exports.hydrogenMiddleware = hydrogenMiddleware;
-function shouldInterceptRequest(request, isReactHydrationRequest) {
-    var _a;
-    return (/text\/html|application\/hydrogen/.test((_a = request.headers['accept']) !== null && _a !== void 0 ? _a : '') ||
-        isReactHydrationRequest);
-}
 /**
  * /graphiql and /___graphql are supported
  */

package/dist/node/framework/plugin.d.ts

@@ -1,3 +1,3 @@
 import type { HydrogenVitePluginOptions, ShopifyConfig } from '../types';
-declare const _default: (shopifyConfig: ShopifyConfig, pluginOptions: HydrogenVitePluginOptions) => ("" | import("vite").Plugin | import("vite").PluginOption[] | undefined)[];
+declare const _default: (shopifyConfig: ShopifyConfig, pluginOptions?: HydrogenVitePluginOptions) => (false | "" | import("vite").Plugin | import("vite").PluginOption[] | undefined)[];
 export default _default;

package/dist/node/framework/plugin.js

@@ -6,14 +6,16 @@ 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_react_server_components_shim_1 = __importDefault(require("./plugins/vite-plugin-react-server-components-shim"));
+const vite_plugin_purge_query_cache_1 = __importDefault(require("./plugins/vite-plugin-purge-query-cache"));
 const vite_plugin_inspect_1 = __importDefault(require("vite-plugin-inspect"));
 const plugin_react_1 = __importDefault(require("@vitejs/plugin-react"));
-exports.default = (shopifyConfig, pluginOptions) => {
+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_middleware_1.default)(shopifyConfig, pluginOptions),
         (0, vite_plugin_react_server_components_shim_1.default)(),
         (0, plugin_react_1.default)(),
+        pluginOptions.purgeQueryCacheOnBuild && (0, vite_plugin_purge_query_cache_1.default)(),
     ];
 };

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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 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");
@@ -30,6 +31,7 @@ exports.default = (shopifyConfig, pluginOptions) => {
                 shopifyConfig,
                 dev: true,
             }));
+            server.middlewares.use(body_parser_1.default.raw({ type: '*/*' }));
             return () => server.middlewares.use((0, middleware_1.hydrogenMiddleware)({
                 dev: true,
                 shopifyConfig,

package/dist/node/framework/plugins/vite-plugin-purge-query-cache.d.ts

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

package/dist/node/framework/plugins/vite-plugin-purge-query-cache.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+exports.default = () => {
+    const buildCacheId = crypto_1.default.randomBytes(8).toString('hex').slice(0, 8);
+    return {
+        name: 'vite-plugin-purge-query-cache',
+        enforce: 'pre',
+        transform(code) {
+            return code.replace('__QUERY_CACHE_ID__', buildCacheId);
+        },
+    };
+};

package/dist/node/handle-event.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const cache_1 = require("./framework/cache");
 const runtime_1 = require("./framework/runtime");
 const config_1 = require("./framework/config");
+const apiRoutes_1 = require("./utilities/apiRoutes");
 async function handleEvent(event, { request, entrypoint, indexTemplate, assetHandler, streamableResponse, dev, cache, context, }) {
     var _a, _b, _c, _d, _e;
     const url = new URL(request.url);
@@ -23,12 +24,21 @@ async function handleEvent(event, { request, entrypoint, indexTemplate, assetHan
         assetHandler) {
         return assetHandler(event, url);
     }
-    const { render, hydrate, stream } = entrypoint.default || entrypoint;
+    const { render, hydrate, stream, getApiRoute, log } = entrypoint.default || entrypoint;
     // @ts-ignore
-    if (dev && !(render && hydrate && stream)) {
+    if (dev && !(render && hydrate && stream && getApiRoute)) {
         throw new Error(`entry-server.jsx could not be loaded. This likely occurred because of a Vite compilation error.\n` +
             `Please check your server logs for more information.`);
     }
+    if (!isReactHydrationRequest) {
+        const apiRoute = getApiRoute(url);
+        // The API Route might have a default export, making it also a server component
+        // If it does, only render the API route if the request method is GET
+        if (apiRoute &&
+            (!apiRoute.hasServerComponent || request.method !== 'GET')) {
+            return (0, apiRoutes_1.renderApiRoute)(request, apiRoute, log);
+        }
+    }
     const userAgent = request.headers.get('user-agent');
     const isStreamable = streamableResponse && !isBotUA(url, userAgent);
     /**

package/dist/node/types.d.ts

@@ -3,6 +3,8 @@ import { ServerResponse } from 'http';
 import type { ServerComponentResponse } from './framework/Hydration/ServerComponentResponse.server';
 import type { ServerComponentRequest } from './framework/Hydration/ServerComponentRequest.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: {
     request: ServerComponentRequest;
     context?: Record<string, any>;
@@ -29,6 +31,8 @@ export declare type EntryServerHandler = {
     render: Renderer;
     stream: Streamer;
     hydrate: Hydrator;
+    getApiRoute: (url: URL) => ApiRouteMatch | null;
+    log: Logger;
 };
 export declare type ShopifyConfig = {
     locale?: string;
@@ -39,11 +43,11 @@ export declare type ShopifyConfig = {
 export declare type Hook = (params: {
     url: URL;
 } & Record<string, any>) => any | Promise<any>;
-export declare type ServerHandler = (App: any, hook?: Hook) => {
-    render: Renderer;
-    stream: Streamer;
-    hydrate: Hydrator;
+export declare type ImportGlobEagerOutput = Record<string, Record<'default' | 'api', any>>;
+export declare type ServerHandlerConfig = {
+    pages?: ImportGlobEagerOutput;
 };
+export declare type ServerHandler = (App: any, config?: ServerHandlerConfig, hook?: Hook) => EntryServerHandler;
 export declare type ClientHandler = (App: any, hook?: Hook) => Promise<void>;
 export interface GraphQLConnection<T> {
     edges?: {
@@ -87,5 +91,6 @@ export interface CacheOptions {
 }
 export interface HydrogenVitePluginOptions {
     devCache?: boolean;
+    purgeQueryCacheOnBuild?: boolean;
 }
 export {};

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

@@ -0,0 +1,21 @@
+import { ImportGlobEagerOutput } from '../types';
+import { Logger } from '../utilities/log/log';
+declare type RouteParams = Record<string, string>;
+declare type RequestOptions = {
+    params: RouteParams;
+};
+declare type ResourceGetter = (request: Request, requestOptions: RequestOptions) => Promise<Response>;
+interface HydrogenApiRoute {
+    path: string;
+    resource: ResourceGetter;
+    hasServerComponent: boolean;
+}
+export declare type ApiRouteMatch = {
+    resource: ResourceGetter;
+    hasServerComponent: boolean;
+    params: RouteParams;
+};
+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 {};

package/dist/node/utilities/apiRoutes.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderApiRoute = exports.getApiRouteFromURL = exports.getApiRoutesFromPages = void 0;
+const matchPath_1 = require("./matchPath");
+const log_1 = require("../utilities/log/log");
+let cachedRoutes = [];
+function getApiRoutesFromPages(pages, topLevelPath = '*') {
+    if ((cachedRoutes === null || cachedRoutes === void 0 ? void 0 : cachedRoutes.length) || !pages)
+        return cachedRoutes;
+    const topLevelPrefix = topLevelPath.replace('*', '').replace(/\/$/, '');
+    const routes = Object.keys(pages)
+        .filter((key) => pages[key].api)
+        .map((key) => {
+        const path = key
+            .replace('./pages', '')
+            .replace(/\.server\.(t|j)sx?$/, '')
+            /**
+             * Replace /index with /
+             */
+            .replace(/\/index$/i, '/')
+            /**
+             * Only lowercase the first letter. This allows the developer to use camelCase
+             * dynamic paths while ensuring their standard routes are normalized to lowercase.
+             */
+            .replace(/\b[A-Z]/, (firstLetter) => firstLetter.toLowerCase())
+            /**
+             * Convert /[handle].jsx and /[...handle].jsx to /:handle.jsx for react-router-dom
+             */
+            .replace(/\[(?:[.]{3})?(\w+?)\]/g, (_match, param) => `:${param}`);
+        /**
+         * Catch-all routes [...handle].jsx don't need an exact match
+         * https://reactrouter.com/core/api/Route/exact-bool
+         */
+        const exact = !/\[(?:[.]{3})(\w+?)\]/.test(key);
+        return {
+            path: topLevelPrefix + path,
+            resource: pages[key].api,
+            hasServerComponent: !!pages[key].default,
+            exact,
+        };
+    });
+    cachedRoutes = [
+        ...routes.filter((route) => !route.path.includes(':')),
+        ...routes.filter((route) => route.path.includes(':')),
+    ];
+    return cachedRoutes;
+}
+exports.getApiRoutesFromPages = getApiRoutesFromPages;
+function getApiRouteFromURL(url, routes) {
+    let foundRoute, foundRouteDetails;
+    for (let i = 0; i < routes.length; i++) {
+        foundRouteDetails = (0, matchPath_1.matchPath)(url.pathname, routes[i]);
+        if (foundRouteDetails) {
+            foundRoute = routes[i];
+            break;
+        }
+    }
+    if (!foundRoute)
+        return null;
+    return {
+        resource: foundRoute.resource,
+        params: foundRouteDetails.params,
+        hasServerComponent: foundRoute.hasServerComponent,
+    };
+}
+exports.getApiRouteFromURL = getApiRouteFromURL;
+async function renderApiRoute(request, route, log) {
+    let response;
+    try {
+        response = await route.resource(request, { params: route.params });
+    }
+    catch (e) {
+        log.error(e);
+        response = new Response('Error processing: ' + request.url, { status: 500 });
+    }
+    (0, log_1.logServerResponse)('api', log, request, response.status);
+    return response;
+}
+exports.renderApiRoute = renderApiRoute;

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

@@ -1,5 +1,5 @@
 import { GraphQLConnection } from '../../types';
 /**
- * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](api/storefront/reference/products/product#connections)) into a flat array of nodes.
+ * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](/api/storefront/reference/products/product)) into a flat array of nodes.
  */
 export declare function flattenConnection<T>(connection: GraphQLConnection<T>): T[];

package/dist/node/utilities/flattenConnection/flattenConnection.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flattenConnection = void 0;
 /**
- * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](api/storefront/reference/products/product#connections)) into a flat array of nodes.
+ * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](/api/storefront/reference/products/product)) into a flat array of nodes.
  */
 function flattenConnection(connection) {
     var _a;

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

@@ -0,0 +1,17 @@
+import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+/** A utility for logging debugging, warning, and error information about the application.
+ * Use by importing `log` `@shopify/hydrogen` or by using a `log` prop passed to each page
+ * component. Using the latter is ideal, because it will ty your log to the current request in progress.
+ */
+export interface Logger {
+    trace: (...args: Array<any>) => void;
+    debug: (...args: Array<any>) => void;
+    warn: (...args: Array<any>) => void;
+    error: (...args: Array<any>) => void;
+    fatal: (...args: Array<any>) => void;
+}
+export declare function getLoggerFromContext(context: any): Logger;
+export declare function setLogger(newLogger: Logger): void;
+export declare function resetLogger(): void;
+export declare const log: Logger;
+export declare function logServerResponse(type: 'str' | 'rsc' | 'ssr' | 'api', log: Logger, request: ServerComponentRequest, responseStatus: number): void;

package/dist/node/utilities/log/log.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logServerResponse = exports.log = exports.resetLogger = exports.setLogger = exports.getLoggerFromContext = void 0;
+const kolorist_1 = require("kolorist");
+const timing_1 = require("../timing");
+const defaultLogger = {
+    trace(context, ...args) {
+        console.log(...args);
+    },
+    debug(context, ...args) {
+        console.log(...args);
+    },
+    warn(context, ...args) {
+        console.warn((0, kolorist_1.yellow)('WARN: '), ...args);
+    },
+    error(context, ...args) {
+        console.error((0, kolorist_1.red)('ERROR: '), ...args);
+    },
+    fatal(context, ...args) {
+        console.error((0, kolorist_1.red)('FATAL: '), ...args);
+    },
+};
+let logger = defaultLogger;
+function getLoggerFromContext(context) {
+    return {
+        trace: (...args) => logger.trace(context, ...args),
+        debug: (...args) => logger.debug(context, ...args),
+        warn: (...args) => logger.warn(context, ...args),
+        error: (...args) => logger.error(context, ...args),
+        fatal: (...args) => logger.fatal(context, ...args),
+    };
+}
+exports.getLoggerFromContext = getLoggerFromContext;
+function setLogger(newLogger) {
+    logger = newLogger;
+}
+exports.setLogger = setLogger;
+function resetLogger() {
+    logger = defaultLogger;
+}
+exports.resetLogger = resetLogger;
+exports.log = {
+    trace(...args) {
+        return logger.trace({}, ...args);
+    },
+    debug(...args) {
+        return logger.debug({}, ...args);
+    },
+    warn(...args) {
+        return logger.warn({}, ...args);
+    },
+    error(...args) {
+        return logger.error({}, ...args);
+    },
+    fatal(...args) {
+        return logger.fatal({}, ...args);
+    },
+};
+const SERVER_RESPONSE_MAP = {
+    str: 'streaming SSR',
+    rsc: 'server Components',
+    ssr: 'buffered SSR',
+};
+function logServerResponse(type, log, request, responseStatus) {
+    const coloredResponseStatus = responseStatus >= 500
+        ? (0, kolorist_1.red)(responseStatus)
+        : responseStatus >= 400
+            ? (0, kolorist_1.yellow)(responseStatus)
+            : responseStatus >= 300
+                ? (0, kolorist_1.lightBlue)(responseStatus)
+                : (0, kolorist_1.green)(responseStatus);
+    const fullType = SERVER_RESPONSE_MAP[type] || type;
+    const styledType = (0, kolorist_1.italic)(pad(fullType, '                 '));
+    const paddedTiming = pad(((0, timing_1.getTime)() - request.time).toFixed(2) + ' ms', '          ');
+    const url = type === 'rsc'
+        ? decodeURIComponent(request.url.substring(request.url.indexOf('=') + 1))
+        : request.url;
+    log.debug(`${request.method} ${styledType} ${coloredResponseStatus} ${paddedTiming} ${url}`);
+}
+exports.logServerResponse = logServerResponse;
+function pad(str, _pad) {
+    return (str + _pad).substring(0, _pad.length);
+}

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

@@ -0,0 +1,10 @@
+import { TokensToRegexpOptions } from 'path-to-regexp';
+interface MatchPathOptions extends TokensToRegexpOptions {
+    path?: string;
+    exact?: boolean;
+}
+/**
+ * Public API for matching a URL pathname to a path.
+ */
+export declare function matchPath(pathname: string, options?: MatchPathOptions): any;
+export {};

package/dist/node/utilities/matchPath.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPath = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+// Modified from React Router v5
+// https://github.com/remix-run/react-router/blob/v5/packages/react-router/modules/matchPath.js
+const cache = {};
+const cacheLimit = 10000;
+let cacheCount = 0;
+function compilePath(path, options) {
+    const cacheKey = `${options.end}${options.strict}${options.sensitive}`;
+    const pathCache = cache[cacheKey] || (cache[cacheKey] = {});
+    if (pathCache[path])
+        return pathCache[path];
+    const keys = [];
+    const regexp = (0, path_to_regexp_1.pathToRegexp)(path, keys, options);
+    const result = { regexp, keys };
+    if (cacheCount < cacheLimit) {
+        pathCache[path] = result;
+        cacheCount++;
+    }
+    return result;
+}
+/**
+ * Public API for matching a URL pathname to a path.
+ */
+function matchPath(pathname, options = {}) {
+    const { path, exact = false, strict = false, sensitive = false } = options;
+    const paths = [].concat(path);
+    return paths.reduce((matched, path) => {
+        if (!path && path !== '')
+            return null;
+        if (matched)
+            return matched;
+        const { regexp, keys } = compilePath(path, {
+            end: exact,
+            strict,
+            sensitive,
+        });
+        const match = regexp.exec(pathname);
+        if (!match)
+            return null;
+        const [url, ...values] = match;
+        const isExact = pathname === url;
+        if (exact && !isExact)
+            return null;
+        return {
+            path,
+            url: path === '/' && url === '' ? '/' : url,
+            isExact,
+            params: keys.reduce((memo, key, index) => {
+                memo[key.name] = values[index];
+                return memo;
+            }, {}),
+        };
+    }, null);
+}
+exports.matchPath = matchPath;

package/dist/node/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "0.8.3";
+export declare const LIB_VERSION = "0.9.0";

package/dist/node/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIB_VERSION = void 0;
-exports.LIB_VERSION = '0.8.3';
+exports.LIB_VERSION = '0.9.0';

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

@@ -15,6 +15,9 @@ export class ServerComponentRequest extends Request {
             super(getUrlFromNodeRequest(input), {
                 headers: new Headers(input.headers),
                 method: input.method,
+                body: input.method !== 'GET' && input.method !== 'HEAD'
+                    ? input.body
+                    : undefined,
             });
         }
         this.time = getTime();

package/dist/worker/handle-event.js

@@ -1,6 +1,7 @@
 import { getCacheControlHeader } from './framework/cache';
 import { setContext, setCache } from './framework/runtime';
 import { setConfig } from './framework/config';
+import { renderApiRoute } from './utilities/apiRoutes';
 export default async function handleEvent(event, { request, entrypoint, indexTemplate, assetHandler, streamableResponse, dev, cache, context, }) {
     var _a, _b, _c, _d, _e;
     const url = new URL(request.url);
@@ -21,12 +22,21 @@ export default async function handleEvent(event, { request, entrypoint, indexTem
         assetHandler) {
         return assetHandler(event, url);
     }
-    const { render, hydrate, stream } = entrypoint.default || entrypoint;
+    const { render, hydrate, stream, getApiRoute, log } = entrypoint.default || entrypoint;
     // @ts-ignore
-    if (dev && !(render && hydrate && stream)) {
+    if (dev && !(render && hydrate && stream && getApiRoute)) {
         throw new Error(`entry-server.jsx could not be loaded. This likely occurred because of a Vite compilation error.\n` +
             `Please check your server logs for more information.`);
     }
+    if (!isReactHydrationRequest) {
+        const apiRoute = getApiRoute(url);
+        // The API Route might have a default export, making it also a server component
+        // If it does, only render the API route if the request method is GET
+        if (apiRoute &&
+            (!apiRoute.hasServerComponent || request.method !== 'GET')) {
+            return renderApiRoute(request, apiRoute, log);
+        }
+    }
     const userAgent = request.headers.get('user-agent');
     const isStreamable = streamableResponse && !isBotUA(url, userAgent);
     /**

package/dist/worker/types.d.ts

@@ -3,6 +3,8 @@ import { ServerResponse } from 'http';
 import type { ServerComponentResponse } from './framework/Hydration/ServerComponentResponse.server';
 import type { ServerComponentRequest } from './framework/Hydration/ServerComponentRequest.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: {
     request: ServerComponentRequest;
     context?: Record<string, any>;
@@ -29,6 +31,8 @@ export declare type EntryServerHandler = {
     render: Renderer;
     stream: Streamer;
     hydrate: Hydrator;
+    getApiRoute: (url: URL) => ApiRouteMatch | null;
+    log: Logger;
 };
 export declare type ShopifyConfig = {
     locale?: string;
@@ -39,11 +43,11 @@ export declare type ShopifyConfig = {
 export declare type Hook = (params: {
     url: URL;
 } & Record<string, any>) => any | Promise<any>;
-export declare type ServerHandler = (App: any, hook?: Hook) => {
-    render: Renderer;
-    stream: Streamer;
-    hydrate: Hydrator;
+export declare type ImportGlobEagerOutput = Record<string, Record<'default' | 'api', any>>;
+export declare type ServerHandlerConfig = {
+    pages?: ImportGlobEagerOutput;
 };
+export declare type ServerHandler = (App: any, config?: ServerHandlerConfig, hook?: Hook) => EntryServerHandler;
 export declare type ClientHandler = (App: any, hook?: Hook) => Promise<void>;
 export interface GraphQLConnection<T> {
     edges?: {
@@ -87,5 +91,6 @@ export interface CacheOptions {
 }
 export interface HydrogenVitePluginOptions {
     devCache?: boolean;
+    purgeQueryCacheOnBuild?: boolean;
 }
 export {};

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

@@ -0,0 +1,21 @@
+import { ImportGlobEagerOutput } from '../types';
+import { Logger } from '../utilities/log/log';
+declare type RouteParams = Record<string, string>;
+declare type RequestOptions = {
+    params: RouteParams;
+};
+declare type ResourceGetter = (request: Request, requestOptions: RequestOptions) => Promise<Response>;
+interface HydrogenApiRoute {
+    path: string;
+    resource: ResourceGetter;
+    hasServerComponent: boolean;
+}
+export declare type ApiRouteMatch = {
+    resource: ResourceGetter;
+    hasServerComponent: boolean;
+    params: RouteParams;
+};
+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 {};