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

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

@@ -0,0 +1,124 @@
+import { RouteHandler } from './Router';
+import PathMatcher from './PathMatcher';
+import Request from './Request';
+import RouteCriteria from './RouteCriteria';
+import Response from './Response';
+/**
+ * @private
+ */
+export default class Route {
+    readonly criteria: RouteCriteria;
+    readonly matcher?: PathMatcher;
+    readonly handler: RouteHandler;
+    readonly options?: RouteOptions;
+    /**
+     * Creates a new Route
+     * @param criteria A string or an object with `path`, `headers`, and `method`.
+     * @param handler A route handler
+     * @param options A route options
+     */
+    constructor(criteria: string | RouteCriteria | null, handler: RouteHandler, options: RouteOptions);
+    /**
+     * Returns params if route matches the request's method, headers, cookies and path.
+     * @param req
+     * @return The path params if the route matches the current request, otherwise false
+     */
+    match(req: Request): {};
+    /**
+     * Matches response. This is used for error routes and each route that contains response matcher is considered as
+     * a route for handling the error pages. Each error route must send a response.
+     * @param res Response
+     * @returns
+     */
+    matchResponse(res: Response): boolean;
+    private matchResponseStatus;
+    private matchPath;
+    private matchMethod;
+    /**
+     * Run thru criteria headers and match with request headers.
+     *
+     * Header names are *not* case-sensitive and they are all lower-cased per Node behavior we pass `toLower` to matcher function.
+     *
+     * @param req Request object
+     */
+    private matchHeaders;
+    /**
+     * Matches JSON body based on given criteria
+     *
+     * @param req Request object
+     *
+     * @returns Boolean
+     */
+    private matchBody;
+    /**
+     * Run thru criteria query and match with request query parameters.
+     *
+     * Query string names are case-sensitive so we use the default behaviour of
+     * `matchCriteriaRegexObjectWithRequestObject`.
+     *
+     * @param req Request object
+     */
+    private matchQueryParams;
+    /**
+     * Run thru criteria cookies and match with request cookies.
+     *
+     * Cookie names are case-sensitive so we use the default behaviour of
+     * `matchCriteriaRegexObjectWithRequestObject`.
+     *
+     * @param req Request object
+     */
+    private matchCookies;
+    /**
+     * Match the protocol for the request. All routes have the implicit `https` protocol
+     * unless explicitly specified as something else.
+     *
+     * Because HTTP is a subset of HTTPS we make sure that when strings are used we match
+     * the whole value rather than just a part of it.
+     *
+     * @param req Request object
+     */
+    private matchProtocol;
+    toString(): string;
+    toRegex(): RegExp;
+    /**
+     * Returns criteria json
+     * This is consumed by cache metrics that will transform the route to be as similar as in routes file
+     */
+    toJson(): string;
+    /**
+     * Returns a string with the regex representation of the route.
+     * @returns Regexp string representation of the route
+     */
+    toRegexString(): string;
+    /**
+     * Returns a regex string compatible with the edge regular express parser
+     */
+    toEdgeRegexString(): string;
+    /**
+     * Returns if the route should match response criteria.
+     *
+     * @returns
+     */
+    isRespRoute(): boolean;
+    static toRegexp(path?: string): RegExp;
+    static toEdgeRegexString(path?: string): string;
+    /**
+     * Generate a path-to-regexp comptible path that includes query strings
+     * In path-to-regexp, '?' is a special character so it needs to be escaped
+     *
+     * Note that we prevent querystring from escaping ':', which is used to inject
+     * matched params from the path
+     *
+     * @param path
+     * @param query
+     */
+    static pathWithQueryString(path: string, query: {
+        [key: string]: string;
+    }): string;
+}
+export interface RouteOptions {
+    /**
+     * Adds the label for static routes
+     */
+    label?: string;
+}

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

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const universalRouteUtils_1 = require("./universalRouteUtils");
+const cookie_1 = require("cookie");
+const path_to_regexp_1 = require("path-to-regexp");
+const normalizeCriteria_1 = __importDefault(require("./normalizeCriteria"));
+const PathMatcher_1 = __importStar(require("./PathMatcher"));
+const querystring_1 = __importDefault(require("querystring"));
+const toEdgeRegex_1 = __importDefault(require("../utils/toEdgeRegex"));
+const toLower_1 = __importDefault(require("../utils/toLower"));
+/**
+ * @private
+ */
+class Route {
+    /**
+     * Creates a new Route
+     * @param criteria A string or an object with `path`, `headers`, and `method`.
+     * @param handler A route handler
+     * @param options A route options
+     */
+    constructor(criteria, handler, options) {
+        this.criteria = normalizeCriteria_1.default(criteria);
+        this.handler = handler;
+        this.options = options;
+        if (this.criteria.path) {
+            this.matcher = new PathMatcher_1.default(this.criteria.path);
+        }
+    }
+    /**
+     * Returns params if route matches the request's method, headers, cookies and path.
+     * @param req
+     * @return The path params if the route matches the current request, otherwise false
+     */
+    match(req) {
+        // Params are mostly extracted from path, but in they can also be extracted from query string, header, cookie, etc.
+        // although that would need to be implemented at EDGE too, which in general is not trivial.
+        // As of now, on EDGE, this is only implemented for query string params to inject in redirect()
+        const matchParamsFns = [
+            this.matchPath,
+            this.matchProtocol,
+            this.matchMethod,
+            this.matchHeaders,
+            this.matchQueryParams,
+            this.matchCookies,
+            this.matchBody,
+        ];
+        const mergedParams = {};
+        for (const matchParamsFn of matchParamsFns) {
+            const paramsOrBoolean = matchParamsFn.bind(this)(req);
+            if (!paramsOrBoolean) {
+                // One matcher failed, no need to go further
+                return false;
+            }
+            Object.assign(mergedParams, paramsOrBoolean);
+        }
+        // We wait until now before assigning params to the request so we are sure the route actually matched the request.
+        req.params = mergedParams;
+        return mergedParams;
+    }
+    /**
+     * Matches response. This is used for error routes and each route that contains response matcher is considered as
+     * a route for handling the error pages. Each error route must send a response.
+     * @param res Response
+     * @returns
+     */
+    matchResponse(res) {
+        return this.matchResponseStatus(res);
+    }
+    matchResponseStatus(res) {
+        var _a, _b, _c;
+        if ((_b = (_a = this.criteria) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) {
+            return !!((_c = res.statusCode) === null || _c === void 0 ? void 0 : _c.toString().match(this.criteria.response.statusCode));
+        }
+        return false;
+    }
+    // Match criteria path to request url
+    matchPath(req) {
+        if (this.matcher) {
+            return this.matcher.match(req.path);
+        }
+        else {
+            return {}; // return a match with no params
+        }
+    }
+    // Match criteria method to request method
+    matchMethod(req) {
+        if (!this.criteria.method || !req.method) {
+            return true;
+        }
+        return new RegExp(this.criteria.method, 'i').test(req.method);
+    }
+    /**
+     * Run thru criteria headers and match with request headers.
+     *
+     * Header names are *not* case-sensitive and they are all lower-cased per Node behavior we pass `toLower` to matcher function.
+     *
+     * @param req Request object
+     */
+    matchHeaders(req) {
+        if (this.criteria.headers) {
+            return universalRouteUtils_1.matchCriteriaRegexObjectWithRequestObject(this.criteria.headers, req.headers, toLower_1.default);
+        }
+        return true;
+    }
+    /**
+     * Matches JSON body based on given criteria
+     *
+     * @param req Request object
+     *
+     * @returns Boolean
+     */
+    matchBody(req) {
+        if (this.criteria.body && this.criteria.body.parse == 'json' && req.body) {
+            let bodyObject;
+            try {
+                bodyObject = JSON.parse(req.body);
+            }
+            catch {
+                return false;
+            }
+            return universalRouteUtils_1.deepMatchObject(bodyObject, this.criteria.body.criteria);
+        }
+        return true;
+    }
+    /**
+     * Run thru criteria query and match with request query parameters.
+     *
+     * Query string names are case-sensitive so we use the default behaviour of
+     * `matchCriteriaRegexObjectWithRequestObject`.
+     *
+     * @param req Request object
+     */
+    matchQueryParams(req) {
+        if (this.criteria.query) {
+            // When there's no query params it means there's no way it's a match when criteria is set
+            if (!req.query) {
+                return false;
+            }
+            return universalRouteUtils_1.matchCriteriaRegexObjectWithRequestObject(this.criteria.query, req.query);
+        }
+        return true;
+    }
+    /**
+     * Run thru criteria cookies and match with request cookies.
+     *
+     * Cookie names are case-sensitive so we use the default behaviour of
+     * `matchCriteriaRegexObjectWithRequestObject`.
+     *
+     * @param req Request object
+     */
+    matchCookies(req) {
+        if (this.criteria.cookies) {
+            const cookieHeader = req.headers['cookie'];
+            if (cookieHeader == null) {
+                // When there is no cookie header, we return true only if all matchers
+                // on cookies are null meaning "cookie not present".
+                return Object.values(this.criteria.cookies).every(regex => regex === null);
+            }
+            const cookieValue = Array.isArray(cookieHeader) ? cookieHeader.join('; ') : cookieHeader;
+            const reqCookies = cookie_1.parse(cookieValue);
+            return universalRouteUtils_1.matchCriteriaRegexObjectWithRequestObject(this.criteria.cookies, reqCookies);
+        }
+        return true;
+    }
+    /**
+     * Match the protocol for the request. All routes have the implicit `https` protocol
+     * unless explicitly specified as something else.
+     *
+     * Because HTTP is a subset of HTTPS we make sure that when strings are used we match
+     * the whole value rather than just a part of it.
+     *
+     * @param req Request object
+     */
+    matchProtocol(req) {
+        const protocol = (req.headers && req.headers[constants_1.HTTP_HEADERS.x0Protocol]) || 'https';
+        let criteriaProtocolRegex;
+        if (typeof this.criteria.protocol === 'string') {
+            criteriaProtocolRegex = new RegExp(`^${this.criteria.protocol}$`, 'i');
+        }
+        else {
+            criteriaProtocolRegex = new RegExp(this.criteria.protocol || '^https$', 'i');
+        }
+        return universalRouteUtils_1.testRegExp(criteriaProtocolRegex, protocol);
+    }
+    toString() {
+        const { path, ...criteria } = this.criteria;
+        if (Object.keys(criteria).length) {
+            return JSON.stringify(this.criteria);
+        }
+        else if (path) {
+            return path;
+        }
+        else {
+            return 'fallback';
+        }
+    }
+    toRegex() {
+        return Route.toRegexp(this.criteria.path);
+    }
+    /**
+     * Returns criteria json
+     * This is consumed by cache metrics that will transform the route to be as similar as in routes file
+     */
+    toJson() {
+        var _a;
+        return JSON.stringify({ ...this.criteria, label: (_a = this.options) === null || _a === void 0 ? void 0 : _a.label }, (_, value) => {
+            // We have to convert regular expressions to string otherwise it will not be logged
+            if (value instanceof RegExp) {
+                return value.toString();
+            }
+            return value;
+        });
+    }
+    /**
+     * Returns a string with the regex representation of the route.
+     * @returns Regexp string representation of the route
+     */
+    toRegexString() {
+        return this.toRegex().source;
+    }
+    /**
+     * Returns a regex string compatible with the edge regular express parser
+     */
+    toEdgeRegexString() {
+        return Route.toEdgeRegexString(this.criteria.path);
+    }
+    /**
+     * Returns if the route should match response criteria.
+     *
+     * @returns
+     */
+    isRespRoute() {
+        return !!this.criteria.response;
+    }
+    static toRegexp(path) {
+        if (path) {
+            try {
+                return path_to_regexp_1.pathToRegexp(path);
+            }
+            catch (e) {
+                throw new PathMatcher_1.PathMatcherError(path);
+            }
+        }
+        else {
+            // For fallbacks we want everything matched so that we can replace everything if needed.
+            // We insist on total matching with `^` and `$` because some regex replacement algorithms
+            // have issues with correctly applying `.*` in completely greedy manner (e.g. Fastly's `regsuball`)
+            return /^.*$/;
+        }
+    }
+    static toEdgeRegexString(path) {
+        return toEdgeRegex_1.default(Route.toRegexp(path));
+    }
+    /**
+     * Generate a path-to-regexp comptible path that includes query strings
+     * In path-to-regexp, '?' is a special character so it needs to be escaped
+     *
+     * Note that we prevent querystring from escaping ':', which is used to inject
+     * matched params from the path
+     *
+     * @param path
+     * @param query
+     */
+    static pathWithQueryString(path, query) {
+        const queryString = querystring_1.default.stringify(query).replace(/%3A/g, ':');
+        return path + (queryString && `\\?${queryString}`);
+    }
+}
+exports.default = Route;

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

@@ -0,0 +1,68 @@
+/**
+ * Criteria for response. Note that all routes that are having this will restart and will eventually be evaluated twice. First response and then request.
+ * This route will only be evaluated when we have x-0-error header present. This header will be set once this criteria matches and the router will be restarted.
+ */
+interface RouteCriteriaResponse {
+    statusCode: RegExp;
+}
+/**
+ * Criteria for matching a request.
+ */
+export default interface RouteCriteria {
+    /**
+     * Matches a request based on its protocol. Unless explicitly specified then `https`
+     * is the default. To serve a route on both HTTPS and HTTP you can specify `/https?/`
+     * regex. If an HTTP request is not matched against any route, Layer0 will
+     * automatically issue a redirect to equivalent HTTPS URL.
+     */
+    protocol?: string | RegExp;
+    /**
+     * Matches a request based on one or more header values. Keys are
+     * case-insensitive header names, values are regular expressions to match or null.
+     * When value is null then requests are matched for the header not being present.
+     */
+    headers?: {
+        [name: string]: string | RegExp | null;
+    };
+    /**
+     * Matches a request based on one or more cookie values. Keys are
+     * case-sensitive cookie names, values are regular expressions to match or null.
+     * When value is null then requests are matched for the cookie not being present.
+     */
+    cookies?: {
+        [name: string]: string | RegExp | null;
+    };
+    /**
+     * Matches a request based on one or more query parameter values. Keys are
+     * case-sensitive names, values are regular expressions to match or null.
+     * When value is null then requests are matched for the query parameter not being present.
+     */
+    query?: {
+        [name: string]: string | RegExp | null;
+    };
+    /**
+     * Matches a request based on the HTTP method. Instead of this, prefer using
+     * `get`, `post`, `put`, `delete`, `options`, and `patch` methods.
+     */
+    method?: string | RegExp;
+    /**
+     * Matches a request based on the path. The same path syntax is used by
+     * the simple form of the Router class's `match` method.
+     */
+    path?: string;
+    /**
+     * Matches a request response. This is used by error pages to make edge aware of a matching error route.
+     * This will issue a restart on a edge with specific header that matches the error route on next eval.
+     */
+    response?: RouteCriteriaResponse;
+    /**
+     * Matches a request based on criteria matching a JSON body
+     */
+    body?: {
+        parse: string;
+        criteria: {
+            [name: string]: string | RegExp;
+        };
+    };
+}
+export {};

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

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

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

@@ -0,0 +1,157 @@
+import Route, { RouteOptions } from './Route';
+import { RouteHandler } from './Router';
+import RouteCriteria from './RouteCriteria';
+/**
+ * The contents to be written to static-asset-manifest.json
+ * @private
+ */
+export declare const staticAssetManifest: {
+    [key: string]: string[];
+};
+/**
+ * The static asset manifest file name
+ * @private
+ */
+export declare const STATIC_ASSET_MANIFEST_FILE = "static-asset-manifest.json";
+/**
+ * This class is needed for creating a route group that holds a routes that can
+ * be dynamically updated on a local env.
+ * @private
+ */
+export default class RouteGroup {
+    readonly name: string;
+    private _routes;
+    /**
+     * @param name Name of the route group - **required**
+     */
+    constructor(name: string);
+    /**
+     * Adds route to group.
+     * @param criteria The criteria to match.
+     * @param handler The handler to use for the route.
+     */
+    match(criteria: RouteCriteria | string | null, handler: RouteHandler, { index, label }?: AddRouteOptions): this;
+    /**
+     * Adds routes for all files in a directory tree.
+     * @private
+     * @param sourcePath The path to a directory containing static assets relative to the root of your project.
+     * @param options
+     * @returns A self-reference, suitable for chaining.
+     */
+    dir(sourcePath: string, options: StaticOptions): this;
+    /**
+     * Adds routes for all static assets in a directory tree.
+     * @param sourcePath The path to a directory containing static assets relative to the root of your project.
+     * @param options
+     * @returns A self-reference, suitable for chaining.
+     */
+    static(sourcePath: string, options: StaticOptions): this;
+    /**
+     * Adds Basic Authentication.
+     *
+     * **example**
+     *
+     * ```js
+     *  router
+     *    .requireBasicAuth({ username: 'user', password: 's3cr3t!' })
+     *    // ...include additional routes below...
+     * ```
+     *
+     * You can also require basic auth for a subset of URLs using the criteria option:
+     *
+     * ```js
+     *  router
+     *    .requireBasicAuth({ criteria: '/secret/:path*' username: 'user', password: 's3cr3t!' })
+     *    // ...include additional routes below...
+     * ```
+     *
+     * The criteria option accepts a path pattern as a string, or a RouteCriteria object.
+     *
+     * @param options
+     * @returns A self-reference, suitable for chaining.
+     */
+    requireBasicAuth(options: BasicAuthOptions): this;
+    /**
+     * Since the files are now on S3, we can no longer crawl the file system to
+     * determine the routes, so we use the manifest file.
+     * We also prevent webpack from trying to bundle the manifest, which will fail.
+     */
+    private staticAssetsForPath;
+    /**
+     * Clears all routes in group.
+     * Used for updating routes dynamically for development purpose.
+     */
+    clear(): this;
+    /**
+     * Returns the routes in group.
+     * @returns Routes in group
+     */
+    get routes(): Route[];
+    /**
+     * Returns number of routes in group.
+     * @returns Number of routes in the group.
+     */
+    get length(): number;
+}
+export interface DirOptions {
+    /**
+     * The handler to call when each resulting route is matched.
+     */
+    handler: (dest: string) => RouteHandler;
+    /**
+     * Limits the files served to only those matching the specified glob pattern.
+     * See https://github.com/isaacs/node-glob#glob-primer for the syntax supported.
+     */
+    glob?: string;
+    /**
+     * By default the path on which files are served corresponds to the path within the directory, so for example, public/css/main.css would be served at '/css/main.css',
+     * you can override this using the `paths` option. For each file, the function is passed the path to the file within the directory. The function
+     * should return the URL paths on which the file should be served.
+     */
+    paths?: (file: string) => string[];
+    /**
+     * An optional function to sort the files before mapping them to routes
+     */
+    sort?: (files: string[]) => string[];
+    /**
+     * Glob pattern of files to exclude
+     */
+    ignore?: string | string[];
+    /**
+     * Adds the label for static routes
+     */
+    label?: string;
+}
+export interface StaticOptions extends Partial<DirOptions> {
+    /**
+     * Add caching or other additional route handling logic here. The function is passed a ResponseWriter, the same as any other route handler would be.
+     */
+    handler?: (dest: string) => RouteHandler;
+}
+/**
+ * Options for Router#requireBasicAuth
+ */
+export interface BasicAuthOptions {
+    /**
+     * The route pattern to which to apply basic authentication
+     */
+    route?: RouteCriteria;
+    /**
+     * The username
+     */
+    username?: string;
+    /**
+     * The password to check
+     */
+    password?: string;
+    /**
+     * The realm name for the browser's basic auth prompt
+     */
+    realm?: string;
+}
+export interface AddRouteOptions extends RouteOptions {
+    /**
+     * Adds the route at the specified index
+     */
+    index?: number;
+}