@ohos-ports/layer0-prefetch 4.20.0-beta.0 → 4.20.0-beta.1

package/node_modules/@layer0/core/router/addBuiltInRoutes.d.ts

@@ -0,0 +1,2 @@
+import Router from './Router';
+export default function addBuiltInRoutes(router: Router): void;

package/node_modules/@layer0/core/router/addBuiltInRoutes.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cacheManifestFromRouter_1 = __importDefault(require("./cacheManifestFromRouter"));
+const environment_1 = require("../environment");
+function addBuiltInRoutes(router) {
+    addCacheManifest(router);
+    try {
+        // Add @layer0/devtools built-in routes if the module is installed
+        require('@layer0/devtools/addBuiltInRoutes')({
+            router,
+            local: environment_1.isLocal(),
+        });
+    }
+    catch (e) {
+        // istanbul ignore if
+        if (e.code !== 'MODULE_NOT_FOUND') {
+            throw e;
+        }
+    }
+}
+exports.default = addBuiltInRoutes;
+/**
+ * Adds /__layer0__/cache-manifest.js, which contains:
+ *
+ * ```
+ *  self.__LAYER0_CACHE_MANIFEST__ = {
+ *    "/some/route": {
+ *      browser: {
+ *        serviceWorkerSeconds: (number)
+ *      },
+ *      edge: {
+ *        maxAgeSeconds: (number)
+ *      }
+ *    }
+ *  }
+ * ```
+ *
+ * @private
+ * @param router
+ */
+function addCacheManifest(router) {
+    router.match('/__layer0__/cache-manifest.js', ({ cache, setResponseHeader, send, allowCors }) => {
+        cache({
+            edge: {
+                maxAgeSeconds: 60 * 60 * 24 * 365,
+            },
+            browser: {
+                maxAgeSeconds: 60 * 60,
+            },
+        });
+        setResponseHeader('content-type', 'text/javascript');
+        allowCors();
+        send(() => `self.__LAYER0_CACHE_MANIFEST__=${cacheManifestFromRouter_1.default(router).toJSON()}`);
+    });
+}

package/node_modules/@layer0/core/router/addPreloadHeaders.d.ts

@@ -0,0 +1,7 @@
+import Response from './Response';
+/**
+ * Adds preload headers for all `<link rel="preload">` tags on the response.body
+ * @private
+ * @param res The response to which headers should be added.
+ */
+export default function addPreloadHeaders(res: Response): void;

package/node_modules/@layer0/core/router/addPreloadHeaders.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Adds preload headers for all `<link rel="preload">` tags on the response.body
+ * @private
+ * @param res The response to which headers should be added.
+ */
+function addPreloadHeaders(res) {
+    if (/text\/html/i.test(res.getHeader('Content-Type'))) {
+        let { body } = res;
+        const matches = [];
+        const preloadRegex = /<link rel="preload" href="([^"]*)".+?(?=>)/gis;
+        const typeRegex = /as="([^"]*)"/i;
+        let match;
+        if (Buffer.isBuffer(body)) {
+            body = body.toString('utf8');
+        }
+        if (typeof body === 'string') {
+            while ((match = preloadRegex.exec(body))) {
+                // determine possible type if defined on the tag
+                const type = typeRegex.exec(match[0]);
+                matches.push({ uri: match[1], as: type && type[1] });
+            }
+        }
+        const newLinks = matches.map(linkFile).join(', ');
+        // Add to existing links if exist
+        const existingLinks = res.getHeader('link');
+        if (existingLinks) {
+            res.setHeader('link', `${existingLinks}, ${newLinks}`);
+        }
+        else if (newLinks.length) {
+            res.setHeader('link', newLinks);
+        }
+    }
+}
+exports.default = addPreloadHeaders;
+/**
+ * Creates a preload header value for the specified file
+ * @param link The request uri and possible type
+ * @private
+ */
+function linkFile(link) {
+    let { uri, as } = link;
+    let name = uri.split('?')[0];
+    if (!as) {
+        if (name.toLowerCase().endsWith('.css')) {
+            as = 'style';
+        }
+        else if (name.toLowerCase().match(/(woff|woff2|truetype|opentype|embedded-opentype)$/)) {
+            as = 'font';
+        }
+        else {
+            as = 'script';
+        }
+    }
+    return `<${name}>; as=${as}; rel=preload`;
+}

package/node_modules/@layer0/core/router/cacheManifestFromRouter.d.ts

