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

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

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = __importDefault(require("url"));
+const querystring_1 = __importDefault(require("querystring"));
+/**
+ * @private
+ * Having a no-op BaseResponseWriter makes it easy for us to stub out the writer
+ * when introspecing the router.  This is needed to implement Router.getPrefetchableRoutes
+ */
+class BaseResponseWriter {
+    constructor(req, res, route) { }
+    cache(options) { }
+    redirect(to, options) { }
+    /**
+     * Translates redirect params into normalized version that solves backward compatibility
+     * issues and also takes into account query parameters that may be included in the query
+     * string itself.
+     *
+     * @param to string to where we are redirecting the request; may have query string
+     * @param options options with which we are redirecting the request
+     */
+    _readRedirectParams(to, options) {
+        const { statusCode = 302, query = {} } = 
+        // Retro-compatibility, second argument used to be statusCode
+        typeof options === 'number' ? { statusCode: options } : options;
+        // Parse `to` param to extract query strings from it.
+        let toQuery = {};
+        const parsedTo = url_1.default.parse(to);
+        // istanbul ignore next - ?. gives istanbul indigestion
+        if (parsedTo === null || parsedTo === void 0 ? void 0 : parsedTo.search) {
+            to = to.substr(0, to.length - parsedTo.search.length);
+            // @ts-ignore: whenever search is truthy query is at least an empty string
+            toQuery = querystring_1.default.parse(parsedTo.query);
+        }
+        return {
+            to,
+            statusCode,
+            query: {
+                ...toQuery,
+                ...query,
+            },
+        };
+    }
+    proxy(backend, options) { }
+    render(cb) { }
+    stream(backend) { }
+    serveStatic(path, options) { }
+    updatePath(destination) { }
+    rewrite(destination, pattern) { }
+    setRequestHeader(name, value) { }
+    updateRequestHeader(name, match, replace) { }
+    removeRequestHeader(name) { }
+    setUpstreamResponseHeader(name, value) { }
+    updateUpstreamResponseHeader(name, match, replace) { }
+    removeUpstreamResponseHeader(name) { }
+    /*
+     * JWTs are only verified on the edge, not locally or on the user lambda
+     * implementation here is empty in ResponseWriter as here, and overwritten
+     * with some bejaviour in EdgeResponseWriter
+     */
+    verifyJwt(options) { }
+    setResponseHeader(name, value) { }
+    updateResponseHeader(name, match, replace) { }
+    removeResponseHeader(name) { }
+    addResponseCookie(name, value, options) { }
+    updateResponseCookie(name, match, replace) { }
+    removeResponseCookie(name) { }
+    addUpstreamResponseCookie(name, value, options) { }
+    updateUpstreamResponseCookie(name, match, replace) { }
+    removeUpstreamResponseCookie(name) { }
+    send(content, statusCode, statusMessage) { }
+    compute(callback) { }
+    serviceWorker(path) { }
+    allowCors(options) { }
+    appShell(indexHtmlPath) { }
+    renderWithApp(options) { }
+}
+exports.BaseResponseWriter = BaseResponseWriter;

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

@@ -0,0 +1,4 @@
+declare const _default: {
+    create: (writer: any) => any;
+};
+export default _default;

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

@@ -0,0 +1,89 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Set of methods that are to be intercepted and made noop
+ * outside of the immediate mode (which is in effect only
+ * during compute on serverless)
+ *
+ * @private
+ */
+const conditionallyExecutedMethods = new Set([
+    'cache',
+    'setRequestHeader',
+    'updateRequestHeader',
+    'removeRequestHeader',
+    'setResponseHeader',
+    'updateResponseHeader',
+    'removeResponseHeader',
+    'setUpstreamResponseHeader',
+    'updateUpstreamResponseHeader',
+    'removeUpstreamResponseHeader',
+    'addResponseCookie',
+    'updateResponseCookie',
+    'removeResponseCookie',
+    'addUpstreamResponseCookie',
+    'updateUpstreamResponseCookie',
+    'removeUpstreamResponseCookie',
+]);
+/**
+ * Response writer proxy used then core router is not on the edge.
+ *
+ * Notes:
+ * - We need this to avoid running header and other transformations on
+ * both edge and in the cloud. We do this by overriding the ResponseWriter
+ * header transformation methods so that they are either a noop when
+ * running outside of immediate mode or immediately executing them.
+ *
+ * @param writer ResponseWriter to which we are proxying the requests
+ *
+ * @private
+ */
+const create = (writer) => {
+    const wrapComputeConditionedFunction = (target, property) => {
+        // We cannot use closures but rather functions so that we can bind them.
+        return async function (...args) {
+            if (!target.runningImmediately) {
+                return;
+            }
+            return await target[property](...args);
+        }.bind(target);
+    };
+    return new Proxy(writer, {
+        get: (target, property) => {
+            if (property === 'serveStatic') {
+                return wrapServeStatic(target, target.serveStatic);
+            }
+            else if (conditionallyExecutedMethods.has(property.toString())) {
+                return wrapComputeConditionedFunction(target, property);
+            }
+            else {
+                return target[property];
+            }
+        },
+    });
+};
+exports.default = {
+    create,
+};
+/**
+ * Overrides the default behavior of serveStatic when running behind the edge to
+ * skip trying to pull the file from S3 and just running the onNotFound function
+ * because the edge has already tried and failed to pull the file from S3.
+ * @param _path
+ * @param options
+ */
+function wrapServeStatic(res, originalMethod) {
+    return async (path, options = {}) => {
+        // @ts-ignore We want to leave runningImmediately private
+        if (res.runningImmediately) {
+            return originalMethod.call(res, path, options);
+        }
+        else if (options.onNotFound) {
+            // @ts-ignore We want to leave runImmediately private
+            res.setCreateResponseAction(() => res.runImmediately(() => options.onNotFound(res)));
+        }
+        else {
+            throw new Error('Should not get to serveStatic without onNotFound when running behind the edge.');
+        }
+    };
+}

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

