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

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

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const context_1 = require("./context");
+exports.NOT_ENDED_VALUE = 'na';
+class InternalTiming {
+    /**
+     * @param name The name of the timing component that will be reported in the `x-0-user-t` header
+     */
+    constructor(name, internal = true) {
+        /**
+         * The number of milliseconds elapsed
+         */
+        this.duration = 0;
+        /**
+         * Set to true if the timing has been ended
+         */
+        this.ended = false;
+        this.name = name;
+        const timings = internal ? internalTimings() : userTimings();
+        timings.push(this);
+    }
+    /**
+     * Starts the timing.
+     * @returns A self-reference, suitable for chaining
+     */
+    start() {
+        this.startTime = new Date();
+        this.ended = false;
+        return this;
+    }
+    /**
+     * Sets the discrete value for this timing
+     * @param discreteValue
+     * @returns A self-reference, suitable for chaining
+     */
+    set(discreteValue) {
+        this.discreteValue = discreteValue;
+        return this;
+    }
+    /**
+     * Ends the timing.
+     * @returns A self-reference, suitable for chaining
+     */
+    end() {
+        if (!this.startTime) {
+            console.warn(`Timing ${this.name} not started.`);
+            return this;
+        }
+        this.ended = true;
+        this.duration += new Date().getTime() - this.startTime.getTime();
+        return this;
+    }
+    /**
+     * Convenience method that is the same as `end`, but meant to indicate
+     * that the timing may be resumed later
+     */
+    pause() {
+        return this.end();
+    }
+    /**
+     * Convenience method that is the same as `start`, but meant to indicate
+     * that the timing has been paused.
+     */
+    resume() {
+        return this.start();
+    }
+    /**
+     * Gets the value of the timing for response headers. Will be 'na' if not started, otherwise
+     * the numeric duration in milliseconds.
+     */
+    get value() {
+        if (this.discreteValue != null) {
+            return this.discreteValue;
+        }
+        else {
+            return this.ended ? this.duration : exports.NOT_ENDED_VALUE;
+        }
+    }
+}
+exports.InternalTiming = InternalTiming;
+/**
+ * A higher order function that wraps the provided function in a request context with user
+ * and internal timings reset
+ * @private
+ * @param handler
+ */
+function withTimings(handler) {
+    return (...args) => {
+        return context_1.withContext(() => {
+            return handler(...args);
+        });
+    };
+}
+exports.withTimings = withTimings;
+/**
+ * Returns the value of the internal timing with the specified name
+ * @private
+ * @param name The name of an internal timing, for example "ecc"
+ */
+function getInternalTiming(name) {
+    var _a;
+    return (_a = internalTimings().find(t => t.name === name)) === null || _a === void 0 ? void 0 : _a.value;
+}
+exports.getInternalTiming = getInternalTiming;
+/**
+ * Returns the internal timings from the current request context
+ * @private
+ */
+function internalTimings() {
+    return context_1.get('internalTimings', []);
+}
+/**
+ * Returns the user timings from the current request context
+ * @private
+ */
+function userTimings() {
+    return context_1.get('userTimings', []);
+}
+/**
+ * Adds x-0-t, x-0-user-t, and server-timing headers to the response
+ * @private
+ * @param response
+ */
+function addTimings(response) {
+    const userT = userTimings();
+    const internalT = internalTimings();
+    if (userT.length) {
+        response.setHeader(constants_1.HTTP_HEADERS.x0UserT, getTimingsResponseHeader(userT));
+        response.setHeader(constants_1.HTTP_HEADERS.serverTiming, appendServerTimings(response));
+    }
+    if (internalT.length) {
+        response.setHeader(constants_1.HTTP_HEADERS.x0T, getTimingsResponseHeader(internalT));
+    }
+}
+exports.addTimings = addTimings;
+/**
+ * Gets the value of the x-0-user-t header.
+ * @private
+ */
+function getTimingsResponseHeader(timings) {
+    return timings.map(t => `${t.name}=${t.value}`).join(',');
+}
+/**
+ * Returns the user timings in server-timing response header format
+ * @private
+ */
+function appendServerTimings(response) {
+    const existingHeader = response.getHeader(constants_1.HTTP_HEADERS.serverTiming);
+    const timings = userTimings().map(t => `${t.name};dur=${t.value}`);
+    if (Array.isArray(existingHeader)) {
+        timings.push(...existingHeader);
+    }
+    else if (existingHeader) {
+        timings.push(existingHeader);
+    }
+    return timings.join(', ');
+}
+/**
+ * Allows you to track the performance of your code and asynchronous operations such as fetches.
+ * Timings will be returned as a comma delimited list in the `x-0-user-t` header.
+ *
+ * ** Example **
+ *
+ * ```js
+ * import Timing from '@layer0/core/timing'
+ *
+ * const timing = new Timing('fetch').start()
+ * const result = await fetch('http://my-api.com/products/1')
+ * timing.end() // will result in `x-0-user-t: fetch=(millis)` response header
+ * ```
+ *
+ * If a timing is started but not finished by the time the response is sent, the value will be `na`.
+ */
+class Timing extends InternalTiming {
+    constructor(name) {
+        super(name, false);
+    }
+}
+exports.default = Timing;
+/**
+ * Names for x-0-t components
+ */
+var InternalNames;
+(function (InternalNames) {
+    InternalNames["edgeCache"] = "ecc";
+    InternalNames["transformRequest"] = "wa";
+    InternalNames["transformResponse"] = "wz";
+    InternalNames["routeMatching"] = "wr";
+    InternalNames["proxying"] = "wp";
+})(InternalNames = exports.InternalNames || (exports.InternalNames = {}));
+/**
+ * Values for edgeCache component of x-0-t
+ */
+var CacheValue;
+(function (CacheValue) {
+    CacheValue["hit"] = "hit";
+    CacheValue["pass"] = "pass";
+    CacheValue["cached"] = "cached";
+})(CacheValue = exports.CacheValue || (exports.CacheValue = {}));

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

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

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var transformMethod_1 = require("./transformMethod");
+exports.transformMethod = transformMethod_1.default;