@@ -0,0 +1,6 @@
+import { Router } from '.';
+import CacheManifest from './CacheManifest';
+/**
+ * Generates a new `CacheManifest` object from the rules given in the provided `Router`
+ */
+export default function cacheManifestFromRouter(router: Router): CacheManifest;

package/node_modules/@layer0/core/router/cacheManifestFromRouter.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseResponseWriter_1 = require("./BaseResponseWriter");
+const CacheManifest_1 = __importDefault(require("./CacheManifest"));
+const mapValues_1 = __importDefault(require("../utils/mapValues"));
+/**
+ * Generates a new `CacheManifest` object from the rules given in the provided `Router`
+ */
+function cacheManifestFromRouter(router) {
+    const manifest = new CacheManifest_1.default();
+    const propToString = (regexOrString) => {
+        if (regexOrString === undefined)
+            return undefined;
+        return regexOrString instanceof RegExp ? regexOrString.source : regexOrString;
+    };
+    for (let route of router.routeGroups.getRoutes()) {
+        const writer = new StubWriter();
+        // @ts-ignore Typescript doesn't like that we're passing in the base class here -
+        // but we keep ResponseWriter on the handler method for documentation purposes
+        route.handler(writer);
+        const entry = {
+            criteriaPath: route.criteria.path,
+            route: route.toRegexString(),
+            method: propToString(route.criteria.method),
+            protocol: propToString(route.criteria.protocol),
+            cacheOptions: writer.cacheOptions,
+            returnsResponse: writer.returnsResponse,
+        };
+        if (route.criteria.query) {
+            // @ts-ignore The lodash response is a Dictionary which confuses TS
+            entry.query = mapValues_1.default(route.criteria.query, (value) => value ? value.source : null);
+        }
+        // Because service worker cannot match on headers and cookies we ignore them
+        // during the creation of cache manifest. This is problematic but it's
+        // less problematic than pretending to not ignore them and creating
+        // routes that are too "greedy" (they can never match on headers/cookies
+        // so overall the condition is always weaker and thus matches more than
+        // it should)
+        //
+        // An example of the issues this causes arises when users try to block some
+        // traffic in the router (e.g. from certain countries) The blocking is
+        // based on the geo location headers that are injected into the request
+        // by the edge so aren't even theoretically available for evaluation
+        // in the browser. This leads to service worker matching *all* requests
+        // to something that has no caching options (it only has the blocking code)
+        // leading to service worker rejecting to cache anything, contrary to what
+        // the rest of the router states.
+        if (route.criteria.headers || route.criteria.cookies) {
+            continue;
+        }
+        manifest.entries.push(entry);
+    }
+    return manifest;
+}
+exports.default = cacheManifestFromRouter;
+/**
+ * Helper class used to generate manifest entries from a Router
+ * @private
+ */
+class StubWriter extends BaseResponseWriter_1.BaseResponseWriter {
+    constructor() {
+        super(...arguments);
+        this.response = {};
+        this.request = {};
+        this.cacheOptions = {};
+        this.returnsResponse = false;
+        this.doesReturnResponse = () => (this.returnsResponse = true);
+        this.cache = (options) => {
+            this.cacheOptions = options;
+        };
+        this.send = this.doesReturnResponse;
+        this.compute = this.doesReturnResponse;
+        this.proxy = this.doesReturnResponse;
+        this.redirect = this.doesReturnResponse;
+        this.render = this.doesReturnResponse;
+        this.serveStatic = this.doesReturnResponse;
+        this.serviceWorker = this.doesReturnResponse;
+        this.renderWithApp = this.doesReturnResponse;
+        this.appShell = this.doesReturnResponse;
+        this.stream = this.doesReturnResponse;
+    }
+}

package/node_modules/@layer0/core/router/createCustomCacheKey.d.ts

@@ -0,0 +1,27 @@
+import CustomCacheKey from './CustomCacheKey';
+/**
+ * Returns a DSL for creating custom server cache keys based on cookies, query parameters, and
+ * request headers.
+ *
+ * example:
+ *
+ * ```js
+ *  new Router()
+ *    .get('/s/:id',
+ *      cache({
+ *        edge: {
+ *          key: createCustomCacheKey()
+ *            .addHeader('user-agent')
+ *            .excludeQueryParameters(['uid'])
+ *            .addCookie('location', cookie => {
+ *              cookie.group('na').byPattern('us|ca')
+ *              cookie.group('eur').byPattern('de|fr|ee')
+ *            })
+ *        }
+ *      })
+ *    )
+ * ```
+ * @deprecated Use `new CustomCacheKey()` instead.
+ * @return {CustomCacheKey}
+ */
+export default function createCustomCacheKey(): CustomCacheKey;