@@ -0,0 +1,80 @@
+import { CacheOptions } from './CacheOptions';
+/**
+ * A representation of a route to be passed to the browser.
+ * @private
+ */
+export interface CacheManifestEntry {
+    /**
+     * Criteria path as expressed in User's routes
+     */
+    criteriaPath: string | undefined;
+    /**
+     * The criteria path turned into a regexp string
+     */
+    route: string;
+    /**
+     * Key/value pairs for the route's query params to match
+     */
+    query?: {
+        [key: string]: string | null;
+    };
+    /**
+     * Caching options for the route
+     */
+    cacheOptions: CacheOptions;
+    /**
+     * Optional http method to match for the route
+     */
+    method?: string;
+    /**
+     * Optional protocol to match for the route
+     */
+    protocol?: string;
+    /**
+     * Set to true if the route returns a response (e.g. proxy, send, compute) in which
+     * case the router/prefetcher should stop searching for other route matches.
+     */
+    returnsResponse: boolean;
+}
+/**
+ * A serializable array of route descriptors to be passed to the browser.
+ * @private
+ */
+export default class CacheManifest {
+    entries: CacheManifestEntry[];
+    constructor(entries?: CacheManifestEntry[]);
+    /**
+     * Returns a list of entries in this CacheManifest where both the browser and
+     * edge cache times are defined, and greater than 0
+     */
+    get cacheableEntries(): CacheManifestEntry[];
+    /**
+     * Returns a list of routes (as RegExp) that are cacheable SPA routes
+     */
+    get spaRoutes(): RegExp[];
+    /**
+     * Returns true if the URL should be prefetched, based on the matched route's `cacheOptions`
+     * @param url The URL to test
+     */
+    shouldPrefetch(url: URL): boolean;
+    /**
+     * Returns true if the entry matches the URL's path, query params, and/or protocol
+     * @param entry The entry to test
+     * @param url URL to check against the entry
+     */
+    static entryMatches(entry: CacheManifestEntry, url: URL): boolean;
+    /**
+     * Returns true if the given entry has its `cacheOptions` set so that the route
+     * is cacheable by the edge and the browser.
+     * @param entry The entry to test
+     */
+    static isEntryCacheable({ cacheOptions }: CacheManifestEntry): boolean;
+    /**
+     * Creates a new `CacheManifest` object from the provided serialized entries
+     */
+    static fromEntries(entries: CacheManifestEntry[]): CacheManifest;
+    /**
+     * Serializes the list so that it can be passed to the browser
+     */
+    toJSON(): string;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const universalRouteUtils_1 = require("./universalRouteUtils");
+const mapValues_1 = __importDefault(require("../utils/mapValues"));
+/**
+ * A serializable array of route descriptors to be passed to the browser.
+ * @private
+ */
+class CacheManifest {
+    constructor(entries) {
+        this.entries = entries || [];
+    }
+    /**
+     * Returns a list of entries in this CacheManifest where both the browser and
+     * edge cache times are defined, and greater than 0
+     */
+    get cacheableEntries() {
+        return this.entries.filter(CacheManifest.isEntryCacheable);
+    }
+    /**
+     * Returns a list of routes (as RegExp) that are cacheable SPA routes
+     */
+    get spaRoutes() {
+        return this.cacheableEntries
+            .filter(({ cacheOptions }) => cacheOptions.browser && cacheOptions.browser.spa)
+            .map(({ route }) => new RegExp(route, 'i'));
+    }
+    /**
+     * Returns true if the URL should be prefetched, based on the matched route's `cacheOptions`
+     * @param url The URL to test
+     */
+    shouldPrefetch(url) {
+        let doPrefetch = false;
+        this.entries.some(entry => {
+            const matches = CacheManifest.entryMatches(entry, url);
+            if (matches) {
+                doPrefetch =
+                    CacheManifest.isEntryCacheable(entry) || !!entry.cacheOptions.prefetchUpstreamRequests;
+                // if it's prefetchable, or if it matches a stop route, then no need to continue checking:
+                return doPrefetch || entry.returnsResponse;
+            }
+            return false;
+        });
+        return doPrefetch;
+    }
+    /**
+     * Returns true if the entry matches the URL's path, query params, and/or protocol
+     * @param entry The entry to test
+     * @param url URL to check against the entry
+     */
+    static entryMatches(entry, url) {
+        return (new RegExp(entry.route, 'i').test(url.pathname) &&
+            universalRouteUtils_1.matchCriteriaRegexObjectWithRequestObject(mapValues_1.default(entry.query || {}, value => (value ? new RegExp(value, 'i') : null)), Object.fromEntries(Array.from(url.searchParams.entries()))) &&
+            (entry.protocol ? new RegExp(entry.protocol, 'i').test(url.protocol) : true));
+    }
+    /**
+     * Returns true if the given entry has its `cacheOptions` set so that the route
+     * is cacheable by the edge and the browser.
+     * @param entry The entry to test
+     */
+    static isEntryCacheable({ cacheOptions }) {
+        return !!(cacheOptions.browser &&
+            (cacheOptions.browser.serviceWorkerSeconds || 0) > 0 &&
+            cacheOptions.edge &&
+            (cacheOptions.edge.maxAgeSeconds || 0) > 0);
+    }
+    /**
+     * Creates a new `CacheManifest` object from the provided serialized entries
+     */
+    static fromEntries(entries) {
+        return new CacheManifest(entries);
+    }
+    /**
+     * Serializes the list so that it can be passed to the browser
+     */
+    toJSON() {
+        return JSON.stringify(this.entries);
+    }
+}
+exports.default = CacheManifest;

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

@@ -0,0 +1,171 @@
+import CustomCacheKey from './CustomCacheKey';
+import { HTTP_METHODS } from '../constants';
+export declare type HTTPMethod = keyof typeof HTTP_METHODS;
+/**
+ * Options for controlling caching behavior in the browser and at the network edge.
+ */
+export interface CacheOptions {
+    /**
+     * Sets the caching behavior at edge. When set to `false` the caching in the edge is turned
+     * off. This also turns off queueing of potentially cacheable requests that platform performs
+     * automatically.
+     *
+     * Note: if know for sure that a specific `GET` route will never cache then you should
+     * always set `edge` caching to `false` for it as it will disable `GET` request coalescing
+     * making your application faster.
+     */
+    edge?: EdgeCacheOptions | false;
+    /**
+     * Sets the caching behavior in the browser. When set to `false` the caching in the browser
+     * is turned off.
+     */
+    browser?: BrowserCacheOptions | false;
+    /**
+     * 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
+     *        }
+     *      })
+     *    })
+     * ```
+     */
+    key?: CustomCacheKey;
+    /**
+     * If true, prefetch requests that match the route pattern will not be cached directly,
+     * but will instead force the Prefetcher to prefetch paths listed in the response's
+     * `x-0-upstream-requests` header.
+     */
+    prefetchUpstreamRequests?: boolean;
+}
+/**
+ * Options for controlling caching behavior at edge
+ */
+export interface EdgeCacheOptions {
+    /**
+     * The maximum number of seconds that a response is served from the cache until it is
+     * considered stale. Unless `staleWhileRevalidate` is specified, stale responses will
+     * not be returned to the browser.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * Extends the duration that a response will be served from the cache after it has become stale.
+     * When using staleWhileRevalidate, if Layer0 receives a request for a stale asset, the cached
+     * response will be served and a fresh response will be concurrently fetch so that it can be served
+     * for future requests. The stale response will continue to be served until the fresh fetched.
+     */
+    staleWhileRevalidateSeconds?: number;
+    /**
+     * Allows you to force caching of responses marked as `private` in their `cache-control` header.
+     * This option must be used with utmost care to avoid leaking private information.
+     *
+     * **Example**
+     *
+     * ```js
+     *  import { Router, CustomCacheKey } from '@layer0/core/router'
+     *
+     *  new Router()
+     *    .match('/private/path', ({ cache }) => {
+     *      cache({
+     *        edge: {
+     *          maxAgeSeconds: 60 * 60,
+     *          key: new CustomCacheKey()
+     *            .addCookie('session'),
+     *          forcePrivateCaching: true,
+     *        }
+     *      })
+     *    })
+     * ```
+     */
+    forcePrivateCaching?: boolean;
+}
+/**
+ * Options for controlling caching behavior in the browser
+ */
+export interface BrowserCacheOptions {
+    /**
+     * Sets the `max-age` value of the `cache-control` header sent to the browser.  This controls the duration
+     * that the response is held in the browser's http cache.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * Sends an `x-sw-cache-control` header with a value of `max-age={serviceWorkerSeconds}`.  This is not a standard
+     * header that service workers understand by default.  You'll need to implement logic to handle this in your service worker.
+     */
+    serviceWorkerSeconds?: number;
+    /**
+     * Set to `true` to convert all requests to GETs using the service worker. Doing so
+     * allows you to prefetch and cache non-GET requests.  Since all prefetch requests are GETs,
+     * setting this config to `true` will ensure that the actual, non-prefetch requests use
+     * GET as well and thus have the same cache key as their prefetch counterparts.
+     *
+     * When `true`, the service worker will add the request body as the `pref_layer0_body` parameter.
+     * You can then use a `.get()` route with `transformRequest` to convert the `get` to the original method (`post`, for example)
+     * when fetching from the backend.
+     *
+     * Note that you must specify two routes when using this method: one for the `get` and one for the original method,
+     * This is because do not guarantee that the service worker is installed and running by the time requests are sent, so some
+     * requests will inevitably sent using their original method and body.
+     *
+     * **Example**
+     *
+     * ```js
+     *  import { Router } from '@layer0/core/router'
+     *  import { transformMethod } from '@layer0/core/transform'
+     *
+     *  const cacheConfig = {
+     *    edge: {
+     *      maxAgeSeconds: 60 * 60 * 24,
+     *      staleWhileRevalidateSeconds: 60 * 60
+     *    },
+     *    browser: {
+     *      serviceWorkerSeconds: 60 * 60 * 24,
+     *      convertToGet: true // convert POSTs to GETs so we can prefetch and cache them
+     *    }
+     *  }
+     *
+     *  export default new Router()
+     *    // When the request is a GET, convert it to post using serverless compute and cache the result
+     *    .get('/some-post-path', (res) => {
+     *      cache(cacheConfig)
+     *      res.proxy('origin', {
+     *        transformRequest: transformMethod('post')
+     *      })
+     *    })
+     *    // When the request is a POST, forward it to origin from the edge without using serverless compute
+     *    .post('/some-post-path', ({ cache, proxy }) => {
+     *      cache(cacheConfig)
+     *      proxy('origin')
+     *    })
+     * ```
+     *
+     * @param toMethod The method to to set
+     */
+    convertToGet?: boolean;
+    /**
+     * Set to true if the request is for a SPA and there will be prefetch requests made
+     * based on the headers of another request
+     *
+     * @private - Until we ensure that the layer0_head requests are viable
+     */
+    spa?: boolean;
+}

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

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

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

@@ -0,0 +1,140 @@
+import Groups from './Groups';
+import Request from './Request';
+import CacheKey from '../cache/CacheKey';
+export interface CustomCacheKeyConfig {
+    action: string;
+    names?: string[];
+    groups?: any;
+}
+export declare const CUSTOM_CACHE_KEY_ACTIONS: {
+    blacklistAll: string;
+    blacklistSome: string;
+    whitelistSome: string;
+    addValue: string;
+    removeMethod: string;
+    removeBody: string;
+};
+declare type GroupCreator = (groups: Groups) => void;
+/**
+ * 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
+ *        }
+ *      })
+ *    })
+ * ```
+ */
+export default class CustomCacheKey {
+    private config;
+    private actions;
+    /**
+     * Creates a copy of the cache key.
+     */
+    clone(): CustomCacheKey;
+    /**
+     * Excludes the entire query string from the cache key.
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    excludeAllQueryParameters(): 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: string[]): 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: string[]): 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: string, createGroups?: GroupCreator): this;
+    /**
+     * Removes the HTTP method from the cache key.
+     * @return A self-reference, suitable for chaining.
+     */
+    removeMethod(): this;
+    /**
+     * Removes the HTTP body from the cache key.
+     * @return A self-reference, suitable for chaining.
+     */
+    removeBody(): 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
+     */
+    private createGroupedValue;
+    private findMatchingGroup;
+    /**
+     * 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(): this;
+    /**
+     * 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(): this;
+    /**
+     * 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(): this;
+    /**
+     * 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(): this;
+    /**
+     * 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: string, createGroups?: GroupCreator): this;
+    /**
+     * @private
+     * @return {CustomCacheKey} A self-reference, suitable for chaining.
+     */
+    private addValue;
+    getActions(): ((key: CacheKey, srcRequest: Request) => void)[];
+    toJSON(): CustomCacheKeyConfig[];
+}
+export {};