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

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

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Route_1 = __importDefault(require("./Route"));
+const Cache_1 = require("../cache/Cache");
+const environment_1 = require("../environment");
+const path_1 = require("path");
+const nonWebpackRequire_1 = __importDefault(require("../utils/nonWebpackRequire"));
+const normalizeCriteria_1 = __importDefault(require("./normalizeCriteria"));
+const constants_1 = require("../constants");
+const source_1 = require("../source");
+const slash_1 = __importDefault(require("slash"));
+const requireInternal_1 = __importDefault(require("../utils/requireInternal"));
+/**
+ * The contents to be written to static-asset-manifest.json
+ * @private
+ */
+exports.staticAssetManifest = {};
+/**
+ * The static asset manifest file name
+ * @private
+ */
+exports.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
+ */
+class RouteGroup {
+    /**
+     * @param name Name of the route group - **required**
+     */
+    constructor(name) {
+        this._routes = [];
+        if (!name) {
+            throw new Error('Route group name is required!');
+        }
+        this.name = name;
+    }
+    /**
+     * Adds route to group.
+     * @param criteria The criteria to match.
+     * @param handler The handler to use for the route.
+     */
+    match(criteria, handler, { index, label } = {}) {
+        const route = new Route_1.default(criteria, handler, { label });
+        if (index != null) {
+            this._routes.splice(index, 0, route);
+        }
+        else {
+            this._routes.push(route);
+        }
+        return 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, options) {
+        const directory = path_1.join(source_1.getSourceDir(), sourcePath);
+        const manifest = (exports.staticAssetManifest[slash_1.default(sourcePath)] = []); // we normalize paths to use "/" here in case the user is building on windows but running on Linux
+        let { ignore, label } = options;
+        if (typeof ignore === 'string') {
+            ignore = [ignore];
+        }
+        let files = environment_1.isCloud()
+            ? this.staticAssetsForPath(sourcePath)
+            : requireInternal_1.default('globby').sync(options.glob || '**/*', {
+                // glob is large and we don't need it in production so we use nonWebpackRequire
+                cwd: directory,
+                onlyFiles: true,
+                ignore: ignore || [],
+            });
+        if (options.sort) {
+            files = options.sort(files);
+        }
+        for (let file of files) {
+            const paths = (options.paths && options.paths(file)) || [`/${file}`];
+            if (!environment_1.isCloud()) {
+                manifest.push(slash_1.default(file)); // we normalize paths to use "/" here in case the user is building on windows but running on Linux
+            }
+            for (let path of paths) {
+                let route = path.replace(/\/index.html$/, '');
+                if (route.length === 0) {
+                    route = '/';
+                }
+                this.match(route, async (res) => {
+                    options.handler && options.handler(file)(res);
+                }, { label });
+            }
+        }
+        return 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, options) {
+        const handler = (file) => (res) => {
+            if (options.handler) {
+                options.handler(file)(res);
+            }
+            res.serveStatic(`${sourcePath}/${file}`);
+        };
+        return this.dir(sourcePath, { ...options, handler, label: `static('${sourcePath}')` });
+    }
+    /**
+     * 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) {
+        let { route, username, password, realm = 'Access to the site' } = options;
+        if (username && password) {
+            const token = Buffer.from(`${username}:${password}`).toString('base64');
+            route = normalizeCriteria_1.default(route);
+            // Add route handlers that will return 401, 403 or remove the authorizaton header,
+            // depending on the request properties.
+            // We run these handlers only if they have not already run in the edge. To detect this
+            // we cannot use `x-0-version` header because it gets injected very early in the edge
+            // so by the time the router matching runs, it's already present. We also cannot use
+            // `x-0-lambda-name` header because it gets removed by XBP before it reaches the lambda.
+            // We use `x-0-matched-routes` as the definitive indicator that a router has ran before
+            // the traffic reached this router.
+            this
+                // Provide challenge when the Authorization header is not present.
+                .match({
+                ...route,
+                headers: {
+                    ...route.headers,
+                    [constants_1.HTTP_HEADERS.authorization]: null,
+                    [constants_1.HTTP_HEADERS.x0MatchedRoutes]: null,
+                },
+            }, ({ send, setResponseHeader }) => {
+                setResponseHeader('WWW-Authenticate', `Basic realm="${realm}"`);
+                send('', 401, 'Unauthorized');
+            })
+                // Block the request when the Authorization header is not matching the basic auth token.
+                .match({
+                ...route,
+                headers: {
+                    ...route.headers,
+                    [constants_1.HTTP_HEADERS.authorization]: new RegExp(`^((?!Basic ${token}).)*$`),
+                    [constants_1.HTTP_HEADERS.x0MatchedRoutes]: null,
+                },
+            }, ({ send }) => {
+                send('', 403, 'Forbidden');
+            })
+                // Do not leak authorization header upstream as upstreams are not likely to recognize it
+                // and are free to block the request.
+                .match({
+                ...route,
+                headers: {
+                    ...route.headers,
+                    [constants_1.HTTP_HEADERS.x0MatchedRoutes]: null,
+                },
+            }, ({ removeRequestHeader }) => {
+                removeRequestHeader('authorization');
+            });
+        }
+        return 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.
+     */
+    staticAssetsForPath(path) {
+        return nonWebpackRequire_1.default(path_1.join(process.cwd(), exports.STATIC_ASSET_MANIFEST_FILE))[path];
+    }
+    /**
+     * Clears all routes in group.
+     * Used for updating routes dynamically for development purpose.
+     */
+    clear() {
+        this._routes = [];
+        if (!environment_1.isCloud()) {
+            Cache_1.clearCache();
+        }
+        return this;
+    }
+    /**
+     * Returns the routes in group.
+     * @returns Routes in group
+     */
+    get routes() {
+        return this._routes;
+    }
+    /**
+     * Returns number of routes in group.
+     * @returns Number of routes in the group.
+     */
+    get length() {
+        return this._routes.length;
+    }
+}
+exports.default = RouteGroup;

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

