@sitecore-jss/sitecore-jss-proxy 22.3.0 → 22.3.1-canary.2

package/dist/esm/personalize/PersonalizeHelper.js

@@ -0,0 +1,236 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { CloudSDK } from '@sitecore-cloudsdk/core/server';
+import { personalize } from '@sitecore-cloudsdk/personalize/server';
+import { debug } from '@sitecore-jss/sitecore-jss';
+import { CdpHelper, DEFAULT_VARIANT, GraphQLPersonalizeService, getGroomedVariantIds, personalizeLayout, } from '@sitecore-jss/sitecore-jss/personalize';
+import querystring from 'querystring';
+export class PersonalizeHelper {
+    constructor(config) {
+        this.config = config;
+        /**
+         * Performs personalize on layout data before a page is rendered
+         * @param {IncomingMessage} req Incoming request nodejs object
+         * @param {OutgoingMessage} res Outgoing response nodejs object
+         * @param {LayoutServiceData} layoutData layoutData for the page
+         * @returns layout data with personalization applied
+         */
+        this.personalizeLayoutData = (req, res, layoutData) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!((_a = layoutData.sitecore) === null || _a === void 0 ? void 0 : _a.context)) {
+                debug.personalize('skipped (sitecore context is empty)');
+                return layoutData;
+            }
+            if (!((_b = layoutData.sitecore) === null || _b === void 0 ? void 0 : _b.route)) {
+                debug.personalize('skipped (layout is empty)');
+                return layoutData;
+            }
+            // current method can run for page requests and for layout service requests.
+            // the latter will not have the correct path - so we use path from layoutData instead
+            const pathname = layoutData.sitecore.context.itemPath;
+            const language = this.getLanguage(layoutData);
+            const hostname = this.getHostHeader(req) || this.defaultHostname;
+            const startTimestamp = Date.now();
+            if (!pathname) {
+                debug.personalize('skipped (pathname missing from layoutData)');
+                return layoutData;
+            }
+            debug.personalize('personalize layout start: %o', {
+                pathname,
+                language,
+                hostname,
+                headers: this.extractDebugHeaders(req.headers),
+            });
+            if (this.excludeRoute(pathname)) {
+                debug.personalize('skipped (route excluded)');
+                return layoutData;
+            }
+            if (this.config.disabled && this.config.disabled(req, res)) {
+                debug.personalize('skipped (personalize is disabled)');
+                return layoutData;
+            }
+            try {
+                yield this.initPersonalizeServer(req, res, hostname);
+            }
+            catch (e) {
+                debug.personalize('skipped (CloudSDK initialization failed), error %o', e);
+                return layoutData;
+            }
+            const variantIds = yield this.getVariantIds(req, language, pathname);
+            if (!variantIds) {
+                return layoutData;
+            }
+            const personalizeData = getGroomedVariantIds(variantIds);
+            // layout will be personalized here
+            personalizeLayout(layoutData, personalizeData.variantId, personalizeData.componentVariantIds);
+            debug.personalize('personalize layout end in %dms: %o', Date.now() - startTimestamp, {
+                headers: this.extractDebugHeaders(req.headers),
+                variantIds: variantIds,
+            });
+            return layoutData;
+        });
+        this.getVariantIds = (req, language, pathname) => __awaiter(this, void 0, void 0, function* () {
+            const timeout = this.config.cdpConfig.timeout;
+            // Get personalization info from Experience Edge
+            const personalizeInfo = yield this.personalizeService.getPersonalizeInfo(pathname, language, this.config.sitecoreSiteName);
+            if (!personalizeInfo) {
+                // Likely an invalid route / language
+                debug.personalize('skipped (personalize info not found)');
+                return [];
+            }
+            if (personalizeInfo.variantIds.length === 0) {
+                debug.personalize('skipped (no personalization configured)');
+                return [];
+            }
+            const params = this.getExperienceParams(req);
+            const executions = this.getPersonalizeExecutions(personalizeInfo, language);
+            const identifiedVariantIds = [];
+            try {
+                yield Promise.all(executions.map((execution) => this.personalize({
+                    friendlyId: execution.friendlyId,
+                    variantIds: execution.variantIds,
+                    params,
+                    language,
+                    timeout,
+                }, req).then((personalization) => {
+                    const variantId = personalization.variantId;
+                    if (variantId) {
+                        if (!execution.variantIds.includes(variantId)) {
+                            debug.personalize('invalid variant %s', variantId);
+                        }
+                        else {
+                            identifiedVariantIds.push(variantId);
+                        }
+                    }
+                })));
+            }
+            catch (e) {
+                debug.personalize('skipped, error %o', e);
+            }
+            if (identifiedVariantIds.length === 0) {
+                debug.personalize('skipped (no variant(s) identified)');
+                return [];
+            }
+            return identifiedVariantIds;
+        });
+        this.personalizeService = new GraphQLPersonalizeService(Object.assign({}, config.edgeConfig));
+        this.defaultHostname = config.defaultHostname || 'localhost';
+    }
+    /**
+     * Init CloudSDK personalization on server side
+     * @param {IncomingMessage} request incoming nodejs request object
+     * @param {OutgoingMessage} response outgoing nodejs response object
+     * @param {string} hostname host for cookies. Usually a host header, or a fallback config
+     */
+    initPersonalizeServer(request, response, hostname) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield CloudSDK(request, response, {
+                sitecoreEdgeUrl: this.config.cdpConfig.sitecoreEdgeUrl,
+                sitecoreEdgeContextId: this.config.cdpConfig.sitecoreEdgeContextId,
+                siteName: this.config.sitecoreSiteName,
+                cookieDomain: hostname,
+                enableServerCookie: true,
+            })
+                .addPersonalize({ enablePersonalizeCookie: true })
+                .initialize();
+        });
+    }
+    getLanguage(layoutData) {
+        var _a, _b;
+        return ((_b = (_a = layoutData.sitecore) === null || _a === void 0 ? void 0 : _a.context) === null || _b === void 0 ? void 0 : _b.language) || this.config.defaultLanguage || 'en';
+    }
+    getHostHeader(req) {
+        var _a;
+        return ((_a = req.headers.host) === null || _a === void 0 ? void 0 : _a.split(':')[0]) || '';
+    }
+    excludeRoute(pathname) {
+        var _a, _b;
+        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.excludeRoute) && ((_b = this.config) === null || _b === void 0 ? void 0 : _b.excludeRoute(pathname));
+    }
+    extractDebugHeaders(incomingHeaders) {
+        const headers = {};
+        Object.keys(incomingHeaders).forEach((key) => incomingHeaders[key] && (headers[key] = incomingHeaders[key]));
+        return headers;
+    }
+    personalize(_a, request_1) {
+        return __awaiter(this, arguments, void 0, function* ({ params, friendlyId, language, timeout, variantIds, }, request) {
+            var _b;
+            debug.personalize('executing experience for %s %o', friendlyId, params);
+            return (yield personalize(request, {
+                channel: this.config.cdpConfig.channel || 'WEB',
+                currency: (_b = this.config.cdpConfig.currency) !== null && _b !== void 0 ? _b : 'USD',
+                friendlyId,
+                params,
+                language,
+                pageVariantIds: variantIds,
+            }, { timeout }));
+        });
+    }
+    getExperienceParams(req) {
+        var _a;
+        // nodejs req.url does not have a hostname, we parse query string the old fashioned way
+        const rawQs = ((_a = req.url) === null || _a === void 0 ? void 0 : _a.split('?')[1]) || '';
+        const queryString = querystring.parse(rawQs);
+        // also need to account for types (string | string[]) returned by parse()
+        const utm = {
+            campaign: [queryString.utm_campaign].join('') || undefined,
+            content: [queryString.utm_content].join('') || undefined,
+            medium: [queryString.utm_medium].join('') || undefined,
+            source: [queryString.utm_source].join('') || undefined,
+        };
+        return {
+            // It's expected that the header name "referer" is actually a misspelling of the word "referrer"
+            // req.referrer is used during fetching to determine the value of the Referer header of the request being made,
+            // used as a fallback
+            referrer: req.headers.referer || [''].concat(req.headers.referrer || '').join(''),
+            utm: utm,
+        };
+    }
+    getPersonalizeExecutions(personalizeInfo, language) {
+        if (personalizeInfo.variantIds.length === 0) {
+            return [];
+        }
+        const results = [];
+        return personalizeInfo.variantIds.reduce((results, variantId) => {
+            if (variantId.includes('_')) {
+                // Component-level personalization in format "<ComponentID>_<VariantID>"
+                const componentId = variantId.split('_')[0];
+                const friendlyId = CdpHelper.getComponentFriendlyId(personalizeInfo.pageId, componentId, language, this.config.scope);
+                const execution = results.find((x) => x.friendlyId === friendlyId);
+                if (execution) {
+                    execution.variantIds.push(variantId);
+                }
+                else {
+                    // The default/control variant (format "<ComponentID>_default") is also a valid value returned by the execution
+                    const defaultVariant = `${componentId}${DEFAULT_VARIANT}`;
+                    results.push({
+                        friendlyId,
+                        variantIds: [defaultVariant, variantId],
+                    });
+                }
+            }
+            else {
+                // Embedded (page-level) personalization in format "<VariantID>"
+                const friendlyId = CdpHelper.getPageFriendlyId(personalizeInfo.pageId, language, this.config.scope);
+                const execution = results.find((x) => x.friendlyId === friendlyId);
+                if (execution) {
+                    execution.variantIds.push(variantId);
+                }
+                else {
+                    results.push({
+                        friendlyId,
+                        variantIds: [variantId],
+                    });
+                }
+            }
+            return results;
+        }, results);
+    }
+}