package/node_modules/@layer0/core/transform/transformMethod.d.ts

@@ -0,0 +1,40 @@
+import Request from '../router/Request';
+/**
+ * A function for `transformRequest` that alters the request method to `toMethod`.
+ * The request body is set to the value of the `pref_layer0_body` query parameter.
+ *
+ * **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', ({ cache, proxy }) => {
+ *      cache(cacheConfig)
+ *      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
+ */
+export default function transformMethod(toMethod: string): (request: Request) => void;

package/node_modules/@layer0/core/transform/transformMethod.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+/**
+ * A function for `transformRequest` that alters the request method to `toMethod`.
+ * The request body is set to the value of the `pref_layer0_body` query parameter.
+ *
+ * **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', ({ cache, proxy }) => {
+ *      cache(cacheConfig)
+ *      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
+ */
+function transformMethod(toMethod) {
+    return (request) => {
+        if (request.method !== toMethod) {
+            const url = new URL(`http://dummy.com${request.url}`);
+            // convert the request to a post
+            request.method = toMethod;
+            // get the post body from body query param
+            request.body = url.searchParams.get(constants_1.POST_BODY_QUERY_PARAM) || '';
+            // the backend proxy is now using rawBody property, so we need to create new Buffer with content of body
+            request.rawBody = Buffer.from(request.body, 'utf8');
+            // remove body from the URL
+            url.searchParams.delete(constants_1.POST_BODY_QUERY_PARAM);
+            request.url = url.pathname + url.search;
+        }
+    };
+}
+exports.default = transformMethod;

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

