@middy/util 6.1.5 → 6.2.0

package/index.d.ts

@@ -1,147 +1,147 @@
-import middy from '@middy/core'
-import { Context as LambdaContext } from 'aws-lambda'
+import type middy from "@middy/core";
+import type { Context as LambdaContext } from "aws-lambda";
 import type {
-  ArrayValues,
-  Choose,
-  DeepAwaited,
-  IsUnknown,
-  SanitizeKey,
-  SanitizeKeys
-} from './type-utils.d.ts'
+	ArrayValues,
+	Choose,
+	DeepAwaited,
+	IsUnknown,
+	SanitizeKey,
+	SanitizeKeys,
+} from "./type-utils.d.ts";
 
 interface Options<Client, ClientOptions> {
-  AwsClient?: new (...[config]: [any] | any) => Client
-  awsClientOptions?: Partial<ClientOptions>
-  awsClientAssumeRole?: string
-  awsClientCapture?: (service: Client) => Client
-  fetchData?: { [key: string]: string }
-  disablePrefetch?: boolean
-  cacheKey?: string
-  cacheExpiry?: number
-  setToContext?: boolean
+	AwsClient?: new (...[config]: [any] | any) => Client;
+	awsClientOptions?: Partial<ClientOptions>;
+	awsClientAssumeRole?: string;
+	awsClientCapture?: (service: Client) => Client;
+	fetchData?: { [key: string]: string };
+	disablePrefetch?: boolean;
+	cacheKey?: string;
+	cacheExpiry?: number;
+	setToContext?: boolean;
 }
 
 declare class HttpError extends Error {
-  status: number
-  statusCode: number
-  expose: boolean;
-  [key: string]: any
-  [key: number]: any
+	status: number;
+	statusCode: number;
+	expose: boolean;
+	[key: string]: any;
+	[key: number]: any;
 }
 
-declare function createPrefetchClient<Client, ClientOptions> (
-  options: Options<Client, ClientOptions>
-): Client
+declare function createPrefetchClient<Client, ClientOptions>(
+	options: Options<Client, ClientOptions>,
+): Client;
 
-declare function createClient<Client, ClientOptions> (
-  options: Options<Client, ClientOptions>,
-  request: middy.Request
-): Promise<Client>
+declare function createClient<Client, ClientOptions>(
+	options: Options<Client, ClientOptions>,
+	request: middy.Request,
+): Promise<Client>;
 
-declare function canPrefetch<Client, ClientOptions> (
-  options: Options<Client, ClientOptions>
-): boolean
+declare function canPrefetch<Client, ClientOptions>(
+	options: Options<Client, ClientOptions>,
+): boolean;
 
 type InternalOutput<TVariables> = TVariables extends string[]
