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

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

@@ -0,0 +1,196 @@
+"use strict";
+/*
+ * Wrap the stdout/stderr write function to get a JSON output with request metadata
+ * when we are running as a lambda
+ */
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const environment = require('../environment');
+const consoleWrapper_1 = __importStar(require("./consoleWrapper"));
+const layer0OriginalOutputs = {
+    stdoutWrite: process.stdout.write,
+    stderrWrite: process.stderr.write,
+};
+const PINO_ERROR_LEVEL = 50;
+const PINO_INFO_LEVEL = 30;
+let layer0EnabledCount = 0;
+const JSON_LOG_IDENTIFIER = JSON.stringify(consoleWrapper_1.awsCloudWatchTag).replace('{', '').replace('}', '');
+/**
+ * Check if this log is already wrapped into a json payload
+ * @param log
+ */
+function isLayer0JsonLog(log) {
+    return log.indexOf(JSON_LOG_IDENTIFIER) >= 0;
+}
+// Connascence of values with LeDeployer UI: it depends on the values to correctly
+// render the logged request data.
+// Connascence of values with Log Streamr lambda: it depends on these values to
+// correctly apply the filtering,
+const DOWNSTREAM_REQUEST_INFO_LEVEL = 100;
+const DOWNSTREAM_RESPONSE_INFO_LEVEL = 101;
+const UPSTREAM_REQUEST_INFO_LEVEL = 102;
+const UPSTREAM_RESPONSE_INFO_LEVEL = 103;
+const UPSTREAM_RESPONSE_BODY_INFO_LEVEL = 104;
+// Base JSON object for the ongoing request. In AWS lambda all
+// requests are processed serially so we can keep this globally.
+// If we have to make this work for local development, we will
+// have to use "thread local storage".
+let currentBaseJsonObject = {};
+function deepRequestInspectionLogger(instance) {
+    // Logs the HTTP request information at the given level, provided that
+    // the HTTP request logging is globally enabled.
+    // 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 logHttpRequestInfo(data, level) {
+        try {
+            // A global that is ultimately set through the UI in the environment version.
+            if (process.env.LAYER0_HTTP_REQUEST_LOGGING === '1') {
+                layer0OriginalOutputs.stdoutWrite.apply(process.stdout, [
+                    JSON.stringify({
+                        level,
+                        time: Date.now(),
+                        wi: instance.id,
+                        ...currentBaseJsonObject,
+                        data,
+                    }),
+                ]);
+                layer0OriginalOutputs.stdoutWrite.apply(process.stdout, ['\n']);
+            }
+        }
+        catch (e) {
+            // istanbul ignore next
+            console.error(`Error while logging HTTP request info at level ${level}: ${e && e.message}`);
+        }
+    }
+    function logDownstreamRequestInfo(data) {
+        return logHttpRequestInfo(data, DOWNSTREAM_REQUEST_INFO_LEVEL);
+    }
+    function logDownstreamResponseInfo(data) {
+        return logHttpRequestInfo(data, DOWNSTREAM_RESPONSE_INFO_LEVEL);
+    }
+    function logUpstreamRequestInfo(data) {
+        return logHttpRequestInfo(data, UPSTREAM_REQUEST_INFO_LEVEL);
+    }
+    function logUpstreamResponseInfo(data) {
+        return logHttpRequestInfo(data, UPSTREAM_RESPONSE_INFO_LEVEL);
+    }
+    function logUpstreamResponseBodyInfo(data) {
+        return logHttpRequestInfo(data, UPSTREAM_RESPONSE_BODY_INFO_LEVEL);
+    }
+    return {
+        logDownstreamRequestInfo,
+        logDownstreamResponseInfo,
+        logUpstreamRequestInfo,
+        logUpstreamResponseInfo,
+        logUpstreamResponseBodyInfo,
+    };
+}
+exports.deepRequestInspectionLogger = deepRequestInspectionLogger;
+/**
+ * Overrides the given stream #write method so that every chunk
+ * of text sent to that function is wrapped into a JSON object
+ * as a 'msg' attribute.
+ * The rest of the JSON object is defined by baseJsonObject
+ *
+ * @param stream Stream to override
+ * @param baseJsonObject JSON object into which we inject the stream message
+ */
+function jsonifyWriteStream(stream, baseJsonObject) {
+    const originalWrite = stream.write;
+    // @ts-ignore
+    stream.write = function (chunk, ...otherArgs) {
+        // Converts Buffer or Uint8Array to string
+        let convertedChunk;
+        if (typeof chunk === 'object') {
+            convertedChunk = Buffer.from(chunk).toString();
+        }
+        else {
+            convertedChunk = chunk;
+        }
+        const dynamicObject = {
+            time: Date.now(),
+        };
+        // Let JSON pass through without wrapping it again.
+        if (chunk && !isLayer0JsonLog(convertedChunk)) {
+            chunk =
+                JSON.stringify({
+                    ...baseJsonObject,
+                    ...dynamicObject,
+                    msg: convertedChunk,
+                }) + '\n';
+        }
+        // @ts-ignore
+        return originalWrite.apply(stream, [chunk, ...otherArgs]);
+    };
+}
+const stdStreamsWrapper = {
+    /**
+     * Wraps console.xxx methods AND standard streams into a JSON payload that will
+     * be sent back to the final user in the log streaming interface.
+     *
+     * Notes:
+     * - We have to wrap standard streams because some logging libraries (like 'consola')
+     *   writes to those directly without going through console.xxx
+     * - We have to wrap console.xxx methods too, as they don't seem to be bound to
+     *   standard streams in AWS Lambda Environment. That wrapper (using pino) streams
+     *   to process.stdout, leading to the point below.
+     * - Both notes above would result in a double json encapsulation when logging via
+     *   console.xxx methods. We prevent that in our standard stream wrapper by detecting
+     *   a json string that coming from pino logger.
+     */
+    enable: ({ clientIp, requestId, wi, } = {}) => {
+        if (!environment.isCloud()) {
+            return;
+        }
+        if (layer0EnabledCount === 0) {
+            let basePayload = consoleWrapper_1.awsCloudWatchTag;
+            if (clientIp) {
+                basePayload = {
+                    ...basePayload,
+                    clientIp,
+                };
+            }
+            if (requestId) {
+                basePayload = {
+                    ...basePayload,
+                    requestId,
+                };
+            }
+            if (wi) {
+                basePayload = {
+                    ...basePayload,
+                    wi,
+                };
+            }
+            // Since lambda processes the requests serially, we can rely on a global.
+            currentBaseJsonObject = basePayload;
+            // Wrap standard streams as some
+            // As we don't have the same degree of "level" details as console methods, we
+            // assign INFO for stdout and ERROR for stderr
+            jsonifyWriteStream(process.stdout, { level: PINO_INFO_LEVEL, ...basePayload });
+            jsonifyWriteStream(process.stderr, { level: PINO_ERROR_LEVEL, ...basePayload });
+            // Wrap console.xxx methods
+            consoleWrapper_1.default.enable({ clientIp, requestId, wi });
+        }
+        layer0EnabledCount++;
+    },
+    disable: () => {
+        if (!environment.isCloud()) {
+            return;
+        }
+        layer0EnabledCount--;
+        if (layer0EnabledCount === 0) {
+            process.stdout.write = layer0OriginalOutputs.stdoutWrite;
+            process.stderr.write = layer0OriginalOutputs.stderrWrite;
+            currentBaseJsonObject = {};
+            consoleWrapper_1.default.disable();
+        }
+    },
+};
+exports.default = stdStreamsWrapper;

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

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { RequestListener } from 'http';
+import JSBackend from './JSBackend';
+/**
+ * Normalizes the provided server as a JSBackend by returning it if it's already an instance of
+ * JSBackend, or wrapping it in RequestListenerJSBackend if it's a RequestListener
+ * @param server
+ * @param port
+ */
+export default function toJSBackend(server: RequestListener | typeof JSBackend, port: number): JSBackend;

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

