@rio-cloud/cdk-v2-constructs 6.12.6 → 6.13.0

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/appconfig/getAppConfig.d.ts

@@ -0,0 +1,140 @@
+import type { AppConfigGetOutput, GetAppConfigOptions } from '../types/AppConfigProvider.js';
+/**
+ * ## Intro
+ * The Parameters utility provides an AppConfigProvider that allows to retrieve configuration profiles from AWS AppConfig.
+ *
+ * ## Getting started
+ *
+ * This utility supports AWS SDK v3 for JavaScript only. This allows the utility to be modular, and you to install only
+ * the SDK packages you need and keep your bundle size small.
+ *
+ * To use the provider, you must install the Parameters utility and the AWS SDK v3 for JavaScript for AppConfig:
+ *
+ * ```sh
+ * npm install @aws-lambda-powertools/parameters @aws-sdk/client-appconfigdata
+ * ```
+ *
+ * ## Basic usage
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a configuration profile
+ *   const encodedConfig = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *   });
+ *   const config = new TextDecoder('utf-8').decode(encodedConfig);
+ * };
+ * ```
+ *
+ * ## Advanced usage
+ *
+ * ### Caching
+ *
+ * By default, the provider will cache parameters retrieved in-memory for 5 seconds.
+ * You can adjust how long values should be kept in cache by using the `maxAge` parameter.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a configuration profile and cache it for 10 seconds
+ *   const encodedConfig = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *   });
+ *   const config = new TextDecoder('utf-8').decode(encodedConfig);
+ * };
+ * ```
+ *
+ * If instead you'd like to always ensure you fetch the latest parameter from the store regardless if already available in cache, use the `forceFetch` parameter.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a config and always fetch the latest value
+ *   const config = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *     forceFetch: true,
+ *   });
+ *   const config = new TextDecoder('utf-8').decode(encodedConfig);
+ * };
+ * ```
+ *
+ * ### Transformations
+ *
+ * For configurations stored as freeform JSON, Freature Flag, you can use the transform argument for deserialization. This will return a JavaScript object instead of a string.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a JSON config or Feature Flag and parse it as JSON
+ *   const config = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *     transform: 'json'
+ *   });
+ * };
+ * ```
+ *
+ * For configurations that are instead stored as base64-encoded binary data, you can use the transform argument set to `binary` for decoding. This will return a decoded string.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a base64-encoded string and decode it
+ *   const config = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *     transform: 'binary'
+ *   });
+ * };
+ * ```
+ *
+ * ### Extra SDK options
+ *
+ * When retrieving a configuration profile, you can pass extra options to the AWS SDK v3 for JavaScript client by using the `sdkOptions` parameter.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a config and pass extra options to the AWS SDK v3 for JavaScript client
+ *   const config = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *     sdkOptions: {
+ *       RequiredMinimumPollIntervalInSeconds: 60,
+ *     },
+ *   });
+ *   const config = new TextDecoder('utf-8').decode(encodedConfig);
+ * };
+ * ```
+ *
+ * This object accepts the same options as the [AWS SDK v3 for JavaScript AppConfigData client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-appconfigdata/interfaces/startconfigurationsessioncommandinput.html).
+ *
+ * ### Built-in provider class
+ *
+ * For greater flexibility such as configuring the underlying SDK client used by built-in providers, you can use the {@link AppConfigProvider} class.
+ *
+ * For more usage examples, see [our documentation](https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/).
+ *
+ * @param {string} name - The name of the configuration profile or its ID
+ * @param {GetAppConfigOptions} options - Options to configure the provider
+ * @see https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/
+ */
+declare const getAppConfig: <ExplicitUserProvidedType = undefined, InferredFromOptionsType extends GetAppConfigOptions | undefined = GetAppConfigOptions>(name: string, options: InferredFromOptionsType & GetAppConfigOptions) => Promise<AppConfigGetOutput<ExplicitUserProvidedType, InferredFromOptionsType> | undefined>;
+export { getAppConfig };
+//# sourceMappingURL=getAppConfig.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/appconfig/getAppConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAppConfig.d.ts","sourceRoot":"","sources":["../../../src/appconfig/getAppConfig.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,+BAA+B,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuIG;AACH,QAAA,MAAM,YAAY,GAChB,wBAAwB,cACxB,uBAAuB,SACnB,mBAAmB,GACnB,SAAS,8BAEP,MAAM,WACH,uBAAuB,GAAG,mBAAmB,KACrD,OAAO,CACN,kBAAkB,CAAC,wBAAwB,EAAE,uBAAuB,CAAC,GACrE,SAAS,CAkBZ,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/appconfig/getAppConfig.js

