@middy/util 5.0.0-alpha.0 → 5.0.0-alpha.2

package/README.md

@@ -19,8 +19,9 @@
   <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://lgtm.com/projects/g/middyjs/middy/context:javascript">
-    <img src="https://img.shields.io/lgtm/grade/javascript/g/middyjs/middy.svg?logo=lgtm&logoWidth=18" alt="Language grade: JavaScript" style="max-width:100%;">
+  <a href="https://github.com/middyjs/middy/actions/workflows/sast.yml">
+    <img src="https://github.com/middyjs/middy/actions/workflows/sast.yml/badge.svg
+?branch=main&event=push" alt="CodeQL" style="max-width:100%;">
   </a>
   <a href="https://bestpractices.coreinfrastructure.org/projects/5280">
     <img src="https://bestpractices.coreinfrastructure.org/projects/5280/badge" alt="Core Infrastructure Initiative (CII) Best Practices"  style="max-width:100%;">

package/index.d.ts

@@ -1,7 +1,9 @@
 import middy from '@middy/core'
+import { Context as LambdaContext } from 'aws-lambda'
+import { ArrayValues, Choose, DeepAwaited, IsUnknown, SanitizeKey, SanitizeKeys } from './type-utils'
 
 interface Options<Client, ClientOptions> {
-  AwsClient?: new (...args: any[]) => Client
+  AwsClient?: new (...[config]: [any] | any) => Client
   awsClientOptions?: Partial<ClientOptions>
   awsClientAssumeRole?: string
   awsClientCapture?: (service: Client) => Client
@@ -12,7 +14,7 @@ interface Options<Client, ClientOptions> {
   setToContext?: boolean
 }
 
-type HttpError = Error & {
+declare class HttpError extends Error {
   status: number
   statusCode: number
   expose: boolean
@@ -33,12 +35,77 @@ declare function canPrefetch<Client, ClientOptions> (
   options: Options<Client, ClientOptions>
 ): boolean
 
-declare function getInternal (
-  variables: any,
-  request: middy.Request
-): Promise<any>
+type InternalOutput<TVariables> = TVariables extends string[] ? { [key in TVariables[number]]: unknown } : never
+
+// get an empty object if false is passed
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>
+> (
+  variables: false,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): Promise<{}>
+
+// get all internal values if true is passed (with promises resolved)
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>
+> (
+  variables: true,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): Promise<DeepAwaited<TInternal>>
+
+// get a single value
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>,
+  TVars extends keyof TInternal | string
+> (
+  variables: TVars,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): TVars extends keyof TInternal
+  ? Promise<DeepAwaited<{ [_ in SanitizeKey<TVars>]: TInternal[TVars] }>>
+  : TVars extends string
+    ? IsUnknown<Choose<DeepAwaited<TInternal>, TVars>> extends true
+      ? unknown // could not find the path
+      : Promise<{ [_ in SanitizeKey<TVars>]: Choose<DeepAwaited<TInternal>, TVars> }>
+    : unknown // path is not a string or a keyof TInternal
+
+// get multiple values
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>,
+  TVars extends Array<keyof TInternal | string>
+> (
+  variables: TVars,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): Promise<SanitizeKeys<{
+  [TVar in ArrayValues<TVars>]:
+  TVar extends keyof TInternal
+    ? DeepAwaited<TInternal[TVar]>
+    : TVar extends string
+      ? Choose<DeepAwaited<TInternal>, TVar>
+      : unknown // path is not a string or a keyof TInternal
+}>>
+
+// remap object
+declare function getInternal<
+  TContext extends LambdaContext,
+  TInternal extends Record<string, unknown>,
+  TMap extends Record<string, keyof TInternal | string>
+> (
+  variables: TMap,
+  request: middy.Request<unknown, unknown, unknown, TContext, TInternal>
+): Promise<{
+  [P in keyof TMap]:
+  TMap[P] extends keyof TInternal
+    ? DeepAwaited<TInternal[TMap[P]]>
+    : TMap[P] extends string
+      ? Choose<DeepAwaited<TInternal>, TMap[P]>
+      : unknown // path is not a string or a keyof TInternal
+}>
 
-declare function sanitizeKey (key: string): string
+declare function sanitizeKey<T extends string> (key: T): SanitizeKey<T>
 
 declare function processCache<Client, ClientOptions> (
   options: Options<Client, ClientOptions>,

package/index.js

@@ -1,6 +1,7 @@
 export const createPrefetchClient = (options)=>{
-    const { awsClientOptions  } = options;
+    const { awsClientOptions } = options;
     const client = new options.AwsClient(awsClientOptions);
+    // AWS XRay
     if (options.awsClientCapture && options.disablePrefetch) {
         return options.awsClientCapture(client);
     } else if (options.awsClientCapture) {
@@ -10,9 +11,14 @@ export const createPrefetchClient = (options)=>{
 };
 export const createClient = async (options, request)=>{
     let awsClientCredentials = {};
+    // Role Credentials
     if (options.awsClientAssumeRole) {
         if (!request) {
-            throw new Error('Request required when assuming role');
+            throw new Error('Request required when assuming role', {
+                cause: {
+                    package: '@middy/util'
+                }
+            });
         }
         awsClientCredentials = await getInternal({
             credentials: options.awsClientAssumeRole
@@ -30,6 +36,7 @@ export const createClient = async (options, request)=>{
 export const canPrefetch = (options = {})=>{
     return !options.awsClientAssumeRole && !options.disablePrefetch;
 };
+// Internal Context
 export const getInternal = async (variables, request)=>{
     if (!variables || !request) return {};
     let keys = [];
@@ -48,6 +55,7 @@ export const getInternal = async (variables, request)=>{
     }
     const promises = [];
     for (const internalKey of values){
+        // 'internal.key.sub_value' -> { [key]: internal.key.sub_value }
         const pathOptionKey = internalKey.split('.');
         const rootOptionKey = pathOptionKey.shift();
         let valuePromise = request.internal[rootOptionKey];
@@ -56,11 +64,16 @@ export const getInternal = async (variables, request)=>{
         }
         promises.push(valuePromise.then((value)=>pathOptionKey.reduce((p, c)=>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);
     if (errors.length) {
         throw new Error('Failed to resolve internal values', {
-            cause: errors
+            cause: {
+                package: '@middy/util',
+                data: errors
+            }
         });
     }
     return keys.reduce((obj, key, index)=>({
@@ -74,9 +87,12 @@ const sanitizeKeyRemoveDisallowedChar = /[^a-zA-Z0-9]+/g;
 export const sanitizeKey = (key)=>{
     return key.replace(sanitizeKeyPrefixLeadingNumber, '_$1').replace(sanitizeKeyRemoveDisallowedChar, '_');
 };
-const cache = {};
+// fetch Cache
+const cache = {} // key: { value:{fetchKey:Promise}, expiry }
+;
 export const processCache = (options, fetch = ()=>undefined, request)=>{
-    const { cacheExpiry , cacheKey  } = options;
+    let { cacheKey, cacheKeyExpiry, cacheExpiry } = options;
+    cacheExpiry = cacheKeyExpiry?.[cacheKey] ?? cacheExpiry;
     if (cacheExpiry) {
         const cached = getCache(cacheKey);
         const unexpired = cached.expiry && (cacheExpiry < 0 || cached.expiry > Date.now());
@@ -99,9 +115,12 @@ export const processCache = (options, fetch = ()=>undefined, request)=>{
         }
     }
     const value = fetch(request);
-    const expiry = Date.now() + cacheExpiry;
+    const now = Date.now();
+    // secrets-manager overrides to unix timestamp
+    const expiry = cacheExpiry > 86400000 ? cacheExpiry : now + cacheExpiry;
+    const duration = cacheExpiry > 86400000 ? cacheExpiry - now : cacheExpiry;
     if (cacheExpiry) {
-        const refresh = cacheExpiry > 0 ? setInterval(()=>processCache(options, fetch, request), cacheExpiry) : undefined;
+        const refresh = duration > 0 ? setInterval(()=>processCache(options, fetch, request), duration) : undefined;
         cache[cacheKey] = {
             value,
             expiry,
@@ -117,6 +136,7 @@ export const getCache = (key)=>{
     if (!cache[key]) return {};
     return cache[key];
 };
+// Used to remove parts of a cache
 export const modifyCache = (cacheKey, value)=>{
     if (!cache[cacheKey]) return;
     clearInterval(cache[cacheKey]?.refresh);
@@ -152,7 +172,7 @@ export const jsonSafeStringify = (value, replacer, space)=>{
     return value;
 };
 export const normalizeHttpResponse = (request)=>{
-    let { response  } = request;
+    let { response } = request;
     if (typeof response === 'undefined') {
         response = {};
     } else if (typeof response?.statusCode === 'undefined' && typeof response?.body === 'undefined' && typeof response?.headers === 'undefined') {
@@ -177,7 +197,8 @@ export class HttpError extends Error {
         super(message, options);
         const name = httpErrorCodes[code].replace(createErrorRegexp, '');
         this.name = name.substr(-5) !== 'Error' ? name + 'Error' : name;
-        this.status = this.statusCode = code;
+        this.status = this.statusCode = code // setting `status` for backwards compatibility w/ `http-errors`
+        ;
         this.expose = options.expose ?? code < 500;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/util",
-  "version": "5.0.0-alpha.0",
+  "version": "5.0.0-alpha.2",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (util package)",
   "type": "module",
   "engines": {
@@ -10,24 +10,18 @@
   "publishConfig": {
     "access": "public"
   },
-  "main": "./index.cjs",
   "module": "./index.js",
   "exports": {
     ".": {
       "import": {
         "types": "./index.d.ts",
         "default": "./index.js"
-      },
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./index.cjs"
       }
     }
   },
   "types": "index.d.ts",
   "files": [
     "index.js",
-    "index.cjs",
     "index.d.ts",
     "codes.js"
   ],
@@ -61,9 +55,9 @@
   },
   "devDependencies": {
     "@aws-sdk/client-ssm": "^3.0.0",
-    "@middy/core": "5.0.0-alpha.0",
+    "@middy/core": "5.0.0-alpha.2",
     "@types/aws-lambda": "^8.10.76",
-    "@types/node": "^18.0.0",
+    "@types/node": "^20.0.0",
     "aws-xray-sdk": "^3.3.3"
   },
   "homepage": "https://middy.js.org",
@@ -71,5 +65,5 @@
     "type": "github",
     "url": "https://github.com/sponsors/willfarrell"
   },
-  "gitHead": "08c35e3dba9efdad0b86666ce206ce302cc65d07"
+  "gitHead": "ebce8d5df8783077fa49ba62ee9be20e8486a7f1"
 }

package/index.cjs

@@ -1,279 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createPrefetchClient: ()=>createPrefetchClient,
-    createClient: ()=>createClient,
-    canPrefetch: ()=>canPrefetch,
-    getInternal: ()=>getInternal,
-    sanitizeKey: ()=>sanitizeKey,
-    processCache: ()=>processCache,
-    getCache: ()=>getCache,
-    modifyCache: ()=>modifyCache,
-    clearCache: ()=>clearCache,
-    jsonSafeParse: ()=>jsonSafeParse,
-    jsonSafeStringify: ()=>jsonSafeStringify,
-    normalizeHttpResponse: ()=>normalizeHttpResponse,
-    HttpError: ()=>HttpError,
-    createError: ()=>createError
-});
-const createPrefetchClient = (options)=>{
-    const { awsClientOptions  } = options;
-    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;
-};
-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
-    });
-};
-const canPrefetch = (options = {})=>{
-    return !options.awsClientAssumeRole && !options.disablePrefetch;
-};
-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 (!isPromise(valuePromise)) {
-            valuePromise = Promise.resolve(valuePromise);
-        }
-        promises.push(valuePromise.then((value)=>pathOptionKey.reduce((p, c)=>p?.[c], value)));
-    }
-    values = await Promise.allSettled(promises);
-    const errors = values.filter((res)=>res.status === 'rejected').map((res)=>res.reason);
-    if (errors.length) {
-        throw new Error('Failed to resolve internal values', {
-            cause: errors
-        });
-    }
-    return keys.reduce((obj, key, index)=>({
-            ...obj,
-            [sanitizeKey(key)]: values[index].value
-        }), {});
-};
-const isPromise = (promise)=>typeof promise?.then === 'function';
-const sanitizeKeyPrefixLeadingNumber = /^([0-9])/;
-const sanitizeKeyRemoveDisallowedChar = /[^a-zA-Z0-9]+/g;
-const sanitizeKey = (key)=>{
-    return key.replace(sanitizeKeyPrefixLeadingNumber, '_$1').replace(sanitizeKeyRemoveDisallowedChar, '_');
-};
-const cache = {};
-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] = Object.create({
-                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) {
-        const refresh = cacheExpiry > 0 ? setInterval(()=>processCache(options, fetch, request), cacheExpiry) : undefined;
-        cache[cacheKey] = {
-            value,
-            expiry,
-            refresh
-        };
-    }
-    return {
-        value,
-        expiry
-    };
-};
-const getCache = (key)=>{
-    if (!cache[key]) return {};
-    return cache[key];
-};
-const modifyCache = (cacheKey, value)=>{
-    if (!cache[cacheKey]) return;
-    clearInterval(cache[cacheKey]?.refresh);
-    cache[cacheKey] = {
-        ...cache[cacheKey],
-        value,
-        modified: true
-    };
-};
-const clearCache = (keys = null)=>{
-    keys = keys ?? Object.keys(cache);
-    if (!Array.isArray(keys)) keys = [
-        keys
-    ];
-    for (const cacheKey of keys){
-        clearInterval(cache[cacheKey]?.refresh);
-        cache[cacheKey] = undefined;
-    }
-};
-const jsonSafeParse = (text, reviver)=>{
-    if (typeof text !== 'string') return text;
-    const firstChar = text[0];
-    if (firstChar !== '{' && firstChar !== '[' && firstChar !== '"') return text;
-    try {
-        return JSON.parse(text, reviver);
-    } catch (e) {}
-    return text;
-};
-const jsonSafeStringify = (value, replacer, space)=>{
-    try {
-        return JSON.stringify(value, replacer, space);
-    } catch (e) {}
-    return value;
-};
-const normalizeHttpResponse = (request)=>{
-    let { response  } = request;
-    if (typeof response === 'undefined') {
-        response = {};
-    } else if (typeof response?.statusCode === 'undefined' && typeof response?.body === 'undefined' && typeof response?.headers === 'undefined') {
-        response = {
-            statusCode: 200,
-            body: response
-        };
-    }
-    response.statusCode ??= 500;
-    response.headers ??= {};
-    request.response = response;
-    return response;
-};
-const createErrorRegexp = /[^a-zA-Z]/g;
-class HttpError extends Error {
-    constructor(code, message, options = {}){
-        if (message && typeof message !== 'string') {
-            options = message;
-            message = undefined;
-        }
-        message ??= httpErrorCodes[code];
-        super(message, options);
-        const name = httpErrorCodes[code].replace(createErrorRegexp, '');
-        this.name = name.substr(-5) !== 'Error' ? name + 'Error' : name;
-        this.status = this.statusCode = code;
-        this.expose = options.expose ?? code < 500;
-    }
-}
-const createError = (code, message, properties = {})=>{
-    return new HttpError(code, message, properties);
-};
-const httpErrorCodes = {
-    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'
-};
-