package/node_modules/@layer0/core/router/createCustomCacheKey.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CustomCacheKey_1 = __importDefault(require("./CustomCacheKey"));
+/**
+ * Returns a DSL for creating custom server cache keys based on cookies, query parameters, and
+ * request headers.
+ *
+ * example:
+ *
+ * ```js
+ *  new Router()
+ *    .get('/s/:id',
+ *      cache({
+ *        edge: {
+ *          key: createCustomCacheKey()
+ *            .addHeader('user-agent')
+ *            .excludeQueryParameters(['uid'])
+ *            .addCookie('location', cookie => {
+ *              cookie.group('na').byPattern('us|ca')
+ *              cookie.group('eur').byPattern('de|fr|ee')
+ *            })
+ *        }
+ *      })
+ *    )
+ * ```
+ * @deprecated Use `new CustomCacheKey()` instead.
+ * @return {CustomCacheKey}
+ */
+function createCustomCacheKey() {
+    return new CustomCacheKey_1.default();
+}
+exports.default = createCustomCacheKey;

package/node_modules/@layer0/core/router/deriveSurrogateKeysFromJson.d.ts

@@ -0,0 +1,36 @@
+import Response from './Response';
+export interface DeriveSurrogateKeyOptions {
+    /**
+     * Determines the behavior when the origin returns a `x-0-surrogate-key` response header
+     * - Use "merge" to include surrogate keys returned from the origin via the `x-0-surrogate-key` response header.
+     * - Use "override" to discard surrogate keys returned from the origin via the `x-0-surrogate-key` response header.
+     */
+    onConflict: 'merge' | 'override';
+}
+/**
+ * Creates a response transformer that assigns surrogate keys for the given body parsed as JSON. Accepts a
+ * callback function that takes the response body parsed as json and returns an array of surrogate
+ * keys to assign the response when cached. This function will only be called on cache misses. When a request
+ * has no body or a body that cannot be parsed as JSON, the callback function will be passed `undefined`.
+ * Returning anything other than an array of string will result in no surrogate keys being assigned and a warning
+ * will be logged.
+ *
+ * Example:
+ *
+ * ```
+ *  new Router()
+ *    .graphqlOperation('GetPost', ({ cache }) => {
+ *      cache({
+ *        edge: {
+ *          maxAgeSeconds: 60 * 60
+ *        }
+ *      })
+ *      proxy('graphql', {
+ *        transformResponse: deriveSurrogateKeysFromJson(json => [`posts.${json.id}`])
+ *      })
+ *    })
+ * ```
+ * @param extractKeys
+ * @returns
+ */
+export default function deriveSurrogateKeysFromJson(extractKeys: (bodyFromJson: any | undefined) => string[], options?: DeriveSurrogateKeyOptions): (res: Response) => Promise<void>;

package/node_modules/@layer0/core/router/deriveSurrogateKeysFromJson.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
+/**
+ * Creates a response transformer that assigns surrogate keys for the given body parsed as JSON. Accepts a
+ * callback function that takes the response body parsed as json and returns an array of surrogate
+ * keys to assign the response when cached. This function will only be called on cache misses. When a request
+ * has no body or a body that cannot be parsed as JSON, the callback function will be passed `undefined`.
+ * Returning anything other than an array of string will result in no surrogate keys being assigned and a warning
+ * will be logged.
+ *
+ * Example:
+ *
+ * ```
+ *  new Router()
+ *    .graphqlOperation('GetPost', ({ cache }) => {
+ *      cache({
+ *        edge: {
+ *          maxAgeSeconds: 60 * 60
+ *        }
+ *      })
+ *      proxy('graphql', {
+ *        transformResponse: deriveSurrogateKeysFromJson(json => [`posts.${json.id}`])
+ *      })
+ *    })
+ * ```
+ * @param extractKeys
+ * @returns
+ */
+function deriveSurrogateKeysFromJson(extractKeys, options = { onConflict: 'merge' }) {
+    return async (res) => {
+        const result = extractKeys(parseBodyAsJson(res.body));
+        if (!Array.isArray(result)) {
+            console.warn(`The function provided to deriveSurrogateKeysFromJson should return an array, but returned a value of type "${typeof result}" instead. Surrogate keys will not be set.`);
+            return;
+        }
+        const keys = new Set(result);
+        if (options.onConflict === 'merge') {
+            let surrogateKeyFromOrigin = res.getHeader(__1.HTTP_HEADERS.x0SurrogateKey);
+            if (surrogateKeyFromOrigin != null) {
+                if (!Array.isArray(surrogateKeyFromOrigin)) {
+                    surrogateKeyFromOrigin = [surrogateKeyFromOrigin];
+                }
+                for (let header of surrogateKeyFromOrigin) {
+                    for (let key of header.split(' ')) {
+                        keys.add(key);
+                    }
+                }
+            }
+        }
+        else if (options.onConflict !== 'override') {
+            throw new Error(`invalid value "${options.onConflict}" for onConflict option in deriveSurrogateKeysFromJson. Use "override" or "merge".`);
+        }
+        if (keys.size > 0) {
+            res.setHeader(__1.HTTP_HEADERS.x0SurrogateKey, Array.from(keys).join(' '));
+        }
+    };
+}
+exports.default = deriveSurrogateKeysFromJson;
+function parseBodyAsJson(body) {
+    if (!body) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(typeof body === 'string' ? body : body.toString('utf8'));
+    }
+    catch (e) {
+        return undefined;
+    }
+}