package/dist/esm/personalize/index.js

@@ -0,0 +1 @@
+export { PersonalizeHelper } from './PersonalizeHelper';

package/dist/esm/personalize/test-data/personalizeData.js

@@ -0,0 +1,82 @@
+export const mountainBikeVariant = {
+    uid: '0b6d23d8-c50e-4e79-9eca-317ec43e82b0',
+    componentName: 'ContentBlock',
+    dataSource: '20679cd4-356b-4452-b507-453beeb0be39',
+    fields: {
+        content: {
+            value: '<p><img src="https://edge-beta.sitecorecloud.io/ser-edge-personalization/media/JssNextWeb/Mountain-Bike.jpg?h=675&amp;w=1200" style="width:1200px;height:675px;" /></p>',
+        },
+        heading: { value: 'Mountain Bike' },
+    },
+};
+export const cityBikeVariant = {
+    uid: '0b6d23d8-c50e-4e79-9eca-317ec43e82b0',
+    componentName: 'ContentBlock',
+    dataSource: '36e02581-2056-4c55-a4d5-f4b700ba1ae2',
+    fields: {
+        content: {
+            value: '<p><img src="https://edge-beta.sitecorecloud.io/ser-edge-personalization/media/JssNextWeb/Mountain-Bike.jpg?h=675&amp;w=1200" style="width:1200px;height:675px;" /></p>',
+        },
+        heading: { value: 'Mountain Bike' },
+    },
+};
+export const component_variant = {
+    uid: '0b6d23d8-c50e-4e79-9eca-317ec43e82b0',
+    componentName: 'ContentBlock',
+    dataSource: '36e02581-2056-4c55-a4d5-f4b700ba1ae2',
+    fields: {
+        content: {
+            value: '<p><img src="https://edge-beta.sitecorecloud.io/ser-edge-personalization/media/JssNextWeb/Hybrid-Bike.jpg?h=675&amp;w=1200" style="width:1200px;height:675px;" /></p>',
+        },
+        heading: { value: 'Hybrid Bike' },
+    },
+};
+const defaultRendering = {
+    uid: '0b6d23d8-c50e-4e79-9eca-317ec43e82b0',
+    componentName: 'ContentBlock',
+    dataSource: 'e020fb58-1be8-4537-aab8-67916452ecf2',
+    fields: { content: { value: '' }, heading: { value: 'Default Content' } },
+    experiences: {
+        'mountain-bike-audience': mountainBikeVariant,
+        'city-bike-audience': cityBikeVariant,
+        'componentid_variant-id': component_variant,
+    },
+};
+export const getPersonalizeLayoutData = (variant, language, path) => {
+    const baseLayout = {
+        sitecore: {
+            context: {
+                pageEditing: false,
+                site: { name: 'JssNextWeb' },
+                visitorIdentificationTimestamp: 1038543,
+                language: language || 'en',
+                variantId: '',
+                itemPath: path || '/styleguide',
+            },
+            route: {
+                name: 'styleguide',
+                placeholders: {
+                    main: {},
+                },
+            },
+        },
+    };
+    switch (variant) {
+        case 'mountain-bike-audience':
+            baseLayout.sitecore.route.placeholders.main = [mountainBikeVariant];
+            baseLayout.sitecore.context.variantId = 'mountain-bike-audience';
+            break;
+        case 'city-bike-audience':
+            baseLayout.sitecore.route.placeholders.main = [cityBikeVariant];
+            baseLayout.sitecore.context.variantId = 'city-bike-audience';
+            break;
+        case 'componentid_variant-id':
+            baseLayout.sitecore.route.placeholders.main = [component_variant];
+            baseLayout.sitecore.context.variantId = '_default';
+            break;
+        default:
+            baseLayout.sitecore.route.placeholders.main = [defaultRendering];
+            break;
+    }
+    return baseLayout;
+};