@@ -0,0 +1,153 @@
+import { DEFAULT_PROVIDERS } from '../base/index.js';
+import { AppConfigProvider } from './AppConfigProvider.js';
+/**
+ * ## Intro
+ * The Parameters utility provides an AppConfigProvider that allows to retrieve configuration profiles from AWS AppConfig.
+ *
+ * ## Getting started
+ *
+ * This utility supports AWS SDK v3 for JavaScript only. This allows the utility to be modular, and you to install only
+ * the SDK packages you need and keep your bundle size small.
+ *
+ * To use the provider, you must install the Parameters utility and the AWS SDK v3 for JavaScript for AppConfig:
+ *
+ * ```sh
+ * npm install @aws-lambda-powertools/parameters @aws-sdk/client-appconfigdata
+ * ```
+ *
+ * ## Basic usage
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a configuration profile
+ *   const encodedConfig = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *   });
+ *   const config = new TextDecoder('utf-8').decode(encodedConfig);
+ * };
+ * ```
+ *
+ * ## Advanced usage
+ *
+ * ### Caching
+ *
+ * By default, the provider will cache parameters retrieved in-memory for 5 seconds.
+ * You can adjust how long values should be kept in cache by using the `maxAge` parameter.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a configuration profile and cache it for 10 seconds
+ *   const encodedConfig = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *   });
+ *   const config = new TextDecoder('utf-8').decode(encodedConfig);
+ * };
+ * ```
+ *
+ * If instead you'd like to always ensure you fetch the latest parameter from the store regardless if already available in cache, use the `forceFetch` parameter.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a config and always fetch the latest value
+ *   const config = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *     forceFetch: true,
+ *   });
+ *   const config = new TextDecoder('utf-8').decode(encodedConfig);
+ * };
+ * ```
+ *
+ * ### Transformations
+ *
+ * For configurations stored as freeform JSON, Freature Flag, you can use the transform argument for deserialization. This will return a JavaScript object instead of a string.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a JSON config or Feature Flag and parse it as JSON
+ *   const config = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *     transform: 'json'
+ *   });
+ * };
+ * ```
+ *
+ * For configurations that are instead stored as base64-encoded binary data, you can use the transform argument set to `binary` for decoding. This will return a decoded string.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a base64-encoded string and decode it
+ *   const config = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *     transform: 'binary'
+ *   });
+ * };
+ * ```
+ *
+ * ### Extra SDK options
+ *
+ * When retrieving a configuration profile, you can pass extra options to the AWS SDK v3 for JavaScript client by using the `sdkOptions` parameter.
+ *
+ * @example
+ * ```typescript
+ * import { getAppConfig } from '@aws-lambda-powertools/parameters/appconfig';
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a config and pass extra options to the AWS SDK v3 for JavaScript client
+ *   const config = await getAppConfig('my-config', {
+ *     application: 'my-app',
+ *     environment: 'prod',
+ *     sdkOptions: {
+ *       RequiredMinimumPollIntervalInSeconds: 60,
+ *     },
+ *   });
+ *   const config = new TextDecoder('utf-8').decode(encodedConfig);
+ * };
+ * ```
+ *
+ * This object accepts the same options as the [AWS SDK v3 for JavaScript AppConfigData client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-appconfigdata/interfaces/startconfigurationsessioncommandinput.html).
+ *
+ * ### Built-in provider class
+ *
+ * For greater flexibility such as configuring the underlying SDK client used by built-in providers, you can use the {@link AppConfigProvider} class.
+ *
+ * For more usage examples, see [our documentation](https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/).
+ *
+ * @param {string} name - The name of the configuration profile or its ID
+ * @param {GetAppConfigOptions} options - Options to configure the provider
+ * @see https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/
+ */
+const getAppConfig = (name, options) => {
+    if (!Object.hasOwn(DEFAULT_PROVIDERS, 'appconfig')) {
+        DEFAULT_PROVIDERS.appconfig = new AppConfigProvider({
+            application: options?.application,
+            environment: options.environment,
+        });
+    }
+    return DEFAULT_PROVIDERS.appconfig.get(name, {
+        maxAge: options?.maxAge,
+        transform: options?.transform,
+        forceFetch: options?.forceFetch,
+        sdkOptions: options?.sdkOptions,
+    });
+};
+export { getAppConfig };

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/appconfig/index.d.ts

