@salesforce/pwa-kit-runtime 3.9.0-nightly-20241206080208 → 4.0.0-extensibility-preview.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/pwa-kit-runtime",
-  "version": "3.9.0-nightly-20241206080208",
+  "version": "4.0.0-extensibility-preview.0",
   "description": "The PWAKit Runtime",
   "homepage": "https://github.com/SalesforceCommerceCloud/pwa-kit/tree/develop/packages/pwa-kit-runtime#readme",
   "bugs": {
@@ -19,8 +19,8 @@
     "utils"
   ],
   "scripts": {
-    "build": "cross-env NODE_ENV=production internal-lib-build build",
-    "build:watch": "nodemon --watch 'src/**' --exec 'npm run build'",
+    "build": "cross-env NODE_ENV=production internal-lib-build build && tsc",
+    "build:watch": "nodemon --watch 'src/**' --ext 'js,jsx,ts,tsx' --exec 'npm run build'",
     "format": "internal-lib-build format \"**/*.{js,jsx}\"",
     "lint": "npm run lint:js",
     "lint:fix": "npm run lint:js -- --fix",
@@ -46,11 +46,13 @@
   },
   "devDependencies": {
     "@loadable/component": "^5.15.3",
-    "@salesforce/pwa-kit-dev": "3.9.0-nightly-20241206080208",
+    "@salesforce/pwa-kit-dev": "4.0.0-extensibility-preview.0",
+    "@salesforce/pwa-kit-extension-sdk": "4.0.0-extensibility-preview.0",
     "@serverless/event-mocks": "^1.1.1",
+    "@types/express": "^4.17.21",
     "aws-lambda-mock-context": "^3.2.1",
     "fs-extra": "^11.1.1",
-    "internal-lib-build": "3.9.0-nightly-20241206080208",
+    "internal-lib-build": "4.0.0-extensibility-preview.0",
     "nock": "^13.3.0",
     "nodemon": "^2.0.22",
     "sinon": "^13.0.2",
@@ -58,7 +60,7 @@
     "supertest": "^4.0.2"
   },
   "peerDependencies": {
-    "@salesforce/pwa-kit-dev": "3.9.0-nightly-20241206080208"
+    "@salesforce/pwa-kit-dev": "4.0.0-extensibility-preview.0"
   },
   "peerDependenciesMeta": {
     "@salesforce/pwa-kit-dev": {
@@ -72,5 +74,5 @@
   "publishConfig": {
     "directory": "dist"
   },
-  "gitHead": "eb411ded96be11c84688a4d325cd525b37c661cc"
+  "gitHead": "16a2673cbdb9b22e3071435e8afbc2e89b2e37da"
 }

package/ssr/server/build-remote-server.d.ts

@@ -0,0 +1,211 @@
+/**
+ * Environment variables that must be set for the Express app to run remotely.
+ *
+ * @private
+ */
+export const REMOTE_REQUIRED_ENV_VARS: string[];
+export namespace RemoteServerFactory {
+    /**
+     * @private
+     */
+    function _configure(options: any): any;
+    /**
+     * @private
+     */
+    function _logStartupMessage(options: any): void;
+    /**
+     * @private
+     */
+    function _getAllowCookies(options: any): boolean;
+    /**
+     * @private
+     */
+    function _getProtocol(options: any): string;
+    /**
+     * @private
+     */
+    function _getDefaultCacheControl(options: any): string;
+    /**
+     * @private
+     */
+    function _strictSSL(options: any): boolean;
+    /**
+     * @private
+     */
+    function _isBundleOrProxyPath(url: any): any;
+    /**
+     * @private
+     */
+    function _getSlasEndpoint(options: any): string | undefined;
+    /**
+     * @private
+     */
+    function _setCompression(app: any): void;
+    /**
+     * @private
+     */
+    function _setupLogging(app: any): void;
+    /**
+     * Passing the correlation Id from MRT to locals
+     * @private
+     */
+    function _setRequestId(app: any): void;
+    /**
+     * @private
+     */
+    function _setupMetricsFlushing(app: any): void;
+    /**
+     * @private
+     */
+    function _updatePackageMobify(options: any): void;
+    /**
+     * @private
+     */
+    function _configureProxyConfigs(options: any): void;
+    /**
+     * @private
+     */
+    function _createApp(options: any): import("express-serve-static-core").Express;
+    /**
+     * @private
+     */
+    function _createExpressApp(options: any): import("express-serve-static-core").Express;
+    /**
+     * @private
+     */
+    function _addSDKInternalHandlers(app: any): void;
+    /**
+     * @private
+     */
+    function _setupSSRRequestProcessorMiddleware(app: any): void;
+    /**
+     * @private
+     */
+    function _setupProxying(app: any, options: any): void;
+    /**
+     * @private
+     */
+    function _handleMissingSlasPrivateEnvVar(app: any): void;
+    /**
+     * @private
+     */
+    function _setupSlasPrivateClientProxy(app: any, options: any): void;
+    /**
+     * @private
+     */
+    function _setupHealthcheck(app: any): void;
+    /**
+     * @private
+     */
+    function _setupCommonMiddleware(app: any, options: any): void;
+    /**
+     * @private
+     */
+    function _validateConfiguration(options: any): void;
+    /**
+     * @private
+     */
+    function _addStaticAssetServing(): void;
+    /**
+     * @private
+     */
+    function _addDevServerGarbageCollection(): void;
+    /**
+     * Serve the service worker at `req.path`
+     *
+     * For best results, serve the service worker at the root of the site and
+     * it must not be a redirect. We set a long value for s-maxage (to allow CDN
+     * caching), plus a strong etag (for CDN-only revalidation), and to set
+     * maxage to 0 to prevent browser caching.
+     *
+     * See https://developer.chrome.com/blog/fresher-sw/ for details on
+     * efficiently serving service workers.
+     *
+     */
+    function serveServiceWorker(req: any, res: any): void;
+    /**
+     * Serve static files from the app's build directory and set default
+     * cache-control headers.
+     * @since v2.0.0
+     *
+     * @param {String} filePath - the location of the static file relative to the build directory
+     * @param {Object} opts - the options object to pass to the original `sendFile` method
+     */
+    function serveStaticFile(filePath: string, opts?: Object): (req: any, res: any) => void;
+    /**
+     * @private
+     */
+    function _serveStaticFile(req: any, res: any, baseDir: any, filePath: any, opts?: {}): void;
+    /**
+     * Server side rendering entry.
+     *
+     * @since v2.0.0
+     *
+     * This is a wrapper around the Express `res.sendFile` method.
+     *
+     * @param {Object} req - the req object
+     * @param {Object} req - the res object
+     * @param {function} next - the callback function for middleware chain
+     */
+    function render(req: Object, res: any, next: Function): void;
+    /**
+     * Builds a Lambda handler function from an Express app.
+     *
+     * See: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html
+     *
+     * @param app {Express} - an Express App
+     * @private
+     */
+    function _createHandler(app: Express): {
+        handler: (event: any, context: any, callback: any) => void;
+        server: any;
+        app: Express;
+    };
+    /**
+     * Create an SSR (Server-Side Rendering) Server.
+     *
+     * @constructor
+     * @param {Object} options
+     * @param {String} [options.buildDir] - The build directory path, either as an
+     * absolute path, or relative to the current working directory. Defaults
+     * to 'build'.
+     * @param {Number} [options.defaultCacheTimeSeconds=600] - The cache time
+     * for rendered pages and assets (not used in local development mode).
+     * @param {Object} options.mobify - The 'mobify' object from the project's
+     * package.json file, containing the SSR parameters.
+     * @param {Number} [options.port=3443] - the localhost port on which the local
+     * development Express app listens.
+     * @param {String} [options.protocol='https'] - the protocol on which the development
+     * Express app listens.
+     * @param {Boolean} [options.proxyKeepAliveAgent] - This boolean value indicates
+     * whether or not we are using a keep alive agent for proxy connections. Defaults
+     * to 'true'. NOTE: This keep alive agent will only be used on remote.
+     * @param {String} options.sslFilePath - the absolute path to a PEM format
+     * certificate file to be used by the local development server. This should
+     * contain both the certificate and the private key.
+     * @param {function} customizeApp - a callback that takes an express app
+     * as an argument. Use this to customize the server.
+     * @param {Boolean} [options.allowCookies] - This boolean value indicates
+     * whether or not we strip cookies from requests and block setting of cookies. Defaults
+     * to 'false'.
+     */
+    function createHandler(options: {
+        buildDir?: string | undefined;
+        defaultCacheTimeSeconds?: number | undefined;
+        mobify: Object;
+        port?: number | undefined;
+        protocol?: string | undefined;
+        proxyKeepAliveAgent?: boolean | undefined;
+        sslFilePath: string;
+    }, customizeApp: Function): {
+        handler: (event: any, context: any, callback: any) => void;
+        server: any;
+        app: Express;
+    };
+    /**
+     * @private
+     */
+    function _getRequestProcessor(req: any): null;
+}
+export function once(fn: any): (...args: any[]) => any;
+//# sourceMappingURL=build-remote-server.d.ts.map

package/ssr/server/build-remote-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-remote-server.d.ts","sourceRoot":"","sources":["../../../src/ssr/server/build-remote-server.js"],"names":[],"mappings":"AAoEA;;;;GAIG;AACH,gDAKC;;IAWG;;OAEG;IACH,uCAgFC;IAED;;OAEG;IAEH,gDAEC;IAED;;OAEG;IAEH,iDAEC;IAED;;OAEG;IAEH,4CAEC;IAED;;OAEG;IACH,uDAEC;IAED;;OAEG;IAEH,2CAEC;IAED;;OAEG;IACH,6CAEC;IAED;;OAEG;IACH,4DAIC;IAED;;OAEG;IAEH,yCAEC;IAED;;OAEG;IAEH,uCA6CC;IAED;;;OAGG;IACH,uCAcC;IAED;;OAEG;IAEH,+CAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,oDAEC;IAED;;OAEG;IACH,+EA0CC;IAED;;OAEG;IACH,sFAyDC;IAED;;OAEG;IAEH,iDAEC;IAED;;OAEG;IACH,6DAwLC;IAED;;OAEG;IAEH,sDAOC;IAED;;OAEG;IACH,yDAOC;IAED;;OAEG;IACH,oEAuEC;IAED;;OAEG;IACH,2CAIC;IAED;;OAEG;IACH,8DAaC;IAED;;OAEG;IACH,oDA0EC;IAED;;OAEG;IACH,wCAEC;IAED;;OAEG;IACH,gDAGC;IAED;;;;;;;;;;;OAWG;IACH,sDAwBC;IAED;;;;;;;OAOG;IACH,wFAKC;IAED;;OAEG;IACH,4FASC;IAED;;;;;;;;;;OAUG;IACH,6DAWC;IAED;;;;;;;OAOG;IACH;;;;MA8EC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;;;;;;;;;;;;MAKC;IAED;;OAEG;IAEH,8CAEC;;AAyFE,uDASN"}

package/ssr/server/build-remote-server.js

@@ -27,6 +27,7 @@ var _awsServerlessExpress = _interopRequireDefault(require("aws-serverless-expre
 var _morgan = _interopRequireDefault(require("morgan"));
 var _loggerInstance = _interopRequireDefault(require("../../utils/logger-instance"));
 var _httpProxyMiddleware = require("http-proxy-middleware");
+var _express3 = require("@salesforce/pwa-kit-extension-sdk/express");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -296,7 +297,6 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
     // want request-processors applied to development views.
     this._addSDKInternalHandlers(app);
     this._setupSSRRequestProcessorMiddleware(app);
-    this._setForwardedHeaders(app, options);
     this._setupLogging(app);
     this._setupMetricsFlushing(app);
     this._setupHealthcheck(app);
@@ -371,22 +371,6 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
   _addSDKInternalHandlers(app) {
     // This method is used by the dev server, but is not needed here.
   },
-  /**
-   * Set x-forward-* headers into locals, this is primarily used to facilitate react sdk hook `useOrigin`
-   * @private
-   */
-  _setForwardedHeaders(app, options) {
-    app.use((req, res, next) => {
-      var _req$headers, _req$headers2;
-      const xForwardedHost = (_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers['x-forwarded-host'];
-      const xForwardedProto = (_req$headers2 = req.headers) === null || _req$headers2 === void 0 ? void 0 : _req$headers2['x-forwarded-proto'];
-      if (xForwardedHost) {
-        // prettier-ignore
-        res.locals.xForwardedOrigin = `${xForwardedProto || options.protocol}://${xForwardedHost}`;
-      }
-      next();
-    });
-  },
   /**
    * @private
    */
@@ -600,7 +584,7 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
         [_ssrNamespacePaths.slasPrivateProxyPath]: ''
       },
       onProxyReq: (proxyRequest, incomingRequest) => {
-        var _incomingRequest$path, _incomingRequest$path2;
+        var _incomingRequest$path;
         (0, _configureProxy.applyProxyRequestHeaders)({
           proxyRequest,
           incomingRequest,
@@ -619,11 +603,6 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
         if ((_incomingRequest$path = incomingRequest.path) !== null && _incomingRequest$path !== void 0 && _incomingRequest$path.match(options.applySLASPrivateClientToEndpoints)) {
           proxyRequest.setHeader('Authorization', `Basic ${encodedSlasCredentials}`);
         }
-
-        // /oauth2/trusted-agent/token endpoint requires a different auth header
-        if ((_incomingRequest$path2 = incomingRequest.path) !== null && _incomingRequest$path2 !== void 0 && _incomingRequest$path2.match(/\/oauth2\/trusted-agent\/token/)) {
-          proxyRequest.setHeader('_sfdc_client_auth', encodedSlasCredentials);
-        }
       },
       onProxyRes: (proxyRes, req) => {
         if (proxyRes.statusCode && proxyRes.statusCode >= 400) {
@@ -663,9 +642,10 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
     // to add in their projects, like in any regular Express app.
     app.use(ssrMiddleware);
     app.use(errorHandlerMiddleware);
-    if (options !== null && options !== void 0 && options.encodeNonAsciiHttpHeaders) {
-      app.use(encodeNonAsciiMiddleware);
-    }
+
+    // NOTE: Think about changing the name of this function to `applyApplicationExtensions`. First look into
+    // what a common pattern is for application enhancement.
+    (0, _express3.applyApplicationExtensions)(app);
     applyPatches(options);
   },
   /**
@@ -680,7 +660,7 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
     // A string like '8.10.0'
     requiredNode)) {
       /* istanbul ignore next */
-      console.warn(`Warning: You are using Node ${process.versions.node}. ` + `Your app may not work as expected when deployed to Managed ` + `Runtime servers which are compatible with Node ${requiredNode}`);
+      _loggerInstance.default.warn(`Warning: You are using Node ${process.versions.node}. ` + `Your app may not work as expected when deployed to Managed ` + `Runtime servers which are compatible with Node ${requiredNode}`);
     }
 
     // Verify the remote environment
@@ -714,7 +694,7 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
       throw new Error('The sslFilePath option passed to the SSR server constructor ' + 'must be a path to an SSL certificate file ' + 'in PEM format, whose name ends with ".pem". ' + 'See the "cert" and "key" options on ' + 'https://nodejs.org/api/tls.html#tls_tls_createsecurecontext_options');
     }
     if (!options.strictSSL) {
-      console.warn('The SSR Server has _strictSSL turned off for https requests');
+      _loggerInstance.default.warn('The SSR Server has _strictSSL turned off for https requests');
     }
   },
   /**
@@ -824,29 +804,13 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
    * @param app {Express} - an Express App
    * @private
    */
-  _createHandler(app, options) {
+  _createHandler(app) {
     // This flag is initially false, and is set true on the first request
     // handled by a Lambda. If it is true on entry to the handler function,
     // it indicates that the Lambda container has been reused.
     let lambdaContainerReused = false;
     const server = _awsServerlessExpress.default.createServer(app, null, binaryMimeTypes);
     const handler = (event, context, callback) => {
-      // encode non ASCII request headers
-      if (options !== null && options !== void 0 && options.encodeNonAsciiHttpHeaders) {
-        Object.keys(event.headers).forEach(key => {
-          if (!isASCII(event.headers[key])) {
-            event.headers[key] = encodeURIComponent(event.headers[key]);
-            // x-encoded-headers keeps track of which headers have been modified and encoded
-            if (event.headers[_constants.X_ENCODED_HEADERS]) {
-              // append header key
-              event.headers[_constants.X_ENCODED_HEADERS] = `${event.headers[_constants.X_ENCODED_HEADERS]},${key}`;
-            } else {
-              event.headers[_constants.X_ENCODED_HEADERS] = key;
-            }
-          }
-        });
-      }
-
       // We don't want to wait for an empty event loop once the response
       // has been sent. Setting this to false will "send the response
       // right away when the callback executes", but any pending events
@@ -948,8 +912,8 @@ const RemoteServerFactory = exports.RemoteServerFactory = {
   createHandler(options, customizeApp) {
     process.on('unhandledRejection', _ssrServer.catchAndLog);
     const app = this._createApp(options);
-    customizeApp(app, options);
-    return this._createHandler(app, options);
+    customizeApp(app);
+    return this._createHandler(app);
   },
   /**
    * @private
@@ -1032,37 +996,6 @@ const errorHandlerMiddleware = (err, req, res, next) => {
   res.sendStatus(500);
 };
 
-/**
- * Helper function that checks if a string is composed of ASCII characters
- * We only check printable ASCII characters and not special ASCII characters
- * such as NULL
- *
- * @private
- */
-const isASCII = str => {
-  return /^[\x20-\x7E]*$/.test(str);
-};
-
-/**
- * Express Middleware applied to responses that encode any non ASCII headers
- *
- * @private
- */
-const encodeNonAsciiMiddleware = (req, res, next) => {
-  const originalSetHeader = res.setHeader;
-  res.setHeader = function (key, value) {
-    if (!isASCII(value)) {
-      originalSetHeader.call(this, key, encodeURIComponent(value));
-      let encodedHeaders = res.getHeader(_constants.X_ENCODED_HEADERS);
-      encodedHeaders = encodedHeaders ? `${encodedHeaders},${key}` : key;
-      originalSetHeader.call(this, _constants.X_ENCODED_HEADERS, encodedHeaders);
-    } else {
-      originalSetHeader.call(this, key, value);
-    }
-  };
-  next();
-};
-
 /**
  * Wrap the function fn in such a way that it will be called at most once. Subsequent
  * calls will always return the same value.

package/ssr/server/build-remote-server.test.js

@@ -1,8 +1,7 @@
 "use strict";
 
+var _supertest = _interopRequireDefault(require("supertest"));
 var _buildRemoteServer = require("./build-remote-server");
-var _constants = require("./constants");
-var _awsServerlessExpress = _interopRequireDefault(require("aws-serverless-express"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -14,12 +13,39 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
  * SPDX-License-Identifier: BSD-3-Clause
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
-jest.mock('aws-serverless-express', () => {
-  return {
-    createServer: jest.fn(),
-    proxy: jest.fn()
+const opts = (overrides = {}) => {
+  const defaults = {
+    buildDir: './src/ssr/server/test_fixtures',
+    mobify: {
+      app: {
+        extensions: ['test-extension', 'another-extension', 'extension-with-bad-setup-server', 'extension-with-setup-server-no-default-export', 'extension-without-setup-server']
+      },
+      ssrEnabled: true,
+      ssrOnly: ['main.js.map', 'ssr.js', 'ssr.js.map'],
+      ssrShared: ['main.js', 'ssr-loader.js', 'worker.js'],
+      ssrParameters: {
+        proxyConfigs: [{
+          protocol: 'https',
+          host: 'test.proxy.com',
+          path: 'base'
+        }, {
+          protocol: 'https',
+          // This is intentionally an unreachable host
+          host: '0.0.0.0',
+          path: 'base2'
+        }, {
+          protocol: 'https',
+          host: 'test.proxy.com',
+          path: 'base3',
+          caching: true
+        }]
+      }
+    },
+    sslFilePath: './src/ssr/server/test_fixtures/localhost.pem',
+    quiet: true
   };
-});
+  return _objectSpread(_objectSpread({}, defaults), overrides);
+};
 describe('the once function', () => {
   test('should prevent a function being called more than once', () => {
     const fn = jest.fn(() => ({
@@ -46,69 +72,110 @@ describe('remote server factory test coverage', () => {
     expect(endpoint).toBeDefined();
   });
 });
-describe('encodeNonAsciiHttpHeaders flag in options to createHandler', () => {
-  test('encodes request headers', () => {
-    const mockApp = {
-      sendMetric: jest.fn()
-    };
-    const mockOptions = {
-      encodeNonAsciiHttpHeaders: true
-    };
-    const originalHeaders = {
-      'x-non-ascii-header-one': 'テスト',
-      'x-non-ascii-header-two': '测试',
-      'x-regular-header': 'ascii-str'
-    };
-    const event = {
-      headers: _objectSpread({}, originalHeaders)
-    };
-    const expectedHeaders = {
-      'x-non-ascii-header-one': '%E3%83%86%E3%82%B9%E3%83%88',
-      'x-non-ascii-header-two': '%E6%B5%8B%E8%AF%95',
-      'x-encoded-headers': 'x-non-ascii-header-one,x-non-ascii-header-two',
-      'x-regular-header': 'ascii-str'
-    };
-    const {
-      handler
-    } = _buildRemoteServer.RemoteServerFactory._createHandler(mockApp, mockOptions);
-    expect(event.headers).toEqual(originalHeaders);
-    handler(event, {}, {});
-    expect(event.headers).toEqual(expectedHeaders);
-    expect(decodeURIComponent(event.headers['x-non-ascii-header-one'])).toEqual(originalHeaders['x-non-ascii-header-one']);
-  });
-  test('encodes response headers', () => {
-    const mockApp = {
-      use: jest.fn()
-    };
-    const mockOptions = {
-      encodeNonAsciiHttpHeaders: true
-    };
-    const res = {
-      headers: {},
-      setHeader: (key, value) => {
-        res.headers[key] = value;
-      },
-      getHeader: key => {
-        return res.headers[key];
-      }
-    };
-    const nonASCIIheader = 'x-non-ascii-header';
-    const nonASCIIstr = 'テスト';
-    const expectedEncoding = '%E3%83%86%E3%82%B9%E3%83%88';
-    const regularHeaderKey = 'x-regular-header';
-    const regularHeaderValue = 'ascii-str';
-    _buildRemoteServer.RemoteServerFactory._setupCommonMiddleware(mockApp, mockOptions);
-    const encodeNonAsciiMiddleware = mockApp.use.mock.calls[3][0];
-    res.setHeader(nonASCIIheader, nonASCIIstr);
-    expect(res.getHeader(nonASCIIheader)).toEqual(nonASCIIstr);
-    encodeNonAsciiMiddleware({}, res, () => {});
-    res.setHeader(nonASCIIheader, nonASCIIstr);
-    expect(res.getHeader(nonASCIIheader)).toEqual(expectedEncoding);
-    expect(decodeURI(expectedEncoding)).toEqual(nonASCIIstr);
-    expect(res.getHeader(_constants.X_ENCODED_HEADERS)).toEqual(nonASCIIheader);
 
-    // confirm ASCII headers are not modified
-    res.setHeader(regularHeaderKey, regularHeaderValue);
-    expect(res.getHeader(regularHeaderKey)).toEqual(regularHeaderValue);
-  });
-});
+// describe('extensions', () => {
+//     beforeEach(() => {
+//         jest.clearAllMocks()
+//     })
+
+//     test('can register extensions properly via _setupExtensions', () => {
+//         const app = RemoteServerFactory._createApp(opts())
+//         expect(app.__extensions).toBeDefined()
+//         return request(app)
+//             .get('/test-extension')
+//             .expect(200)
+//             .then((res) => {
+//                 expect(res.text).toBe('test')
+//             })
+//     })
+//     test('can register multiple extensions', () => {
+//         const app = RemoteServerFactory._createApp(opts())
+//         expect(app.__extensions).toBeDefined()
+//         return request(app)
+//             .get('/another-extension')
+//             .expect(200)
+//             .then((res) => {
+//                 expect(res.text).toBe('test')
+//             })
+//     })
+
+//     test('mixed types in extensions configuration', async () => {
+//         const options = opts({
+//             mobify: {app: {extensions: [['test-extension', {path: '/foo'}], 'another-extension']}}
+//         })
+//         const app = RemoteServerFactory._createApp(options)
+//         expect(app.__extensions).toBeDefined()
+
+//         await request(app)
+//             .get('/test-extension')
+//             .expect(200)
+//             .then((res) => {
+//                 expect(res.text).toBe('test')
+//             })
+
+//         await request(app)
+//             .get('/another-extension')
+//             .expect(200)
+//             .then((res) => {
+//                 expect(res.text).toBe('test')
+//             })
+
+//         await request(app)
+//             .get('/test-extension-config')
+//             .expect(200)
+//             .then((res) => {
+//                 // The config should have {enabled: true} by default
+//                 expect(res.text).toBe('{"enabled":true,"path":"/foo"}')
+//             })
+//     })
+
+//     test('disabled extension will not run', () => {
+//         const options = opts({mobify: {app: {extensions: [['test-extension', {enabled: false}]]}}})
+//         const app = RemoteServerFactory._createApp(options)
+//         expect(app.__extensions).toBeDefined()
+//         return request(app).get('/test-extension').expect(404)
+//     })
+
+//     test('logs warning when setup-server.js file is not found', () => {
+//         const warn = jest.spyOn(console, 'warn').mockImplementation(() => {})
+//         const app = RemoteServerFactory._createApp(
+//             opts({
+//                 mobify: {app: {extensions: ['extension-without-setup-server']}}
+//             })
+//         )
+//         expect(warn.mock.calls).toEqual([
+//             [
+//                 'pwa-kit-runtime WARN No setup-server.js file found for extension-without-setup-server. Skipping.'
+//             ]
+//         ])
+//     })
+
+//     test('logs error when there is an error loading extension', () => {
+//         const errorlog = jest.spyOn(console, 'error').mockImplementation(() => {})
+//         const app = RemoteServerFactory._createApp(
+//             opts({
+//                 mobify: {app: {extensions: ['extension-with-bad-setup-server']}}
+//             })
+//         )
+//         expect(errorlog.mock.calls).toEqual([
+//             [
+//                 'pwa-kit-runtime.RemoteServerFactory._setupExtensions ERROR Error setting extension extension-with-bad-setup-server: {"error":{}}'
+//             ]
+//         ])
+//     })
+
+//     test('logs error when instantiating extension throws an error', () => {
+//         const errorlog = jest.spyOn(console, 'error').mockImplementation(() => {})
+//         const app = RemoteServerFactory._createApp(
+//             opts({
+//                 mobify: {app: {extensions: ['extension-with-setup-server-no-default-export']}}
+//             })
+//         )
+
+//         expect(errorlog.mock.calls).toEqual([
+//             [
+//                 `pwa-kit-runtime.RemoteServerFactory._setupExtensions ERROR 'extension-with-setup-server-no-default-export' is not a valid PWA-Kit Application Extension, please ensure you are exporting a class of type 'ApplicationExtension'. Skipping.`
+//             ]
+//         ]).toF
+//     })
+// })