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

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

@@ -0,0 +1,132 @@
+"use strict";
+// This module has connascence of behavior with the module of the same name in XBP.
+// There are differences in the actual implementation, most notably the use of asynchronous
+// compression which relies on the threadpool rather than blocking the main thread.
+// In lambda we are free to block the main thread as lambda processes the requests serially.
+// In XBP we are not free to block the main thread as it processes many requests concurrently.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib_1 = require("zlib");
+const constants_1 = require("../constants");
+const content_type_1 = require("content-type");
+const isEmpty_1 = __importDefault(require("../utils/isEmpty"));
+const isString_1 = __importDefault(require("../utils/isString"));
+const decode_1 = __importDefault(require("../utils/decode"));
+/**
+ * Those content types that will be gzipped are generated from the lists in:
+ * our Layer0 v1 production Nginx + Layer0 v1 production Varnish + default CDN gzip policy
+ *
+ * Set is not always optimal but in the benchmarks came out on top the most times.
+ * It is also the easiest to read and check for correctness.
+ */
+const COMPRESSIBLE_TYPES = new Set([
+    'application/atom_xml',
+    'application/javascript',
+    'application/json',
+    'application/rss+xml',
+    'application/vnd.ms-fontobject',
+    'application/x-font-opentype',
+    'application/x-font-ttf',
+    'application/x-javascript',
+    'application/xhtml+xml',
+    'application/xml',
+    'application/xml+rss',
+    'font/eot',
+    'font/opentype',
+    'font/otf',
+    'image/svg+xml',
+    'image/x-icon',
+    'text/css',
+    'text/html',
+    'text/javascript',
+    'text/js',
+    'text/plain',
+]);
+/**
+ * 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
+ */
+const adaptResponseEncodingToDownstream = (acceptEncoding, res, response) => {
+    let contentEncoding = res.getHeader(constants_1.HTTP_HEADERS.contentEncoding);
+    // Figure out if we first need to encode anything.
+    if (isEmpty_1.default(acceptEncoding)) {
+        if (!isEmpty_1.default(contentEncoding)) {
+            // Best effort to decode and return the decoded body.
+            decode_1.default(res);
+            response.body = res.body;
+        }
+        return;
+    }
+    const BROTLI_ENCODING_REGEX = /\bbr\b/;
+    const GZIP_ENCODING_REGEX = /\bgzip\b/;
+    const downstreamIsGzipCompatible = GZIP_ENCODING_REGEX.test(acceptEncoding);
+    const downstreamIsBrotliCompatible = BROTLI_ENCODING_REGEX.test(acceptEncoding);
+    if (downstreamIsGzipCompatible && contentEncoding === constants_1.GZIP_ENCODING) {
+        return;
+    }
+    if (downstreamIsBrotliCompatible && contentEncoding === constants_1.BROTLI_ENCODING) {
+        return;
+    }
+    // Try to decode the content. If we cannot decode then we will pass the content
+    // as-is and on the edge we will refuse to cache it (see the logic in upstream
+    // response handling on the edge and specifically the bad-encoding caching status)
+    if (!decode_1.default(res)) {
+        return;
+    }
+    // Since AWS lambda holds multiValueHeaders as array convert string to array
+    let contentType = res.getHeader(constants_1.HTTP_HEADERS.contentType);
+    contentType = isString_1.default(contentType) ? [contentType] : contentType;
+    // Return body if content-type does not exist or match the list of mimes
+    if (!contentType ||
+        !COMPRESSIBLE_TYPES.has(content_type_1.parse(contentType[0]).type.toLowerCase())) {
+        return;
+    }
+    // If request accepts a gzip response, then encode it with gzip.
+    // If request accepts a brotli response, then encoding it with brotli.
+    // If both are acceptable then use gzip which we prefer gzip compression in lambda because
+    // while the lambdas can scale (unlike the edge) the throughout for small un-cached objects
+    // has been observed to drop by 40%.
+    // End developers can work around this default behavior by doing the Brotli compression
+    // themselves and correctly setting the `content-encoding`.
+    let targetContentEncoding;
+    if (downstreamIsGzipCompatible) {
+        targetContentEncoding = constants_1.GZIP_ENCODING;
+    }
+    else if (downstreamIsBrotliCompatible) {
+        targetContentEncoding = constants_1.BROTLI_ENCODING;
+    }
+    // Encode the body.
+    let encodedBody;
+    switch (targetContentEncoding) {
+        case constants_1.BROTLI_ENCODING: {
+            encodedBody = zlib_1.brotliCompressSync(Buffer.from(response.body));
+            break;
+        }
+        case constants_1.GZIP_ENCODING: {
+            encodedBody = zlib_1.gzipSync(Buffer.from(response.body));
+            break;
+        }
+        default: {
+            // We only support gzip and brotli so if neither is supported we just return
+            // the un-encoded response.
+            return;
+        }
+    }
+    // Set the response headers and body.
+    res.setHeader(constants_1.HTTP_HEADERS.contentLength, Buffer.byteLength(encodedBody));
+    res.setHeader(constants_1.HTTP_HEADERS.contentEncoding, targetContentEncoding);
+    response.body = encodedBody;
+};
+exports.default = adaptResponseEncodingToDownstream;

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