@@ -0,0 +1,102 @@
+import BackendOptions from './router/BackendOptions';
+export interface EdgeConfig {
+    version: string;
+    backends: BackendOptions[];
+    destinations: EdgeDestination[];
+}
+export interface EdgeDestination {
+    index: number;
+    routes: EdgeRule[];
+    errorRoutes: EdgeRule[];
+}
+export interface EdgeRule {
+    path?: string;
+    matchProtocolJavaScriptRegExpSource?: string;
+    match?: (EdgeRegexMatcher | EdgeBodyMatcher)[];
+    route?: EdgeRoute;
+    cache?: EdgeCacheConfig;
+    transform: {
+        request: EdgeTransform[];
+        upstreamResponse: EdgeTransform[];
+        response: EdgeTransform[];
+    };
+    jwtVerification?: JwtVerification;
+}
+export interface EdgeRegexMatcher {
+    value: string;
+    matchRegex: string | null;
+}
+export interface EdgeBodyMatcher {
+    matchBody: string;
+}
+export interface EdgeRoute {
+    action: string;
+    statusCode?: number;
+    statusMessage?: string;
+    backend?: string;
+    content?: string;
+    fallbackToCompute?: boolean;
+    loadingPage?: PathTransform;
+    expiresSeconds?: number;
+    fsPath?: string[];
+    fsExclude?: string[];
+    jwtVerification?: JwtVerification;
+    disableAutoPublish?: boolean;
+}
+export interface EdgeCacheConfig {
+    disabled?: boolean;
+    maxAgeSeconds?: number;
+    staleWhileRevalidateSeconds?: number;
+    customKey?: any;
+    forcePrivateCaching?: boolean;
+}
+export interface PathTransform {
+    valueRegex?: string;
+    replaceValue?: string;
+}
+/**
+ * @typedef {number} JwtAlgo
+ *
+ * JwtAlgos are specified in the "JSON Web Algorithms" RFC #7518
+ *
+ * @enum
+ */
+export declare enum JwtAlgo {
+    /** HMAC using SHA-256, symmetric */
+    HS256 = "HS256",
+    /** HMAC using SHA-384, symmetric */
+    HS384 = "HS384",
+    /** HMAC using SHA-512, symmetric */
+    HS512 = "HS512",
+    /** RSASSA-PKCS1-v1_5 using SHA-256, asymmetric, RSA */
+    RS256 = "RS256",
+    /** RSASSA-PKCS1-v1_5 using SHA-384, asymmetric, RSA */
+    RS384 = "RS384",
+    /** RSASSA-PKCS1-v1_5 using SHA-512, asymmetric, RSA */
+    RS512 = "RS512",
+    /** ECDSA using P-256 and SHA-256, asymmetric, ECDSA */
+    ES256 = "ES256",
+    /** ECDSA using P-384 and SHA-384, asymmetric, ECDSA */
+    ES384 = "ES384",
+    /** ECDSA using P-512 and SHA-512, asymmetric, ECDSA */
+    ES512 = "ES512"
+}
+/**
+ * @ignore
+ *
+ * (See ResponseWriter.VerifyJwtOptions)
+ */
+export interface JwtVerification {
+    algo: JwtAlgo;
+    secret: String;
+    header?: String;
+    cookie?: String;
+    redirectExpiredAbsent?: String;
+    redirectInvalid?: String;
+    returnUrlParamName?: String;
+}
+export interface EdgeTransform extends PathTransform {
+    action: string;
+    name?: string;
+    value?: string;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @typedef {number} JwtAlgo
+ *
+ * JwtAlgos are specified in the "JSON Web Algorithms" RFC #7518
+ *
+ * @enum
+ */
+var JwtAlgo;
+(function (JwtAlgo) {
+    /** HMAC using SHA-256, symmetric */
+    JwtAlgo["HS256"] = "HS256";
+    /** HMAC using SHA-384, symmetric */
+    JwtAlgo["HS384"] = "HS384";
+    /** HMAC using SHA-512, symmetric */
+    JwtAlgo["HS512"] = "HS512";
+    /** RSASSA-PKCS1-v1_5 using SHA-256, asymmetric, RSA */
+    JwtAlgo["RS256"] = "RS256";
+    /** RSASSA-PKCS1-v1_5 using SHA-384, asymmetric, RSA */
+    JwtAlgo["RS384"] = "RS384";
+    /** RSASSA-PKCS1-v1_5 using SHA-512, asymmetric, RSA */
+    JwtAlgo["RS512"] = "RS512";
+    /** ECDSA using P-256 and SHA-256, asymmetric, ECDSA */
+    JwtAlgo["ES256"] = "ES256";
+    /** ECDSA using P-384 and SHA-384, asymmetric, ECDSA */
+    JwtAlgo["ES384"] = "ES384";
+    /** ECDSA using P-512 and SHA-512, asymmetric, ECDSA */
+    JwtAlgo["ES512"] = "ES512";
+})(JwtAlgo = exports.JwtAlgo || (exports.JwtAlgo = {}));

package/node_modules/@layer0/core/utils/Tasks.d.ts

@@ -0,0 +1,32 @@
+export default class Tasks {
+    private readonly _tasks;
+    private _resolveHandler;
+    private _errorHandler;
+    /**
+     * Adds a task to taks array that can be resolved with tasks.resolve()
+     *
+     * @param tasks List of tasks to finish
+     */
+    add(...tasks: (Promise<any> | any)[]): Tasks;
+    /**
+     * Resolve Handler that will be called per each task with resolved value
+     *
+     * @param handler
+     */
+    onTaskDone(handler: Function): this;
+    /**
+     * Error Handler that will be called per each task and can be useful
+     * for ignoring the specific errors
+     *
+     * @param errorHandler
+     */
+    onTaskError(errorHandler: Function): this;
+    /**
+     * Finishes all tasks
+     */
+    resolve(): Promise<any[]>;
+    /**
+     * Returns list of tasks that are converted into promises | functions
+     */
+    private _convertTasksToPromises;
+}

package/node_modules/@layer0/core/utils/Tasks.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Tasks {
+    constructor() {
+        this._tasks = [];
+        this._resolveHandler = Function.prototype;
+        this._errorHandler = (err) => {
+            throw err;
+        };
+    }
+    /**
+     * Adds a task to taks array that can be resolved with tasks.resolve()
+     *
+     * @param tasks List of tasks to finish
+     */
+    add(...tasks) {
+        this._tasks.push(...tasks);
+        return this;
+    }
+    /**
+     * Resolve Handler that will be called per each task with resolved value
+     *
+     * @param handler
+     */
+    onTaskDone(handler) {
+        this._resolveHandler = handler;
+        return this;
+    }
+    /**
+     * Error Handler that will be called per each task and can be useful
+     * for ignoring the specific errors
+     *
+     * @param errorHandler
+     */
+    onTaskError(errorHandler) {
+        this._errorHandler = errorHandler;
+        return this;
+    }
+    /**
+     * Finishes all tasks
+     */
+    resolve() {
+        const promises = this._convertTasksToPromises().map((task, i) => {
+            return task
+                .then((res) => {
+                this._resolveHandler(res);
+                return res;
+            })
+                .catch((err) => {
+                return this._errorHandler(err);
+            });
+        });
+        return Promise.all(promises);
+    }
+    /**
+     * Returns list of tasks that are converted into promises | functions
+     */
+    _convertTasksToPromises() {
+        return this._tasks.map(task => {
+            if (typeof task !== 'function') {
+                return Promise.resolve(task);
+            }
+            // Run the task and check if it returns a promise
+            try {
+                const taskResult = task();
+                if (taskResult instanceof Promise) {
+                    return taskResult;
+                }
+                // sync function results
+                return Promise.resolve(taskResult);
+            }
+            catch (e) {
+                // Return a error promise if sync task fails
+                // This allows to ignore some errors with error handler
+                return Promise.reject(e);
+            }
+        });
+    }
+}
+exports.default = Tasks;

package/node_modules/@layer0/core/utils/Validator.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An object used to validate an layer0 config.
+ *
+ * Example:
+ * ```js
+ * Validator.validateLayer0FileConfiguration(config)
+ * ```
+ */
+declare class Validator {
+    /**
+     * Validates `layer0.config.js`. If the config is validated, it is returned; otherwise,
+     * an error is thrown.
+     * @param config Loaded layer0 configuration
+     * @returns The validated config
+     */
+    static validateLayer0FileConfiguration(config: any): any;
+}
+export default Validator;