package/dist/esm/types/personalize.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sitecore-jss/sitecore-jss-proxy",
-  "version": "22.3.0",
-  "description": "Proxy middleware for express.js server.",
+  "version": "22.3.1-canary.2",
+  "description": "Middlewares, utilities to work in a headless mode",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "sideEffects": false,
@@ -9,13 +9,13 @@
     "build": "npm run clean && tsc -p tsconfig.json && tsc -p tsconfig-esm.json",
     "clean": "del-cli dist types",
     "lint": "eslint \"./src/**/*.ts\"",
-    "test": "mocha --require ts-node/register \"./src/**/*.test.ts\"",
+    "test": "mocha --require ts-node/register \"./src/**/*.test.ts\" --exit",
     "prepublishOnly": "npm run build",
     "coverage": "nyc npm test",
-    "generate-docs": "npx typedoc --plugin typedoc-plugin-markdown --readme none --out ../../ref-docs/sitecore-jss-proxy src/index.ts --githubPages false"
+    "generate-docs": "npx typedoc --plugin typedoc-plugin-markdown --outputFileStrategy Members --parametersFormat table --readme none --entryPoints src/personalize/index.ts --out ../../ref-docs/sitecore-jss-proxy src/index.ts --githubPages false"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "author": {
     "name": "Sitecore Corporation",
@@ -27,6 +27,9 @@
     "url": "https://github.com/sitecore/jss/issues"
   },
   "dependencies": {
+    "@sitecore-cloudsdk/core": "^0.4.1",
+    "@sitecore-cloudsdk/personalize": "^0.4.1",
+    "@sitecore-jss/sitecore-jss": "^22.3.1-canary.2",
     "http-proxy-middleware": "^2.0.6",
     "http-status-codes": "^2.2.0",
     "set-cookie-parser": "^2.5.1"
@@ -35,18 +38,28 @@
     "@types/chai": "^4.3.4",
     "@types/express": "^4.17.17",
     "@types/mocha": "^10.0.1",
-    "@types/node": "^20.14.2",
+    "@types/node": "^22.9.0",
+    "@types/proxyquire": "^1.3.31",
     "@types/set-cookie-parser": "^2.4.2",
+    "@types/sinon": "^17.0.3",
+    "@types/supertest": "^6.0.2",
     "chai": "^4.3.7",
     "del-cli": "^5.0.0",
-    "eslint": "^8.33.0",
+    "eslint": "^8.56.0",
+    "express": "^4.19.2",
     "mocha": "^10.2.0",
     "nyc": "^15.1.0",
+    "proxyquire": "^2.1.3",
+    "sinon": "^17.0.1",
+    "supertest": "^7.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "~4.9.5"
+    "typescript": "~5.6.3"
+  },
+  "peerDependencies": {
+    "express": "^4.19.2"
   },
   "types": "types/index.d.ts",
