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

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

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Groups_1 = __importDefault(require("./Groups"));
+const cookie_1 = require("cookie");
+exports.CUSTOM_CACHE_KEY_ACTIONS = {
+    blacklistAll: 'blacklist-all-query-parameters',
+    blacklistSome: 'blacklist-some-query-parameters',
+    whitelistSome: 'whitelist-some-query-parameters',
+    addValue: 'add-value',
+    removeMethod: 'remove-method',
+    removeBody: 'remove-body',
+};
+/**
+ * Allows you to split or normalize the cache space for a given route. Common use cases include:
+ *
+ * - serving multiple variants of the same URL based on a currency and/or language cookie.
+ * - caching different responses based on device type
+ * - ignoring all but a specific set of query parameters when looking up a response from the cache.
+ *
+ * **Example**
+ *
+ * ```js
+ *  import { Router, CustomCacheKey } from '@layer0/core/router'
+ *
+ *  new Router()
+ *    .match('/some-path', ({ cache }) => {
+ *      cache({
+ *        key: new CustomCacheKey()
+ *          .excludeAllQueryParametersExcept('color', 'size')
+ *          .addCookie('currency')
+ *          .addCookie('location', cookie => {
+ *            cookie.group('na').byPattern('us|ca')
+ *            cookie.group('eur').byPattern('de|fr|ee')
+ *          }),
+ *        edge: {
+ *          maxAgeSeconds: 60 * 60
+ *        }
+ *      })
+ *    })
+ * ```
+ */
+class CustomCacheKey {
+    constructor() {
+        this.config = [];
+        this.actions = [];
+    }
+    /**
+     * Creates a copy of the cache key.
+     */
+    clone() {
+        const newKey = new CustomCacheKey();
+        newKey.actions = this.actions;
+        newKey.config = this.config;
+        return newKey;
+    }
+    /**
+     * Excludes the entire query string from the cache key.
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    excludeAllQueryParameters() {
+        this.config.push({ action: exports.CUSTOM_CACHE_KEY_ACTIONS.blacklistAll });
+        this.actions.push((key, srcRequest) => {
+            key.query = {};
+        });
+        return this;
+    }
+    /**
+     * Excludes the provided query parameters from the cache key.  All other parameters
+     * will still be part of the cache key. We also refer to this as "blacklisting" query parameters.
+     * @param names The names of the query parameters to blacklist
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    excludeQueryParameters(...names) {
+        this.config.push({
+            action: exports.CUSTOM_CACHE_KEY_ACTIONS.blacklistSome,
+            names,
+        });
+        this.actions.push((key, srcRequest) => {
+            for (let name of names) {
+                delete key.query[name];
+            }
+        });
+        return this;
+    }
+    /**
+     * Excludes all query parameters except those provided from the cache key.  We also refer to
+     * this as "whitelisting" query parameters.  We recommend using this method over `excludeQueryParameters`
+     * as it's difficult to know all of the query parameters your application might receive and unexpected
+     * query parameters can lead to significantly lower cache hit rates.
+     * @param names The names of the query parameters to whitelist
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    excludeAllQueryParametersExcept(...names) {
+        this.config.push({
+            action: exports.CUSTOM_CACHE_KEY_ACTIONS.whitelistSome,
+            names,
+        });
+        this.actions.push((key, srcRequest) => {
+            const toKeep = new Set(names);
+            for (let name in key.query) {
+                if (!toKeep.has(name)) {
+                    delete key.query[name];
+                }
+            }
+        });
+        return this;
+    }
+    /**
+     * Adds a request header to the cache key.
+     * This will have no effect on service worker cache.
+     * @param name The name of the request header
+     * @param createGroups A function that accepts a `Groups` instance and calls `groups.group(name)` to group multiple values into a single cache key component
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    addHeader(name, createGroups) {
+        this.actions.push((key, srcRequest) => {
+            let values = srcRequest.headers[name];
+            if (!Array.isArray(values)) {
+                values = [values];
+            }
+            if (createGroups) {
+                key.headers[name] = this.createGroupedValue(createGroups, values);
+            }
+            else {
+                key.headers[name] = values;
+            }
+        });
+        return this.addValue(`\${req:${name}}`, createGroups);
+    }
+    /**
+     * Removes the HTTP method from the cache key.
+     * @return A self-reference, suitable for chaining.
+     */
+    removeMethod() {
+        this.actions.push((key, srcRequest) => {
+            key.method = undefined;
+        });
+        this.config.push({
+            action: exports.CUSTOM_CACHE_KEY_ACTIONS.removeMethod,
+        });
+        return this;
+    }
+    /**
+     * Removes the HTTP body from the cache key.
+     * @return A self-reference, suitable for chaining.
+     */
+    removeBody() {
+        this.actions.push((key, srcRequest) => {
+            key.body = undefined;
+        });
+        this.config.push({
+            action: exports.CUSTOM_CACHE_KEY_ACTIONS.removeBody,
+        });
+        return this;
+    }
+    /**
+     * Creates a key value for a header or cookie based on the specified group creator
+     * @param createGroups the GroupCreator
+     * @param srcValues The values of the header or cookie in the request
+     */
+    createGroupedValue(createGroups, srcValues) {
+        const groups = new Groups_1.default();
+        const result = [];
+        createGroups(groups);
+        const matchingGroup = this.findMatchingGroup(groups, srcValues);
+        if (matchingGroup) {
+            result.push(matchingGroup);
+        }
+        else {
+            // if the value doesn't match any group, use the value itself
+            result.push(...srcValues);
+        }
+        return result;
+    }
+    findMatchingGroup(groups, srcValues) {
+        var _a;
+        for (let group of groups.groups) {
+            for (let value of srcValues) {
+                /* istanbul ignore next */
+                if ((_a = group.pattern) === null || _a === void 0 ? void 0 : _a.test(value)) {
+                    return group.name;
+                }
+            }
+        }
+    }
+    /**
+     * Specifies that requests should be cached on a per-device basis.
+     * This will have no effect on service worker cache.
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    addDevice() {
+        return this.addHeader('x-0-device');
+    }
+    /**
+     * Specifies that requests should be cached on a per-vendor basis.
+     * This will have no effect on service worker cache.
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    addVendor() {
+        return this.addHeader('x-0-vendor');
+    }
+    /**
+     * Specifies that requests should be cached differently for bots.
+     * This will have no effect on service worker cache.
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    addIsBot() {
+        return this.addHeader('x-0-device-is-bot');
+    }
+    /**
+     * Specifies that requests should be cached on a per-browser basis.
+     * This will have no effect on service worker cache.
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    addBrowser() {
+        return this.addHeader('x-0-browser');
+    }
+    /**
+     * Adds a cookie to the cache key.
+     * This will have no effect on service worker cache.
+     * @param name The name of the cookie
+     * @param createGroups An function that accepts a `Groups` instance and calls `groups.group(name)` to group multiple values into a single cache key component
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    addCookie(name, createGroups) {
+        this.actions.push((key, srcRequest) => {
+            let cookieHeader = srcRequest.headers.cookie || '';
+            if (Array.isArray(cookieHeader)) {
+                // Based on https://tools.ietf.org/html/rfc6265#section-5.4 we should only get a single cookie header
+                // If we get more than one, we, just join them into a single parseable cookie value in case
+                // the origin decides to read them all
+                cookieHeader = cookieHeader.join(';');
+            }
+            const cookie = cookie_1.parse(cookieHeader);
+            const value = cookie[name];
+            if (createGroups) {
+                key.cookies[name] = this.createGroupedValue(createGroups, [value]);
+            }
+            else {
+                key.cookies[name] = value;
+            }
+        });
+        return this.addValue(`\${req:cookie:${name}}`, createGroups);
+    }
+    /**
+     * @private
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    addValue(value, createGroups) {
+        const action = {
+            action: exports.CUSTOM_CACHE_KEY_ACTIONS.addValue,
+            value,
+        };
+        if (createGroups != null) {
+            const groups = new Groups_1.default();
+            createGroups(groups);
+            action.groups = groups.toJSON();
+        }
+        this.config.push(action);
+        return this;
+    }
+    getActions() {
+        return this.actions;
+    }
+    toJSON() {
+        return this.config;
+    }
+}
+exports.default = CustomCacheKey;

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

@@ -0,0 +1,7 @@
+export default class GroupConfig {
+    name: string;
+    pattern?: RegExp;
+    constructor(name: string);
+    byPattern(pattern: RegExp): void;
+    toJSON(): any;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class GroupConfig {
+    constructor(name) {
+        this.name = name;
+    }
+    byPattern(pattern) {
+        this.pattern = pattern;
+    }
+    toJSON() {
+        if (!this.pattern) {
+            throw new Error('byPattern is required for group ' + this.name);
+        }
+        return {
+            groupedValue: this.name,
+            matchRegex: this.pattern.source,
+        };
+    }
+}
+exports.default = GroupConfig;

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

@@ -0,0 +1,7 @@
+import GroupConfig from './GroupConfig';
+export default class Groups {
+    groups: GroupConfig[];
+    private name;
+    group(name: string): GroupConfig;
+    toJSON(): any[];
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const GroupConfig_1 = __importDefault(require("./GroupConfig"));
+class Groups {
+    constructor() {
+        this.groups = [];
+        this.name = null;
+    }
+    group(name) {
+        const group = new GroupConfig_1.default(name);
+        this.groups.push(group);
+        return group;
+    }
+    toJSON() {
+        return this.groups.map(p => p.toJSON());
+    }
+}
+exports.default = Groups;

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

@@ -0,0 +1,3 @@
+export default interface Headers {
+    [name: string]: string;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,51 @@
+/**
+ * Error class thrown by PathMatcher class.
+ */
+export declare class PathMatcherError extends Error {
+    /**
+     * Indicates that the error is user error and that it should be handled as so.
+     */
+    readonly isUserError: boolean;
+    constructor(pattern: string);
+}
+/**
+ * @private
+ * A simple abstraction of path-to-regexp that makes the process of
+ * extracting variables from requests paths repeatable across multiple use cases
+ * such as matching a route and rewriting params.
+ */
+export default class PathMatcher {
+    private readonly pattern;
+    private matcher?;
+    /**
+     * A path param in path-to-regexp syntax
+     * @param pattern
+     */
+    constructor(pattern: string);
+    /**
+     * Returns key/value pairs if the path matches the pattern, otherwise undefined
+     * @param path
+     */
+    match(path: string): {
+        [key: string]: string | string[];
+    } | undefined;
+    /**
+     * Matches partial splat (e.g. `/partial-:splat*`) routes.
+     */
+    private static PARTIAL_SPLAT_ROUTE;
+    /**
+     * Validate the given pattern as acceptable. If it's not acceptable an exception is raised
+     * with sufficient information to fix the problem.
+     *
+     * Notes:
+     * - Partial splat patterns (e.g. `/partial-:splat*`) have both semantic and execution issues.
+     * Semantic issues lie in the fact that path-to-regexp will generate a surprisingly different
+     * regexp for partial splat vs full splat pattern (e.g. `/full/:splat*`) that will actually not
+     * match all the sub-paths that follow the partial prefix but rather only the rest of the path
+     * until the end of the string. Execution issues lie in the fact that such regexes have been
+     * observed to block Chrome, Node and other regular expression engines. To prevent issues with
+     * these patterns we do not support them but propose a reasonable alternative of splitting the
+     * splat into fixed and splat parameters.
+     */
+    private static validatePattern;
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_to_regexp_1 = require("path-to-regexp");
+/**
+ * Error class thrown by PathMatcher class.
+ */
+class PathMatcherError extends Error {
+    constructor(pattern) {
+        super(`Route pattern "${pattern}" contains invalid syntax. See https://docs.layer0.co/guides/routing#section_route_pattern_syntax`); // istanbul ignore next - this is a known issue with TypeScript
+        this.isUserError = true;
+    }
+}
+exports.PathMatcherError = PathMatcherError;
+/**
+ * @private
+ * A simple abstraction of path-to-regexp that makes the process of
+ * extracting variables from requests paths repeatable across multiple use cases
+ * such as matching a route and rewriting params.
+ */
+class PathMatcher {
+    /**
+     * A path param in path-to-regexp syntax
+     * @param pattern
+     */
+    constructor(pattern) {
+        this.pattern = pattern;
+    }
+    /**
+     * Returns key/value pairs if the path matches the pattern, otherwise undefined
+     * @param path
+     */
+    match(path) {
+        if (!this.matcher) {
+            try {
+                this.matcher = path_to_regexp_1.match(this.pattern, { decode: decodeURIComponent });
+            }
+            catch (e) {
+                throw new PathMatcherError(this.pattern);
+            }
+        }
+        PathMatcher.validatePattern(this.pattern);
+        const result = this.matcher(path);
+        return result ? result.params : undefined;
+    }
+    /**
+     * Validate the given pattern as acceptable. If it's not acceptable an exception is raised
+     * with sufficient information to fix the problem.
+     *
+     * Notes:
+     * - Partial splat patterns (e.g. `/partial-:splat*`) have both semantic and execution issues.
+     * Semantic issues lie in the fact that path-to-regexp will generate a surprisingly different
+     * regexp for partial splat vs full splat pattern (e.g. `/full/:splat*`) that will actually not
+     * match all the sub-paths that follow the partial prefix but rather only the rest of the path
+     * until the end of the string. Execution issues lie in the fact that such regexes have been
+     * observed to block Chrome, Node and other regular expression engines. To prevent issues with
+     * these patterns we do not support them but propose a reasonable alternative of splitting the
+     * splat into fixed and splat parameters.
+     */
+    static validatePattern(pattern) {
+        const partialSplatRouteMatch = pattern.match(this.PARTIAL_SPLAT_ROUTE);
+        if (partialSplatRouteMatch) {
+            const [_, prefix, splat] = partialSplatRouteMatch;
+            const alternativePattern = pattern.replace(`${prefix}${splat}`, `${prefix}:suffix/${splat}`);
+            throw new PathMatcherError(`Partial splat routes are not supported. Use "${alternativePattern}" instead of "${pattern}"`);
+        }
+        return true;
+    }
+}
+exports.default = PathMatcher;
+/**
+ * Matches partial splat (e.g. `/partial-:splat*`) routes.
+ */
+PathMatcher.PARTIAL_SPLAT_ROUTE = /(\/[^:/]+)(:[^*/#?]+\*)/;

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

@@ -0,0 +1,16 @@
+import Headers from './Headers';
+export interface PreloadRequestConfig {
+    path?: string;
+    headers?: Headers;
+    top?: number;
+}
+export interface CompletePreloadRequestConfig extends PreloadRequestConfig {
+    destination: string;
+}
+export interface DestinationPreloadConfig {
+    requests: CompletePreloadRequestConfig[];
+}
+export interface CompiledPreloadOptions {
+    requests: CompletePreloadRequestConfig[];
+    concurrency?: number;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,23 @@
+import { CompiledPreloadOptions, DestinationPreloadConfig, PreloadRequestConfig } from './Preload';
+import Router from './Router';
+export default class PreloadRequests {
+    options: Array<PreloadRequestConfig[] | (() => Promise<PreloadRequestConfig[]>) | (() => PreloadRequestConfig[])>;
+    /**
+     * Adds prerender config to list
+     *
+     * @param preloadConfig
+     */
+    push(...preloadConfig: Array<PreloadRequestConfig[] | (() => Promise<PreloadRequestConfig[]>) | (() => PreloadRequestConfig[])>): void;
+    /**
+     * Resolves Preload config per destination
+     * @param router
+     * @private
+     */
+    static resolveDestinationPreloadConfig(router: Router, destination: string): Promise<DestinationPreloadConfig>;
+    /**
+     * Resolves compiled Preload config across all destinatons
+     * @param router
+     * @private
+     */
+    static resolvePreloadConfig(router: Router): Promise<CompiledPreloadOptions>;
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("../config"));
+const Tasks_1 = __importDefault(require("../utils/Tasks"));
+class PreloadRequests {
+    constructor() {
+        this.options = [];
+    }
+    /**
+     * Adds prerender config to list
+     *
+     * @param preloadConfig
+     */
+    push(...preloadConfig) {
+        this.options.push(...preloadConfig);
+    }
+    /**
+     * Resolves Preload config per destination
+     * @param router
+     * @private
+     */
+    static async resolveDestinationPreloadConfig(router, destination) {
+        const requests = [];
+        await new Tasks_1.default()
+            .add(...router.preloadRequests.options)
+            .onTaskDone((result) => {
+            requests.push(...result.map(r => ({ ...r, destination })));
+        })
+            .resolve();
+        return {
+            requests,
+        };
+    }
+    /**
+     * Resolves compiled Preload config across all destinatons
+     * @param router
+     * @private
+     */
+    static async resolvePreloadConfig(router) {
+        const preloadRequests = [];
+        const tasks = new Tasks_1.default();
+        const destinations = router.getDestinations();
+        // Compile all the requests and options across all destinations
+        if (!Object.keys(destinations).length) {
+            tasks.add(PreloadRequests.resolveDestinationPreloadConfig(router, 'default'));
+        }
+        else {
+            for (let d in destinations) {
+                tasks.add(PreloadRequests.resolveDestinationPreloadConfig(destinations[d], d));
+            }
+        }
+        await tasks
+            .onTaskDone(({ requests }) => {
+            preloadRequests.push(...requests);
+        })
+            .resolve();
+        return {
+            requests: preloadRequests,
+            concurrency: config_1.default.get('prerenderConcurrency', null),
+        };
+    }
+}
+exports.default = PreloadRequests;

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

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+/**
+ * Represents an incoming request.
+ */
+export default interface Request {
+    /**
+     * The path and query string
+     */
+    url: string;
+    /**
+     * Just the path part of the URL
+     */
+    path: string;
+    /**
+     * The request body as a string
+     */
+    body?: string;
+    /**
+     * The raw request body as a buffer
+     */
+    rawBody?: Buffer;
+    /**
+     * The HTTP method
+     */
+    method: string;
+    /**
+     * The request headers.  Keys are header names, values are either a string, or when multiple values for
+     * the same header name are present, an array of strings.
+     */
+    headers: {
+        [key: string]: string | string[];
+    };
+    /** @private */
+    on: (event: string, callback: Function) => void;
+    /**
+     * The path params returned by the matching route.
+     */
+    params?: {
+        [key: string]: string | string[];
+    };
+    /**
+     * The params extracted from the request URL's query string
+     */
+    query?: {
+        [key: string]: string | string[] | undefined;
+    };
+    /**
+     * Flag indicating if the connection to Layer0 is secure (HTTPS) or not (HTTP).
+     */
+    secure: boolean;
+    /**
+     * Sets a header
+     * @param name The name of the header to set
+     * @param value The value to set
+     */
+    setHeader: (name: string, value: string) => void;
+    /**
+     * Gets the value of a header
+     * @param name The name of the header to return
+     * @returns The value of the header
+     */
+    getHeader: (name: string) => string;
+    /**
+     * Gets all headers as key/value pairs.
+     */
+    getHeaders: () => {
+        [name: string]: string;
+    };
+    /**
+     * Removes a header
+     * @param name The header to remove
+     */
+    removeHeader: (name: string) => void;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,12 @@
+import CacheKey from '../cache/CacheKey';
+export default class RequestContext {
+    /**
+     * Set to true if ResponseWriter#cache is called with edge: { forcePrivateCaching: true }
+     */
+    forcePrivateCaching: boolean;
+    /**
+     * The method criteria from the route that set caching
+     */
+    cacheRouteMethod?: string;
+    cacheKey?: CacheKey;
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RequestContext {
+    constructor() {
+        /**
+         * Set to true if ResponseWriter#cache is called with edge: { forcePrivateCaching: true }
+         */
+        this.forcePrivateCaching = false;
+    }
+}
+exports.default = RequestContext;