@@ -0,0 +1,23 @@
+"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 RequestListenerJSBackend_1 = __importDefault(require("./RequestListenerJSBackend"));
+/**
+ * Normalizes the provided server as a JSBackend by returning it if it's already an instance of
+ * JSBackend, or wrapping it in RequestListenerJSBackend if it's a RequestListener
+ * @param server
+ * @param port
+ */
+function toJSBackend(server, port) {
+    if (JSBackend_1.default.isSubclass(server)) {
+        // @ts-ignore
+        return new server(port);
+    }
+    else {
+        return new RequestListenerJSBackend_1.default(port, server);
+    }
+}
+exports.default = toJSBackend;

package/node_modules/@layer0/core/node_modules/esbuild/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Evan Wallace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,3 @@
+# esbuild
+
+This is a JavaScript bundler and minifier. See https://github.com/evanw/esbuild and the [JavaScript API documentation](https://esbuild.github.io/api/) for details.

package/node_modules/@layer0/core/node_modules/esbuild/bin/esbuild

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
+var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
+var packageDarwin_arm64 = "@esbuild/darwin-arm64";
+var packageDarwin_x64 = "@esbuild/darwin-x64";
+var knownWindowsPackages = {
+  "win32 arm64 LE": "@esbuild/win32-arm64",
+  "win32 ia32 LE": "@esbuild/win32-ia32",
+  "win32 x64 LE": "@esbuild/win32-x64"
+};
+var knownUnixlikePackages = {
+  "aix ppc64 BE": "@esbuild/aix-ppc64",
+  "android arm64 LE": "@esbuild/android-arm64",
+  "darwin arm64 LE": "@esbuild/darwin-arm64",
+  "darwin x64 LE": "@esbuild/darwin-x64",
+  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
+  "freebsd x64 LE": "@esbuild/freebsd-x64",
+  "linux arm LE": "@esbuild/linux-arm",
+  "linux arm64 LE": "@esbuild/linux-arm64",
+  "linux ia32 LE": "@esbuild/linux-ia32",
+  "linux mips64el LE": "@esbuild/linux-mips64el",
+  "linux ppc64 LE": "@esbuild/linux-ppc64",
+  "linux riscv64 LE": "@esbuild/linux-riscv64",
+  "linux s390x BE": "@esbuild/linux-s390x",
+  "linux x64 LE": "@esbuild/linux-x64",
+  "linux loong64 LE": "@esbuild/linux-loong64",
+  "netbsd arm64 LE": "@esbuild/netbsd-arm64",
+  "netbsd x64 LE": "@esbuild/netbsd-x64",
+  "openbsd arm64 LE": "@esbuild/openbsd-arm64",
+  "openbsd x64 LE": "@esbuild/openbsd-x64",
+  "openharmony arm64 LE": "@ohos-ports/esbuild-openharmony-arm64",
+  "sunos x64 LE": "@esbuild/sunos-x64"
+};
+var knownWebAssemblyFallbackPackages = {
+  "android arm LE": "@esbuild/android-arm",
+  "android x64 LE": "@esbuild/android-x64"
+};
+function pkgAndSubpathForCurrentPlatform() {
+  let pkg;
+  let subpath;
+  let isWASM2 = false;
+  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  if (platformKey in knownWindowsPackages) {
+    pkg = knownWindowsPackages[platformKey];
+    subpath = "esbuild.exe";
+  } else if (platformKey in knownUnixlikePackages) {
+    pkg = knownUnixlikePackages[platformKey];
+    subpath = "bin/esbuild";
+  } else if (platformKey in knownWebAssemblyFallbackPackages) {
+    pkg = knownWebAssemblyFallbackPackages[platformKey];
+    subpath = "bin/esbuild";
+    isWASM2 = true;
+  } else {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  return { pkg, subpath, isWASM: isWASM2 };
+}
+function pkgForSomeOtherPlatform() {
+  const libMainJS = __filename; // renamed port: resolve own package via __filename
+  const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
+  if (path.basename(nodeModulesDirectory) === "node_modules") {
+    for (const unixKey in knownUnixlikePackages) {
+      try {
+        const pkg = knownUnixlikePackages[unixKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+    for (const windowsKey in knownWindowsPackages) {
+      try {
+        const pkg = knownWindowsPackages[windowsKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function downloadedBinPath(pkg, subpath) {
+  const esbuildLibDir = __dirname; // renamed port: own lib dir
+  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+function generateBinPath() {
+  if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
+    if (!fs.existsSync(ESBUILD_BINARY_PATH)) {
+      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
+    } else {
+      return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
+    }
+  }
+  const { pkg, subpath, isWASM: isWASM2 } = pkgAndSubpathForCurrentPlatform();
+  let binPath2;
+  try {
+    binPath2 = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    binPath2 = downloadedBinPath(pkg, subpath);
+    if (!fs.existsSync(binPath2)) {
+      try {
+        require.resolve(pkg);
+      } catch {
+        const otherPkg = pkgForSomeOtherPlatform();
+        if (otherPkg) {
+          let suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild on Windows or macOS and copying "node_modules"
+into a Docker image that runs Linux, or by copying "node_modules" between
+Windows and WSL environments.
+
+If you are installing with npm, you can try not copying the "node_modules"
+directory when you copy the files over, and running "npm ci" or "npm install"
+on the destination platform after the copy. Or you could consider using yarn
+instead of npm which has built-in support for installing a package on multiple
+platforms simultaneously.
+
+If you are installing with yarn, you can try listing both this platform and the
+other platform in your ".yarnrc.yml" file using the "supportedArchitectures"
+feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          if (pkg === packageDarwin_x64 && otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 && otherPkg === packageDarwin_x64) {
+            suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild with npm running inside of Rosetta 2 and then
+trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta
+2 is Apple's on-the-fly x86_64-to-arm64 translation service).
+
+If you are installing with npm, you can try ensuring that both npm and node are
+not running under Rosetta 2 and then reinstalling esbuild. This likely involves
+changing how you installed npm and/or node. For example, installing node with
+the universal installer here should work: https://nodejs.org/en/download/. Or
+you could consider using yarn instead of npm which has built-in support for
+installing a package on multiple platforms simultaneously.
+
+If you are installing with yarn, you can try listing both "arm64" and "x64"
+in your ".yarnrc.yml" file using the "supportedArchitectures" feature:
+https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          }
+          throw new Error(`
+You installed esbuild for another platform than the one you're currently using.
+This won't work because esbuild is written with native code and needs to
+install a platform-specific binary executable.
+${suggestions}
+Another alternative is to use the "esbuild-wasm" package instead, which works
+the same way on all platforms. But it comes with a heavy performance cost and
+can sometimes be 10x slower than the "esbuild" package, so you may also not
+want to do that.
+`);
+        }
+        throw new Error(`The package "${pkg}" could not be found, and is needed by esbuild.
+
+If you are installing esbuild with npm, make sure that you don't specify the
+"--no-optional" or "--omit=optional" flags. The "optionalDependencies" feature
+of "package.json" is used by esbuild to install the correct binary executable
+for your current platform.`);
+      }
+      throw e;
+    }
+  }
+  if (/\.zip\//.test(binPath2)) {
+    let pnpapi;
+    try {
+      pnpapi = require("pnpapi");
+    } catch (e) {
+    }
+    if (pnpapi) {
+      const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
+      const binTargetPath = path.join(
+        root,
+        "node_modules",
+        ".cache",
+        "esbuild",
+        `pnpapi-${pkg.replace("/", "-")}-${"0.28.1"}-${path.basename(subpath)}`
+      );
+      if (!fs.existsSync(binTargetPath)) {
+        fs.mkdirSync(path.dirname(binTargetPath), { recursive: true });
+        fs.copyFileSync(binPath2, binTargetPath);
+        fs.chmodSync(binTargetPath, 493);
+      }
+      return { binPath: binTargetPath, isWASM: isWASM2 };
+    }
+  }
+  return { binPath: binPath2, isWASM: isWASM2 };
+}
+
+// lib/npm/node-shim.ts
+var { binPath, isWASM } = generateBinPath();
+if (isWASM) {
+  require("child_process").execFileSync("node", [binPath].concat(process.argv.slice(2)), { stdio: "inherit" });
+} else {
+  require("child_process").execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+}