@@ -0,0 +1,16 @@
+export declare const awsCloudWatchTag: {
+    awsTag: string;
+};
+export default class ConsoleWrapper {
+    static _assert(condition: boolean | undefined, ...args: any[]): void;
+    static _dir(...args: any[]): void;
+    static _time(label: string): void;
+    static _timeEnd(label: string): void;
+    static _timeLog(label: string, ...args: any[]): void;
+    static enable({ clientIp, requestId, wi, }?: {
+        clientIp?: string;
+        requestId?: string;
+        wi?: string;
+    }): void;
+    static disable(): void;
+}

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

@@ -0,0 +1,127 @@
+"use strict";
+/*
+ * Wrap the console logging functions with 'pino' JSON logger
+ * when we are running as a lambda
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awsCloudWatchTag = { awsTag: 'userLogs' };
+const util = require('util');
+const pino = require('pino');
+// The following console function write to stdout,
+// but we do not support them when running as Lambda.
+// console.count
+// console.countReset
+// console.dirxml
+// console.group
+// console.table
+// Because the enable() and disable() functions can
+// be called multiple, overlapping times, we need to
+// put these two variables into a global.
+// istanbul ignore else
+const layer0OriginalConsole = {
+    assert: console.assert,
+    debug: console.debug,
+    dir: console.dir,
+    error: console.error,
+    info: console.info,
+    log: console.log,
+    time: console.time,
+    timeEnd: console.timeEnd,
+    timeLog: console.timeLog,
+    trace: console.trace,
+    warn: console.warn,
+};
+let _timers = {};
+/**
+ * A function set as `logMethod` in Pino options in order to concatenate
+ * trailing parameters to logging functions. This emulates the behavior
+ * of console.log family of methods.
+ *
+ * More at https://github.com/pinojs/pino/blob/HEAD/docs/api.md#interpolationvalues-any
+ */
+function pinoLogArgConcatenationMethod(args, method) {
+    if (args.length >= 2) {
+        // interpolate all non-string arguments with %j which serializes objects properly
+        // @ts-ignore
+        method.apply(this, [
+            args.map(arg => (typeof arg === 'string' ? '%s' : '%j')).join(' '),
+            ...args,
+        ]);
+    }
+    else {
+        // @ts-ignore
+        method.apply(this, args);
+    }
+}
+class ConsoleWrapper {
+    static _assert(condition, ...args) {
+        if (!condition) {
+            console.info(...args);
+        }
+    }
+    static _dir(...args) {
+        console.info(util.inspect(...args));
+    }
+    static _time(label) {
+        _timers[label] = Date.now();
+    }
+    static _timeEnd(label) {
+        ConsoleWrapper._timeLog(label);
+    }
+    static _timeLog(label, ...args) {
+        if (!_timers[label]) {
+            console.warn(`Warning: No such label '${label}' for console.timeEnd()`);
+            return;
+        }
+        const deltaTime = Date.now() - _timers[label];
+        _timers[label] = Date.now();
+        console.info(`${label}: ${deltaTime}ms`, ...args);
+    }
+    static enable({ clientIp, requestId, wi, } = {}) {
+        _timers = {};
+        let logger = pino({
+            base: {
+                ...exports.awsCloudWatchTag,
+                ...{ wi },
+            },
+            // Changing this to true because we are getting rid of cloudwatch
+            // which used to add timestamps automatically. We should use the log generation time over
+            // log ingestion time anyway because the former is more accurate.
+            timestamp: true,
+            hooks: {
+                logMethod: pinoLogArgConcatenationMethod,
+            },
+        });
+        if (clientIp) {
+            logger = logger.child({ clientIp });
+        }
+        if (requestId) {
+            logger = logger.child({ requestId });
+        }
+        console.assert = ConsoleWrapper._assert;
+        console.debug = logger.debug.bind(logger);
+        console.dir = ConsoleWrapper._dir;
+        console.error = logger.error.bind(logger);
+        console.info = logger.info.bind(logger);
+        console.log = logger.info.bind(logger);
+        console.time = ConsoleWrapper._time;
+        console.timeEnd = ConsoleWrapper._timeEnd;
+        console.timeLog = ConsoleWrapper._timeLog;
+        console.trace = logger.trace.bind(logger);
+        console.warn = logger.warn.bind(logger);
+    }
+    static disable() {
+        console.assert = layer0OriginalConsole.assert;
+        console.debug = layer0OriginalConsole.debug;
+        console.dir = layer0OriginalConsole.dir;
+        console.error = layer0OriginalConsole.error;
+        console.info = layer0OriginalConsole.info;
+        console.log = layer0OriginalConsole.log;
+        console.time = layer0OriginalConsole.time;
+        console.timeEnd = layer0OriginalConsole.timeEnd;
+        console.timeLog = layer0OriginalConsole.timeLog;
+        console.trace = layer0OriginalConsole.trace;
+        console.warn = layer0OriginalConsole.warn;
+    }
+}
+exports.default = ConsoleWrapper;

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

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+export default function getBodyLoggingData(rawBody: string | Buffer[], headers?: any): {
+    body?: undefined;
+    bodyLength?: undefined;
+    bodyTruncated?: undefined;
+} | {
+    body: string;
+    bodyLength: any;
+    bodyTruncated: boolean;
+};

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib_1 = require("zlib");
+const constants_1 = require("../constants");
+// We limit the logged body due to CloudWatch 256Kb per line limitation,
+// CloudWatch costs and, last but not least, websocket exploding on
+// larger sizes.
+// Tests have shown that 8Kb length results in responsive UI with enough
+// captured information.
+const MAX_BODY_LENGTH = 8 * 1024;
+function base64encode(str) {
+    return Buffer.from(str).toString('base64');
+}
+// Gets the content encoding value from the given headers, no matter
+// what case the header has been passed through.
+function getContentEncoding(headers) {
+    if (!headers) {
+        return undefined;
+    }
+    let encoding = headers[constants_1.HTTP_HEADERS.contentEncoding];
+    if (!encoding) {
+        for (let name of Object.keys(headers)) {
+            if (name.toLowerCase() === constants_1.HTTP_HEADERS.contentEncoding) {
+                encoding = headers[name];
+                break;
+            }
+        }
+    }
+    if (Array.isArray(encoding)) {
+        if (encoding.length) {
+            encoding = encoding[0];
+        }
+        else {
+            encoding = undefined;
+        }
+    }
+    return encoding;
+}
+// For the purposes of HTTP request and response logging we log the body.
+// This function returns an object with possibly truncated body, full body
+// length and a flag set to true if the body was truncated.
+// The object is directly included in the HTTP request logging result.
+// This functionn never throws as it is just related to logging and we don't
+// want a request to ever fail due to logging issues.
+function getBodyLoggingData(rawBody, headers) {
+    var _a;
+    try {
+        if (!rawBody || rawBody.length === 0) {
+            return {};
+        }
+        let body;
+        if (typeof rawBody === 'string') {
+            body = Buffer.from(rawBody, 'base64');
+        }
+        else if (Buffer.isBuffer(rawBody)) {
+            body = rawBody;
+        }
+        else if (Array.isArray(rawBody)) {
+            body = Buffer.concat(rawBody);
+        }
+        else {
+            // We don't know what we have so the best we can do is return a user visible error.
+            return {
+                body: base64encode(`Unknown body format: ${typeof rawBody}`),
+                // @ts-ignore
+                bodyLength: rawBody.length,
+                bodyTruncated: true,
+            };
+        }
+        let encoding = (_a = getContentEncoding(headers)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        try {
+            switch (encoding) {
+                case constants_1.GZIP_ENCODING: {
+                    body = zlib_1.gunzipSync(body);
+                    break;
+                }
+                case constants_1.BROTLI_ENCODING: {
+                    body = zlib_1.brotliDecompressSync(body);
+                    break;
+                }
+                default: {
+                    // Nothing to do.
+                }
+            }
+        }
+        catch (e) {
+            return {
+                body: base64encode(`Error while decompressing the body [${encoding}]: ${e.message}`),
+                bodyLength: body.length,
+                bodyTruncated: true,
+            };
+        }
+        return {
+            body: body.slice(0, MAX_BODY_LENGTH).toString('base64'),
+            bodyLength: body.length,
+            bodyTruncated: body.length > MAX_BODY_LENGTH,
+        };
+    }
+    catch (e) {
+        // istanbul ignore next
+        return {
+            body: base64encode(`Error while getting body logging data: ${e && e.message}`),
+            bodyLength: rawBody.length,
+            bodyTruncated: true,
+        };
+    }
+}
+exports.default = getBodyLoggingData;

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

@@ -0,0 +1 @@
+export declare function handler(event: any): Promise<any>;