-  ? { [key in TVariables[number]]: unknown }
-  : never
+	? { [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<{}>
+	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>>
+	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>
+	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
+	? 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>
+	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
-}>
->
+	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>
+	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<T extends string> (key: T): SanitizeKey<T>
-
-declare function processCache<Client, ClientOptions> (
-  options: Options<Client, ClientOptions>,
-  fetch: (request: middy.Request, cachedValues: any) => 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 (
-  request: any,
-  fallbackResponse?: any
-): any
-
-declare function createError (
-  code: number,
-  message: string,
-  properties?: Record<string, any>
-): HttpError
-
-declare function modifyCache (cacheKey: string, value: any): void
+	[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<T extends string>(key: T): SanitizeKey<T>;
+
+declare function processCache<Client, ClientOptions>(
+	options: Options<Client, ClientOptions>,
+	fetch: (request: middy.Request, cachedValues: any) => 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(
+	request: 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

@@ -1,295 +1,302 @@
 export const createPrefetchClient = (options) => {
-  const { awsClientOptions } = options
-  const client = new options.AwsClient(awsClientOptions)
+	const { awsClientOptions } = options;
+	const client = new options.AwsClient(awsClientOptions);
 
-  // AWS XRay
-  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.')
-  }
+	// AWS XRay
+	if (options.awsClientCapture) {
+		if (options.disablePrefetch) {
+			return options.awsClientCapture(client);
+		}
+		console.warn("Unable to apply X-Ray outside of handler invocation scope.");
+	}
 
-  return client
-}
+	return client;
+};
 
 export const createClient = async (options, request) => {
-  let awsClientCredentials = {}
+	let awsClientCredentials = {};
 
-  // Role Credentials
-  if (options.awsClientAssumeRole) {
-    if (!request) {
-      throw new Error('Request required when assuming role', {
-        cause: { package: '@middy/util' }
-      })
-    }
-    awsClientCredentials = await getInternal(
-      { credentials: options.awsClientAssumeRole },
-      request
-    )
-  }
+	// Role Credentials
+	if (options.awsClientAssumeRole) {
+		if (!request) {
+			throw new Error("Request required when assuming role", {
+				cause: { package: "@middy/util" },
+			});
+		}
+		awsClientCredentials = await getInternal(
+			{ credentials: options.awsClientAssumeRole },
+			request,
+		);
+	}
 
-  awsClientCredentials = {
-    ...awsClientCredentials,
-    ...options.awsClientOptions
-  }
+	awsClientCredentials = {
+		...awsClientCredentials,
+		...options.awsClientOptions,
+	};
 
-  return createPrefetchClient({
-    ...options,
-    awsClientOptions: awsClientCredentials
-  })
-}
+	return createPrefetchClient({
+		...options,
+		awsClientOptions: awsClientCredentials,
+	});
+};
 
 export const canPrefetch = (options = {}) => {
-  return !options.awsClientAssumeRole && !options.disablePrefetch
-}
+	return !options.awsClientAssumeRole && !options.disablePrefetch;
+};
 
 // Internal Context
 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) {
-    // 'internal.key.sub_value' -> { [key]: internal.key.sub_value }
-    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)
-      )
-    )
-  }
-  // 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: { package: '@middy/util', data: errors }
-    })
-  }
-  return keys.reduce(
-    (obj, key, index) => ({ ...obj, [sanitizeKey(key)]: values[index].value }),
-    {}
-  )
-}
+	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) {
+		// 'internal.key.sub_value' -> { [key]: internal.key.sub_value }
+		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),
+			),
+		);
+	}
+	// 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: { package: "@middy/util", data: errors },
+		});
+	}
+	return keys.reduce(
+		(obj, key, index) =>
+			Object.assign(obj, { [sanitizeKey(key)]: values[index].value }),
+		{},
+	);
+};
 
-const isPromise = (promise) => typeof promise?.then === 'function'
+const isPromise = (promise) => typeof promise?.then === "function";
 
-const sanitizeKeyPrefixLeadingNumber = /^([0-9])/
-const sanitizeKeyRemoveDisallowedChar = /[^a-zA-Z0-9]+/g
+const sanitizeKeyPrefixLeadingNumber = /^([0-9])/;
+const sanitizeKeyRemoveDisallowedChar = /[^a-zA-Z0-9]+/g;
 export const sanitizeKey = (key) => {
-  return key
-    .replace(sanitizeKeyPrefixLeadingNumber, '_$1')
-    .replace(sanitizeKeyRemoveDisallowedChar, '_')
-}
+	return key
+		.replace(sanitizeKeyPrefixLeadingNumber, "_$1")
+		.replace(sanitizeKeyRemoveDisallowedChar, "_");
+};
 
 // fetch Cache