@@ -0,0 +1,3 @@
+export { AppConfigProvider } from './AppConfigProvider.js';
+export { getAppConfig } from './getAppConfig.js';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/appconfig/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/appconfig/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/appconfig/index.js

@@ -0,0 +1,2 @@
+export { AppConfigProvider } from './AppConfigProvider.js';
+export { getAppConfig } from './getAppConfig.js';

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/BaseProvider.d.ts

@@ -0,0 +1,83 @@
+import { EnvironmentVariablesService } from '../config/EnvironmentVariablesService.js';
+import type { BaseProviderInterface, GetMultipleOptionsInterface, GetOptionsInterface } from '../types/BaseProvider.js';
+import { ExpirableValue } from './ExpirableValue.js';
+/**
+ * Base class for all providers.
+ *
+ * As an abstract class, it should not be used directly, but rather extended by other providers.
+ *
+ * It implements the common logic for all providers, such as caching, transformation, etc.
+ * Each provider that extends this class must implement the `_get` and `_getMultiple` abstract methods.
+ *
+ * These methods are responsible for retrieving the values from the underlying parameter store. They are
+ * called by the `get` and `getMultiple` methods, which are responsible for caching and transformation.
+ *
+ * If there are multiple calls to the same parameter but in a different transform, they will be stored multiple times.
+ * This allows us to optimize by transforming the data only once per retrieval, thus there is no need to transform cached values multiple times.
+ *
+ * However, this means that we need to make multiple calls to the underlying parameter store if we need to return it in different transforms.
+ *
+ * Since the number of supported transform is small and the probability that a given parameter will always be used in a specific transform,
+ * this should be an acceptable tradeoff.
+ */
+declare abstract class BaseProvider implements BaseProviderInterface {
+    envVarsService: EnvironmentVariablesService;
+    protected client: unknown;
+    protected store: Map<string, ExpirableValue>;
+    constructor({ awsSdkV3Client, clientConfig, proto, }: {
+        awsSdkV3Client?: unknown;
+        clientConfig?: unknown;
+        proto: new (config?: unknown) => unknown;
+    });
+    /**
+     * Add a value to the cache.
+     *
+     * @param {string} key - Key of the cached value
+     * @param {string | Uint8Array | Record<string, unknown>} value - Value to be cached
+     * @param {number} maxAge - Maximum age in seconds for the value to be cached
+     */
+    addToCache(key: string, value: unknown, maxAge: number): void;
+    /**
+     * Clear the cache.
+     */
+    clearCache(): void;
+    /**
+     * Retrieve a parameter value or return the cached value.
+     *
+     * @param {string} name - Parameter name
+     * @param {GetOptionsInterface} options - Options to configure maximum age, trasformation, AWS SDK options, or force fetch
+     */
+    get(name: string, options?: GetOptionsInterface): Promise<unknown | undefined>;
+    /**
+     * Retrieve multiple parameter values or return the cached values.
+     *
+     * @param {string} path - Parameters path
+     * @param {GetMultipleOptionsInterface} options - Options to configure maximum age, trasformation, AWS SDK options, or force fetch
+     * @returns
+     */
+    getMultiple(path: string, options?: GetMultipleOptionsInterface): Promise<unknown>;
+    /**
+     * Check whether a key has expired in the cache or not.
+     *
+     * It returns true if the key is expired or not present in the cache.
+     *
+     * @param {string} key - Stringified representation of the key to retrieve
+     */
+    hasKeyExpiredInCache(key: string): boolean;
+    /**
+     * Retrieve parameter value from the underlying parameter store.
+     *
+     * @param {string} name - Parameter name
+     * @param {unknown} options - Options to pass to the underlying implemented method
+     */
+    protected abstract _get(name: string, options?: unknown): Promise<unknown>;
+    /**
+     * Retrieve multiple parameter values from the underlying parameter store.
+     *
+     * @param {string} path - Parameter name
+     * @param {unknown} options - Options to pass to the underlying implementated method
+     */
+    protected abstract _getMultiple(path: string, options?: unknown): Promise<Record<string, unknown> | undefined>;
+}
+export { BaseProvider };
+//# sourceMappingURL=BaseProvider.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/BaseProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseProvider.d.ts","sourceRoot":"","sources":["../../../src/base/BaseProvider.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AAEvF,OAAO,KAAK,EACV,qBAAqB,EACrB,2BAA2B,EAC3B,mBAAmB,EACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAKrD;;;;;;;;;;;;;;;;;;GAkBG;AACH,uBAAe,YAAa,YAAW,qBAAqB;IACnD,cAAc,EAAE,2BAA2B,CAAC;IACnD,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1B,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;gBAE1B,EACjB,cAAc,EACd,YAAY,EACZ,KAAK,GACN,EAAE;QACD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,KAAK,EAAE,KAAK,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;KAC1C;IAkBD;;;;;;OAMG;IACI,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAMpE;;OAEG;IACI,UAAU,IAAI,IAAI;IAIzB;;;;;OAKG;IACU,GAAG,CACd,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;IA6B/B;;;;;;OAMG;IACU,WAAW,CACtB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,OAAO,CAAC;IAiDnB;;;;;;OAMG;IACI,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAOjD;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAE1E;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CAChD;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/BaseProvider.js

