@sitecore-jss/sitecore-jss-nextjs 21.1.0-canary.98 → 21.1.0

package/types/middleware/middleware.d.ts

@@ -0,0 +1,68 @@
+import { SiteInfo, SiteResolver } from '@sitecore-jss/sitecore-jss/site';
+import { NextRequest, NextResponse } from 'next/server';
+export type MiddlewareBaseConfig = {
+    /**
+     * function, determines if middleware should be turned off, based on cookie, header, or other considerations
+     * @param {NextRequest} [req] request object from middleware handler
+     * @param {NextResponse} [res] response object from middleware handler
+     */
+    disabled?: (req?: NextRequest, res?: NextResponse) => boolean;
+    /**
+     * Function used to determine if route should be excluded.
+     * By default, files (pathname.includes('.')), Next.js API routes (pathname.startsWith('/api/')), and Sitecore API routes (pathname.startsWith('/sitecore/')) are ignored.
+     * This is an important performance consideration since Next.js Edge middleware runs on every request.
+     * @param {string} pathname The pathname
+     * @returns {boolean} Whether to exclude the route
+     */
+    excludeRoute?: (pathname: string) => boolean;
+    /**
+     * Fallback hostname in case `host` header is not present
+     * @default localhost
+     */
+    defaultHostname?: string;
+    /**
+     * Site resolution implementation by name/hostname
+     */
+    siteResolver: SiteResolver;
+};
+export declare abstract class MiddlewareBase {
+    protected config: MiddlewareBaseConfig;
+    protected SITE_SYMBOL: string;
+    protected defaultHostname: string;
+    constructor(config: MiddlewareBaseConfig);
+    /**
+     * Determines if mode is preview
+     * @param {NextRequest} req request
+     * @returns {boolean} is preview
+     */
+    protected isPreview(req: NextRequest): boolean;
+    protected excludeRoute(pathname: string): boolean | undefined;
+    /**
+     * Safely extract all headers for debug logging
+     * Necessary to avoid middleware issue https://github.com/vercel/next.js/issues/39765
+     * @param {Headers} incomingHeaders Incoming headers
+     * @returns Object with headers as key/value pairs
+     */
+    protected extractDebugHeaders(incomingHeaders: Headers): {
+        [key: string]: string;
+    };
+    /**
+     * Provides used language
+     * @param {NextRequest} req request
+     * @returns {string} language
+     */
+    protected getLanguage(req: NextRequest): string;
+    /**
+     * Extract 'host' header
+     * @param {NextRequest} req request
+     */
+    protected getHostHeader(req: NextRequest): string | undefined;
+    /**
+     * Get site information.
+     * Can not be used in **Preview** mode, since site will not be resolved
+     * @param {NextRequest} req request
+     * @param {NextResponse} [res] response
+     * @returns {SiteInfo} site information
+     */
+    protected getSite(req: NextRequest, res?: NextResponse): SiteInfo;
+}

package/types/middleware/multisite-middleware.d.ts

@@ -1,23 +1,6 @@
 import { NextResponse, NextRequest } from 'next/server';