@@ -0,0 +1,45 @@
+import RouteGroup from './RouteGroup';
+import Route from './Route';
+import { RouteHandler } from './Router';
+/**
+ * Holds a list of route groups
+ * This class is needed for querying route groups that is needed
+ * for keeping the routes hierarchy while changing the routes in a group.
+ * For example, updating next.js routes in local dev env.
+ */
+export default class RouteGroupList {
+    private routeGroups;
+    private fallback?;
+    /**
+     * Pushes route group to list.
+     * @param group The route group.
+     * @returns A self-reference suitable for chaining.
+     */
+    add(group: RouteGroup): this;
+    /**
+     * Returns all route groups.
+     * @returns A list of all the route groups.
+     */
+    getGroups(): RouteGroup[];
+    /**
+     * Returns route group by name.
+     * @param name The name of the route group to find.
+     * @returns The route group with the given name, or `null` if not found.
+     */
+    findByName(name: string): RouteGroup | undefined;
+    /**
+     * Returns all registered routes in all groups.
+     * @returns List of registered routes.
+     */
+    getRoutes(): Route[];
+    /**
+     * Sets the fallback group, which is always run last.
+     * @param handler
+     */
+    setFallback(handler: RouteHandler): void;
+    /**
+     * Returns the length of route groups list.
+     * @returns The number of route groups in the list.
+     */
+    get length(): number;
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RouteGroup_1 = __importDefault(require("./RouteGroup"));
+const constants_1 = require("../constants");
+/**
+ * Holds a list of route groups
+ * This class is needed for querying route groups that is needed
+ * for keeping the routes hierarchy while changing the routes in a group.
+ * For example, updating next.js routes in local dev env.
+ */
+class RouteGroupList {
+    constructor() {
+        this.routeGroups = [];
+    }
+    /**
+     * Pushes route group to list.
+     * @param group The route group.
+     * @returns A self-reference suitable for chaining.
+     */
+    add(group) {
+        this.routeGroups.push(group);
+        return this;
+    }
+    /**
+     * Returns all route groups.
+     * @returns A list of all the route groups.
+     */
+    getGroups() {
+        return this.routeGroups;
+    }
+    /**
+     * Returns route group by name.
+     * @param name The name of the route group to find.
+     * @returns The route group with the given name, or `null` if not found.
+     */
+    findByName(name) {
+        return this.routeGroups.find(g => g.name === name);
+    }
+    /**
+     * Returns all registered routes in all groups.
+     * @returns List of registered routes.
+     */
+    getRoutes() {
+        let routes = [];
+        this.getGroups().forEach(group => {
+            routes = routes.concat(group.routes);
+        });
+        if (this.fallback) {
+            routes = routes.concat(this.fallback.routes);
+        }
+        return routes;
+    }
+    /**
+     * Sets the fallback group, which is always run last.
+     * @param handler
+     */
+    setFallback(handler) {
+        const fallbackGroup = new RouteGroup_1.default(constants_1.ROUTES_FALLBACK);
+        fallbackGroup.match(null, handler);
+        this.fallback = fallbackGroup;
+    }
+    /**
+     * Returns the length of route groups list.
+     * @returns The number of route groups in the list.
+     */
+    get length() {
+        return this.routeGroups.length;
+    }
+}
+exports.default = RouteGroupList;