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

package/dist/esnext/index.js

@@ -2,7 +2,7 @@ export * from './foundation/';
 export * from './components/';
 export * from './hooks/';
 export { flattenConnection, fetchBuilder, graphqlRequestBody, decodeShopifyId, isClient, getTime, } from './utilities';
-export { log, setLogger } from './utilities/log';
+export { log, setLogger, setLoggerOptions } from './utilities/log';
 // This is exported here because it contains a Server Component
 export { LocalizationProvider } from './components/LocalizationProvider/LocalizationProvider.server';
 // Exported here because users shouldn't be making `useShopQuery` calls from the client
@@ -10,3 +10,4 @@ export * from './hooks/useShopQuery';
 // Export server-only CartQuery here instead of `CartProvider.client` to prevent
 // it from being bundled with other client components
 export { CartQuery } from './graphql/graphql-constants';
+export { generateCacheControlHeader, NoStore, CacheSeconds, CacheMinutes, CacheHours, CacheDays, CacheWeeks, CacheMonths, CacheCustom, } from './framework/CachingStrategy';

package/dist/esnext/platforms/node.d.ts

@@ -0,0 +1,10 @@
+import '../utilities/web-api-polyfill';
+import connect from 'connect';
+declare type CreateServerOptions = {
+    port?: number | string;
+};
+export declare function createServer({ port, }?: CreateServerOptions): Promise<{
+    app: connect.Server;
+    port: string | number;
+}>;
+export {};

package/dist/esnext/platforms/node.js

@@ -0,0 +1,38 @@
+import '../utilities/web-api-polyfill';
+import path from 'path';
+// @ts-ignore
+// eslint-disable-next-line node/no-missing-import
+import entrypoint from '__SERVER_ENTRY__';
+// @ts-ignore
+// eslint-disable-next-line node/no-missing-import
+import indexTemplate from '__INDEX_TEMPLATE__?raw';
+import { hydrogenMiddleware } from '../framework/middleware';
+// @ts-ignore
+import serveStatic from 'serve-static';
+// @ts-ignore
+import compression from 'compression';
+import bodyParser from 'body-parser';
+import connect from 'connect';
+const handleRequest = entrypoint;
+export async function createServer({ port = process.env.PORT || 8080, } = {}) {
+    // @ts-ignore
+    globalThis.Oxygen = { env: process.env };
+    const app = connect();
+    app.use(compression());
+    app.use(serveStatic(path.resolve(__dirname, '../client'), {
+        index: false,
+    }));
+    app.use(bodyParser.raw({ type: '*/*' }));
+    app.use(hydrogenMiddleware({
+        getServerEntrypoint: () => handleRequest,
+        indexTemplate,
+    }));
+    return { app, port };
+}
+if (require.main === module) {
+    createServer().then(({ app, port }) => {
+        app.listen(port, () => {
+            console.log(`Hydrogen server running at http://localhost:${port}`);
+        });
+    });
+}

package/dist/esnext/platforms/worker-event.d.ts

@@ -0,0 +1,9 @@
+declare global {
+    var globalThis: {
+        Oxygen: {
+            env: any;
+        };
+        [key: string]: any;
+    };
+}
+export {};

package/dist/esnext/platforms/worker-event.js

@@ -0,0 +1,24 @@
+// @ts-ignore
+// eslint-disable-next-line node/no-missing-import
+import entrypoint from '__SERVER_ENTRY__';
+// @ts-ignore
+// eslint-disable-next-line node/no-missing-import
+import indexTemplate from '__INDEX_TEMPLATE__?raw';
+const handleRequest = entrypoint;
+if (!globalThis.Oxygen) {
+    globalThis.Oxygen = { env: globalThis };
+}
+async function handleEvent(event) {
+    try {
+        return (await handleRequest(event.request, {
+            indexTemplate,
+            cache: caches.default,
+            context: event,
+        }));
+    }
+    catch (error) {
+        return new Response(error.message || error.toString(), { status: 500 });
+    }
+}
+// @ts-ignore
+addEventListener('fetch', (event) => event.respondWith(handleEvent(event)));

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

@@ -1,11 +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;
 };
-export declare const ssrRenderToPipeableStream: any;
-export declare const ssrRenderToReadableStream: (App: JSX.Element, options: {
-    nonce?: string | undefined;
-    onCompleteShell?: (() => void) | undefined;
-    onCompleteAll?: (() => void) | undefined;
-    onError?: ((error: Error) => void) | undefined;
-}) => ReadableStream<Uint8Array>;
+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/esnext/streaming.server.js