package/node_modules/@layer0/core/router/index.d.ts

@@ -0,0 +1,11 @@
+export { default as Router } from './Router';
+export { RouteHandler } from './Router';
+export { default as CustomCacheKey } from './CustomCacheKey';
+export { default as ResponseWriter } from './ResponseWriter';
+export { default as deriveSurrogateKeysFromJson } from './deriveSurrogateKeysFromJson';
+/**
+ * We've deprecated this to simplify the API. The examples in the docs now use `new CustomCacheKey()` instead.
+ * @private
+ * @deprecated Use `new CustomCacheKey()` instead.
+ */
+export { default as createCustomCacheKey } from './createCustomCacheKey';

package/node_modules/@layer0/core/router/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Router_1 = require("./Router");
+exports.Router = Router_1.default;
+var CustomCacheKey_1 = require("./CustomCacheKey");
+exports.CustomCacheKey = CustomCacheKey_1.default;
+var ResponseWriter_1 = require("./ResponseWriter");
+exports.ResponseWriter = ResponseWriter_1.default;
+var deriveSurrogateKeysFromJson_1 = require("./deriveSurrogateKeysFromJson");
+exports.deriveSurrogateKeysFromJson = deriveSurrogateKeysFromJson_1.default;
+/**
+ * We've deprecated this to simplify the API. The examples in the docs now use `new CustomCacheKey()` instead.
+ * @private
+ * @deprecated Use `new CustomCacheKey()` instead.
+ */
+var createCustomCacheKey_1 = require("./createCustomCacheKey");
+exports.createCustomCacheKey = createCustomCacheKey_1.default;

package/node_modules/@layer0/core/router/interpolateParams.d.ts

@@ -0,0 +1,21 @@
+import Request from './Request';
+import Response from './Response';
+/**
+ * @private
+ * Emulates the edge by interpolating header values
+ *
+ * Note: This code must be kept in sync with the interpolateParams: values from ECL compiler
+ *
+ * Supported interpolation strings are:
+ *  - ${method}: the request method GET/PUT/POST/etc...
+ *  - ${path}: the return path without query parameters
+ *  - ${url}: the original unmodified request url
+ *  - ${req:<request header name>}: a request header value
+ *  - ${req:cookie:<request cookie name>}: a request cookie value
+ *  - ${res:<response header name>}: a response header value
+ *
+ * @param req The request
+ * @param res The response
+ * @param value The string or array of strings to interpolate
+ */
+export default function interpolateParams(req: Request, res: Response, value: any): any;