@@ -0,0 +1,151 @@
+import { addUserAgentMiddleware, isNullOrUndefined, isRecord, isSdkClient, isString, } from '@aws-lambda-powertools/commons';
+import { EnvironmentVariablesService } from '../config/EnvironmentVariablesService.js';
+import { GetParameterError, TransformParameterError } from '../errors.js';
+import { ExpirableValue } from './ExpirableValue.js';
+import { GetMultipleOptions } from './GetMultipleOptions.js';
+import { GetOptions } from './GetOptions.js';
+import { transformValue } from './transformValue.js';
+/**
+ * Base class for all providers.
+ *
+ * As an abstract class, it should not be used directly, but rather extended by other providers.
+ *
+ * It implements the common logic for all providers, such as caching, transformation, etc.
+ * Each provider that extends this class must implement the `_get` and `_getMultiple` abstract methods.
+ *
+ * These methods are responsible for retrieving the values from the underlying parameter store. They are
+ * called by the `get` and `getMultiple` methods, which are responsible for caching and transformation.
+ *
+ * If there are multiple calls to the same parameter but in a different transform, they will be stored multiple times.
+ * This allows us to optimize by transforming the data only once per retrieval, thus there is no need to transform cached values multiple times.
+ *
+ * However, this means that we need to make multiple calls to the underlying parameter store if we need to return it in different transforms.
+ *
+ * Since the number of supported transform is small and the probability that a given parameter will always be used in a specific transform,
+ * this should be an acceptable tradeoff.
+ */
+class BaseProvider {
+    envVarsService;
+    client;
+    store;
+    constructor({ awsSdkV3Client, clientConfig, proto, }) {
+        this.store = new Map();
+        this.envVarsService = new EnvironmentVariablesService();
+        if (awsSdkV3Client) {
+            if (!isSdkClient(awsSdkV3Client)) {
+                console.warn('awsSdkV3Client is not an AWS SDK v3 client, using default client');
+                this.client = new proto(clientConfig ?? {});
+            }
+            else {
+                this.client = awsSdkV3Client;
+            }
+        }
+        else {
+            this.client = new proto(clientConfig ?? {});
+        }
+        addUserAgentMiddleware(this.client, 'parameters');
+    }
+    /**
+     * Add a value to the cache.
+     *
+     * @param {string} key - Key of the cached value
+     * @param {string | Uint8Array | Record<string, unknown>} value - Value to be cached
+     * @param {number} maxAge - Maximum age in seconds for the value to be cached
+     */
+    addToCache(key, value, maxAge) {
+        if (maxAge <= 0)
+            return;
+        this.store.set(key, new ExpirableValue(value, maxAge));
+    }
+    /**
+     * Clear the cache.
+     */
+    clearCache() {
+        this.store.clear();
+    }
+    /**
+     * Retrieve a parameter value or return the cached value.
+     *
+     * @param {string} name - Parameter name
+     * @param {GetOptionsInterface} options - Options to configure maximum age, trasformation, AWS SDK options, or force fetch
+     */
+    async get(name, options) {
+        const configs = new GetOptions(this.envVarsService, options);
+        const key = [name, configs.transform].toString();
+        if (!configs.forceFetch && !this.hasKeyExpiredInCache(key)) {
+            return this.store.get(key)?.value;
+        }
+        try {
+            let value = await this._get(name, options);
+            if (isNullOrUndefined(value))
+                return undefined;
+            if (configs.transform &&
+                (isString(value) || value instanceof Uint8Array)) {
+                value = transformValue(value, configs.transform, true, name);
+            }
+            this.addToCache(key, value, configs.maxAge);
+            return value;
+        }
+        catch (error) {
+            if (error instanceof TransformParameterError)
+                throw error;
+            throw new GetParameterError(error.message);
+        }
+    }
+    /**
+     * Retrieve multiple parameter values or return the cached values.
+     *
+     * @param {string} path - Parameters path
+     * @param {GetMultipleOptionsInterface} options - Options to configure maximum age, trasformation, AWS SDK options, or force fetch
+     * @returns
+     */
+    async getMultiple(path, options) {
+        const configs = new GetMultipleOptions(this.envVarsService, options);
+        const key = [path, configs.transform].toString();
+        if (!configs.forceFetch && !this.hasKeyExpiredInCache(key)) {
+            // biome-ignore lint/style/noNonNullAssertion: If the code enters in this block, then the key must exist & not have been expired
+            return this.store.get(key).value;
+        }
+        let values;
+        try {
+            values = await this._getMultiple(path, options);
+            if (!isRecord(values)) {
+                throw new GetParameterError(`Expected result to be a Record<string, unknown> but got ${typeof values}`);
+            }
+        }
+        catch (error) {
+            throw new GetParameterError(error.message);
+        }
+        if (configs.transform) {
+            for (const [entryKey, entryValue] of Object.entries(values)) {
+                if (!(isString(entryValue) || entryValue instanceof Uint8Array))
+                    continue;
+                try {
+                    values[entryKey] = transformValue(entryValue, configs.transform, configs.throwOnTransformError, entryKey);
+                }
+                catch (error) {
+                    if (configs.throwOnTransformError)
+                        throw new TransformParameterError(configs.transform, error.message);
+                }
+            }
+        }
+        if (Object.keys(values).length !== 0) {
+            this.addToCache(key, values, configs.maxAge);
+        }
+        return values;
+    }
+    /**
+     * Check whether a key has expired in the cache or not.
+     *
+     * It returns true if the key is expired or not present in the cache.
+     *
+     * @param {string} key - Stringified representation of the key to retrieve
+     */
+    hasKeyExpiredInCache(key) {
+        const value = this.store.get(key);
+        if (value)
+            return value.isExpired();
+        return true;
+    }
+}
+export { BaseProvider };

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/DefaultProviders.d.ts

