@middy/util 2.5.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2021 Luciano Mammino, will Farrell and the [Middy team](https://github.com/middyjs/middy/graphs/contributors)
+
+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/README.md

@@ -0,0 +1,54 @@
+# Middy Util
+
+<div align="center">
+  <img alt="Middy logo" src="https://raw.githubusercontent.com/middyjs/middy/main/docs/img/middy-logo.png"/>
+</div>
+
+<div align="center">
+  <p><strong>Util component of the middy middleware, the stylish Node.js middleware engine for AWS Lambda</strong></p>
+</div>
+
+<div align="center">
+<p>
+  <a href="http://badge.fury.io/js/%40middy%2Futil">
+    <img src="https://badge.fury.io/js/%40middy%2Futil.svg" alt="npm version" style="max-width:100%;">
+  </a>
+  <a href="https://snyk.io/test/github/middyjs/middy">
+    <img src="https://snyk.io/test/github/middyjs/middy/badge.svg" alt="Known Vulnerabilities" data-canonical-src="https://snyk.io/test/github/middyjs/middy" style="max-width:100%;">
+  </a>
+  <a href="https://standardjs.com/">
+    <img src="https://img.shields.io/badge/code_style-standard-brightgreen.svg" alt="Standard Code Style"  style="max-width:100%;">
+  </a>
+  <a href="https://gitter.im/middyjs/Lobby">
+    <img src="https://badges.gitter.im/gitterHQ/gitter.svg" alt="Chat on Gitter"  style="max-width:100%;">
+  </a>
+</p>
+</div>
+
+
+## Install
+
+To install middy you can use NPM:
+
+```bash
+npm install --save @middy/util
+```
+
+
+## Documentation and examples
+
+For documentation and examples, refers to the main [Middy monorepo on GitHub](https://github.com/middyjs/middy) or [Middy official website](https://middy.js.org).
+
+
+## Contributing
+
+Everyone is very welcome to contribute to this repository. Feel free to [raise issues](https://github.com/middyjs/middy/issues) or to [submit Pull Requests](https://github.com/middyjs/middy/pulls).
+
+
+## License
+
+Licensed under [MIT License](LICENSE). Copyright (c) 2017-2021 Luciano Mammino, will Farrell, and the [Middy team](https://github.com/middyjs/middy/graphs/contributors).
+
+<a href="https://app.fossa.io/projects/git%2Bgithub.com%2Fmiddyjs%2Fmiddy?ref=badge_large">
+  <img src="https://app.fossa.io/api/projects/git%2Bgithub.com%2Fmiddyjs%2Fmiddy.svg?type=large" alt="FOSSA Status"  style="max-width:100%;">
+</a>

package/codes.json

@@ -0,0 +1,66 @@
+{
+  "100": "Continue",
+  "101": "Switching Protocols",
+  "102": "Processing",
+  "103": "Early Hints",
+  "200": "OK",
+  "201": "Created",
+  "202": "Accepted",
+  "203": "Non-Authoritative Information",
+  "204": "No Content",
+  "205": "Reset Content",
+  "206": "Partial Content",
+  "207": "Multi-Status",
+  "208": "Already Reported",
+  "226": "IM Used",
+  "300": "Multiple Choices",
+  "301": "Moved Permanently",
+  "302": "Found",
+  "303": "See Other",
+  "304": "Not Modified",
+  "305": "Use Proxy",
+  "306": "(Unused)",
+  "307": "Temporary Redirect",
+  "308": "Permanent Redirect",
+  "400": "Bad Request",
+  "401": "Unauthorized",
+  "402": "Payment Required",
+  "403": "Forbidden",
+  "404": "Not Found",
+  "405": "Method Not Allowed",
+  "406": "Not Acceptable",
+  "407": "Proxy Authentication Required",
+  "408": "Request Timeout",
+  "409": "Conflict",
+  "410": "Gone",
+  "411": "Length Required",
+  "412": "Precondition Failed",
+  "413": "Payload Too Large",
+  "414": "URI Too Long",
+  "415": "Unsupported Media Type",
+  "416": "Range Not Satisfiable",
+  "417": "Expectation Failed",
+  "418": "I'm a teapot",
+  "421": "Misdirected Request",
+  "422": "Unprocessable Entity",
+  "423": "Locked",
+  "424": "Failed Dependency",
+  "425": "Unordered Collection",
+  "426": "Upgrade Required",
+  "428": "Precondition Required",
+  "429": "Too Many Requests",
+  "431": "Request Header Fields Too Large",
+  "451": "Unavailable For Legal Reasons",
+  "500": "Internal Server Error",
+  "501": "Not Implemented",
+  "502": "Bad Gateway",
+  "503": "Service Unavailable",
+  "504": "Gateway Timeout",
+  "505": "HTTP Version Not Supported",
+  "506": "Variant Also Negotiates",
+  "507": "Insufficient Storage",
+  "508": "Loop Detected",
+  "509": "Bandwidth Limit Exceeded",
+  "510": "Not Extended",
+  "511": "Network Authentication Required"
+}

package/index.d.ts

@@ -0,0 +1,47 @@
+import middy from '@middy/core'
+import { captureAWSClient } from 'aws-xray-sdk'
+
+interface Options<Client, ClientOptions> {
+  AwsClient?: new() => Client
+  awsClientOptions?: Partial<ClientOptions>
+  awsClientAssumeRole?: string
+  awsClientCapture?: typeof captureAWSClient
+  fetchData?: { [key: string]: string }
+  disablePrefetch?: boolean
+  cacheKey?: string
+  cacheExpiry?: number
+  setToEnv?: boolean
+  setToContext?: boolean
+}
+
+type HttpError = Error & {
+  status: number
+  statusCode: number
+  expose: boolean
+  [key: string]: any
+  [key: number]: any
+}
+
+declare function createPrefetchClient<Client, ClientOptions> (options: Options<Client, ClientOptions>): Client
+
+declare function createClient<Client, ClientOptions> (options: Options<Client, ClientOptions>, request: middy.Request): Client
+
+declare function canPrefetch<Client, ClientOptions> (options: Options<Client, ClientOptions>): boolean
+
+declare function getInternal (variables: any, request: middy.Request): Promise<any>
+
+declare function sanitizeKey (key: string): string
+
+declare function processCache<Client, ClientOptions> (options: Options<Client, ClientOptions>, fetch: (request: middy.Request) => any, request: middy.Request): { value: any, expiry: number }
+
+declare function getCache (keys: string): any
+
+declare function clearCache (keys?: string | string[] | null): void
+
+declare function jsonSafeParse (string: string, reviver?: (key: string, value: any) => any): any
+
+declare function normalizeHttpResponse (response: any, fallbackResponse?: any): any
+
+declare function createError (code: number, message: string, properties?: Record<string, any>): HttpError
+
+declare function modifyCache (cacheKey: string, value: any): void

package/index.js

@@ -0,0 +1,275 @@
+"use strict";
+
+const {
+  Agent
+} = require('https'); // const { NodeHttpHandler } = require('@aws-sdk/node-http-handler') // aws-sdk v3
+
+
+const awsClientDefaultOptions = {
+  // AWS SDK v3
+  // Docs: https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/enforcing-tls.html
+
+  /* requestHandler: new NodeHttpHandler({
+    httpsAgent: new Agent(
+      {
+        secureProtocol: 'TLSv1_2_method'
+      }
+    )
+  }) */
+  // Docs: https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/enforcing-tls.html
+  httpOptions: {
+    agent: new Agent({
+      secureProtocol: 'TLSv1_2_method'
+    })
+  }
+};
+
+const createPrefetchClient = options => {
+  const awsClientOptions = { ...awsClientDefaultOptions,
+    ...options.awsClientOptions
+  };
+  const client = new options.AwsClient(awsClientOptions); // AWS XRay
+
+  if (options.awsClientCapture) {
+    return options.awsClientCapture(client);
+  }
+
+  return client;
+};
+
+const createClient = async (options, request) => {
+  let awsClientCredentials = {}; // Role Credentials
+
+  if (options.awsClientAssumeRole) {
+    if (!request) throw new Error('Request required when assuming role');
+    awsClientCredentials = await getInternal({
+      credentials: options.awsClientAssumeRole
+    }, request);
+  }
+
+  awsClientCredentials = { ...awsClientCredentials,
+    ...options.awsClientOptions
+  };
+  return createPrefetchClient({ ...options,
+    awsClientOptions: awsClientCredentials
+  });
+};
+
+const canPrefetch = options => {
+  return !(options !== null && options !== void 0 && options.awsClientAssumeRole) && !(options !== null && options !== void 0 && options.disablePrefetch);
+}; // Internal Context
+
+
+const getInternal = async (variables, request) => {
+  if (!variables || !request) return {};
+  let keys = [];
+  let values = [];
+
+  if (variables === true) {
+    keys = values = Object.keys(request.internal);
+  } else if (typeof variables === 'string') {
+    keys = values = [variables];
+  } else if (Array.isArray(variables)) {
+    keys = values = variables;
+  } else if (typeof variables === 'object') {
+    keys = Object.keys(variables);
+    values = Object.values(variables);
+  }
+
+  const promises = [];
+
+  for (const internalKey of values) {
+    var _valuePromise;
+
+    // 'internal.key.sub_value' -> { [key]: internal.key.sub_value }
+    const pathOptionKey = internalKey.split('.');
+    const rootOptionKey = pathOptionKey.shift();
+    let valuePromise = request.internal[rootOptionKey];
+
+    if (typeof ((_valuePromise = valuePromise) === null || _valuePromise === void 0 ? void 0 : _valuePromise.then) !== 'function') {
+      valuePromise = Promise.resolve(valuePromise);
+    }
+
+    promises.push(valuePromise.then(value => pathOptionKey.reduce((p, c) => p === null || p === void 0 ? void 0 : p[c], value)));
+  } // ensure promise has resolved by the time it's needed
+  // If one of the promises throws it will bubble up to @middy/core
+
+
+  values = await Promise.allSettled(promises);
+  const errors = values.filter(res => res.status === 'rejected').map(res => res.reason.message);
+  if (errors.length) throw new Error(JSON.stringify(errors));
+  return keys.reduce((obj, key, index) => ({ ...obj,
+    [sanitizeKey(key)]: values[index].value
+  }), {});
+};
+
+const sanitizeKeyPrefixLeadingNumber = /^([0-9])/;
+const sanitizeKeyRemoveDisallowedChar = /[^a-zA-Z0-9]+/g;
+
+const sanitizeKey = key => {
+  return key.replace(sanitizeKeyPrefixLeadingNumber, '_$1').replace(sanitizeKeyRemoveDisallowedChar, '_');
+}; // fetch Cache
+
+
+const cache = {}; // key: { value:{fetchKey:Promise}, expiry }
+
+const processCache = (options, fetch = () => undefined, request) => {
+  const {
+    cacheExpiry,
+    cacheKey
+  } = options;
+
+  if (cacheExpiry) {
+    const cached = getCache(cacheKey);
+    const unexpired = cached && (cacheExpiry < 0 || cached.expiry > Date.now());
+
+    if (unexpired && cached.modified) {
+      const value = fetch(request, cached.value);
+      cache[cacheKey] = {
+        value: { ...cached.value,
+          ...value
+        },
+        expiry: cached.expiry
+      };
+      return cache[cacheKey];
+    }
+
+    if (unexpired) {
+      return { ...cached,
+        cache: true
+      };
+    }
+  }
+
+  const value = fetch(request);
+  const expiry = Date.now() + cacheExpiry;
+
+  if (cacheExpiry) {
+    cache[cacheKey] = {
+      value,
+      expiry
+    };
+  }
+
+  return {
+    value,
+    expiry
+  };
+};
+
+const getCache = key => {
+  return cache[key];
+}; // Used to remove parts of a cache
+
+
+const modifyCache = (cacheKey, value) => {
+  if (!cache[cacheKey]) return;
+  cache[cacheKey] = { ...cache[cacheKey],
+    value,
+    modified: true
+  };
+};
+
+const clearCache = (keys = null) => {
+  var _keys;
+
+  keys = (_keys = keys) !== null && _keys !== void 0 ? _keys : Object.keys(cache);
+  if (!Array.isArray(keys)) keys = [keys];
+
+  for (const cacheKey of keys) {
+    cache[cacheKey] = undefined;
+  }
+};
+
+const jsonSafeParse = (string, reviver) => {
+  if (typeof string !== 'string') return string;
+  const firstChar = string[0];
+  if (firstChar !== '{' && firstChar !== '[' && firstChar !== '"') return string;
+
+  try {
+    return JSON.parse(string, reviver);
+  } catch (e) {}
+
+  return string;
+};
+
+const normalizeHttpResponse = response => {
+  var _response$headers, _response;
+
+  // May require updating to catch other types
+  if (response === undefined) {
+    response = {};
+  } else if (Array.isArray(response) || typeof response !== 'object' || response === null) {
+    response = {
+      body: response
+    };
+  }
+
+  response.headers = (_response$headers = (_response = response) === null || _response === void 0 ? void 0 : _response.headers) !== null && _response$headers !== void 0 ? _response$headers : {};
+  return response;
+}; // smaller version of `http-errors`
+
+
+const statuses = require('./codes.json');
+
+const {
+  inherits
+} = require('util');
+
+const createErrorRegexp = /[^a-zA-Z]/g;
+
+const createError = (code, message, properties = {}) => {
+  const name = statuses[code].replace(createErrorRegexp, '');
+  const className = name.substr(-5) !== 'Error' ? name + 'Error' : name;
+
+  function HttpError(message) {
+    // create the error object
+    const msg = message !== null && message !== void 0 ? message : statuses[code];
+    const err = new Error(msg); // capture a stack trace to the construction point
+
+    Error.captureStackTrace(err, HttpError); // adjust the [[Prototype]]
+
+    Object.setPrototypeOf(err, HttpError.prototype); // redefine the error message
+
+    Object.defineProperty(err, 'message', {
+      enumerable: true,
+      configurable: true,
+      value: msg,
+      writable: true
+    }); // redefine the error name
+
+    Object.defineProperty(err, 'name', {
+      enumerable: false,
+      configurable: true,
+      value: className,
+      writable: true
+    });
+    return err;
+  }
+
+  inherits(HttpError, Error);
+  const desc = Object.getOwnPropertyDescriptor(HttpError, 'name');
+  desc.value = className;
+  Object.defineProperty(HttpError, 'name', desc);
+  Object.assign(HttpError.prototype, {
+    status: code,
+    statusCode: code,
+    expose: code < 500
+  }, properties);
+  return new HttpError(message);
+};
+
+module.exports = {
+  createPrefetchClient,
+  createClient,
+  canPrefetch,
+  getInternal,
+  sanitizeKey,
+  processCache,
+  getCache,
+  modifyCache,
+  clearCache,
+  jsonSafeParse,
+  normalizeHttpResponse,
+  createError
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@middy/util",
+  "version": "2.5.2",
+  "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (util package)",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=12"
+  },
+  "engineStrict": true,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.d.ts",
+    "codes.json"
+  ],
+  "scripts": {
+    "test": "npm run test:unit",
+    "test:unit": "ava"
+  },
+  "license": "MIT",
+  "keywords": [
+    "Lambda",
+    "Middleware",
+    "Serverless",
+    "Framework",
+    "AWS",
+    "AWS Lambda",
+    "helper",
+    "util"
+  ],
+  "author": {
+    "name": "Middy contributors",
+    "url": "https://github.com/middyjs/middy/graphs/contributors"
+  },
+  "repository": {
+    "type": "git",
+    "url": "github:middyjs/middy",
+    "directory": "packages/util"
+  },
+  "bugs": {
+    "url": "https://github.com/middyjs/middy/issues"
+  },
+  "devDependencies": {
+    "@middy/core": "^2.5.2",
+    "@types/aws-lambda": "^8.10.76",
+    "@types/node": "^16.0.0",
+    "aws-sdk": "^2.939.0",
+    "aws-xray-sdk": "^3.3.3"
+  },
+  "homepage": "https://github.com/middyjs/middy#readme",
+  "gitHead": "a2bb757a7a13638ae64277f8eecfcf11c1af17d4"
+}