@shopify/hydrogen 0.8.1 → 0.9.1

package/dist/esnext/utilities/apiRoutes.js

@@ -0,0 +1,73 @@
+import { matchPath } from './matchPath';
+import { logServerResponse } from '../utilities/log/log';
+let cachedRoutes = [];
+export 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;
+}
+export function getApiRouteFromURL(url, routes) {
+    let foundRoute, foundRouteDetails;
+    for (let i = 0; i < routes.length; i++) {
+        foundRouteDetails = 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,
+    };
+}
+export 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 });
+    }
+    logServerResponse('api', log, request, response.status);
+    return response;
+}

package/dist/esnext/utilities/fetch.js

@@ -38,6 +38,9 @@ export function fetchBuilder(request) {
             headers,
             method: clonedRequest.method,
         });
+        if (!response.ok) {
+            throw response;
+        }
         const data = await response.json();
         return data;
     };
@@ -50,12 +53,6 @@ export function graphqlRequestBody(query, variables) {
     });
 }
 export function decodeShopifyId(id) {
-    if (!id.startsWith('gid://')) {
-        id =
-            typeof btoa !== 'undefined'
-                ? btoa(id)
-                : Buffer.from(id, 'base64').toString('ascii');
-    }
     if (!id.startsWith('gid://')) {
         throw new Error('invalid Shopify ID');
     }

package/dist/esnext/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/esnext/utilities/flattenConnection/flattenConnection.js

@@ -1,5 +1,5 @@
 /**
- * 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 function flattenConnection(connection) {
     var _a;

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

@@ -5,7 +5,6 @@ export { wrapPromise } from './suspense';
 export { flattenConnection } from './flattenConnection';
 export { isClient } from './isClient';
 export { isServer } from './isServer';
-export { log, setLogger, Logger, logServerResponse, getLoggerFromContext, resetLogger, } from './log';
 export { getMeasurementAsParts, getMeasurementAsString } from './measurement';
 export { parseMetafieldValue } from './parseMetafieldValue';
 export { fetchBuilder, graphqlRequestBody, decodeShopifyId } from './fetch';

package/dist/esnext/utilities/index.js

@@ -5,7 +5,6 @@ export { wrapPromise } from './suspense';
 export { flattenConnection } from './flattenConnection';
 export { isClient } from './isClient';
 export { isServer } from './isServer';
-export { log, setLogger, logServerResponse, getLoggerFromContext, resetLogger, } from './log';
 export { getMeasurementAsParts, getMeasurementAsString } from './measurement';
 export { parseMetafieldValue } from './parseMetafieldValue';
 export { fetchBuilder, graphqlRequestBody, decodeShopifyId } from './fetch';

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

@@ -3,9 +3,6 @@ import { ServerComponentRequest } from '../../framework/Hydration/ServerComponen
  * 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.
  */
-declare global {
-    var __hlogger: Logger;
-}
 export interface Logger {
     trace: (...args: Array<any>) => void;
     debug: (...args: Array<any>) => void;
@@ -14,7 +11,7 @@ export interface Logger {
     fatal: (...args: Array<any>) => void;
 }
 export declare function getLoggerFromContext(context: any): Logger;
-export declare function setLogger(_logger: Logger): void;
+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', log: Logger, request: ServerComponentRequest, responseStatus: number): void;
+export declare function logServerResponse(type: 'str' | 'rsc' | 'ssr' | 'api', log: Logger, request: ServerComponentRequest, responseStatus: number): void;

package/dist/esnext/utilities/log/log.js

@@ -1,17 +1,6 @@
 import { yellow, red, green, italic, lightBlue } from 'kolorist';
 import { getTime } from '../timing';
-export function getLoggerFromContext(context) {
-    return {
-        trace: (...args) => globalThis.__hlogger.trace(context, ...args),
-        debug: (...args) => globalThis.__hlogger.debug(context, ...args),
-        warn: (...args) => globalThis.__hlogger.warn(context, ...args),
-        error: (...args) => globalThis.__hlogger.error(context, ...args),
-        fatal: (...args) => globalThis.__hlogger.fatal(context, ...args),
-    };
-}
-// @todo - multiple instances of log.ts are loaded, we utilitze the
-// global in order to make sure that the logger is a singleton
-const defaultLogger = (globalThis.__hlogger = {
+const defaultLogger = {
     trace(context, ...args) {
         console.log(...args);
     },
@@ -27,30 +16,45 @@ const defaultLogger = (globalThis.__hlogger = {
     fatal(context, ...args) {
         console.error(red('FATAL: '), ...args);
     },
-});
-export function setLogger(_logger) {
-    globalThis.__hlogger = _logger;
+};
+let logger = defaultLogger;
+export 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),
+    };
+}
+export function setLogger(newLogger) {
+    logger = newLogger;
 }
 export function resetLogger() {
-    globalThis.__hlogger = defaultLogger;
+    logger = defaultLogger;
 }
 export const log = {
     trace(...args) {
-        return globalThis.__hlogger.trace({}, ...args);
+        return logger.trace({}, ...args);
     },
     debug(...args) {
-        return globalThis.__hlogger.debug({}, ...args);
+        return logger.debug({}, ...args);
     },
     warn(...args) {
-        return globalThis.__hlogger.warn({}, ...args);
+        return logger.warn({}, ...args);
     },
     error(...args) {
-        return globalThis.__hlogger.error({}, ...args);
+        return logger.error({}, ...args);
     },
     fatal(...args) {
-        return globalThis.__hlogger.fatal({}, ...args);
+        return logger.fatal({}, ...args);
     },
 };
+const SERVER_RESPONSE_MAP = {
+    str: 'streaming SSR',
+    rsc: 'server Components',
+    ssr: 'buffered SSR',
+};
 export function logServerResponse(type, log, request, responseStatus) {
     const coloredResponseStatus = responseStatus >= 500
         ? red(responseStatus)
@@ -59,7 +63,8 @@ export function logServerResponse(type, log, request, responseStatus) {
             : responseStatus >= 300
                 ? lightBlue(responseStatus)
                 : green(responseStatus);
-    const styledType = italic(type);
+    const fullType = SERVER_RESPONSE_MAP[type] || type;
+    const styledType = italic(pad(fullType, '                 '));
     const paddedTiming = pad((getTime() - request.time).toFixed(2) + ' ms', '          ');
     const url = type === 'rsc'
         ? decodeURIComponent(request.url.substring(request.url.indexOf('=') + 1))

package/dist/esnext/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/esnext/utilities/matchPath.js

@@ -0,0 +1,54 @@
+import { pathToRegexp } from '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 = 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.
+ */
+export 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);
+}

package/dist/esnext/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "0.8.1";
+export declare const LIB_VERSION = "0.9.1";

package/dist/esnext/version.js

@@ -1 +1 @@
-export const LIB_VERSION = '0.8.1';
+export const LIB_VERSION = '0.9.1';

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

@@ -18,6 +18,9 @@ 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 = (0, timing_1.getTime)();

package/dist/node/framework/middleware.js

@@ -42,17 +42,6 @@ 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`,
@@ -60,14 +49,17 @@ function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, de
              */
             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.default;
+                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;
             }
             /**
              * Dynamically import ServerComponentResponse after the `fetch`
@@ -95,7 +87,10 @@ function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, de
                     response.setHeader(key, value);
                 });
                 response.statusCode = eventResponse.status;
-                response.end(eventResponse.body);
+                if (eventResponse.body) {
+                    response.write(eventResponse.body);
+                }
+                response.end();
             }
         }
         catch (e) {
@@ -126,11 +121,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,7 +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 log_1 = require("./utilities/log");
+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);
@@ -24,15 +24,23 @@ 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);
-    const logger = (0, log_1.getLoggerFromContext)(request);
     /**
      * Stream back real-user responses, but for bots/etc,
      * use `render` instead. This is because we need to inject <head>
@@ -45,7 +53,6 @@ async function handleEvent(event, { request, entrypoint, indexTemplate, assetHan
                 request,
                 response: streamableResponse,
                 dev,
-                log: logger,
             });
         }
         else {
@@ -55,7 +62,6 @@ async function handleEvent(event, { request, entrypoint, indexTemplate, assetHan
                 response: streamableResponse,
                 template,
                 dev,
-                log: logger,
             });
         }
         return;
@@ -65,7 +71,6 @@ async function handleEvent(event, { request, entrypoint, indexTemplate, assetHan
         context: {},
         isReactHydrationRequest,
         dev,
-        log: logger,
     });
     const headers = componentResponse.headers;
     /**
@@ -102,7 +107,6 @@ async function handleEvent(event, { request, entrypoint, indexTemplate, assetHan
             headers,
         });
     }
-    (0, log_1.logServerResponse)('ssr', logger, request, response.status);
     return response;
 }
 exports.default = handleEvent;

package/dist/node/types.d.ts

@@ -1,15 +1,15 @@
 /// <reference types="node" />
 import { ServerResponse } from 'http';
-import type { Logger } from './utilities/log/log';
 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>;
     isReactHydrationRequest?: boolean;
     dev?: boolean;
-    log: Logger;
 }) => Promise<{
     body: string;
     componentResponse: ServerComponentResponse;
@@ -19,20 +19,20 @@ export declare type Streamer = (url: URL, options: {
     request: ServerComponentRequest;
     response: ServerResponse;
     template: string;
-    log: Logger;
     dev?: boolean;
 }) => void;
 export declare type Hydrator = (url: URL, options: {
     context: any;
     request: ServerComponentRequest;
     response: ServerResponse;
-    log: Logger;
     dev?: boolean;
 }) => void;
 export declare type EntryServerHandler = {
     render: Renderer;
     stream: Streamer;
     hydrate: Hydrator;
+    getApiRoute: (url: URL) => ApiRouteMatch | null;
+    log: Logger;
 };
 export declare type ShopifyConfig = {
     locale?: string;
@@ -43,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?: {
@@ -91,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 {};