@@ -0,0 +1,10 @@
+import type { BaseProviderInterface } from '../types/BaseProvider.js';
+declare const DEFAULT_PROVIDERS: Record<string, BaseProviderInterface>;
+/**
+ * Utility function to clear all the caches of the default providers.
+ *
+ * This is useful when you want to clear the cache of all the providers at once, for example during testing.
+ */
+declare const clearCaches: () => void;
+export { DEFAULT_PROVIDERS, clearCaches };
+//# sourceMappingURL=DefaultProviders.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/DefaultProviders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultProviders.d.ts","sourceRoot":"","sources":["../../../src/base/DefaultProviders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAGtE,QAAA,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAM,CAAC;AAEpE;;;;GAIG;AACH,QAAA,MAAM,WAAW,QAAO,IAMvB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/DefaultProviders.js

@@ -0,0 +1,15 @@
+// These providers are dinamycally intialized on first use of the helper functions
+const DEFAULT_PROVIDERS = {};
+/**
+ * Utility function to clear all the caches of the default providers.
+ *
+ * This is useful when you want to clear the cache of all the providers at once, for example during testing.
+ */
+const clearCaches = () => {
+    for (const provider of Object.values(DEFAULT_PROVIDERS)) {
+        if (provider.clearCache) {
+            provider.clearCache();
+        }
+    }
+};
+export { DEFAULT_PROVIDERS, clearCaches };

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/ExpirableValue.d.ts

