@middy/util 3.0.0-alpha.0 → 3.0.0-alpha.4

package/index.js

@@ -0,0 +1,235 @@
+import { Agent } from 'https';
+import statuses from './codes.js';
+import { inherits } from 'util';
+export const awsClientDefaultOptions = {
+  httpOptions: {
+    agent: new Agent({
+      secureProtocol: 'TLSv1_2_method'
+    })
+  }
+};
+export const createPrefetchClient = options => {
+  const awsClientOptions = { ...awsClientDefaultOptions,
+    ...options.awsClientOptions
+  };
+  const client = new options.AwsClient(awsClientOptions);
+
+  if (options.awsClientCapture && options.disablePrefetch) {
+    return options.awsClientCapture(client);
+  } else if (options.awsClientCapture) {
+    console.warn('Unable to apply X-Ray outside of handler invocation scope.');
+  }
+
+  return client;
+};
+export const createClient = async (options, request) => {
+  let awsClientCredentials = {};
+
+  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
+  });
+};
+export const canPrefetch = (options = {}) => {
+  return !options.awsClientAssumeRole && !options.disablePrefetch;
+};
+export 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) {
+    const pathOptionKey = internalKey.split('.');
+    const rootOptionKey = pathOptionKey.shift();
+    let valuePromise = request.internal[rootOptionKey];
+
+    if (typeof 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)));
+  }
+
+  values = await Promise.allSettled(promises);
+  const errors = values.filter(res => res.status === 'rejected').map(res => res.reason);
+
+  if (errors.length) {
+    const error = new Error('Failed to resolve internal values');
+    error.cause = errors;
+    throw error;
+  }
+
+  return keys.reduce((obj, key, index) => ({ ...obj,
+    [sanitizeKey(key)]: values[index].value
+  }), {});
+};
+const sanitizeKeyPrefixLeadingNumber = /^([0-9])/;
+const sanitizeKeyRemoveDisallowedChar = /[^a-zA-Z0-9]+/g;
+export const sanitizeKey = key => {
+  return key.replace(sanitizeKeyPrefixLeadingNumber, '_$1').replace(sanitizeKeyRemoveDisallowedChar, '_');
+};
+const cache = {};
+export const processCache = (options, fetch = () => undefined, request) => {
+  const {
+    cacheExpiry,
+    cacheKey
+  } = options;
+
+  if (cacheExpiry) {
+    const cached = getCache(cacheKey);
+    const unexpired = cached.expiry && (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
+  };
+};
+export const getCache = key => {
+  if (!cache[key]) return {};
+  return cache[key];
+};
+export const modifyCache = (cacheKey, value) => {
+  if (!cache[cacheKey]) return;
+  cache[cacheKey] = { ...cache[cacheKey],
+    value,
+    modified: true
+  };
+};
+export const clearCache = (keys = null) => {
+  keys = keys ?? Object.keys(cache);
+  if (!Array.isArray(keys)) keys = [keys];
+
+  for (const cacheKey of keys) {
+    cache[cacheKey] = undefined;
+  }
+};
+export 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;
+};
+export const normalizeHttpResponse = request => {
+  var _response, _response2, _response3, _response4;
+
+  let {
+    response
+  } = request;
+
+  if (response === undefined) {
+    response = {};
+  } else if (((_response = response) === null || _response === void 0 ? void 0 : _response.statusCode) === undefined && ((_response2 = response) === null || _response2 === void 0 ? void 0 : _response2.body) === undefined && ((_response3 = response) === null || _response3 === void 0 ? void 0 : _response3.headers) === undefined) {
+    response = {
+      body: response
+    };
+  }
+
+  (_response4 = response).headers ?? (_response4.headers = {});
+  request.response = response;
+  return response;
+};
+const createErrorRegexp = /[^a-zA-Z]/g;
+export const createError = (code, message, properties = {}) => {
+  const name = statuses[code].replace(createErrorRegexp, '');
+  const className = name.substr(-5) !== 'Error' ? name + 'Error' : name;
+
+  function HttpError(message) {
+    const msg = message ?? statuses[code];
+    const err = new Error(msg);
+    Error.captureStackTrace(err, HttpError);
+    Object.setPrototypeOf(err, HttpError.prototype);
+    Object.defineProperty(err, 'message', {
+      enumerable: true,
+      configurable: true,
+      value: msg,
+      writable: true
+    });
+    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);
+};
+export default {
+  createPrefetchClient,
+  createClient,
+  canPrefetch,
+  getInternal,
+  sanitizeKey,
+  processCache,
+  getCache,
+  modifyCache,
+  clearCache,
+  jsonSafeParse,
+  normalizeHttpResponse,
+  createError
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/util",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.0-alpha.4",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (util package)",
   "type": "module",
   "engines": {
@@ -13,12 +13,14 @@
   "exports": "./index.js",
   "types": "index.d.ts",
   "files": [
+    "index.js",
     "index.d.ts",
     "codes.js"
   ],
   "scripts": {
     "test": "npm run test:unit",
-    "test:unit": "ava"
+    "test:unit": "ava",
+    "test:benchmark": "node __benchmarks__/index.js"
   },
   "license": "MIT",
   "keywords": [
@@ -44,12 +46,12 @@
     "url": "https://github.com/middyjs/middy/issues"
   },
   "devDependencies": {
-    "@middy/core": "^3.0.0-alpha.0",
+    "@middy/core": "^3.0.0-alpha.4",
     "@types/aws-lambda": "^8.10.76",
     "@types/node": "^17.0.0",
     "aws-sdk": "^2.939.0",
     "aws-xray-sdk": "^3.3.3"
   },
   "homepage": "https://github.com/middyjs/middy#readme",
-  "gitHead": "c533f62841c8a39d061d7b94f30ba178f002c8db"
+  "gitHead": "d4bea7f4e21f6a9bbb1f6f6908361169598b9e53"
 }