-import { SiteInfo } from '@sitecore-jss/sitecore-jss/site';
-export type MultisiteMiddlewareConfig = {
-    /**
-     * Function used to determine if route should be excluded during execution.
-     * By default, files (pathname.includes('.')), Next.js API routes (pathname.startsWith('/api/')), and Sitecore API routes (pathname.startsWith('/sitecore/')) are ignored.
-     * This is an important performance consideration since Next.js Edge middleware runs on every request.
-     * @param {string} pathname The pathname
-     * @returns {boolean} Whether to exclude the route
-     */
-    excludeRoute?: (pathname: string) => boolean;
-    /**
-     * Function used to resolve site for given hostname
-     */
-    getSite: (hostname: string) => SiteInfo;
-    /**
-     * Fallback hostname in case `host` header is not present
-     * @default localhost
-     */
-    defaultHostname?: string;
+import { MiddlewareBase, MiddlewareBaseConfig } from './middleware';
+export type MultisiteMiddlewareConfig = Omit<MiddlewareBaseConfig, 'disabled'> & {
     /**
      * Function used to determine if site should be resolved from sc_site cookie when present
      */
@@ -26,9 +9,8 @@ export type MultisiteMiddlewareConfig = {
 /**
  * Middleware / handler for multisite support
  */
-export declare class MultisiteMiddleware {
+export declare class MultisiteMiddleware extends MiddlewareBase {
     protected config: MultisiteMiddlewareConfig;
-    private defaultHostname;
     /**
      * @param {MultisiteMiddlewareConfig} [config] Multisite middleware config
      */
@@ -38,9 +20,5 @@ export declare class MultisiteMiddleware {
      * @returns middleware handler
      */
     getHandler(): (req: NextRequest, res?: NextResponse) => Promise<NextResponse>;
-    protected excludeRoute(pathname: string): boolean;
-    protected extractDebugHeaders(incomingHeaders: Headers): {
-        [key: string]: string;
-    };
     private handler;
 }

package/types/middleware/personalize-middleware.d.ts

@@ -1,15 +1,8 @@
 import { NextResponse, NextRequest } from 'next/server';
 import { GraphQLPersonalizeServiceConfig, CdpServiceConfig, ExperienceParams } from '@sitecore-jss/sitecore-jss/personalize';
+import { MiddlewareBase, MiddlewareBaseConfig } from './middleware';
 import { SiteInfo } from '@sitecore-jss/sitecore-jss/site';
-export type PersonalizeMiddlewareConfig = {
-    /**
-     * Function used to determine if route should be excluded from personalization.
-     * By default, files (pathname.includes('.')), Next.js API routes (pathname.startsWith('/api/')), and Sitecore API routes (pathname.startsWith('/sitecore/')) are ignored.
-     * This is an important performance consideration since Next.js Edge middleware runs on every request.
-     * @param {string} pathname The pathname
-     * @returns {boolean} Whether to exclude the route from personalization
-     */
-    excludeRoute?: (pathname: string) => boolean;
+export type PersonalizeMiddlewareConfig = MiddlewareBaseConfig & {
     /**
      * Configuration for your Sitecore Experience Edge endpoint
      */
@@ -19,35 +12,20 @@ export type PersonalizeMiddlewareConfig = {
      */
     cdpConfig: Omit<CdpServiceConfig, 'dataFetcherResolver'>;
     /**
-     * function used to resolve correct point of sale for current locale during a request
-     * @param {string} locale locale at the time of request
-     */
-    getPointOfSale: (locale: string) => string;
-    /**
-     * function, determines if middleware should be turned off, based on cookie, header, or other considerations
-     *  @param {NextRequest} [req] optional: request object from middleware handler
-     *  @param {NextResponse} [res] optional: response object from middleware handler
-     * @returns {boolean} false by default
-     */
-    disabled?: (req?: NextRequest, res?: NextResponse) => boolean;
-    /**
-     * function used to resolve site for given hostname
-     */
-    getSite: (hostname: string) => SiteInfo;
-    /**
-     * fallback hostname in case `host` header is not present
-     * @default localhost
+     * function to resolve point of sale for a site
+     * @param {Siteinfo} site to get info from
+     * @param {string} language to get info for
+     * @returns point of sale value for site/language combination
      */
-    defaultHostname?: string;
+    getPointOfSale?: (site: SiteInfo, language: string) => string;
 };
 /**
  * Middleware / handler to support Sitecore Personalize
  */
-export declare class PersonalizeMiddleware {
+export declare class PersonalizeMiddleware extends MiddlewareBase {
     protected config: PersonalizeMiddlewareConfig;
     private personalizeService;
     private cdpService;
-    private defaultHostname;
     /**
      * @param {PersonalizeMiddlewareConfig} [config] Personalize middleware config
      */
@@ -61,16 +39,5 @@ export declare class PersonalizeMiddleware {
     protected getBrowserId(req: NextRequest): string | undefined;
     protected setBrowserId(res: NextResponse, browserId: string): void;
     protected getExperienceParams(req: NextRequest): ExperienceParams;
-    protected excludeRoute(pathname: string): boolean;
-    protected isPreview(req: NextRequest): string | undefined;
-    /**
-     * Safely extract all headers for debug logging
-     * Necessary to avoid middleware issue https://github.com/vercel/next.js/issues/39765
-     * @param {Headers} incomingHeaders Incoming headers
-     * @returns Object with headers as key/value pairs
-     */
-    protected extractDebugHeaders(incomingHeaders: Headers): {
-        [key: string]: string;
-    };
     private handler;
 }

package/types/middleware/redirects-middleware.d.ts

@@ -1,44 +1,24 @@
 import { NextResponse, NextRequest } from 'next/server';
-import { GraphQLRedirectsServiceConfig, SiteInfo } from '@sitecore-jss/sitecore-jss/site';
+import { GraphQLRedirectsServiceConfig } from '@sitecore-jss/sitecore-jss/site';
+import { MiddlewareBase, MiddlewareBaseConfig } from './middleware';
 /**
  * extended RedirectsMiddlewareConfig config type for RedirectsMiddleware
  */
-export type RedirectsMiddlewareConfig = Omit<GraphQLRedirectsServiceConfig, 'fetch'> & {
-    locales: string[];
-    /**
-     * Function used to determine if route should be excluded from RedirectsMiddleware.
-     * By default, files (pathname.includes('.')), Next.js API routes (pathname.startsWith('/api/')), and Sitecore API routes (pathname.startsWith('/sitecore/')) are ignored.
-     * This is an important performance consideration since Next.js Edge middleware runs on every request.
-     * @param {string} pathname The pathname
-     * @returns {boolean} Whether to exclude the route from RedirectsMiddleware
-     */
-    excludeRoute?: (pathname: string) => boolean;
-    /**
-     * function, determines if middleware should be turned off, based on cookie, header, or other considerations
-     *  @param {NextRequest} [req] optional: request object from middleware handler
-     *  @param {NextResponse} [res] optional: response object from middleware handler
-     * @returns {boolean} false by default
-     */
-    disabled?: (req?: NextRequest, res?: NextResponse) => boolean;
-    /**
-     * function used to resolve site for given hostname
-     */
-    getSite: (hostname: string) => SiteInfo;
+export type RedirectsMiddlewareConfig = Omit<GraphQLRedirectsServiceConfig, 'fetch'> & MiddlewareBaseConfig & {
     /**
-     * fallback hostname in case `host` header is not present
-     * @default localhost
+     * These are all the locales you support in your application.
+     * These should match those in your next.config.js (i18n.locales).
      */
-    defaultHostname?: string;
+    locales: string[];
 };
 /**
  * Middleware / handler fetches all redirects from Sitecore instance by grapqhl service
  * compares with current url and redirects to target url
  */
-export declare class RedirectsMiddleware {
+export declare class RedirectsMiddleware extends MiddlewareBase {
     protected config: RedirectsMiddlewareConfig;
     private redirectsService;
     private locales;
-    private defaultHostname;
     /**
      * @param {RedirectsMiddlewareConfig} [config] redirects middleware config
      */
@@ -48,8 +28,6 @@ export declare class RedirectsMiddleware {
      * @returns route handler
      */
     getHandler(): (req: NextRequest, res?: NextResponse) => Promise<NextResponse>;
-    protected excludeRoute(pathname: string): boolean;
-    protected getHostname(req: NextRequest): string;
     private handler;
     /**
      * Method returns RedirectInfo when matches

package/types/services/base-graphql-sitemap-service.d.ts

@@ -0,0 +1,149 @@
+import { GraphQLClient, PageInfo } from '@sitecore-jss/sitecore-jss/graphql';
+/** @private */
+export declare const languageError = "The list of languages cannot be empty";
+export declare const siteError = "The service needs a site name";
+/**
+ * @param {string} siteName to inject into error text
+ * @private
+ */
+export declare function getSiteEmptyError(siteName: string): string;
+/**
+ * type for input variables for the site routes query
+ */
+interface SiteRouteQueryVariables {
+    /**
+     * Required. The name of the site being queried.
+     */
+    siteName: string;
+    /**
+     * Required. The language to return routes/pages for.
+     */
+    language: string;
+    /**
+     * Optional. Only paths starting with these provided prefixes will be returned.
+     */
+    includedPaths?: string[];
+    /**
+     * Optional. Paths starting with these provided prefixes will be excluded from returned results.
+     */
+    excludedPaths?: string[];
+    /** common variable for all GraphQL queries
+     * it will be used for every type of query to regulate result batch size
+     * Optional. How many result items to fetch in each GraphQL call. This is needed for pagination.
+     * @default 10
+     */
+    pageSize?: number;
+}
+/**
+ * Schema of data returned in response to a "site" query request
+ * @template T The type of objects being requested.
+ */
+export interface SiteRouteQueryResult<T> {
+    site: {
+        siteInfo: {
+            routes: {
+                /**
+                 * Data needed to paginate the site results
+                 */
+                pageInfo: PageInfo;
+                results: T[];
+            };
+        };
+    };
+}
+/**
+ * The schema of data returned in response to a routes list query request
+ */
+export type RouteListQueryResult = {
+    path: string;
+    route?: {
+        personalization?: {
+            variantIds: string[];
+        };
+    };
+};
+/**
+ * Configuration options for @see GraphQLSitemapService instances
+ */
+export interface BaseGraphQLSitemapServiceConfig extends Omit<SiteRouteQueryVariables, 'language' | 'siteName'> {
+    /**
+     * Your Graphql endpoint
+     */
+    endpoint: string;
+    /**
+     * The API key to use for authentication.
+     */
+    apiKey: string;
+    /**
+     * A flag for whether to include personalized routes in service output - only works on XM Cloud
+     * turned off by default
+     */
+    includePersonalizedRoutes?: boolean;
+}
+/**
+ * Object model of a site page item.
+ */
+export type StaticPath = {
+    params: {
+        path: string[];
+    };
+    locale?: string;
+};
+/**
+ * Service that fetches the list of site pages using Sitecore's GraphQL API.
+ * Used to handle a single site
+ * This list is used for SSG and Export functionality.
+ * @mixes SearchQueryService<PageListQueryResult>
+ */
+export declare abstract class BaseGraphQLSitemapService {
+    options: BaseGraphQLSitemapServiceConfig;
+    private _graphQLClient;
+    /**
+     * GraphQL client accessible by descendant classes when needed
+     */
+    protected get graphQLClient(): GraphQLClient;
+    /**
+     * Gets the default query used for fetching the list of site pages
+     */
+    protected get query(): string;
+    /**
+     * Creates an instance of graphQL sitemap service with the provided options
+     * @param {GraphQLSitemapServiceConfig} options instance
+     */
+    constructor(options: BaseGraphQLSitemapServiceConfig);
+    /**
+     * Fetch sitemap which could be used for generation of static pages during `next export`.
+     * The `locale` parameter will be used in the item query, but since i18n is not supported,
+     * the output paths will not include a `language` property.
+     * @param {string} locale which application supports
+     * @returns an array of @see StaticPath objects
+     */
+    fetchExportSitemap(locale: string): Promise<StaticPath[]>;
+    /**
+     * Fetch sitemap which could be used for generation of static pages using SSG mode
+     * @param {string[]} locales locales which application supports
+     * @returns an array of @see StaticPath objects
+     */
+    fetchSSGSitemap(locales: string[]): Promise<StaticPath[]>;
+    protected getTranformedPaths(siteName: string, languages: string[], formatStaticPath: (path: string[], language: string) => StaticPath): Promise<StaticPath[]>;
+    protected transformLanguageSitePaths(sitePaths: RouteListQueryResult[], formatStaticPath: (path: string[], language: string) => StaticPath, language: string): Promise<StaticPath[]>;
+    protected fetchLanguageSitePaths(language: string, siteName: string): Promise<RouteListQueryResult[]>;
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+    /**
+     * Fetch a flat list of all pages that belong to the specificed site and have a
+     * version in the specified language(s).
+     * @param {string[]} languages Fetch pages that have versions in this language(s).
+     * @param {Function} formatStaticPath Function for transforming the raw search results into (@see StaticPath) types.
+     * @returns list of pages
+     * @throws {RangeError} if the list of languages is empty.
+     * @throws {RangeError} if the any of the languages is an empty string.
+     */
+    protected abstract fetchSitemap(languages: string[], formatStaticPath: (path: string[], language: string) => StaticPath): Promise<StaticPath[]>;
+}
+export {};

package/types/services/graphql-sitemap-service.d.ts

@@ -1,88 +1,20 @@
-import { GraphQLClient, PageInfo } from '@sitecore-jss/sitecore-jss/graphql';
+import { BaseGraphQLSitemapService, BaseGraphQLSitemapServiceConfig } from './base-graphql-sitemap-service';
 /** @private */
 export declare const languageError = "The list of languages cannot be empty";
-export declare const sitesError = "The list of sites cannot be empty";
+export declare const siteError = "The service needs a site name";
 /**
  * @param {string} siteName to inject into error text
  * @private
  */
 export declare function getSiteEmptyError(siteName: string): string;
-/**
- * type for input variables for the site routes query
- */
-interface SiteRouteQueryVariables {
-    /**
-     * Required. The name of the site being queried.
-     */
-    siteName: string;
-    /**
-     * Required. The language to return routes/pages for.
-     */
-    language: string;
-    /**
-     * Optional. Only paths starting with these provided prefixes will be returned.
-     */
-    includedPaths?: string[];
-    /**
-     * Optional. Paths starting with these provided prefixes will be excluded from returned results.
-     */
-    excludedPaths?: string[];
-    /** common variable for all GraphQL queries
-     * it will be used for every type of query to regulate result batch size
-     * Optional. How many result items to fetch in each GraphQL call. This is needed for pagination.
-     * @default 10
-     */
-    pageSize?: number;
-}
-/**
- * Schema of data returned in response to a "site" query request
- * @template T The type of objects being requested.
- */
-export interface SiteRouteQueryResult<T> {
-    site: {
-        siteInfo: {
-            routes: {
-                /**
-                 * Data needed to paginate the site results
-                 */
-                pageInfo: PageInfo;
-                results: T[];
-            };
-        };
-    };
-}
-/**
- * The schema of data returned in response to a routes list query request
- */
-export type RouteListQueryResult = {
-    path: string;
-    route?: {
-        personalization?: {
-            variantIds: string[];
-        };
-    };
-};
 /**
  * Configuration options for @see GraphQLSitemapService instances
  */
-export interface GraphQLSitemapServiceConfig extends Omit<SiteRouteQueryVariables, 'language' | 'siteName'> {
-    /**
-     * Your Graphql endpoint
-     */
-    endpoint: string;
-    /**
-     * The API key to use for authentication.
-     */
-    apiKey: string;
-    /**
-     * Names of the configured sites
-     */
-    sites: string[];
+export interface GraphQLSitemapServiceConfig extends BaseGraphQLSitemapServiceConfig {
     /**
-     * A flag for whether to include personalized routes in service output - only works on XM Cloud
-     * turned off by default
+     * Name of the site to retrieve site paths for
      */
-    includePersonalizedRoutes?: boolean;
+    siteName: string;
 }
 /**
  * Object model of a site page item.
@@ -95,35 +27,17 @@ export type StaticPath = {
 };
 /**
  * Service that fetches the list of site pages using Sitecore's GraphQL API.
+ * Used to handle a single site
  * This list is used for SSG and Export functionality.
  * @mixes SearchQueryService<PageListQueryResult>
  */
-export declare class GraphQLSitemapService {
+export declare class GraphQLSitemapService extends BaseGraphQLSitemapService {
     options: GraphQLSitemapServiceConfig;
-    private graphQLClient;
-    /**
-     * Gets the default query used for fetching the list of site pages
-     */
-    protected get query(): string;
     /**
      * Creates an instance of graphQL sitemap service with the provided options
      * @param {GraphQLSitemapServiceConfig} options instance
      */
     constructor(options: GraphQLSitemapServiceConfig);
-    /**
-     * Fetch sitemap which could be used for generation of static pages during `next export`.
-     * The `locale` parameter will be used in the item query, but since i18n is not supported,
-     * the output paths will not include a `language` property.
-     * @param {string} locale which application supports
-     * @returns an array of @see StaticPath objects
-     */
-    fetchExportSitemap(locale: string): Promise<StaticPath[]>;
-    /**
-     * Fetch sitemap which could be used for generation of static pages using SSG mode
-     * @param {string[]} locales locales which application supports
-     * @returns an array of @see StaticPath objects
-     */
-    fetchSSGSitemap(locales: string[]): Promise<StaticPath[]>;
     /**
      * Fetch a flat list of all pages that belong to the specificed site and have a
      * version in the specified language(s).
@@ -134,14 +48,4 @@ export declare class GraphQLSitemapService {
      * @throws {RangeError} if the any of the languages is an empty string.
      */
     protected fetchSitemap(languages: string[], formatStaticPath: (path: string[], language: string) => StaticPath): Promise<StaticPath[]>;
-    protected transformLanguageSitePaths(sitePaths: RouteListQueryResult[], formatStaticPath: (path: string[], language: string) => StaticPath, language: string, multiSiteName?: string): Promise<StaticPath[]>;
-    protected fetchLanguageSitePaths(language: string, siteName: string): Promise<RouteListQueryResult[]>;
-    /**
-     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
-     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
-     * want to use something else.
-     * @returns {GraphQLClient} implementation
-     */
-    protected getGraphQLClient(): GraphQLClient;
 }
-export {};

package/types/services/mutisite-graphql-sitemap-service.d.ts

@@ -0,0 +1,42 @@
+import { BaseGraphQLSitemapService, BaseGraphQLSitemapServiceConfig, RouteListQueryResult, StaticPath } from './base-graphql-sitemap-service';
+export declare const sitesError = "The list of sites cannot be empty";
+/**
+ * Configuration options for @see GraphQLSitemapService instances
+ */
+export interface MultisiteGraphQLSitemapServiceConfig extends BaseGraphQLSitemapServiceConfig {
+    /**
+     * Names of the configured sites
+     */
+    sites: string[];
+}
+/**
+ * Service that fetches the list of site pages using Sitecore's GraphQL API.
+ * Used to handle multiple sites
+ * This list is used for SSG and Export functionality.
+ * @mixes SearchQueryService<PageListQueryResult>
+ */
+export declare class MultisiteGraphQLSitemapService extends BaseGraphQLSitemapService {
+    options: MultisiteGraphQLSitemapServiceConfig;
+    /**
+     * Creates an instance of graphQL sitemap service with the provided options
+     * @param {MultisiteGraphQLSitemapServiceConfig} options instance
+     */
+    constructor(options: MultisiteGraphQLSitemapServiceConfig);
+    /**
+     * Fetch a flat list of all pages that belong to all the requested sites and have a
+     * version in the specified language(s).
+     * @param {string[]} languages Fetch pages that have versions in this language(s).
+     * @param {Function} formatStaticPath Function for transforming the raw search results into (@see StaticPath) types.
+     * @returns list of pages
+     * @throws {RangeError} if the list of languages is empty.
+     * @throws {RangeError} if the any of the languages is an empty string.
+     */
+    protected fetchSitemap(languages: string[], formatStaticPath: (path: string[], language: string) => StaticPath): Promise<StaticPath[]>;
+    /**
+     * Fetch and return site paths for multisite implementation, with prefixes included
+     * @param {string} language path language
+     * @param {string} siteName site name
+     * @returns modified paths
+     */
+    protected fetchLanguageSitePaths(language: string, siteName: string): Promise<RouteListQueryResult[]>;
+}