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

package/node_modules/@layer0/core/README.md

@@ -0,0 +1,50 @@
+## Overview
+
+Core library for the [Layer0](https://docs.layer0.co), infrastructure to run your big, dynamic website frontend and make it load in less than one second.
+
+The `@layer0/core` package provides a CDN-as-JavaScript API for defining edge routing and logic on Layer0.
+
+## Example Routes File
+
+```js
+// routes.js
+
+import { Router } from '@layer0/core/router'
+import { createNextPlugin } = from '@layer0/next'
+import { renderNextPage, nextRoutes } from '@layer0/next'
+
+export default new Router()
+  // redirect at edge
+  .match('/some/path/:withVar', async ({ redirect }) => {
+    redirect('/some/other/path/:withVar', { statusCode: 301 })
+  })
+
+  // proxy the legacy site
+  .match('/some/path/:withVar', async ({ proxy }) => {
+    proxy('legacy', {
+      path: '/some/other/path/:withVar',
+    })
+  })
+
+  // match based on header and proxy the legacy site
+  .match({ headers: { 'layer0-device-type': /desktop/ } }, async ({ proxy }) => {
+    proxy('legacy')
+  })
+
+  // vanity URL for next.js
+  .match('/some/vanity/url/:productId', res => {
+    renderNextPage('/p/[productId]', res)
+  })
+
+  // Send a synthetic html response
+  .match('/static-html', ({ setResponseHeader, send }) => {
+    setResponseHeader('Content-Type', 'text/html; charset=UTF-8')
+    send('<html><body><h1>Hello world!</h1></body></html>', 200)
+  })
+
+  // match Next.js routes based on the pages directory
+  .use(nextRoutes)
+
+  // fall back to proxying the legacy site
+  .fallback(({ proxy }) => proxy('legacy'))
+```

package/node_modules/@layer0/core/build.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The default build script for Layer0.  Clears the previous build and
+ * builds a .layer0 directory with lambda and s3 subdirectories
+ */
+export default function build(): Promise<void>;

package/node_modules/@layer0/core/build.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file */
+const DeploymentBuilder_1 = __importDefault(require("./deploy/DeploymentBuilder"));
+/**
+ * The default build script for Layer0.  Clears the previous build and
+ * builds a .layer0 directory with lambda and s3 subdirectories
+ */
+async function build() {
+    const builder = new DeploymentBuilder_1.default(process.cwd());
+    builder.clearPreviousBuildOutput();
+    await builder.build();
+}
+exports.default = build;

package/node_modules/@layer0/core/cache/Cache.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import CacheKey from './CacheKey';
+import LRU from 'lru-cache';
+import RequestContext from '../router/RequestContext';
+import Response from '../router/Response';
+/**
+ * We store the responses in the cache differently from their actual
+ * representation because they are different classes in different
+ * execution environments.
+ */
+export interface CachedResponse {
+    /**
+     * The HTTP status code
+     */
+    statusCode?: number;
+    /**
+     * The HTTP status message
+     */
+    statusMessage?: string;
+    /**
+     * The response body as a string or a Buffer
+     */
+    body?: string | Buffer;
+    /**
+     * The response HTTP headers
+     */
+    headers: {
+        [key: string]: string | string[];
+    };
+}
+/**
+ * Must have the LAYER0_CACHE environment variable set.
+ */
+export declare function isCacheEnabled(): boolean;
+/**
+ * Gets the singleton instance of the development response cache
+ */
+export declare function getCache(): LRU<string, CachedResponse>;
+/**
+ * Evicts all entries from the cache
+ */
+export declare function clearCache(): void;
+/**
+ * Returns the cached response for the specified key
+ * @param key The cache key
+ */
+export declare function getCachedResponse(key: CacheKey): CachedResponse | undefined;
+export interface AddToCacheOptions {
+    response: Response;
+    cacheKey: CacheKey;
+    context: RequestContext;
+}
+/**
+ * Writes the response to the cache if x-0-cache-control has a non-zero max-age value.
+ */
+export declare function maybeCacheResponse({ response, cacheKey, context }: AddToCacheOptions): boolean;

package/node_modules/@layer0/core/cache/Cache.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+let cache;
+/**
+ * Must have the LAYER0_CACHE environment variable set.
+ */
+function isCacheEnabled() {
+    return process.env.LAYER0_CACHE === 'true';
+}
+exports.isCacheEnabled = isCacheEnabled;
+/**
+ * Gets the singleton instance of the development response cache
+ */
+function getCache() {
+    if (!cache) {
+        cache = new lru_cache_1.default();
+    }
+    return cache;
+}
+exports.getCache = getCache;
+/**
+ * Evicts all entries from the cache
+ */
+function clearCache() {
+    getCache().reset();
+}
+exports.clearCache = clearCache;
+/**
+ * Returns the cached response for the specified key
+ * @param key The cache key
+ */
+function getCachedResponse(key) {
+    return getCache().get(key.toString());
+}
+exports.getCachedResponse = getCachedResponse;
+/**
+ * Writes the response to the cache if x-0-cache-control has a non-zero max-age value.
+ */
+function maybeCacheResponse({ response, cacheKey, context }) {
+    var _a;
+    const method = (_a = cacheKey.method) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (method && !constants_1.CACHEABLE_METHODS.has(method) && context.cacheRouteMethod !== method) {
+        // POSTs should only be cached when the route explicitly defines the method criteria as POST
+        response.setHeader(constants_1.HTTP_HEADERS.x0CachingStatus, constants_1.CACHING_STATUS.method);
+        return false;
+    }
+    else if (cacheKey.body && Buffer.from(cacheKey.body, 'utf8').length > 8000) {
+        // here we ensure that we're counting bytes by reading the string as utf8, which is a single byte per character
+        // The 8000 character limit is the maximum size fastly can read from the request body
+        response.setHeader(constants_1.HTTP_HEADERS.x0CachingStatus, constants_1.CACHING_STATUS.bodyTooBig);
+        return false;
+    }
+    else if (response.statusCode && response.statusCode >= 400) {
+        // we don't cache statuses 400 and above
+        response.setHeader(constants_1.HTTP_HEADERS.x0CachingStatus, constants_1.CACHING_STATUS.code);
+        return false;
+    }
+    else if (response.getHeader(constants_1.HTTP_HEADERS.setCookie)) {
+        // we don't cache responses with set-cookie headers as they may contain personal data
+        response.setHeader(constants_1.HTTP_HEADERS.x0CachingStatus, constants_1.CACHING_STATUS.setCookie);
+        return false;
+    }
+    const cacheParams = getCacheParams(response);
+    if (cacheParams.private && !context.forcePrivateCaching) {
+        response.setHeader(constants_1.HTTP_HEADERS.x0CachingStatus, constants_1.CACHING_STATUS.private);
+        return false;
+    }
+    else if (cacheParams.maxAge) {
+        getCache().set(cacheKey.toString(), convertToCachedResponse(response), cacheParams.maxAge * 1000);
+        response.setHeader(constants_1.HTTP_HEADERS.x0CachingStatus, constants_1.CACHING_STATUS.ok);
+        return true;
+    }
+    else {
+        response.setHeader(constants_1.HTTP_HEADERS.x0CachingStatus, constants_1.CACHING_STATUS.noMaxAge);
+        return false;
+    }
+}
+exports.maybeCacheResponse = maybeCacheResponse;
+/**
+ * We have to deep clone parts of the
+ * @param response HTTP response that we are caching
+ */
+function convertToCachedResponse(response) {
+    return {
+        statusCode: response.statusCode,
+        statusMessage: response.statusMessage,
+        headers: lodash_clonedeep_1.default(response.getHeaders()),
+        body: response.body,
+    };
+}
+/**
+ * Gets the effective caching settings for the response
+ * @param response The current response
+ */
+function getCacheParams(response) {
+    const defaults = {
+        private: false,
+        maxAge: 0,
+    };
+    return {
+        ...defaults,
+        ...getCacheParamsFromHeader(response.getHeader(constants_1.HTTP_HEADERS.cacheControl)),
+        ...getCacheParamsFromHeader(response.getHeader(constants_1.HTTP_HEADERS.x0CacheControl)),
+    };
+}
+/**
+ * Extracts private and max-age/s-maxage from a cache-control header
+ * @param cacheControl
+ */
+function getCacheParamsFromHeader(cacheControl) {
+    const result = {};
+    if (cacheControl) {
+        if (!Array.isArray(cacheControl)) {
+            cacheControl = [cacheControl];
+        }
+        const values = {};
+        for (let header of cacheControl) {
+            const pairs = header.split(/,\s*/).map(v => v.split(/=/));
+            for (let [name, value] of pairs) {
+                if (name && value) {
+                    values[name.toLowerCase()] = value;
+                }
+                if (name.toLowerCase() === 'private') {
+                    // private has no value
+                    result.private = true;
+                }
+            }
+            result.maxAge = parseInt(values['s-maxage'] || values['max-age'] || '0');
+        }
+    }
+    return result;
+}

package/node_modules/@layer0/core/cache/CacheKey.d.ts

@@ -0,0 +1,52 @@
+import { CustomCacheKey } from '../router';
+import Request from '../router/Request';
+/**
+ * An actual cache key derived from a request per the user's CustomCacheKey specification
+ */
+export default class CacheKey {
+    body?: string;
+    method?: string;
+    pathname: string;
+    query: {
+        [key: string]: string | string[] | undefined;
+    };
+    headers: {
+        [key: string]: string | string[];
+    };
+    cookies: {
+        [key: string]: string | string[];
+    };
+    static create(request: Request, customKey?: CustomCacheKey): CacheKey;
+    constructor(request: Request, customKey?: CustomCacheKey);
+    /**
+     * We always ignore layer0_* query params when computing the cache key so that things like layer0_prefetch don't cache bust
+     * @param query
+     */
+    excludeLayer0QueryParams(query: {
+        [name: string]: string | string[] | undefined;
+    }): {
+        [name: string]: string | string[] | undefined;
+    };
+    /**
+     * Returns an array of values in the object sorted by the key
+     * We sort query params so that different orderings will result in a hit
+     * @param source Any object of key/value pairs, e.g. query, headers, cookies, etc...
+     */
+    toSortedArray(source: {
+        [name: string]: any;
+    }): any[][];
+    /**
+     * Returns the values of the request headers that are by default included in the caching key
+     *
+     * Notes:
+     * - Cache hash calculation has a connascence of algorithm with VCL moov_hash subroutine so if you
+     * are modifying it in any way, you have to modify VCL code generator in the same way. When in doubt
+     * the VCL cache hash calculation takes precendence as it is designed to serve production traffic
+     * and has been battle tested to do so reliably.
+     * - VCL cache hash includes some request/service properties that do no apply in local development:
+     * * build number does not exist for local development
+     * * flush timestamps for gradual flushing do not apply locally
+     */
+    private getDefaultHeaders;
+    toString(): string;
+}

package/node_modules/@layer0/core/cache/CacheKey.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * An actual cache key derived from a request per the user's CustomCacheKey specification
+ */
+class CacheKey {
+    constructor(request, customKey) {
+        var _a;
+        this.cookies = {};
+        const { host } = request.headers;
+        this.body = request.body;
+        this.method = (_a = request.method) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        this.query = this.excludeLayer0QueryParams(request.query || {});
+        this.pathname = new URL(request.url, `http://${host}`).pathname;
+        this.headers = this.getDefaultHeaders(request.headers);
+        if (customKey) {
+            for (let action of customKey.getActions()) {
+                action(this, request);
+            }
+        }
+    }
+    static create(request, customKey) {
+        return new CacheKey(request, customKey);
+    }
+    /**
+     * We always ignore layer0_* query params when computing the cache key so that things like layer0_prefetch don't cache bust
+     * @param query
+     */
+    excludeLayer0QueryParams(query) {
+        const result = {};
+        for (let name in query) {
+            if (!name.startsWith('layer0_')) {
+                result[name] = query[name];
+            }
+        }
+        return result;
+    }
+    /**
+     * Returns an array of values in the object sorted by the key
+     * We sort query params so that different orderings will result in a hit
+     * @param source Any object of key/value pairs, e.g. query, headers, cookies, etc...
+     */
+    toSortedArray(source) {
+        return Object.keys(source)
+            .sort()
+            .map(key => [key, source[key]]);
+    }
+    /**
+     * Returns the values of the request headers that are by default included in the caching key
+     *
+     * Notes:
+     * - Cache hash calculation has a connascence of algorithm with VCL moov_hash subroutine so if you
+     * are modifying it in any way, you have to modify VCL code generator in the same way. When in doubt
+     * the VCL cache hash calculation takes precendence as it is designed to serve production traffic
+     * and has been battle tested to do so reliably.
+     * - VCL cache hash includes some request/service properties that do no apply in local development:
+     * * build number does not exist for local development
+     * * flush timestamps for gradual flushing do not apply locally
+     */
+    getDefaultHeaders(headers) {
+        return {
+            [constants_1.HTTP_HEADERS.host]: headers[constants_1.HTTP_HEADERS.host],
+            [constants_1.HTTP_HEADERS.acceptEncoding]: headers[constants_1.HTTP_HEADERS.acceptEncoding],
+            [constants_1.HTTP_HEADERS.x0Destination]: headers[constants_1.HTTP_HEADERS.x0Destination],
+            [constants_1.HTTP_HEADERS.x0Protocol]: headers[constants_1.HTTP_HEADERS.x0Protocol],
+        };
+    }
+    toString() {
+        return JSON.stringify({
+            pathname: this.pathname,
+            method: this.method,
+            query: this.toSortedArray(this.query),
+            body: hash(this.body),
+            headers: this.toSortedArray(this.headers),
+            cookies: this.toSortedArray(this.cookies),
+        });
+    }
+}
+exports.default = CacheKey;
+/**
+ * Returns the sha256 hash of the provided string as hex
+ * @param data The data to hash
+ */
+function hash(data) {
+    if (!data)
+        return null;
+    const hash = crypto_1.default.createHash('sha256');
+    hash.update(data);
+    return hash.digest('hex');
+}

package/node_modules/@layer0/core/config.d.ts

@@ -0,0 +1,53 @@
+/**
+ * An object containing the config settings. This class is internal, but an instance
+ * can be obtained using.
+ *
+ * ```js
+ * import config from '@layer0/core/config'
+ * ```
+ *
+ * @internal
+ */
+declare class Config {
+    private values?;
+    readonly defaults: {
+        production: boolean;
+        backends: {};
+        includeNodeModules: boolean;
+        routes: string;
+    };
+    /**
+     * Get configuration by key. Will throw an error if no value is configured
+     * @param key The key to grab from the config.
+     * @param fallback A value to return if a value is not configured
+     */
+    get(key: string, fallback?: any): any;
+    /**
+     * Returns true if a value has been configured for a specific key, otherwise false.
+     * @param key The key to test.
+     */
+    has(key: string): boolean;
+    /**
+     * Returns all config values
+     */
+    get all(): any;
+    /**
+     * Loads Layer0 config and sets the current configuration.
+     */
+    private loadLayer0Config;
+    /**
+     * Load configuration from file
+     * @private
+     */
+    private loadFromFile;
+    /**
+     * Load configuration from env var
+     * @private
+     */
+    private loadFromEnv;
+}
+declare const _default: Config;
+/**
+ * Create a Config instance.
+ */
+export default _default;

package/node_modules/@layer0/core/config.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_1 = __importDefault(require("./utils/get"));
+const has_1 = __importDefault(require("./utils/has"));
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("./constants");
+const Validator_1 = __importDefault(require("./utils/Validator"));
+const nonWebpackRequire_1 = __importDefault(require("./utils/nonWebpackRequire"));
+/**
+ * An object containing the config settings. This class is internal, but an instance
+ * can be obtained using.
+ *
+ * ```js
+ * import config from '@layer0/core/config'
+ * ```
+ *
+ * @internal
+ */
+class Config {
+    constructor() {
+        this.defaults = {
+            production: true,
+            backends: {},
+            includeNodeModules: false,
+            routes: ['routes.js', 'routes.ts', 'routes.cjs'].find(file => fs_1.existsSync(path_1.join(process.cwd(), file))) || 'routes.js',
+        };
+    }
+    /**
+     * Get configuration by key. Will throw an error if no value is configured
+     * @param key The key to grab from the config.
+     * @param fallback A value to return if a value is not configured
+     */
+    get(key, fallback) {
+        if (this.has(key)) {
+            return get_1.default(this.values, key);
+        }
+        else if (typeof fallback !== 'undefined') {
+            return fallback;
+        }
+        else {
+            throw new Error(`Layer0 configuration key: "${key}" is not defined`);
+        }
+    }
+    /**
+     * Returns true if a value has been configured for a specific key, otherwise false.
+     * @param key The key to test.
+     */
+    has(key) {
+        if (!this.values)
+            this.loadLayer0Config();
+        return has_1.default(this.values, key);
+    }
+    /**
+     * Returns all config values
+     */
+    get all() {
+        if (!this.values)
+            this.loadLayer0Config();
+        return this.values;
+    }
+    /**
+     * Loads Layer0 config and sets the current configuration.
+     */
+    loadLayer0Config() {
+        const file = this.loadFromFile();
+        const env = this.loadFromEnv();
+        this.values = deepmerge_1.default.all([{}, this.defaults, file, env]);
+    }
+    /**
+     * Load configuration from file
+     * @private
+     */
+    loadFromFile() {
+        const configAbsPath = [
+            path_1.join(process.cwd(), constants_1.LAYER0_CONFIG_FILE),
+            path_1.join(process.cwd(), constants_1.LAYER0_CONFIG_FILE.replace('.js', '.cjs')),
+        ].find(fs_1.existsSync);
+        if (configAbsPath) {
+            try {
+                const fileConfig = nonWebpackRequire_1.default(configAbsPath);
+                return Validator_1.default.validateLayer0FileConfiguration(fileConfig);
+            }
+            catch (e) {
+                throw new Error(`Failed to load ${configAbsPath}: ${e.message}`);
+            }
+        }
+        return {};
+    }
+    /**
+     * Load configuration from env var
+     * @private
+     */
+    loadFromEnv() {
+        if (process.env[constants_1.LAYER0_ENV_VARIABLES.config]) {
+            try {
+                return JSON.parse(process.env[constants_1.LAYER0_ENV_VARIABLES.config]);
+            }
+            catch (e) {
+                throw new Error(`Layer0 configuration variable: ${constants_1.LAYER0_ENV_VARIABLES.config}, is not parsable as json`);
+            }
+        }
+        return {};
+    }
+}
+/**
+ * Create a Config instance.
+ */
+exports.default = new Config();