@@ -12,3 +12,47 @@ export const rscRenderToReadableStream = _rscRenderToReadableStream;
 export const createFromReadableStream = _createFromReadableStream;
 export const ssrRenderToPipeableStream = _ssrRenderToPipeableStream;
 export const ssrRenderToReadableStream = _ssrRenderToReadableStream;
+export function supportsReadableStream() {
+    try {
+        new ReadableStream();
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+let cachedStreamingSupport;
+export 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;
+}
+export 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;
+}

package/dist/esnext/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/esnext/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 {};

package/dist/esnext/utilities/apiRoutes.js

@@ -1,5 +1,5 @@
 import { matchPath } from './matchPath';
-import { logServerResponse } from '../utilities/log/log';
+import { getLoggerWithContext, logServerResponse } from '../utilities/log/';
 let memoizedRoutes = [];
 let memoizedPages = {};
 export function getApiRoutesFromPages(pages, topLevelPath = '*') {
@@ -61,8 +61,9 @@ export function getApiRouteFromURL(url, routes) {
         hasServerComponent: foundRoute.hasServerComponent,
     };
 }
-export async function renderApiRoute(request, route, log) {
+export async function renderApiRoute(request, route) {
     let response;
+    const log = getLoggerWithContext(request);
     try {
         response = await route.resource(request, { params: route.params });
         if (!(response instanceof Response)) {
@@ -82,6 +83,6 @@ export async function renderApiRoute(request, route, log) {
         log.error(e);
         response = new Response('Error processing: ' + request.url, { status: 500 });
     }
-    logServerResponse('api', log, request, response.status);
+    logServerResponse('api', request, response.status);
     return response;
 }

package/dist/esnext/utilities/bot-ua.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Determines if the request is from a bot, using the URL and User Agent
+ */
+export declare function isBotUA(url: URL, userAgent: string | null): boolean;

package/dist/esnext/utilities/bot-ua.js

@@ -0,0 +1,54 @@
+/**
+ * An alphabetized list of User Agents of known bots, combined from lists found at:
+ * https://github.com/vercel/next.js/blob/d87dc2b5a0b3fdbc0f6806a47be72bad59564bd0/packages/next/server/utils.ts#L18-L22
+ * https://github.com/GoogleChrome/rendertron/blob/6f681688737846b28754fbfdf5db173846a826df/middleware/src/middleware.ts#L24-L41
+ */
+const botUserAgents = [
+    'AdsBot-Google',
+    'applebot',
+    'Baiduspider',
+    'baiduspider',
+    'bingbot',
+    'Bingbot',
+    'BingPreview',
+    'bitlybot',
+    'Discordbot',
+    'DuckDuckBot',
+    'Embedly',
+    'facebookcatalog',
+    'facebookexternalhit',
+    'Google-PageRenderer',
+    'Googlebot',
+    'googleweblight',
+    'ia_archive',
+    'LinkedInBot',
+    'Mediapartners-Google',
+    'outbrain',
+    'pinterest',
+    'quora link preview',
+    'redditbot',
+    'rogerbot',
+    'showyoubot',
+    'SkypeUriPreview',
+    'Slackbot',
+    'Slurp',
+    'sogou',
+    'Storebot-Google',
+    'TelegramBot',
+    'tumblr',
+    'Twitterbot',
+    'vkShare',
+    'W3C_Validator',
+    'WhatsApp',
+    'yandex',
+];
+/**
+ * Creates a regex based on the botUserAgents array
+ */
+const botUARegex = new RegExp(botUserAgents.join('|'), 'i');
+/**
+ * Determines if the request is from a bot, using the URL and User Agent
+ */
+export function isBotUA(url, userAgent) {
+    return (url.searchParams.has('_bot') || (!!userAgent && botUARegex.test(userAgent)));
+}

package/dist/esnext/utilities/fetch.js

@@ -10,33 +10,8 @@ export function fetchBuilder(request) {
             request.headers.append(property, value);
         }
     }
-    let body;
     return async () => {
-        // Since a request's body can't be consumed more than once,
-        // and throws at the attempt afterwards,
-        // and this function can be cached and re-used, we cache
-        // the body in the outer scope.
-        if (!body) {
-            body = await request.text();
-        }
-        // Oxygen's fetch is a Go implementation which
-        // currently doesn't process some the call
-        // signatures well. Specifically, it can't
-        // consume request/response "body" property
-        // if it follows the standard and is a ReadableStream
-        // instance. It worked before because old Fetch API polyfills
-        // in Oxygen didn't follow the standard but soon they will,
-        // and we have to adjust the way we call fetch().
-        // Oxygen aims at being eventually compliant
-        // with the Fetch API, making these quirks redundant.
-        // Headers must be a plain object unless the whole second argument is instanceof Request
-        // @ts-ignore
-        const headers = Object.fromEntries(request.headers.entries());
-        const response = await fetch(request.url, {
-            body,
-            headers,
-            method: request.method,
-        });
+        const response = await fetch(request.url, request);
         if (!response.ok) {
             throw response;
         }

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

@@ -1 +1,4 @@
-export { log, setLogger, Logger, logServerResponse, getLoggerFromContext, resetLogger, } from './log';
+export { log, setLogger, setLoggerOptions, getLoggerWithContext, Logger, logServerResponse, resetLogger, } from './log';
+export { collectQueryCacheControlHeaders, logCacheControlHeaders, } from './log-cache-header';
+export { logCacheApiStatus } from './log-cache-api-status';
+export { collectQueryTimings, logQueryTimings } from './log-query-timeline';

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

@@ -1 +1,4 @@
-export { log, setLogger, logServerResponse, getLoggerFromContext, resetLogger, } from './log';
+export { log, setLogger, setLoggerOptions, getLoggerWithContext, logServerResponse, resetLogger, } from './log';
+export { collectQueryCacheControlHeaders, logCacheControlHeaders, } from './log-cache-header';
+export { logCacheApiStatus } from './log-cache-api-status';
+export { collectQueryTimings, logQueryTimings } from './log-query-timeline';

package/dist/esnext/utilities/log/log-cache-api-status.d.ts

@@ -0,0 +1 @@
+export declare function logCacheApiStatus(status: string | null, url: string): void;

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

@@ -0,0 +1,9 @@
+import { findQueryName } from './utils';
+import { gray } from 'kolorist';
+import { log } from '.';
+export function logCacheApiStatus(status, url) {
+    if (!log.options().showCacheApiStatus) {
+        return;
+    }
+    log.debug(gray(`[Cache] ${status === null || status === void 0 ? void 0 : status.padEnd(6)} query ${findQueryName(url)}`));
+}

package/dist/esnext/utilities/log/log-cache-header.d.ts

@@ -0,0 +1,10 @@
+import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+import { ServerComponentResponse } from '../../framework/Hydration/ServerComponentResponse.server';
+import { QueryKey } from '../../types';
+import type { RenderType } from './log';
+export declare type QueryCacheControlHeaders = {
+    name: string;
+    header: string | null;
+};
+export declare function collectQueryCacheControlHeaders(request: ServerComponentRequest, queryKey: QueryKey, cacheControlHeader: string | null): void;
+export declare function logCacheControlHeaders(type: RenderType, request: ServerComponentRequest, response?: ServerComponentResponse): void;

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

@@ -0,0 +1,30 @@
+import { hashKey } from '../../framework/cache';
+import { findQueryName, parseUrl } from './utils';
+import { gray } from 'kolorist';
+import { getLoggerWithContext } from './log';
+const color = gray;
+export function collectQueryCacheControlHeaders(request, queryKey, cacheControlHeader) {
+    request.ctx.queryCacheControl.push({
+        name: findQueryName(hashKey(queryKey)),
+        header: cacheControlHeader,
+    });
+}
+export function logCacheControlHeaders(type, request, response) {
+    const log = getLoggerWithContext(request);
+    if (!log.options().showCacheControlHeader) {
+        return;
+    }
+    log.debug(color(`┌── Cache control header for ${parseUrl(type, request.url)}`));
+    if (response) {
+        log.debug(color(`│ ${response.cacheControlHeader}`));
+    }
+    const queryList = request.ctx.queryCacheControl;
+    const longestQueryNameLength = queryList.reduce((max, query) => Math.max(max, query.name.length), 0);
+    if (queryList.length > 0) {
+        log.debug(color('│'));
+        queryList.forEach((query) => {
+            log.debug(color(`│ query ${query.name.padEnd(longestQueryNameLength + 1)}${query.header}`));
+        });
+    }
+    log.debug(color('└──'));
+}

package/dist/esnext/utilities/log/log-query-timeline.d.ts

@@ -0,0 +1,12 @@
+import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+import { QueryKey } from '../../types';
+import type { RenderType } from './log';
+export declare type TimingType = 'requested' | 'resolved' | 'rendered' | 'preload';
+export declare type QueryTiming = {
+    name: string;
+    timingType: TimingType;
+    timestamp: number;
+    duration?: number;
+};
+export declare function collectQueryTimings(request: ServerComponentRequest, queryKey: QueryKey, timingType: TimingType, duration?: number): void;
+export declare function logQueryTimings(type: RenderType, request: ServerComponentRequest): void;

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

@@ -0,0 +1,83 @@
+import { hashKey } from '../../framework/cache';
+import { findQueryName, parseUrl } from './utils';
+import { gray, red, yellow, green } from 'kolorist';
+import { getLoggerWithContext } from './log';
+import { getTime } from '../timing';
+const color = gray;
+const TIMING_MAPPING = {
+    requested: 'Requested',
+    rendered: 'Rendered',
+    resolved: 'Resolved',
+    preload: 'Preload',
+};
+export function collectQueryTimings(request, queryKey, timingType, duration) {
+    request.ctx.queryTimings.push({
+        name: findQueryName(hashKey(queryKey)),
+        timingType,
+        timestamp: getTime(),
+        duration,
+    });
+}
+export function logQueryTimings(type, request) {
+    const log = getLoggerWithContext(request);
+    if (!log.options().showQueryTiming) {
+        return;
+    }
+    log.debug(color(`┌── Query timings for ${parseUrl(type, request.url)}`));
+    const queryList = request.ctx.queryTimings;
+    if (queryList.length > 0) {
+        const requestStartTime = request.time;
+        const detectSuspenseWaterfall = {};
+        const detectMultipleDataLoad = {};
+        let suspenseWaterfallDetectedCount = 0;
+        queryList.forEach((query, index) => {
+            var _a;
+            if (query.timingType === 'requested' || query.timingType === 'preload') {
+                detectSuspenseWaterfall[query.name] = true;
+            }
+            else if (query.timingType === 'rendered') {
+                delete detectSuspenseWaterfall[query.name];
+            }
+            else if (query.timingType === 'resolved') {
+                detectMultipleDataLoad[query.name] = detectMultipleDataLoad[query.name]
+                    ? detectMultipleDataLoad[query.name] + 1
+                    : 1;
+            }
+            const loadColor = query.timingType === 'preload' ? green : color;
+            log.debug(color(`│ ${`${(query.timestamp - requestStartTime).toFixed(2)}ms`.padEnd(10)} ${loadColor(TIMING_MAPPING[query.timingType].padEnd(10))} ${query.name}${query.timingType === 'resolved'
+                ? ` (Took ${(_a = query.duration) === null || _a === void 0 ? void 0 : _a.toFixed(2)}ms)`
+                : ''}`));
+            // SSR + RSC render path generates 2 `load` and `render` for each query
+            // We want to avoid falsely identifying a suspense waterfall near the end
+            // of the query list
+            //
+            // The (index + 4) is detecting that near the end of list.
+            // A complete set of events for a given query is 4 entries
+            // │ (639.62ms)  Requested  Localization
+            // │ (993.33ms)  Resolved   Localization (Took 353.66ms)
+            // │ (993.96ms)  Requested  Localization      <-- second time React tries to load
+            // │ (994.03ms)  Rendered   Localization
+            //
+            // so the end of list index range is 3 (one less from a set entry) + 1 (zero index)
+            if (queryList.length >= index + 4 &&
+                Object.keys(detectSuspenseWaterfall).length === 0) {
+                suspenseWaterfallDetectedCount++;
+                const warningColor = suspenseWaterfallDetectedCount === 1 ? yellow : red;
+                log.debug(`${color(`│ `)}${warningColor(`Suspense waterfall detected`)}`);
+            }
+        });
+        const unusedQueries = Object.keys(detectSuspenseWaterfall);
+        if (unusedQueries.length > 0) {
+            unusedQueries.forEach((queryName) => {
+                log.debug(`${color(`│ `)}${yellow(`Unused query detected: ${queryName}`)}`);
+            });
+        }
+        Object.keys(detectMultipleDataLoad).forEach((queryName) => {
+            const count = detectMultipleDataLoad[queryName];
+            if (count > 1) {
+                log.debug(`${color(`│ `)}${yellow(`Multiple data loads detected: ${queryName}`)}`);
+            }
+        });
+    }
+    log.debug(color('└──'));
+}

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

@@ -1,18 +1,21 @@
 import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
-/** The `log` utility is a function that's used for logging debugging, warning, and error information about the application.
- * Use this utility by importing `log` from `@shopify/hydrogen`, or by using a `log` prop passed to each page
- * component. We recommend using the `log` prop passed to each page because it will associated 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;
+    options: () => LoggerOptions;
 }
-export declare function getLoggerFromContext(context: any): Logger;
+export declare type LoggerOptions = {
+    showCacheControlHeader?: boolean;
+    showCacheApiStatus?: boolean;
+    showQueryTiming?: boolean;
+};
+export declare type RenderType = 'str' | 'rsc' | 'ssr' | 'api';
+export declare const log: Logger;
+export declare function getLoggerWithContext(context?: any): Logger;
 export declare function setLogger(newLogger: Logger): void;
+export declare function setLoggerOptions(options: LoggerOptions): 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;
+export declare function logServerResponse(type: RenderType, request: ServerComponentRequest, responseStatus: number): void;