@@ -0,0 +1,25 @@
+import type { ExpirableValueInterface } from '../types/BaseProvider.js';
+/**
+ * Class to represent a value that can expire.
+ *
+ * Upon creation, the value is assigned a TTL (time to live) that is calculated
+ * by adding the current time with the maximum age.
+ */
+declare class ExpirableValue implements ExpirableValueInterface {
+    ttl: number;
+    value: unknown;
+    /**
+     *
+     * @param value - Value to be cached
+     * @param maxAge - Maximum age in seconds for the value to be cached
+     */
+    constructor(value: unknown, maxAge: number);
+    /**
+     * Check if the value has expired.
+     *
+     * @returns {boolean} - True if the value has expired, false otherwise
+     */
+    isExpired(): boolean;
+}
+export { ExpirableValue };
+//# sourceMappingURL=ExpirableValue.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/ExpirableValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpirableValue.d.ts","sourceRoot":"","sources":["../../../src/base/ExpirableValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAExE;;;;;GAKG;AACH,cAAM,cAAe,YAAW,uBAAuB;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;gBACgB,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM;IAMjD;;;;OAIG;IACI,SAAS,IAAI,OAAO;CAG5B;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/ExpirableValue.js

@@ -0,0 +1,29 @@
+/**
+ * Class to represent a value that can expire.
+ *
+ * Upon creation, the value is assigned a TTL (time to live) that is calculated
+ * by adding the current time with the maximum age.
+ */
+class ExpirableValue {
+    ttl;
+    value;
+    /**
+     *
+     * @param value - Value to be cached
+     * @param maxAge - Maximum age in seconds for the value to be cached
+     */
+    constructor(value, maxAge) {
+        this.value = value;
+        const timeNow = new Date();
+        this.ttl = timeNow.setSeconds(timeNow.getSeconds() + maxAge);
+    }
+    /**
+     * Check if the value has expired.
+     *
+     * @returns {boolean} - True if the value has expired, false otherwise
+     */
+    isExpired() {
+        return this.ttl < Date.now();
+    }
+}
+export { ExpirableValue };

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/GetMultipleOptions.d.ts

@@ -0,0 +1,14 @@
+import type { EnvironmentVariablesService } from '../config/EnvironmentVariablesService.js';
+import type { GetMultipleOptionsInterface } from '../types/BaseProvider.js';
+import { GetOptions } from './GetOptions.js';
+/**
+ * Options for the `getMultiple` method.
+ *
+ * Extends the `GetOptions` class and adds the `throwOnTransformError` option.
+ */
+declare class GetMultipleOptions extends GetOptions implements GetMultipleOptionsInterface {
+    throwOnTransformError: boolean;
+    constructor(envVarsService: EnvironmentVariablesService, options?: GetMultipleOptionsInterface);
+}
+export { GetMultipleOptions };
+//# sourceMappingURL=GetMultipleOptions.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/base/GetMultipleOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetMultipleOptions.d.ts","sourceRoot":"","sources":["../../../src/base/GetMultipleOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AAC5F,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;GAIG;AACH,cAAM,kBACJ,SAAQ,UACR,YAAW,2BAA2B;IAE/B,qBAAqB,UAAS;gBAGnC,cAAc,EAAE,2BAA2B,EAC3C,OAAO,GAAE,2BAAgC;CAQ5C;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}