-  "gitHead": "81b0239517966b6d0debdf6da3f12a98228c4d0c",
+  "gitHead": "5b35bbbe22b6ea21a1829950e371d54422ebf8fd",
   "files": [
     "dist",
     "types"

package/types/index.d.ts

@@ -1,21 +1,4 @@
-/// <reference types="qs" />
-import { IncomingMessage } from 'http';
-import { Request, RequestHandler } from 'express';
-import { AppRenderer } from './AppRenderer';
-import { ProxyConfig, ServerBundle } from './ProxyConfig';
-import { RouteUrlParser } from './RouteUrlParser';
-export declare const removeEmptyAnalyticsCookie: (proxyResponse: IncomingMessage) => void;
-/**
- * @param {string} reqPath
- * @param {Request} req
- * @param {ProxyConfig} config
- * @param {RouteUrlParser} parseRouteUrl
- */
-export declare function rewriteRequestPath(reqPath: string, req: Request, config: ProxyConfig, parseRouteUrl?: RouteUrlParser): string;
-/**
- * @param {AppRenderer} renderer
- * @param {ProxyConfig} config
- * @param {RouteUrlParser} parseRouteUrl
- */
-export default function scProxy(renderer: AppRenderer, config: ProxyConfig, parseRouteUrl: RouteUrlParser): RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>[];
-export { ProxyConfig, ServerBundle };
+export * from './middleware';
+export * from './types';
+export * from './personalize';
+export { GRAPHQL_LAYOUT_QUERY_NAME } from '@sitecore-jss/sitecore-jss/layout';

package/types/middleware/editing/config.d.ts

@@ -0,0 +1,27 @@
+import { Request, Response } from 'express';
+import { Metadata } from '@sitecore-jss/sitecore-jss/utils';
+/**
+ * Configuration for the editing config endpoint
+ */
+export type EditingConfigEndpointOptions = {
+    /**
+     * Custom path for the endpoint. Default is `<routerPath>/config`
+     * @example
+     * { path: '/foo/config' } -> <routerPath>/foo/config
+     */
+    path?: string;
+    /**
+     * Components registered in the application
+     */
+    components: string[] | Map<string, unknown>;
+    /**
+     * Application metadata
+     */
+    metadata: Metadata;
+};
+/**
+ * Middleware to handle editing config requests
+ * @param {EditingConfigEndpointOptions} config Configuration for the endpoint
+ * @returns {RequestHandler} Middleware function
+ */
+export declare const editingConfigMiddleware: (config: EditingConfigEndpointOptions) => (_req: Request, res: Response) => void;

package/types/middleware/editing/index.d.ts

@@ -0,0 +1,32 @@
+import { NextFunction, Request, Response } from 'express';
+import { EditingConfigEndpointOptions } from './config';
+import { EditingRenderEndpointOptions } from './render';
+/**
+ * Configuration for the editing router
+ */
+export type EditingRouterConfig = {
+    /**
+     * Configuration for the /config endpoint
+     */
+    config: EditingConfigEndpointOptions;
+    /**
+     * Configuration for the /render endpoint
+     */
+    render: EditingRenderEndpointOptions;
+};
+/**
+ * Middleware to handle editing requests
+ * @param {Request} req Request
+ * @param {Response} res Response
+ * @param {NextFunction} next Next function
+ */
+export declare const editingMiddleware: (req: Request, res: Response, next: NextFunction) => Promise<unknown>;
+/**
+ * Creates a router for editing requests.
+ * Supports the following routes:
+ * - <routerPath>/render (GET) - renders a route
+ * - <routerPath>/config (GET) - returns the current application configuration
+ * @param {EditingRouterConfig} options Editing router configuration
+ * @returns {Router} Editing router
+ */
+export declare const editingRouter: (options: EditingRouterConfig) => import("express-serve-static-core").Router;

package/types/middleware/editing/render.d.ts

@@ -0,0 +1,42 @@
+import { GraphQLRequestClientFactory } from '@sitecore-jss/sitecore-jss';
+import { AppRenderer } from '../../types/AppRenderer';
+import { Request, Response } from 'express';
+import { RenderMetadataQueryParams } from '@sitecore-jss/sitecore-jss/editing';
+import { PersonalizeHelper } from '../../personalize';
+/**
+ * Configuration for the editing render endpoint
+ */
+export type EditingRenderEndpointOptions = {
+    /**
+     * Custom path for the endpoint. Default is `<routerPath>/render`
+     * @example
+     * { path: '/foo/render' } -> <routerPath>/foo/render
+     */
+    path?: string;
+    /**
+     * GraphQl Request Client Factory provided by the server bundle
+     */
+    clientFactory: GraphQLRequestClientFactory;
+    /**
+     * The appRenderer will produce the requested route's html
+     */
+    renderView: AppRenderer;
+    /**
+     * Personalize helper instance passed from proxy app
+     */
+    personalizeHelper?: PersonalizeHelper;
+};
+type MetadataRequest = Request & {
+    query: RenderMetadataQueryParams;
+};
+/**
+ * Middleware to handle editing render requests
+ * @param {EditingRenderEndpointOptions} config for the endpoint
+ */
+export declare const editingRenderMiddleware: (config: EditingRenderEndpointOptions) => (req: MetadataRequest, res: Response) => Promise<void>;
+/**
+ * Gets the Content-Security-Policy header value
+ * @returns {string} Content-Security-Policy header value
+ */
+export declare const getSCPHeader: () => string;
+export {};

package/types/{ProxyConfig.d.ts → middleware/headless-ssr-proxy/ProxyConfig.d.ts}

@@ -1,11 +1,8 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { IncomingMessage, ServerResponse, Agent } from 'http';
 import { Agent as HttpsAgent } from 'https';
 import { Options } from 'http-proxy-middleware';
-import { AppRenderer } from './AppRenderer';
-import { RenderResponse } from './RenderResponse';
-import { RouteUrlParser } from './RouteUrlParser';
+import { AppRenderer, RenderResponse } from '../../types/AppRenderer';
+import { RouteUrlParser } from '../../types/RouteUrlParser';
 /** A reply from the Sitecore Layout Service */
 export interface LayoutServiceData {
     sitecore: {

package/types/middleware/headless-ssr-proxy/index.d.ts

@@ -0,0 +1,20 @@
+import { IncomingMessage } from 'http';
+import { Request, RequestHandler } from 'express';
+import { AppRenderer } from '../../types/AppRenderer';
+import { RouteUrlParser } from '../../types/RouteUrlParser';
+import { ProxyConfig, ServerBundle } from './ProxyConfig';
+export declare const removeEmptyAnalyticsCookie: (proxyResponse: IncomingMessage) => void;
+/**
+ * @param {string} reqPath
+ * @param {Request} req
+ * @param {ProxyConfig} config
+ * @param {RouteUrlParser} parseRouteUrl
+ */
+export declare function rewriteRequestPath(reqPath: string, req: Request, config: ProxyConfig, parseRouteUrl?: RouteUrlParser): string;
+/**
+ * @param {AppRenderer} renderer
+ * @param {ProxyConfig} config
+ * @param {RouteUrlParser} parseRouteUrl
+ */
+export declare function middleware(renderer: AppRenderer, config: ProxyConfig, parseRouteUrl: RouteUrlParser): RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>[];
+export { ProxyConfig, ServerBundle };

package/types/middleware/healthcheck/index.d.ts

@@ -0,0 +1,6 @@
+import { Router } from 'express';
+/**
+ * Creates a router for health check requests.
+ * @returns {Router} Editing router
+ */
+export declare const healthCheck: () => Router;

package/types/middleware/index.d.ts

@@ -0,0 +1,3 @@
+export * as headlessProxy from './headless-ssr-proxy';
+export { editingRouter } from './editing';
+export { healthCheck } from './healthcheck';

package/types/personalize/PersonalizeHelper.d.ts

@@ -0,0 +1,43 @@
+import { LayoutServiceData } from '@sitecore-jss/sitecore-jss/layout';
+import { PersonalizeInfo } from '@sitecore-jss/sitecore-jss/personalize';
+import { IncomingHttpHeaders, IncomingMessage, OutgoingMessage } from 'http';
+import { ExperienceParams, PersonalizeConfig, PersonalizeExecution } from '../types/personalize';
+export declare class PersonalizeHelper {
+    protected config: PersonalizeConfig;
+    private personalizeService;
+    private defaultHostname;
+    constructor(config: PersonalizeConfig);
+    /**
+     * Performs personalize on layout data before a page is rendered
+     * @param {IncomingMessage} req Incoming request nodejs object
+     * @param {OutgoingMessage} res Outgoing response nodejs object
+     * @param {LayoutServiceData} layoutData layoutData for the page
+     * @returns layout data with personalization applied
+     */
+    personalizeLayoutData: (req: IncomingMessage, res: OutgoingMessage, layoutData: LayoutServiceData) => Promise<LayoutServiceData>;
+    /**
+     * Init CloudSDK personalization on server side
+     * @param {IncomingMessage} request incoming nodejs request object
+     * @param {OutgoingMessage} response outgoing nodejs response object
+     * @param {string} hostname host for cookies. Usually a host header, or a fallback config
+     */
+    protected initPersonalizeServer(request: IncomingMessage, response: OutgoingMessage, hostname: string): Promise<void>;
+    protected getVariantIds: (req: IncomingMessage, language: string, pathname: string) => Promise<string[]>;
+    protected getLanguage(layoutData: LayoutServiceData): string;
+    protected getHostHeader(req: IncomingMessage): string;
+    protected excludeRoute(pathname: string): boolean | undefined;
+    protected extractDebugHeaders(incomingHeaders: IncomingHttpHeaders): {
+        [key: string]: string | string[] | undefined;
+    };
+    protected personalize({ params, friendlyId, language, timeout, variantIds, }: {
+        params: ExperienceParams;
+        friendlyId: string;
+        language: string;
+        timeout?: number;
+        variantIds?: string[];
+    }, request: IncomingMessage): Promise<{
+        variantId: string;
+    }>;
+    protected getExperienceParams(req: IncomingMessage): ExperienceParams;
+    protected getPersonalizeExecutions(personalizeInfo: PersonalizeInfo, language: string): PersonalizeExecution[];
+}

package/types/personalize/index.d.ts

@@ -0,0 +1,2 @@
+export { PersonalizeHelper } from './PersonalizeHelper';
+export { PersonalizeConfig } from '../types/personalize';