-const cache = {} // key: { value:{fetchKey:Promise}, expiry }
+const cache = {}; // key: { value:{fetchKey:Promise}, expiry }
 export const processCache = (
-  options,
-  middlewareFetch = () => undefined,
-  request
+	options,
+	middlewareFetch = () => undefined,
+	request = {},
 ) => {
-  let { cacheKey, cacheKeyExpiry, cacheExpiry } = options
-  cacheExpiry = cacheKeyExpiry?.[cacheKey] ?? cacheExpiry
-  const now = Date.now()
-  if (cacheExpiry) {
-    const cached = getCache(cacheKey)
-    const unexpired = cached.expiry && (cacheExpiry < 0 || cached.expiry > now)
+	let { cacheKey, cacheKeyExpiry, cacheExpiry } = options;
+	cacheExpiry = cacheKeyExpiry?.[cacheKey] ?? cacheExpiry;
+	const now = Date.now();
+	if (cacheExpiry) {
+		const cached = getCache(cacheKey);
+		const unexpired = cached.expiry && (cacheExpiry < 0 || cached.expiry > now);
 
-    if (unexpired) {
-      if (cached.modified) {
-        const value = middlewareFetch(request, cached.value)
-        Object.assign(cached.value, value)
-        cache[cacheKey] = { value: cached.value, expiry: cached.expiry }
-        return cache[cacheKey]
-      }
-      return { ...cached, cache: true }
-    }
-  }
-  const value = middlewareFetch(request)
-  // secrets-manager can override to unix timestamp
-  const expiry = cacheExpiry > 86400000 ? cacheExpiry : now + cacheExpiry
-  const duration = cacheExpiry > 86400000 ? cacheExpiry - now : cacheExpiry
-  if (cacheExpiry) {
-    const refresh =
-      duration > 0
-        ? setTimeout(
-          () => processCache(options, middlewareFetch, request),
-          duration
-        )
-        : undefined
-    cache[cacheKey] = { value, expiry, refresh }
-  }
-  return { value, expiry }
-}
+		if (unexpired) {
+			if (cached.modified) {
+				const value = middlewareFetch(request, cached.value);
+				Object.assign(cached.value, value);
+				cache[cacheKey] = { value: cached.value, expiry: cached.expiry };
+				return cache[cacheKey];
+			}
+			return { ...cached, cache: true };
+		}
+	}
+	const value = middlewareFetch(request);
+	// secrets-manager can override to unix timestamp
+	const expiry = cacheExpiry > 86400000 ? cacheExpiry : now + cacheExpiry;
+	const duration = cacheExpiry > 86400000 ? cacheExpiry - now : cacheExpiry;
+	if (cacheExpiry) {
+		const refresh =
+			duration > 0
+				? setTimeout(
+						() => processCache(options, middlewareFetch, request),
+						duration,
+					)
+				: undefined;
+		cache[cacheKey] = { value, expiry, refresh };
+	}
+	return { value, expiry };
+};
 
 export const catchInvalidSignatureException = (e, client, command) => {
-  if (e.__type === 'InvalidSignatureException') {
-    return client.send(command)
-  }
-  throw e
-}
+	if (e.__type === "InvalidSignatureException") {
+		return client.send(command);
+	}
+	throw e;
+};
 
 export const getCache = (key) => {
-  if (!cache[key]) return {}
-  return cache[key]
-}
+	if (!cache[key]) return {};
+	return cache[key];
+};
 
 // Used to remove parts of a cache
 export const modifyCache = (cacheKey, value) => {
-  if (!cache[cacheKey]) return
-  clearTimeout(cache[cacheKey]?.refresh)
-  cache[cacheKey] = { ...cache[cacheKey], value, modified: true }
-}
+	if (!cache[cacheKey]) return;
+	clearTimeout(cache[cacheKey]?.refresh);
+	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) {
-    clearTimeout(cache[cacheKey]?.refresh)
-    cache[cacheKey] = undefined
-  }
-}
+export const clearCache = (inputKeys = null) => {
+	let keys = inputKeys;
+	keys ??= Object.keys(cache);
+	if (!Array.isArray(keys)) {
+		keys = [keys];
+	}
+	for (const cacheKey of keys) {
+		clearTimeout(cache[cacheKey]?.refresh);
+		cache[cacheKey] = undefined;
+	}
+};
 
 export 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) {}
+	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
-}
+	return text;
+};
 
 export const jsonSafeStringify = (value, replacer, space) => {
-  try {
-    return JSON.stringify(value, replacer, space)
-  } catch (e) {}
+	try {
+		return JSON.stringify(value, replacer, space);
+	} catch (e) {}
 
-  return value
-}
+	return value;
+};
 
 export 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
