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

package/node_modules/@layer0/core/edge/createEdgeConfig.js

@@ -0,0 +1,284 @@
+"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 toEdgeRegex_1 = __importDefault(require("../utils/toEdgeRegex"));
+const toHttpMethodMatchRegex_1 = __importDefault(require("../utils/toHttpMethodMatchRegex"));
+const convertStringMatcherToRegex_1 = __importDefault(require("../utils/convertStringMatcherToRegex"));
+const EdgeResponseWriter_1 = __importDefault(require("./EdgeResponseWriter"));
+const constants_1 = require("../constants");
+const RequestContext_1 = __importDefault(require("../router/RequestContext"));
+const universalRouteUtils_1 = require("../router/universalRouteUtils");
+const EdgeErrorPageResponseWriter_1 = __importDefault(require("./EdgeErrorPageResponseWriter"));
+/**
+ * Returns cache object
+ *
+ * Notes:
+ * - Method caching is only allowed when it's explicit:
+ * 1. The matching was explicitly done on `post` and other methods and
+ * 2. The caching properties were defined on the same route.
+ *
+ * @private
+ */
+function buildRouteCacheKeysFromEdgeWriter({ edgeConfig }, matchExplicitMethod) {
+    var _a, _b;
+    // istanbul ignore next - edgeConfig.cache?.maxAgeSeconds is apparently untestable as it always shows as uncovered
+    if (edgeConfig.cache && ((_a = edgeConfig.cache) === null || _a === void 0 ? void 0 : _a.maxAgeSeconds) &&
+        ((_b = edgeConfig.cache) === null || _b === void 0 ? void 0 : _b.maxAgeSeconds) > 0 &&
+        matchExplicitMethod) {
+        return {
+            ...edgeConfig.cache,
+            matchExplicitMethod,
+        };
+    }
+    return edgeConfig.cache;
+}
+/**
+ * Returns route action
+ * @private
+ */
+function buildRouteActionFromEdgeWriter({ edgeConfig }, isErrorRoute) {
+    var _a;
+    const route = edgeConfig.route;
+    // On error routes we don't use the default statusCode since we must preserve the status code
+    // of the error route.
+    if (((_a = edgeConfig.route) === null || _a === void 0 ? void 0 : _a.action) === constants_1.ACTIONS.syntheticRes &&
+        !edgeConfig.route.statusCode &&
+        !isErrorRoute) {
+        edgeConfig.route.statusCode = 200;
+    }
+    return route;
+}
+/**
+ * Returns transformation object
+ * @private
+ */
+function buildTransformFromEdgeWriter({ edgeConfig }) {
+    return edgeConfig.transform;
+}
+/**
+ * Returns the jwtVerification object (if any) validation is performed earlier
+ * @private
+ */
+function buildVerifyJwtFromEdgeWriter({ edgeConfig, }) {
+    return edgeConfig.jwtVerification;
+}
+function transformBodyCriteria(obj) {
+    return Object.entries(obj).reduce((memo, [key, value]) => {
+        if (value instanceof RegExp) {
+            memo[key] = convertStringMatcherToRegex_1.default(value);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            memo[key] = transformBodyCriteria(value);
+        }
+        else {
+            memo[key] = convertStringMatcherToRegex_1.default(value);
+        }
+        return memo;
+    }, {});
+}
+/**
+ * Build Outer Edge match configuration
+ *
+ * Notes:
+ * - When resulting array is empty, it means that all requests should match
+ * - If method matching is set to explicit method then set it in `matchExplicitMethod`
+ * - All routes have implicit https protocol, so only if a criteria has explicitly been
+ * set to http do we match for that protocol, otherwise we match https.
+ *
+ * @param route
+ * @returns An array of match criteria
+ * @private
+ */
+function buildMatcherFromRoute(route) {
+    var _a;
+    const match = [];
+    const matchResp = [];
+    let matchProtocolJavaScriptRegExpSource;
+    let matchExplicitMethod;
+    if (route.criteria.protocol) {
+        let regex;
+        // 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.
+        if (typeof route.criteria.protocol === 'string') {
+            regex = new RegExp(`^${route.criteria.protocol}$`, 'i');
+        }
+        else {
+            regex = new RegExp(route.criteria.protocol);
+        }
+        if (!regex.test('http') && !regex.test('https')) {
+            throw new Error('Protocol matcher must match either "http" or "https"');
+        }
+        matchProtocolJavaScriptRegExpSource = regex.source;
+    }
+    if (route.criteria.path) {
+        match.push({
+            value: '${path}',
+            matchRegex: route.toEdgeRegexString(),
+        });
+    }
+    if (route.criteria.method) {
+        let matchRegex;
+        if (typeof route.criteria.method !== 'string') {
+            matchRegex = route.criteria.method;
+        }
+        else {
+            matchRegex = toHttpMethodMatchRegex_1.default(route.criteria.method);
+            if (Object.values(constants_1.HTTP_METHODS).includes(route.criteria.method)) {
+                matchExplicitMethod = route.criteria.method;
+            }
+        }
+        match.push({
+            value: '${method}',
+            matchRegex: toEdgeRegex_1.default(matchRegex),
+        });
+    }
+    if (route.criteria.headers) {
+        Object.entries(route.criteria.headers).forEach(([name, value]) => {
+            match.push({
+                value: `\${req:${name}}`,
+                matchRegex: convertStringMatcherToRegex_1.default(value),
+            });
+        });
+    }
+    // Match is executed on deliver phase. This is required for error pages.
+    if ((_a = route.criteria.response) === null || _a === void 0 ? void 0 : _a.statusCode) {
+        matchResp.push({
+            value: `\${res:status}`,
+            matchRegex: toEdgeRegex_1.default(route.criteria.response.statusCode),
+        });
+    }
+    if (route.criteria.query) {
+        Object.entries(route.criteria.query).forEach(([name, value]) => {
+            // Dynamic query matcher (ex: { query: { id: ':id' } }) don't need to be
+            // strictly matched against the route. They can be present or not.
+            if (universalRouteUtils_1.isParamMatcher(value))
+                return;
+            match.push({
+                value: `\${query:${name}}`,
+                matchRegex: convertStringMatcherToRegex_1.default(value),
+            });
+        });
+    }
+    if (route.criteria.cookies) {
+        Object.entries(route.criteria.cookies).forEach(([name, value]) => {
+            match.push({
+                value: `\${req:cookie:${name}}`,
+                matchRegex: convertStringMatcherToRegex_1.default(value),
+            });
+        });
+    }
+    if (route.criteria.body) {
+        match.push({
+            matchBody: JSON.stringify({
+                parse: route.criteria.body.parse,
+                criteria: transformBodyCriteria(route.criteria.body.criteria),
+            }),
+        });
+    }
+    return {
+        match,
+        matchResp,
+        matchExplicitMethod,
+        matchProtocolJavaScriptRegExpSource,
+    };
+}
+/**
+ * Creates an outer edge manager config for the specified router by iterating through
+ * each route and calling it with a mock request
+ * and response.
+ * @param router
+ * @return An object containing the Edge config
+ */
+async function createEdgeConfig(router) {
+    let destinations = {};
+    if (!Object.keys(router.getDestinations()).length) {
+        destinations = {
+            default: await createDestination(router),
+        };
+    }
+    else {
+        for (let d in router.getDestinations()) {
+            destinations[d] = await createDestination(router.getDestinations()[d]);
+        }
+    }
+    return {
+        version: getLayer0Version(),
+        backends: {
+            ...config_1.default.get('backends'),
+        },
+        destinations,
+    };
+}
+exports.default = createEdgeConfig;
+/**
+ * Gets the version of @layer0/core.  For this to work in testing an entry needed
+ * to be added to moduleNameMapper in the jest config specifically for package.json
+ * @return {String}
+ */
+function getLayer0Version() {
+    // We purposefully don't override this version so that we can see in edge
+    // responses the *exact* version with which the edge was built.
+    return require('../package.json').version;
+}
+async function createDestinationMapFunction(route, writer, faultyRoutes, isErrorRoute) {
+    try {
+        // @ts-ignore
+        await route.handler(writer);
+    }
+    catch (e) {
+        Error.captureStackTrace(e);
+        faultyRoutes.push({
+            route: route.toString(),
+            stackTrace: e.stack,
+        });
+    }
+    const { match, matchResp, matchExplicitMethod, matchProtocolJavaScriptRegExpSource } = buildMatcherFromRoute(route);
+    return {
+        // used when building .layer0 to assemble the s3 directory structure
+        path: route.criteria.path,
+        // Consumed by Cache metrics to build the route string
+        routeJson: route.toJson(),
+        match,
+        matchResp,
+        matchProtocolJavaScriptRegExpSource,
+        cache: buildRouteCacheKeysFromEdgeWriter(writer, matchExplicitMethod),
+        route: buildRouteActionFromEdgeWriter(writer, isErrorRoute),
+        transform: buildTransformFromEdgeWriter(writer),
+        jwtVerification: buildVerifyJwtFromEdgeWriter(writer),
+    };
+}
+async function createDestination(router) {
+    const faultyRoutes = [];
+    const destination = {
+        index: router.index,
+        errorRoutes: await Promise.all(router
+            .getRouteGroups()
+            .getRoutes()
+            .filter(route => route.isRespRoute())
+            .map(route => createDestinationMapFunction(route, new EdgeErrorPageResponseWriter_1.default({
+            url: '',
+            headers: {},
+        }, {}, route, new RequestContext_1.default()), faultyRoutes, true))),
+        routes: await Promise.all(router
+            .getRouteGroups()
+            .getRoutes()
+            .filter(route => !route.isRespRoute())
+            .map(route => createDestinationMapFunction(route, new EdgeResponseWriter_1.default({
+            url: '',
+            headers: {},
+        }, {}, route, new RequestContext_1.default()), faultyRoutes, false))),
+    };
+    // If any faulty routes occured, throw error with all faulty routes listed
+    if (faultyRoutes.length) {
+        let errorMessage = '\nErrors occurred while attempting to deploy your application to Layer0 edge.' +
+            `\nThe following ${faultyRoutes.length > 1 ? 'routes' : 'route'} could not be processed:`;
+        faultyRoutes.forEach(({ route, stackTrace }) => {
+            errorMessage = errorMessage.concat(`\n* ${route}: ${stackTrace}`);
+        });
+        throw new Error(errorMessage);
+    }
+    return destination;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Used to determine if the app is running in the cloud.
+ * @returns `true` when running in the cloud, `false` otherwise
+ */
+export declare function isCloud(): boolean;
+/**
+ * Returns true when running locally, either in dev or production mode
+ */
+export declare function isLocal(): boolean;
+/**
+ * Used to determine if the app is running on a production build.
+ * @returns `true` when running a production build, either locally or in the cloud; `false` otherwise
+ */
+export declare function isProductionBuild(): boolean;
+/**
+ * Used to determine if the app is running in `layer0 run` development environment
+ * @returns `true` when running with `layer0 run`without production flag, `false` otherwise
+ */
+export declare function isLayer0RunDev(): boolean;
+/**
+ * Determines whether or not we are running in a browser
+ * @returns `true` when running in a browser, otherwise false
+ */
+export declare function isBrowser(): boolean;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+/**
+ * Used to determine if the app is running in the cloud.
+ * @returns `true` when running in the cloud, `false` otherwise
+ */
+function isCloud() {
+    return process.env[constants_1.LAYER0_ENV_VARIABLES.deploymentType] === constants_1.LAYER0_DEPLOYMENT_TYPE_AWS;
+}
+exports.isCloud = isCloud;
+/**
+ * Returns true when running locally, either in dev or production mode
+ */
+function isLocal() {
+    return process.env.LAYER0_LOCAL === 'true';
+}
+exports.isLocal = isLocal;
+/**
+ * Used to determine if the app is running on a production build.
+ * @returns `true` when running a production build, either locally or in the cloud; `false` otherwise
+ */
+function isProductionBuild() {
+    return process.env.NODE_ENV === 'production';
+}
+exports.isProductionBuild = isProductionBuild;
+/**
+ * Used to determine if the app is running in `layer0 run` development environment
+ * @returns `true` when running with `layer0 run`without production flag, `false` otherwise
+ */
+function isLayer0RunDev() {
+    return !isCloud() && !isProductionBuild();
+}
+exports.isLayer0RunDev = isLayer0RunDev;
+/**
+ * Determines whether or not we are running in a browser
+ * @returns `true` when running in a browser, otherwise false
+ */
+function isBrowser() {
+    return typeof window !== 'undefined';
+}
+exports.isBrowser = isBrowser;

package/node_modules/@layer0/core/errors/BackendFetchError.d.ts

@@ -0,0 +1,11 @@
+/**
+ * To be thrown when failing to connect to a backend.
+ */
+export default class BackendFetchError extends Error {
+    readonly cause: Error;
+    readonly type = "BackendFetchError";
+    /**
+     * @param cause The root error emitted by http/https.request
+     */
+    constructor(cause: Error);
+}

package/node_modules/@layer0/core/errors/BackendFetchError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file - For some reason the constructor can't get 100% coverage on the super call */
+/**
+ * To be thrown when failing to connect to a backend.
+ */
+class BackendFetchError extends Error {
+    /**
+     * @param cause The root error emitted by http/https.request
+     */
+    constructor(cause) {
+        super(cause.message);
+        this.type = 'BackendFetchError';
+        this.cause = cause;
+    }
+}
+exports.default = BackendFetchError;

package/node_modules/@layer0/core/errors/FrameworkBuildError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * To be thrown when the user's application fails to build.
+ */
+export default class FrameworkBuildError extends Error {
+    readonly isUserError = true;
+    constructor(framework: string, command: string, error?: any);
+}

package/node_modules/@layer0/core/errors/FrameworkBuildError.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const v8_1 = __importDefault(require("v8"));
+/**
+ * To be thrown when the user's application fails to build.
+ */
+class FrameworkBuildError extends Error {
+    constructor(framework, command, error) {
+        super(`${framework} build command "${command}" failed. This is most likely due to an error in your application code and not a problem with Layer0. Try running "${command}" on your CLI`); // istanbul ignore next - this is a known issue with TypeScript
+        this.isUserError = true;
+        if (error && error.message.includes('JavaScript heap out of memory')) {
+            const currentMemoryLimit = v8_1.default.getHeapStatistics().total_available_size;
+            const memoryInMb = (+currentMemoryLimit * 2) / (1024 * 1024);
+            this.message = `Node.js ran out of memory while attempting to build your app.
+Currently Node processes are capped at ${currentMemoryLimit} bytes of memory.
+You can raise this limit by setting the following environment variable in your shell initialization script:
+
+  NODE_OPTIONS=--max_old_space_size=${Math.round(memoryInMb)}
+`;
+        }
+    }
+}
+exports.default = FrameworkBuildError;

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

@@ -0,0 +1,3 @@
+export * from './router';
+export * from './constants';
+export { default as config } from './config';

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

@@ -0,0 +1,9 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./router"));
+__export(require("./constants"));
+var config_1 = require("./config");
+exports.config = config_1.default;

package/node_modules/@layer0/core/init/addToPackageJson.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Merges the provided config into package.json and writes the result to disk.
+ * @param contents The config to add
+ * @param overwrite True to overwrite any values that already exist in the package.json file
+ * @return The resulting package.json contents as an object
+ */
+export default function addToPackageJson(contents: any, overwrite?: boolean): any;

package/node_modules/@layer0/core/init/addToPackageJson.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+/**
+ * Merges the provided config into package.json and writes the result to disk.
+ * @param contents The config to add
+ * @param overwrite True to overwrite any values that already exist in the package.json file
+ * @return The resulting package.json contents as an object
+ */
+function addToPackageJson(contents, overwrite = true) {
+    const file = path_1.join(process.cwd(), 'package.json');
+    let packageContents = JSON.parse(fs_1.readFileSync(file, 'utf8'));
+    packageContents = overwrite ? deepmerge_1.default(packageContents, contents) : deepmerge_1.default(contents, packageContents);
+    fs_1.writeFileSync(file, JSON.stringify(packageContents, null, 2), 'utf8');
+    return packageContents;
+}
+exports.default = addToPackageJson;

package/node_modules/@layer0/core/init/index.d.ts

@@ -0,0 +1,2 @@
+export { default as addToPackageJson } from './addToPackageJson';
+export { default } from './init';

package/node_modules/@layer0/core/init/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var addToPackageJson_1 = require("./addToPackageJson");
+exports.addToPackageJson = addToPackageJson_1.default;
+var init_1 = require("./init");
+exports.default = init_1.default;

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

@@ -0,0 +1,5 @@
+/**
+ * Adds all required dependencies and files to the user's app by copying them
+ * over from src/default-app.
+ */
+export default function init(): void;

package/node_modules/@layer0/core/init/init.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"));
+const path_1 = require("path");
+/**
+ * Adds all required dependencies and files to the user's app by copying them
+ * over from src/default-app.
+ */
+function init() {
+    const builder = new DeploymentBuilder_1.default(process.cwd());
+    builder.addDefaultAppResources(path_1.join(__dirname, '..', 'default-app'));
+}
+exports.default = init;

package/node_modules/@layer0/core/lambda/JSBackend.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Base class that all framework integration packages should implement to start a
+ * server instance of the framework to which requests can be proxied as the __js__ backend.
+ */
+export default class JSBackend {
+    protected readonly port: number;
+    private started;
+    static readonly __type__ = "JSBackend";
+    /**
+     * Returns true if the provided class extends JSBackend.
+     * @param obj A class
+     */
+    static isSubclass(obj: any): boolean;
+    /**
+     * @param port The port to which the server instance should bind.
+     */
+    constructor(port: number);
+    /**
+     * Starts the app's server build. We don't start the app if the target port is already
+     * taken. This will be the case when using layer0 run --serverless to emulate the cloud locally,
+     * since serverless-offline sandboxes the app in such a way that it's difficult to keep
+     * track of whether or not the app has been started - checking the port is the easiest way -
+     * and it will attempt to start the app on every request.
+     */
+    start(): Promise<void>;
+    /**
+     * Subclasses must override this method to implement starting the app's server build.
+     */
+    protected doStart(): Promise<void>;
+}

package/node_modules/@layer0/core/lambda/JSBackend.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tcp_port_used_1 = __importDefault(require("tcp-port-used"));
+let started = false;
+/**
+ * Base class that all framework integration packages should implement to start a
+ * server instance of the framework to which requests can be proxied as the __js__ backend.
+ */
+class JSBackend {
+    /**
+     * @param port The port to which the server instance should bind.
+     */
+    constructor(port) {
+        this.started = false;
+        this.port = port;
+    }
+    /**
+     * Returns true if the provided class extends JSBackend.
+     * @param obj A class
+     */
+    static isSubclass(obj) {
+        return obj.__type__ == 'JSBackend';
+    }
+    /**
+     * Starts the app's server build. We don't start the app if the target port is already
+     * taken. This will be the case when using layer0 run --serverless to emulate the cloud locally,
+     * since serverless-offline sandboxes the app in such a way that it's difficult to keep
+     * track of whether or not the app has been started - checking the port is the easiest way -
+     * and it will attempt to start the app on every request.
+     */
+    async start() {
+        if (started || (await tcp_port_used_1.default.check(this.port))) {
+            return;
+        }
+        else {
+            started = true;
+            await this.doStart();
+        }
+    }
+    /**
+     * Subclasses must override this method to implement starting the app's server build.
+     */
+    async doStart() {
+        throw new Error('Subclasses must override the doStart method.');
+    }
+}
+exports.default = JSBackend;
+JSBackend.__type__ = 'JSBackend';

package/node_modules/@layer0/core/lambda/RequestListenerJSBackend.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import JSBackend from './JSBackend';
+import { RequestListener } from 'http';
+export default class RequestListenerJSBackend extends JSBackend {
+    private listener;
+    constructor(port: number, listener: RequestListener);
+    doStart(): Promise<void>;
+}

package/node_modules/@layer0/core/lambda/RequestListenerJSBackend.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSBackend_1 = __importDefault(require("./JSBackend"));
+const http_1 = require("http");
+class RequestListenerJSBackend extends JSBackend_1.default {
+    constructor(port, listener) {
+        super(port);
+        this.listener = listener;
+    }
+    async doStart() {
+        return new Promise(resolve => {
+            http_1.createServer(this.listener).listen(this.port, resolve);
+        });
+    }
+}
+exports.default = RequestListenerJSBackend;

package/node_modules/@layer0/core/lambda/adaptResponseEncodingToDownstream.d.ts

@@ -0,0 +1,17 @@
+import Response from '../router/Response';
+/**
+ * Adapts the response body to the downstream accept encoding. This may mean:
+ * a) Not doing anything if the downstream accept encoding the content encoding are compatible.
+ * b) Compressing the response body to a downstream compatible encoding, if response body has no encoding.
+ * c) Decompressing the response body from downstream incompatible encoding and optionally re-compressing it
+ * to downstream compatible encoding.
+ *
+ * If any compression is done by this function, then the content-encoding and content-length headers will
+ * correspond to the new encoding/length of the response body.
+ *
+ * @param acceptEncoding Value of downstream accept-encoding header
+ * @param res HttpResponse object
+ * @param response Lambda response object
+ */
+declare const adaptResponseEncodingToDownstream: (acceptEncoding: string, res: Response, response: any) => void;
+export default adaptResponseEncodingToDownstream;