@middy/ssm 6.1.6 → 6.2.1

package/index.d.ts

@@ -1,40 +1,46 @@
-import middy from '@middy/core'
-import { Options as MiddyOptions } from '@middy/util'
-import { Context as LambdaContext } from 'aws-lambda'
-import { SSMClient, SSMClientConfig } from '@aws-sdk/client-ssm'
+import type { SSMClient, SSMClientConfig } from "@aws-sdk/client-ssm";
+import type middy from "@middy/core";
+import type { Options as MiddyOptions } from "@middy/util";
+import type { Context as LambdaContext } from "aws-lambda";
 
-export type ParamType<T> = string & { __returnType?: T }
-export declare function ssmParam<T> (path: string): ParamType<T>
+export type ParamType<T> = string & { __returnType?: T };
+export declare function ssmParam<T>(path: string): ParamType<T>;
 
 export interface SSMOptions<AwsSSMClient = SSMClient>
-  extends Omit<MiddyOptions<AwsSSMClient, SSMClientConfig>, 'fetchData'> {
-  fetchData?: { [key: string]: string | ParamType<unknown> }
+	extends Omit<MiddyOptions<AwsSSMClient, SSMClientConfig>, "fetchData"> {
+	fetchData?: { [key: string]: string | ParamType<unknown> };
 }
 
 export type Context<TOptions extends SSMOptions | undefined> =
-TOptions extends { setToContext: true }
-  ? TOptions extends { fetchData: infer TFetchData }
-    ? LambdaContext & {
-      [Key in keyof TFetchData]: TFetchData[Key] extends ParamType<infer T>
-        ? T
-        : unknown
-    }
-    : never
-  : LambdaContext
+	TOptions extends { setToContext: true }
+		? TOptions extends { fetchData: infer TFetchData }
+			? LambdaContext & {
+					[Key in keyof TFetchData]: TFetchData[Key] extends ParamType<infer T>
+						? T
+						: unknown;
+				}
+			: never
+		: LambdaContext;
 
 export type Internal<TOptions extends SSMOptions | undefined> =
-TOptions extends SSMOptions
-  ? TOptions extends { fetchData: infer TFetchData }
-    ? {
-        [Key in keyof TFetchData]: TFetchData[Key] extends ParamType<infer T>
-          ? T
-          : unknown
-      }
-    : {}
-  : {}
+	TOptions extends SSMOptions
+		? TOptions extends { fetchData: infer TFetchData }
+			? {
+					[Key in keyof TFetchData]: TFetchData[Key] extends ParamType<infer T>
+						? T
+						: unknown;
+				}
+			: {}
+		: {};
 
-declare function ssm<TOptions extends SSMOptions> (
-  options?: TOptions
-): middy.MiddlewareObj<unknown, any, Error, Context<TOptions>, Internal<TOptions>>
+declare function ssm<TOptions extends SSMOptions>(
+	options?: TOptions,
+): middy.MiddlewareObj<
+	unknown,
+	any,
+	Error,
+	Context<TOptions>,
+	Internal<TOptions>
+>;
 
-export default ssm
+export default ssm;

package/index.js

@@ -1,196 +1,198 @@
 import {
-  canPrefetch,
-  createPrefetchClient,
-  createClient,
-  processCache,
-  getCache,
-  modifyCache,
-  jsonSafeParse,
-  getInternal,
-  sanitizeKey,
-  catchInvalidSignatureException
-} from '../util/index.js'
+	GetParametersByPathCommand,
+	GetParametersCommand,
+	SSMClient,
+} from "@aws-sdk/client-ssm";
 import {
-  SSMClient,
-  GetParametersCommand,
-  GetParametersByPathCommand
-} from '@aws-sdk/client-ssm'
-
-const awsRequestLimit = 10
+	canPrefetch,
+	catchInvalidSignatureException,
+	createClient,
+	createPrefetchClient,
+	getCache,
+	getInternal,
+	jsonSafeParse,
+	modifyCache,
+	processCache,
+	sanitizeKey,
+} from "../util/index.js";
+
+const awsRequestLimit = 10;
 const defaults = {
-  AwsClient: SSMClient, // Allow for XRay
-  awsClientOptions: {},
-  awsClientAssumeRole: undefined,
-  awsClientCapture: undefined,
-  fetchData: {}, // { contextKey: fetchKey, contextPrefix: fetchPath/ }
-  disablePrefetch: false,
-  cacheKey: 'ssm',
-  cacheKeyExpiry: {},
-  cacheExpiry: -1,
-  setToContext: false
-}
+	AwsClient: SSMClient, // Allow for XRay
+	awsClientOptions: {},
+	awsClientAssumeRole: undefined,
+	awsClientCapture: undefined,
+	fetchData: {}, // { contextKey: fetchKey, contextPrefix: fetchPath/ }
+	disablePrefetch: false,
+	cacheKey: "ssm",
+	cacheKeyExpiry: {},
+	cacheExpiry: -1,
+	setToContext: false,
+};
 
 const ssmMiddleware = (opts = {}) => {
-  const options = { ...defaults, ...opts }
-
-  const fetchRequest = (request, cachedValues) => {
-    return {
-      ...fetchSingleRequest(request, cachedValues),
-      ...fetchByPathRequest(request, cachedValues)
-    }
-  }
-
-  const fetchSingleRequest = (request, cachedValues = {}) => {
-    const values = {}
-    let batchReq = null
-    let batchInternalKeys = []
-    let batchFetchKeys = []
-    const namedKeys = []
-
-    const internalKeys = Object.keys(options.fetchData)
-    const fetchKeys = Object.values(options.fetchData)
-    for (const internalKey of internalKeys) {
-      if (cachedValues[internalKey]) continue
-      if (options.fetchData[internalKey].substr(-1) === '/') continue // Skip path passed in
-      namedKeys.push(internalKey)
-    }
-
-    for (const [idx, internalKey] of namedKeys.entries()) {
-      const fetchKey = options.fetchData[internalKey]
-      batchInternalKeys.push(internalKey)
-      batchFetchKeys.push(fetchKey)
-      // from the first to the batch size skip, unless it's the last entry
-      if (
-        (!idx || (idx + 1) % awsRequestLimit !== 0) &&
-        !(idx + 1 === namedKeys.length)
-      ) {
-        continue
-      }
-
-      const command = new GetParametersCommand({
-        Names: batchFetchKeys,
-        WithDecryption: true
-      })
-      batchReq = client
-        .send(command)
-        .catch((e) => catchInvalidSignatureException(e, client, command))
-        .then((resp) => {
-          // Don't sanitize key, mapped to set value in options
-          return Object.assign(
-            ...(resp.InvalidParameters ?? []).map((fetchKey) => {
-              return {
-                [fetchKey]: new Promise(() => {
-                  const internalKey = internalKeys[fetchKeys.indexOf(fetchKey)]
-                  const value = getCache(options.cacheKey).value ?? {}
-                  value[internalKey] = undefined
-                  modifyCache(options.cacheKey, value)
-                  throw new Error('InvalidParameter ' + fetchKey, {
-                    cause: { package: '@middy/ssm' }
-                  })
-                })
-              }
-            }),
-            ...(resp.Parameters ?? []).map((param) => {
-              return { [param.Name]: parseValue(param) }
-            })
-          )
-        })
-        .catch((e) => {
-          const value = getCache(options.cacheKey).value ?? {}
-          value[internalKey] = undefined
-          modifyCache(options.cacheKey, value)
-          throw e
-        })
-
-      for (const internalKey of batchInternalKeys) {
-        values[internalKey] = batchReq.then((params) => {
-          return params[options.fetchData[internalKey]]
-        })
-      }
-
-      batchInternalKeys = []
-      batchFetchKeys = []
-      batchReq = null
-    }
-    return values
-  }
-
-  const fetchByPathRequest = (request, cachedValues = {}) => {
-    const values = {}
-    for (const internalKey in options.fetchData) {
-      if (cachedValues[internalKey]) continue
-      const fetchKey = options.fetchData[internalKey]
-      if (fetchKey.substr(-1) !== '/') continue // Skip not path passed in
-      values[internalKey] = fetchPathRequest(fetchKey).catch((e) => {
-        const value = getCache(options.cacheKey).value ?? {}
-        value[internalKey] = undefined
-        modifyCache(options.cacheKey, value)
-        throw e
-      })
-    }
-    return values
-  }
-
-  const fetchPathRequest = (path, nextToken, values = {}) => {
-    const command = new GetParametersByPathCommand({
-      Path: path,
-      NextToken: nextToken,
-      Recursive: true,
-      WithDecryption: true
-    })
-    return client
-      .send(command)
-      .catch((e) => catchInvalidSignatureException(e, client, command))
-      .then((resp) => {
-        Object.assign(
-          values,
-          ...resp.Parameters.map((param) => {
-            return {
-              [sanitizeKey(param.Name.replace(path, ''))]: parseValue(param)
-            }
-          })
-        )
-        if (resp.NextToken) { return fetchPathRequest(path, resp.NextToken, values) }
-        return values
-      })
-  }
-
-  const parseValue = (param) => {
-    if (param.Type === 'StringList') {
-      return param.Value.split(',')
-    }
-    return jsonSafeParse(param.Value)
-  }
-
-  let client
-  if (canPrefetch(options)) {
-    client = createPrefetchClient(options)
-    processCache(options, fetchRequest)
-  }
-
-  const ssmMiddlewareBefore = async (request) => {
-    if (!client) {
-      client = await createClient(options, request)
-    }
-
-    const { value } = processCache(options, fetchRequest, request)
-
-    Object.assign(request.internal, value)
-
-    if (options.setToContext) {
-      const data = await getInternal(Object.keys(options.fetchData), request)
-      Object.assign(request.context, data)
-    }
-  }
-
-  return {
-    before: ssmMiddlewareBefore
-  }
-}
-
-export default ssmMiddleware
+	const options = { ...defaults, ...opts };
+
+	const fetchRequest = (request, cachedValues) => {
+		return {
+			...fetchSingleRequest(request, cachedValues),
+			...fetchByPathRequest(request, cachedValues),
+		};
+	};
+
+	const fetchSingleRequest = (request, cachedValues = {}) => {
+		const values = {};
+		let batchReq = null;
+		let batchInternalKeys = [];
+		let batchFetchKeys = [];
+		const namedKeys = [];
+
+		const internalKeys = Object.keys(options.fetchData);
+		const fetchKeys = Object.values(options.fetchData);
+		for (const internalKey of internalKeys) {
+			if (cachedValues[internalKey]) continue;
+			if (options.fetchData[internalKey].substr(-1) === "/") continue; // Skip path passed in
+			namedKeys.push(internalKey);
+		}
+
+		for (const [idx, internalKey] of namedKeys.entries()) {
+			const fetchKey = options.fetchData[internalKey];
+			batchInternalKeys.push(internalKey);
+			batchFetchKeys.push(fetchKey);
+			// from the first to the batch size skip, unless it's the last entry
+			if (
+				(!idx || (idx + 1) % awsRequestLimit !== 0) &&
+				!(idx + 1 === namedKeys.length)
+			) {
+				continue;
+			}
+
+			const command = new GetParametersCommand({
+				Names: batchFetchKeys,
+				WithDecryption: true,
+			});
+			batchReq = client
+				.send(command)
+				.catch((e) => catchInvalidSignatureException(e, client, command))
+				.then((resp) => {
+					// Don't sanitize key, mapped to set value in options
+					return Object.assign(
+						...(resp.InvalidParameters ?? []).map((fetchKey) => {
+							return {
+								[fetchKey]: new Promise(() => {
+									const internalKey = internalKeys[fetchKeys.indexOf(fetchKey)];
+									const value = getCache(options.cacheKey).value ?? {};
+									value[internalKey] = undefined;
+									modifyCache(options.cacheKey, value);
+									throw new Error(`InvalidParameter ${fetchKey}`, {
+										cause: { package: "@middy/ssm" },
+									});
+								}),
+							};
+						}),
+						...(resp.Parameters ?? []).map((param) => {
+							return { [param.Name]: parseValue(param) };
+						}),
+					);
+				})
+				.catch((e) => {
+					const value = getCache(options.cacheKey).value ?? {};
+					value[internalKey] = undefined;
+					modifyCache(options.cacheKey, value);
+					throw e;
+				});
+
+			for (const internalKey of batchInternalKeys) {
+				values[internalKey] = batchReq.then((params) => {
+					return params[options.fetchData[internalKey]];
+				});
+			}
+
+			batchInternalKeys = [];
+			batchFetchKeys = [];
+			batchReq = null;
+		}
+		return values;
+	};
+
+	const fetchByPathRequest = (request, cachedValues = {}) => {
+		const values = {};
+		for (const internalKey in options.fetchData) {
+			if (cachedValues[internalKey]) continue;
+			const fetchKey = options.fetchData[internalKey];
+			if (fetchKey.substr(-1) !== "/") continue; // Skip not path passed in
+			values[internalKey] = fetchPathRequest(fetchKey).catch((e) => {
+				const value = getCache(options.cacheKey).value ?? {};
+				value[internalKey] = undefined;
+				modifyCache(options.cacheKey, value);
+				throw e;
+			});
+		}
+		return values;
+	};
+
+	const fetchPathRequest = (path, nextToken, values = {}) => {
+		const command = new GetParametersByPathCommand({
+			Path: path,
+			NextToken: nextToken,
+			Recursive: true,
+			WithDecryption: true,
+		});
+		return client
+			.send(command)
+			.catch((e) => catchInvalidSignatureException(e, client, command))
+			.then((resp) => {
+				Object.assign(
+					values,
+					...resp.Parameters.map((param) => {
+						return {
+							[sanitizeKey(param.Name.replace(path, ""))]: parseValue(param),
+						};
+					}),
+				);
+				if (resp.NextToken) {
+					return fetchPathRequest(path, resp.NextToken, values);
+				}
+				return values;
+			});
+	};
+
+	const parseValue = (param) => {
+		if (param.Type === "StringList") {
+			return param.Value.split(",");
+		}
+		return jsonSafeParse(param.Value);
+	};
+
+	let client;
+	if (canPrefetch(options)) {
+		client = createPrefetchClient(options);
+		processCache(options, fetchRequest);
+	}
+
+	const ssmMiddlewareBefore = async (request) => {
+		if (!client) {
+			client = await createClient(options, request);
+		}
+
+		const { value } = processCache(options, fetchRequest, request);
+
+		Object.assign(request.internal, value);
+
+		if (options.setToContext) {
+			const data = await getInternal(Object.keys(options.fetchData), request);
+			Object.assign(request.context, data);
+		}
+	};
+
+	return {
+		before: ssmMiddlewareBefore,
+	};
+};
+
+export default ssmMiddleware;
 
 // used for TS type inference (see index.d.ts)