-}
+	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
+const createErrorRegexp = /[^a-zA-Z]/g;
 export class HttpError extends Error {
-  constructor (code, message, options = {}) {
-    if (message && typeof message !== 'string') {
-      options = message
-      message = undefined
-    }
-    message ??= httpErrorCodes[code]
-    super(message, options)
+	constructor(code, optionalMessage, optionalOptions = {}) {
+		let message = optionalMessage;
+		let options = optionalOptions;
+		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
+		const name = httpErrorCodes[code].replace(createErrorRegexp, "");
+		this.name = name.substr(-5) !== "Error" ? `${name}Error` : name;
 
-    this.status = this.statusCode = code // setting `status` for backwards compatibility w/ `http-errors`
-    this.expose = options.expose ?? code < 500
-  }
+		this.status = this.statusCode = code; // setting `status` for backwards compatibility w/ `http-errors`
+		this.expose = options.expose ?? code < 500;
+	}
 }
 
 export const createError = (code, message, properties = {}) => {
-  return new HttpError(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'
-}
+	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/package.json

@@ -1,73 +1,69 @@
 {
-  "name": "@middy/util",
-  "version": "6.1.5",
-  "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (util package)",
-  "type": "module",
-  "engines": {
-    "node": ">=20"
-  },
-  "engineStrict": true,
-  "publishConfig": {
-    "access": "public"
-  },
-  "module": "./index.js",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "require": {
-        "default": "./index.js"
-      }
-    }
-  },
-  "types": "index.d.ts",
-  "files": [
-    "index.js",
-    "index.d.ts",
-    "type-utils.d.ts"
-  ],
-  "scripts": {
-    "test": "npm run test:unit && npm run test:fuzz",
-    "test:unit": "node --test __tests__/index.js",
-    "test:fuzz": "node --test __tests__/fuzz.js",
-    "test:benchmark": "node __benchmarks__/index.js"
-  },
-  "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": "git+https://github.com/middyjs/middy.git",
-    "directory": "packages/util"
-  },
-  "bugs": {
-    "url": "https://github.com/middyjs/middy/issues"
-  },
-  "devDependencies": {
-    "@aws-sdk/client-ssm": "^3.0.0",
-    "@middy/core": "6.1.5",
-    "@types/aws-lambda": "^8.10.76",
-    "@types/node": "^20.0.0",
-    "aws-xray-sdk": "^3.3.3"
-  },
-  "homepage": "https://middy.js.org",
-  "funding": {
-    "type": "github",
-    "url": "https://github.com/sponsors/willfarrell"
-  },
-  "gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431"
+	"name": "@middy/util",
+	"version": "6.2.0",
+	"description": "🛵 The stylish Node.js middleware engine for AWS Lambda (util package)",
+	"type": "module",
+	"engines": {
+		"node": ">=20"
+	},
+	"engineStrict": true,
+	"publishConfig": {
+		"access": "public"
+	},
+	"module": "./index.js",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./index.d.ts",
+				"default": "./index.js"
+			},
+			"require": {
+				"default": "./index.js"
+			}
+		}
+	},
+	"types": "index.d.ts",
+	"files": ["index.js", "index.d.ts", "type-utils.d.ts"],
+	"scripts": {
+		"test": "npm run test:unit && npm run test:fuzz",
+		"test:unit": "node --test",
+		"test:fuzz": "node --test index.fuzz.js",
+		"test:perf": "node --test index.perf.js"
+	},
+	"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": "git+https://github.com/middyjs/middy.git",
+		"directory": "packages/util"
+	},
+	"bugs": {
+		"url": "https://github.com/middyjs/middy/issues"
+	},
+	"devDependencies": {
+		"@aws-sdk/client-ssm": "^3.0.0",
+		"@middy/core": "6.2.0",
+		"@types/aws-lambda": "^8.10.76",
+		"@types/node": "^20.0.0",
+		"aws-xray-sdk": "^3.3.3"
+	},
+	"homepage": "https://middy.js.org",
+	"funding": {
+		"type": "github",
+		"url": "https://github.com/sponsors/willfarrell"
+	},
+	"gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431"
 }

package/type-utils.d.ts

@@ -1,71 +1,88 @@
-type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
-type LetterLower = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i'
-| 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't'
-| 'u' | 'v' | 'w' | 'x' | 'y' | 'z'
-type LetterUpper = Uppercase<LetterLower>
-type AlphaNumeric = Digit | LetterLower | LetterUpper
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type LetterLower =
+	| "a"
+	| "b"
+	| "c"
+	| "d"
+	| "e"
+	| "f"
+	| "g"
+	| "h"
+	| "i"
+	| "j"
+	| "k"
+	| "l"
+	| "m"
+	| "n"
+	| "o"
+	| "p"
+	| "q"
+	| "r"
+	| "s"
+	| "t"
+	| "u"
+	| "v"
+	| "w"
+	| "x"
+	| "y"
+	| "z";
+type LetterUpper = Uppercase<LetterLower>;
+type AlphaNumeric = Digit | LetterLower | LetterUpper;
 
 type SanitizeKeyPrefixLeadingNumber<T> =
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  T extends `${infer _ extends Digit}${any}`
-    ? `_${T}`
-    : T
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	T extends `${infer _ extends Digit}${any}` ? `_${T}` : T;
 
 type SanitizeKeyRemoveDisallowedChar<T> =