package/node_modules/@layer0/core/router/interpolateParams.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cookie_1 = __importDefault(require("cookie"));
+const querystring_1 = require("querystring");
+const identity_1 = __importDefault(require("../utils/identity"));
+/**
+ * @private
+ * Emulates the edge by interpolating header values
+ *
+ * Note: This code must be kept in sync with the interpolateParams: values from ECL compiler
+ *
+ * Supported interpolation strings are:
+ *  - ${method}: the request method GET/PUT/POST/etc...
+ *  - ${path}: the return path without query parameters
+ *  - ${url}: the original unmodified request url
+ *  - ${req:<request header name>}: a request header value
+ *  - ${req:cookie:<request cookie name>}: a request cookie value
+ *  - ${res:<response header name>}: a response header value
+ *
+ * @param req The request
+ * @param res The response
+ * @param value The string or array of strings to interpolate
+ */
+function interpolateParams(req, res, value) {
+    if (typeof value === 'string') {
+        return interpolateParam(req, res, value);
+    }
+    if (!Array.isArray(value)) {
+        // Skip any non-string and non-string array values
+        return value;
+    }
+    const results = [];
+    value.forEach(v => {
+        results.push(interpolateParams(req, res, v));
+    });
+    return results;
+}
+exports.default = interpolateParams;
+/**
+ * @private
+ * Interpolates a single string value
+ *
+ *  NOTE: We emulate the Fastly Edge closely, but there are known difference. E.g. if you have header='hi ${req:cookie:test}' and there is no
+ *        cookie name 'test' Fastly will return header='hi (null)' but if you have header='${req:cookie:test}' Fastly will drop the header.
+ *        This interpolator just returns '' for not found values.
+ * @param req The request
+ * @param res The response
+ * @param value a string to interpolate
+ */
+function interpolateParam(req, res, value) {
+    // We can have multiple replacements per value, so we need to loop through all the possible cases
+    // Use '--backslashdollar--' so we do not interpret '\${' in the results.
+    // Use '--separator--' so we keep the '${' in the results of split().
+    const segments = value
+        .replace(/\\\${/g, '--backslashdollar--')
+        .replace(/\${/g, '--separator--${')
+        .split('--separator--');
+    // Parse cookies once at the top of the function as an optimization
+    let cookies = {};
+    if (req === null || req === void 0 ? void 0 : req.headers.cookie) {
+        // Pass in the 'do nothing' decode function to return the cookie value without decoding it
+        cookies = cookie_1.default.parse(req.headers.cookie, { decode: identity_1.default });
+    }
+    // Parse query parameters once at the top of the function as an optimization
+    let qs = {};
+    if (req === null || req === void 0 ? void 0 : req.url) {
+        const queryParameterIndex = req.url.indexOf('?');
+        if (queryParameterIndex >= 0) {
+            const queryParameters = req.url.substring(queryParameterIndex + 1);
+            qs = querystring_1.parse(queryParameters);
+        }
+    }
+    const interpolatedResults = [];
+    const requestPrefixLength = '${req:'.length;
+    const queryPrefixLength = '${query:'.length;
+    segments.forEach(segment => {
+        if (req) {
+            segment = segment.replace(/\${method}/, req.method);
+            segment = segment.replace(/\${path}/, req.path);
+            segment = segment.replace(/\${url}/, req.url);
+            // ${query:paramName} returns the found query parameter
+            const startQueryParameterIndex = segment.search(/\${query:/);
+            if (startQueryParameterIndex >= 0) {
+                let queryParameterName = segment.substring(startQueryParameterIndex + queryPrefixLength);
+                const endQueryParameterIndex = queryParameterName.indexOf('}');
+                if (endQueryParameterIndex <= 0) {
+                    throw new Error(`Cannot interpolate substring "${segment}" of value "${value}" (1)`);
+                }
+                queryParameterName = queryParameterName.substring(0, endQueryParameterIndex);
+                // When there are multiple matches for the query parameter's name, we emulate
+                // the edge's behavior and return the first match only.
+                let queryReplacementString = qs[queryParameterName] || '';
+                if (Array.isArray(queryReplacementString)) {
+                    queryReplacementString = queryReplacementString[0];
+                }
+                segment = segment.replace(/\${query:.*?}/, queryReplacementString);
+            }
+            const startRequestIndex = segment.search(/\${req:/);
+            if (startRequestIndex >= 0) {
+                let requestHeaderName = segment.substring(startRequestIndex + requestPrefixLength);
+                const endRequestIndex = requestHeaderName.indexOf('}');
+                if (endRequestIndex <= 0) {
+                    throw new Error(`Cannot interpolate substring "${segment}" of value "${value}" (2)`);
+                }
+                requestHeaderName = requestHeaderName.substring(0, endRequestIndex);
+                let replacementString = '';
+                // req:cookie:<key> injects the value of cookie named <key> or an empty string if <key> not found
+                if (requestHeaderName.indexOf('cookie:') === 0) {
+                    const cookieName = requestHeaderName.split(':')[1];
+                    replacementString = cookies[cookieName] || '';
+                    // req:param:<name> injects the value of named parameter <name> or an empty string if <name> not found
+                }
+                else if (requestHeaderName.indexOf('param:') === 0) {
+                    const paramName = requestHeaderName.split(':')[1];
+                    if (req.params && req.params[paramName]) {
+                        replacementString = String(req.params[paramName]);
+                    }
+                    // req:<header>
+                }
+                else {
+                    // Use an empty string if the request header is not found
+                    replacementString = req.headers[requestHeaderName] || '';
+                }
+                segment = segment.replace(/\${req:.*?}/, replacementString);
+            }
+        }
+        const startResponseIndex = segment.search(/\${res:/);
+        if (startResponseIndex >= 0) {
+            if (!res) {
+                throw new Error(`Cannot interpolate response parameter "${segment}" during receive phase`);
+            }
+            let responseHeaderName = segment.substring(startResponseIndex + requestPrefixLength);
+            const endResponseIndex = responseHeaderName.indexOf('}');
+            if (endResponseIndex <= 0) {
+                throw new Error(`Cannot interpolate substring "${segment}" of value "${value}" (3)`);
+            }
+            responseHeaderName = responseHeaderName.substring(0, endResponseIndex);
+            segment = segment.replace(/\${res:.*?}/, res.getHeader(responseHeaderName) || '');
+        }
+        // If no replacement was done, we assume the <key> in ${<key>} was not valid and throw an error
+        if (segment.search(/\${/) >= 0) {
+            throw new Error(`Cannot interpolate substring "${segment}" of "${value}" (4)`);
+        }
+        interpolatedResults.push(segment);
+    });
+    return interpolatedResults.join('').replace(/--backslashdollar--/g, '${');
+}

package/node_modules/@layer0/core/router/loadRouter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Loads and returns a router.  This function can accomodate:
+ *
+ * 1.) a routes file that uses `module.exports` or `export default`.
+ * 2.) a routes file that exports a function using `module.exports` or `export default`.
+ * 3.) a router instance
+ * 4.) An object with a default key that is a router instance
+ * 5.) An object with a default key whose value is a function that returns a router instance.
+ *
+ * @param routerPath A path to routes.js,
+ * @return {Router} The Router instance
+ */
+export default function loadRouter(router: any): any;

package/node_modules/@layer0/core/router/loadRouter.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nonWebpackRequire_1 = __importDefault(require("../utils/nonWebpackRequire"));
+/**
+ * Loads and returns a router.  This function can accomodate:
+ *
+ * 1.) a routes file that uses `module.exports` or `export default`.
+ * 2.) a routes file that exports a function using `module.exports` or `export default`.
+ * 3.) a router instance
+ * 4.) An object with a default key that is a router instance
+ * 5.) An object with a default key whose value is a function that returns a router instance.
+ *
+ * @param routerPath A path to routes.js,
+ * @return {Router} The Router instance
+ */
+function loadRouter(router) {
+    if (typeof router === 'string') {
+        router = nonWebpackRequire_1.default(router);
+    }
+    if (router.default)
+        router = router.default;
+    if (typeof router === 'function')
+        router = router();
+    return router;
+}
+exports.default = loadRouter;

package/node_modules/@layer0/core/router/mergeQueryString.d.ts

@@ -0,0 +1 @@
+export default function mergeQueryString(requestUrl: string, targetRedirectOrPath: string): string;

package/node_modules/@layer0/core/router/mergeQueryString.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Used to create URL instance with just a path
+ */
+const PLACEHOLDER_HOSTNAME = '__';
+function mergeQueryString(requestUrl, targetRedirectOrPath) {
+    // `https://${PLACEHOLDER_HOSTNAME}` is temporarily inserted to make the `URL` object work
+    // with relative path, but is removed from the returned value right after.
+    const requestSearchParams = new URL(requestUrl, `https://${PLACEHOLDER_HOSTNAME}`).searchParams;
+    const targetUrl = new URL(targetRedirectOrPath, `https://${PLACEHOLDER_HOSTNAME}`);
+    // Apply query string from request to the target, except if they are already set explicitly on the target
+    requestSearchParams.forEach((value, key) => {
+        if (!targetUrl.searchParams.get(key)) {
+            targetUrl.searchParams.set(key, value);
+        }
+    });
+    // Keep the target as initially intended, absolute or relative path
+    return targetUrl.hostname === PLACEHOLDER_HOSTNAME
+        ? `${targetUrl.pathname}${targetUrl.search}`
+        : targetUrl.toString();
+}
+exports.default = mergeQueryString;