-export function ssmParam (name) {
-  return name
+export function ssmParam(name) {
+	return name;
 }

package/package.json

@@ -1,76 +1,73 @@
 {
-  "name": "@middy/ssm",
-  "version": "6.1.6",
-  "description": "SSM (EC2 Systems Manager) parameters middleware for the middy framework",
-  "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"
-  ],
-  "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",
-    "Middy",
-    "SSM",
-    "EC2 Systems Manager",
-    "Parameters"
-  ],
-  "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/ssm"
-  },
-  "bugs": {
-    "url": "https://github.com/middyjs/middy/issues"
-  },
-  "homepage": "https://middy.js.org",
-  "funding": {
-    "type": "github",
-    "url": "https://github.com/sponsors/willfarrell"
-  },
-  "dependencies": {
-    "@middy/util": "6.1.6"
-  },
-  "devDependencies": {
-    "@aws-sdk/client-ssm": "^3.0.0",
-    "@middy/core": "6.1.6",
-    "@types/aws-lambda": "^8.10.101",
-    "aws-xray-sdk": "^3.3.3"
-  },
-  "gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431"
+	"name": "@middy/ssm",
+	"version": "6.2.1",
+	"description": "SSM (EC2 Systems Manager) parameters middleware for the middy framework",
+	"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"],
+	"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",
+		"Middy",
+		"SSM",
+		"EC2 Systems Manager",
+		"Parameters"
+	],
+	"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/ssm"
+	},
+	"bugs": {
+		"url": "https://github.com/middyjs/middy/issues"
+	},
+	"homepage": "https://middy.js.org",
+	"funding": {
+		"type": "github",
+		"url": "https://github.com/sponsors/willfarrell"
+	},
+	"dependencies": {
+		"@middy/util": "6.2.1"
+	},
+	"devDependencies": {
+		"@aws-sdk/client-ssm": "^3.0.0",
+		"@middy/core": "6.2.1",
+		"@types/aws-lambda": "^8.10.101",
+		"aws-xray-sdk": "^3.3.3"
+	},
+	"gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431"
 }