-  T extends `${infer First}${infer Rest}`
-    ? First extends AlphaNumeric
-      ? `${First}${SanitizeKeyRemoveDisallowedChar<Rest>}`
-      : `_${SanitizeKeyRemoveDisallowedChar<Rest>}`
-    : T extends ''
-      ? T
-      : never
+	T extends `${infer First}${infer Rest}`
+		? First extends AlphaNumeric
+			? `${First}${SanitizeKeyRemoveDisallowedChar<Rest>}`
+			: `_${SanitizeKeyRemoveDisallowedChar<Rest>}`
+		: T extends ""
+			? T
+			: never;
 
-type RemoveAllLeadingUnderscore<T> =
-  T extends `_${infer Rest}`
-    ? RemoveAllLeadingUnderscore<Rest>
-    : T extends string
-      ? T
-      : never
+type RemoveAllLeadingUnderscore<T> = T extends `_${infer Rest}`
+	? RemoveAllLeadingUnderscore<Rest>
+	: T extends string
+		? T
+		: never;
 
-type RemoveRepeatedUnderscore<T> =
-  T extends `${infer First}_${infer Rest}`
-    ? `${First}_${RemoveRepeatedUnderscore<RemoveAllLeadingUnderscore<Rest>>}`
-    : T extends string
-      ? T
-      : never
+type RemoveRepeatedUnderscore<T> = T extends `${infer First}_${infer Rest}`
+	? `${First}_${RemoveRepeatedUnderscore<RemoveAllLeadingUnderscore<Rest>>}`
+	: T extends string
+		? T
+		: never;
 
-export type SanitizeKey<T> =
-  RemoveRepeatedUnderscore<
-  SanitizeKeyRemoveDisallowedChar<
-  SanitizeKeyPrefixLeadingNumber<T>
-  >
-  >
+export type SanitizeKey<T> = RemoveRepeatedUnderscore<
+	SanitizeKeyRemoveDisallowedChar<SanitizeKeyPrefixLeadingNumber<T>>
+>;
 
 export type SanitizeKeys<T extends Record<string, unknown>> = {
-  [P in keyof T as SanitizeKey<P>]: T[P]
-}
+	[P in keyof T as SanitizeKey<P>]: T[P];
+};
 
 // recursion limit hack from https://www.angularfix.com/2022/01/why-am-i-getting-instantiation-is.html
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-export type DeepAwaited<T, RecursionDepth extends Prev[number] = 4> =
-  [RecursionDepth] extends [never]
-    ? unknown // stop evaluating recursively rather than failing with never
-    : T extends Promise<infer R>
-      ? Awaited<R>
-      : T extends Record<any, any>
-        ? {
-            [P in keyof T]:
-            T[P] extends Promise<infer R>
-              ? Awaited<R> // if it's a Promise resolve
-              : DeepAwaited<T[P], Prev[RecursionDepth]>
-          }
-        : T
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+export type DeepAwaited<T, RecursionDepth extends Prev[number] = 4> = [
+	RecursionDepth,
+] extends [never]
+	? unknown // stop evaluating recursively rather than failing with never
+	: T extends Promise<infer R>
+		? Awaited<R>
+		: T extends Record<any, any>
+			? {
+					[P in keyof T]: T[P] extends Promise<infer R>
+						? Awaited<R> // if it's a Promise resolve
+						: DeepAwaited<T[P], Prev[RecursionDepth]>;
+				}
+			: T;
 
 export type Choose<
-  T extends Record<string | number, any>,
-  K extends string
-> = K extends `${infer U}.${infer Rest}` ? Choose<T[U], Rest> : T[K]
+	T extends Record<string | number, any>,
+	K extends string,
+> = K extends `${infer U}.${infer Rest}` ? Choose<T[U], Rest> : T[K];
 
-export type IsUnknown<T> = unknown extends T ? true : false
+export type IsUnknown<T> = unknown extends T ? true : false;
 
-export type ArrayValues<T> = T extends Array<infer U> ? U : never
+export type ArrayValues<T> = T extends Array<infer U> ? U : never;