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

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/dynamodb/DynamoDBProvider.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBProvider = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const BaseProvider_js_1 = require("../base/BaseProvider.js");
+/**
+ * ## Intro
+ * The Parameters utility provides a DynamoDBProvider that allows to retrieve values from Amazon DynamoDB.
+ *
+ * ## Getting started
+ *
+ * This utility supports AWS SDK v3 for JavaScript only (`@aws-sdk/client-dynamodb` and `@aws-sdk/util-dynamodb`). This allows the utility to be modular, and you to install only
+ * the SDK packages you need and keep your bundle size small.
+ *
+ * ## Basic usage
+ *
+ * Retrieve a value from DynamoDB:
+ *
+ * @example
+ * ```typescript
+ * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ * });
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a value from DynamoDB
+ *   const value = await tableProvider.get('my-value-key');
+ * };
+ * ```
+ *
+ * You can also retrieve multiple values at once:
+ *
+ * @example
+ * ```typescript
+ * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ * });
+ *
+ * export const handler = async (): Promise<void> => {
+ *  // Retrieve multiple values from DynamoDB
+ *  const values = await tableProvider.getMultiple('my-values-path');
+ * };
+ * ```
+ *
+ * ## 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 { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ * });
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a value and cache it for 10 seconds
+ *   const value = await tableProvider.get('my-value-key', { maxAge: 10 });
+ *   // Retrieve multiple values and cache them for 20 seconds
+ *   const values = await tableProvider.getMultiple('my-values-path', { maxAge: 20 });
+ * };
+ * ```
+ *
+ * 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 { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ * });
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a value and skip cache
+ *   const value = await tableProvider.get('my-value-key', { forceFetch: true });
+ *   // Retrieve multiple values and skip cache
+ *   const values = await tableProvider.getMultiple('my-values-path', { forceFetch: true });
+ * };
+ * ```
+ *
+ * ### Transformations
+ *
+ * For values stored as JSON you can use the transform argument for deserialization. This will return a JavaScript object instead of a string.
+ *
+ * @example
+ * ```typescript
+ * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ * });
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a value and parse it as JSON
+ *   const value = await tableProvider.get('my-value-key', { transform: 'json' });
+ *   // Retrieve multiple values and parse them as JSON
+ *   const values = await tableProvider.getMultiple('my-values-path', { transform: 'json' });
+ * };
+ * ```
+ *
+ * For values 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 { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ * });
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a base64-encoded string and decode it
+ *   const value = await tableProvider.get('my-value-key', { transform: 'binary' });
+ *   // Retrieve multiple base64-encoded strings and decode them
+ *   const values = await tableProvider.getMultiple('my-values-path', { transform: 'binary' });
+ * };
+ * ```
+ *
+ * When retrieving multiple values, you can also use the `transform` argument set to `auto` to let the provider automatically detect the type of transformation to apply.
+ * The provider will use the suffix of the sort key (`sk`) to determine the transformation to apply. For example, if the sort key is `my-value-key.json`, the provider will
+ * automatically parse the value as JSON. Likewise, if the sort key is `my-value-key.binary`, the provider will automatically decode the value as base64-encoded binary data.
+ *
+ * @example
+ * ```typescript
+ * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ * });
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve multiple values and automatically detect the transformation to apply
+ *   const values = await tableProvider.getMultiple('my-values-path', { transform: 'auto' });
+ * };
+ * ```
+ *
+ * ### Custom key names
+ *
+ * By default, the provider will use the following key names: `id` for the partition key, `sk` for the sort key, and `value` for the value.
+ * You can adjust the key names by using the `keyAttr`, `sortAttr`, and `valueAttr` parameters.
+ *
+ * @example
+ * ```typescript
+ * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ *   keyAttr: 'key',
+ *   sortAttr: 'sort',
+ *   valueAttr: 'val',
+ * });
+ * ```
+ *
+ * ### Extra SDK options
+ *
+ * When retrieving values, you can pass extra options to the AWS SDK v3 for JavaScript client by using the `sdkOptions` parameter.
+ *
+ * @example
+ * ```typescript
+ * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   tableName: 'my-table',
+ * });
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a value and pass extra options to the AWS SDK v3 for JavaScript client
+ *   const value = await tableProvider.get('my-value-key', {
+ *     sdkOptions: {
+ *       ConsistentRead: true,
+ *     },
+ *   });
+ * };
+ * ```
+ *
+ * The objects accept the same options as respectively the [AWS SDK v3 for JavaScript PutItem command](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-dynamodb/classes/putitemcommand.html) and the [AWS SDK v3 for JavaScript DynamoDB client Query command](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-dynamodb/classes/querycommand.html).
+ *
+ * ### Customize AWS SDK v3 for JavaScript client
+ *
+ * By default, the provider will create a new DynamoDB client using the default configuration.
+ *
+ * You can customize the client by passing a custom configuration object to the provider.
+ *
+ * @example
+ * ```typescript
+ * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ *
+ * const tableProvider = new DynamoDBProvider({
+ *   clientConfig: { region: 'eu-west-1' },
+ * });
+ * ```
+ *
+ * This object accepts the same options as the [AWS SDK v3 for JavaScript DynamoDB client constructor](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-dynamodb/classes/dynamodbclient.html).
+ *
+ * Otherwise, if you want to use a custom client altogether, you can pass it to the provider.
+ *
+ * @example
+ * ```typescript
+ * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+ * import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+ *
+ * const client = new DynamoDBClient({ region: 'eu-west-1' });
+ * const tableProvider = new DynamoDBProvider({
+ *   awsSdkV3Client: client,
+ * });
+ * ```
+ *
+ * This object must be an instance of the [AWS SDK v3 for JavaScript DynamoDB client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-dynamodb/classes/dynamodbclient.html).
+ *
+ * For more usage examples, see [our documentation](https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/).
+ */
+class DynamoDBProvider extends BaseProvider_js_1.BaseProvider {
+    keyAttr = 'id';
+    sortAttr = 'sk';
+    tableName;
+    valueAttr = 'value';
+    /**
+     * It initializes the DynamoDBProvider class.
+     *
+     * @param {DynamoDBProviderOptions} config - The configuration object.
+     */
+    constructor(config) {
+        super({
+            proto: client_dynamodb_1.DynamoDBClient,
+            ...config,
+        });
+        const { tableName, keyAttr, sortAttr, valueAttr } = config;
+        this.tableName = tableName;
+        if (keyAttr)
+            this.keyAttr = keyAttr;
+        if (sortAttr)
+            this.sortAttr = sortAttr;
+        if (valueAttr)
+            this.valueAttr = valueAttr;
+    }
+    /**
+     * Retrieve a value from Amazon DynamoDB.
+     *
+     * @example
+     * ```typescript
+     * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+     *
+     * const tableProvider = new DynamoDBProvider({
+     *   tableName: 'my-table',
+     * });
+     *
+     * export const handler = async (): Promise<void> => {
+     *   // Retrieve a single value
+     *   const value = await tableProvider.get('my-value-key');
+     * };
+     * ```
+     *
+     * You can customize the retrieval of the value by passing options to the function:
+     * * `maxAge` - The maximum age of the value in cache before fetching a new one (in seconds) (default: 5)
+     * * `forceFetch` - Whether to always fetch a new value from the store regardless if already available in cache
+     * * `transform` - Whether to transform the value before returning it. Supported values: `json`, `binary`
+     * * `sdkOptions` - Extra options to pass to the AWS SDK v3 for JavaScript client
+     *
+     * For usage examples check {@link DynamoDBProvider}.
+     *
+     * @param {string} name - The name of the value to retrieve (i.e. the partition key)
+     * @param {DynamoDBGetOptionsInterface} options - Options to configure the provider
+     * @see https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/
+     */
+    async get(name, options) {
+        return super.get(name, options);
+    }
+    /**
+     * Retrieve multiple values from Amazon DynamoDB.
+     *
+     * @example
+     * ```typescript
+     * import { DynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamodb';
+     *
+     * const tableProvider = new DynamoDBProvider({
+     *   tableName: 'my-table',
+     * });
+     *
+     * export const handler = async (): Promise<void> => {
+     *   // Retrieve multiple values
+     *   const values = await tableProvider.getMultiple('my-values-path');
+     * };
+     * ```
+     *
+     * You can customize the retrieval of the values by passing options to the function:
+     * * `maxAge` - The maximum age of the value in cache before fetching a new one (in seconds) (default: 5)
+     * * `forceFetch` - Whether to always fetch a new value from the store regardless if already available in cache
+     * * `transform` - Whether to transform the value before returning it. Supported values: `json`, `binary`
+     * * `sdkOptions` - Extra options to pass to the AWS SDK v3 for JavaScript client
+     * * `throwOnTransformError` - Whether to throw an error if the transform fails (default: `true`)
+     *
+     * For usage examples check {@link DynamoDBProvider}.
+     *
+     * @param {string} path - The path of the values to retrieve (i.e. the partition key)
+     * @param {DynamoDBGetMultipleOptions} options - Options to configure the provider
+     * @see https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/
+     */
+    async getMultiple(path, options) {
+        return super.getMultiple(path, options);
+    }
+    /**
+     * Retrieve an item from Amazon DynamoDB.
+     *
+     * @param {string} name - Key of the item to retrieve (i.e. the partition key)
+     * @param {DynamoDBGetOptions} options - Options to customize the retrieval
+     */
+    async _get(name, options) {
+        const sdkOptions = {
+            ...(options?.sdkOptions || {}),
+            TableName: this.tableName,
+            Key: (0, util_dynamodb_1.marshall)({ [this.keyAttr]: name }),
+            ProjectionExpression: '#value',
+            ExpressionAttributeNames: {
+                '#value': this.valueAttr,
+            },
+        };
+        const result = await this.client.send(new client_dynamodb_1.GetItemCommand(sdkOptions));
+        return result.Item ? (0, util_dynamodb_1.unmarshall)(result.Item)[this.valueAttr] : undefined;
+    }
+    /**
+     * Retrieve multiple items from Amazon DynamoDB.
+     *
+     * @param {string} path - The path of the values to retrieve (i.e. the partition key)
+     * @param {DynamoDBGetMultipleOptions} options - Options to customize the retrieval
+     */
+    async _getMultiple(path, options) {
+        const sdkOptions = {
+            ...(options?.sdkOptions || {}),
+            TableName: this.tableName,
+            KeyConditionExpression: '#key = :key',
+            ExpressionAttributeValues: (0, util_dynamodb_1.marshall)({ ':key': path }),
+            ExpressionAttributeNames: {
+                '#key': this.keyAttr,
+                '#sk': this.sortAttr,
+                '#value': this.valueAttr,
+            },
+            ProjectionExpression: '#sk, #value',
+        };
+        const paginationOptions = {
+            client: this.client,
+            pageSize: options?.sdkOptions?.Limit,
+        };
+        const parameters = {};
+        for await (const page of (0, client_dynamodb_1.paginateQuery)(paginationOptions, sdkOptions)) {
+            for (const item of page.Items || []) {
+                const unmarshalledItem = (0, util_dynamodb_1.unmarshall)(item);
+                parameters[unmarshalledItem[this.sortAttr]] =
+                    unmarshalledItem[this.valueAttr];
+            }
+        }
+        return parameters;
+    }
+}
+exports.DynamoDBProvider = DynamoDBProvider;

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/dynamodb/index.d.ts

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

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/dynamodb/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dynamodb/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/dynamodb/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBProvider = void 0;
+var DynamoDBProvider_js_1 = require("./DynamoDBProvider.js");
+Object.defineProperty(exports, "DynamoDBProvider", { enumerable: true, get: function () { return DynamoDBProvider_js_1.DynamoDBProvider; } });

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/errors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Error thrown when a parameter cannot be retrieved.
+ *
+ * You can use this error to catch and handle errors when getting a parameter, the `cause` property will contain the original error.
+ */
+declare class GetParameterError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when a parameter cannot be set.
+ *
+ * You can use this error to catch and handle errors when setting a parameter, the `cause` property will contain the original error.
+ */
+declare class SetParameterError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when a transform fails.
+ */
+declare class TransformParameterError extends Error {
+    constructor(transform: string, message: string);
+}
+export { GetParameterError, TransformParameterError, SetParameterError };
+//# sourceMappingURL=errors.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAM,iBAAkB,SAAQ,KAAK;gBAChB,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAI5D;AAED;;;;GAIG;AACH,cAAM,iBAAkB,SAAQ,KAAK;gBAChB,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAI5D;AAED;;GAEG;AACH,cAAM,uBAAwB,SAAQ,KAAK;gBACtB,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAKtD;AAED,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/errors.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetParameterError = exports.TransformParameterError = exports.GetParameterError = void 0;
+/**
+ * Error thrown when a parameter cannot be retrieved.
+ *
+ * You can use this error to catch and handle errors when getting a parameter, the `cause` property will contain the original error.
+ */
+class GetParameterError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'GetParameterError';
+    }
+}
+exports.GetParameterError = GetParameterError;
+/**
+ * Error thrown when a parameter cannot be set.
+ *
+ * You can use this error to catch and handle errors when setting a parameter, the `cause` property will contain the original error.
+ */
+class SetParameterError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'SetParameterError';
+    }
+}
+exports.SetParameterError = SetParameterError;
+/**
+ * Error thrown when a transform fails.
+ */
+class TransformParameterError extends Error {
+    constructor(transform, message) {
+        super(message);
+        this.name = 'TransformParameterError';
+        this.message = `Unable to transform value using '${transform}' transform: ${message}`;
+    }
+}
+exports.TransformParameterError = TransformParameterError;

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

@@ -0,0 +1,4 @@
+export { clearCaches } from './base/DefaultProviders.js';
+export { GetParameterError, TransformParameterError } from './errors.js';
+export { Transform } from './constants.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transform = exports.TransformParameterError = exports.GetParameterError = exports.clearCaches = void 0;
+var DefaultProviders_js_1 = require("./base/DefaultProviders.js");
+Object.defineProperty(exports, "clearCaches", { enumerable: true, get: function () { return DefaultProviders_js_1.clearCaches; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "GetParameterError", { enumerable: true, get: function () { return errors_js_1.GetParameterError; } });
+Object.defineProperty(exports, "TransformParameterError", { enumerable: true, get: function () { return errors_js_1.TransformParameterError; } });
+var constants_js_1 = require("./constants.js");
+Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return constants_js_1.Transform; } });

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/secrets/SecretsProvider.d.ts

@@ -0,0 +1,192 @@
+import { SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+import { BaseProvider } from '../base/BaseProvider.js';
+import type { SecretsGetOptions, SecretsGetOutput, SecretsProviderOptions } from '../types/SecretsProvider.js';
+/**
+ * ## Intro
+ * The Parameters utility provides a SecretsProvider that allows to retrieve secrets from AWS Secrets Manager.
+ *
+ * ## Getting started
+ *
+ * This utility supports AWS SDK v3 for JavaScript only (`@aws-sdk/client-secrets-manager`). This allows the utility to be modular, and you to install only
+ * the SDK packages you need and keep your bundle size small.
+ *
+ * ## Basic usage
+ *
+ * @example
+ * ```typescript
+ * import { SecretsProvider } from '@aws-lambda-powertools/parameters/secrets';
+ *
+ * const secretsProvider = new SecretsProvider();
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a secret
+ *   const secret = await secretsProvider.get('my-secret');
+ * };
+ * ```
+ *
+ * If you want to retrieve secrets without customizing the provider, you can use the {@link getSecret} function instead.
+ *
+ * ## 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 { SecretsProvider } from '@aws-lambda-powertools/parameters/secrets';
+ *
+ * const secretsProvider = new SecretsProvider();
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a secret and cache it for 10 seconds
+ *   const secret = await secretsProvider.get('my-secret', { maxAge: 10 });
+ * };
+ * ```
+ *
+ * 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 { SecretsProvider } from '@aws-lambda-powertools/parameters/secrets';
+ *
+ * const secretsProvider = new SecretsProvider();
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a secret and always fetch the latest value
+ *   const secret = await secretsProvider.get('my-secret', { forceFetch: true });
+ * };
+ * ```
+ *
+ * ### Transformations
+ *
+ * For parameters stored in JSON or Base64 format, you can use the transform argument for deserialization.
+ *
+ * @example
+ * ```typescript
+ * import { SecretsProvider } from '@aws-lambda-powertools/parameters/secrets';
+ *
+ * const secretsProvider = new SecretsProvider();
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a secret and parse it as JSON
+ *   const secret = await secretsProvider.get('my-secret', { transform: 'json' });
+ * };
+ * ```
+ *
+ * ### Extra SDK options
+ *
+ * When retrieving a secret, you can pass extra options to the AWS SDK v3 for JavaScript client by using the `sdkOptions` parameter.
+ *
+ * @example
+ * ```typescript
+ * import { SecretsProvider } from '@aws-lambda-powertools/parameters/secrets';
+ *
+ * const secretsProvider = new SecretsProvider();
+ *
+ * export const handler = async (): Promise<void> => {
+ *   // Retrieve a secret and pass extra options to the AWS SDK v3 for JavaScript client
+ *   const secret = await secretsProvider.get('my-secret', {
+ *     sdkOptions: {
+ *       VersionId: 1,
+ *     },
+ *   });
+ * };
+ * ```
+ *
+ * This object accepts the same options as the [AWS SDK v3 for JavaScript Secrets Manager client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-secrets-manager/interfaces/getsecretvaluecommandinput.html).
+ *
+ * ### Customize AWS SDK v3 for JavaScript client
+ *
+ * By default, the provider will create a new Secrets Manager client using the default configuration.
+ *
+ * You can customize the client by passing a custom configuration object to the provider.
+ *
+ * @example
+ * ```typescript
+ * import { SecretsProvider } from '@aws-lambda-powertools/parameters/secrets';
+ *
+ * const secretsProvider = new SecretsProvider({
+ *  clientConfig: { region: 'eu-west-1' },
+ * });
+ * ```
+ *
+ * This object accepts the same options as the [AWS SDK v3 for JavaScript Secrets Manager client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-secrets-manager/interfaces/secretsmanagerclientconfig.html).
+ *
+ * Otherwise, if you want to use a custom client altogether, you can pass it to the provider.
+ *
+ * @example
+ * ```typescript
+ * import { SecretsProvider } from '@aws-lambda-powertools/parameters/secrets';
+ * import { SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+ *
+ * const client = new SecretsManagerClient({ region: 'eu-west-1' });
+ * const secretsProvider = new SecretsProvider({
+ *  awsSdkV3Client: client,
+ * });
+ * ```
+ *
+ * This object must be an instance of the [AWS SDK v3 for JavaScript Secrets Manager client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-secrets-manager/classes/secretsmanagerclient.html).
+ *
+ * For more usage examples, see [our documentation](https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/).
+ *
+ * @class
+ * @see https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/
+ */
+declare class SecretsProvider extends BaseProvider {
+    client: SecretsManagerClient;
+    /**
+     * It initializes the SecretsProvider class.
+     *
+     * @param {SecretsProviderOptions} config - The configuration object.
+     */
+    constructor(config?: SecretsProviderOptions);
+    /**
+     * Retrieve a secret from AWS Secrets Manager.
+     *
+     * @example
+     * ```typescript
+     * import { SecretsProvider } from '@aws-lambda-powertools/parameters/secrets';
+     *
+     * const secretsProvider = new SecretsProvider();
+     *
+     * export const handler = async (): Promise<void> => {
+     *   // Retrieve a secret
+     *   const secret = await secretsProvider.get('my-secret');
+     * };
+     * ```
+     *
+     * You can customize the retrieval of the secret by passing options to the function:
+     * * `maxAge` - The maximum age of the value in cache before fetching a new one (in seconds) (default: 5)
+     * * `forceFetch` - Whether to always fetch a new value from the store regardless if already available in cache
+     * * `transform` - Whether to transform the value before returning it. Supported values: `json`, `binary`
+     * * `sdkOptions` - Extra options to pass to the AWS SDK v3 for JavaScript client
+     *
+     * For usage examples check {@link SecretsProvider}.
+     *
+     * @param {string} name - The name of the secret
+     * @param {SecretsGetOptions} options - Options to customize the retrieval of the secret
+     * @see https://docs.powertools.aws.dev/lambda/typescript/latest/utilities/parameters/
+     */
+    get<ExplicitUserProvidedType = undefined, InferredFromOptionsType extends SecretsGetOptions | undefined = SecretsGetOptions>(name: string, options?: InferredFromOptionsType & SecretsGetOptions): Promise<SecretsGetOutput<ExplicitUserProvidedType, InferredFromOptionsType> | undefined>;
+    /**
+     * Retrieving multiple parameter values is not supported with AWS Secrets Manager.
+     */
+    getMultiple(path: string, _options?: unknown): Promise<void>;
+    /**
+     * Retrieve a configuration from AWS Secrets Manager.
+     *
+     * @param {string} name - Name of the configuration or its ID
+     * @param {SecretsGetOptions} options - SDK options to propagate to the AWS SDK v3 for JavaScript client
+     */
+    protected _get(name: string, options?: SecretsGetOptions): Promise<string | Uint8Array | undefined>;
+    /**
+     * Retrieving multiple parameter values is not supported with AWS Secrets Manager.
+     *
+     * @throws Not Implemented Error.
+     */
+    protected _getMultiple(_path: string, _options?: unknown): Promise<Record<string, unknown> | undefined>;
+}
+export { SecretsProvider };
+//# sourceMappingURL=SecretsProvider.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/cjs/secrets/SecretsProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecretsProvider.d.ts","sourceRoot":"","sources":["../../../src/secrets/SecretsProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,oBAAoB,EACrB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,6BAA6B,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoIG;AACH,cAAM,eAAgB,SAAQ,YAAY;IACzB,MAAM,EAAE,oBAAoB,CAAC;IAE5C;;;;OAIG;gBACgB,MAAM,CAAC,EAAE,sBAAsB;IASlD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACU,GAAG,CACd,wBAAwB,GAAG,SAAS,EACpC,uBAAuB,SACnB,iBAAiB,GACjB,SAAS,GAAG,iBAAiB,EAEjC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,uBAAuB,GAAG,iBAAiB,GACpD,OAAO,CACN,gBAAgB,CAAC,wBAAwB,EAAE,uBAAuB,CAAC,GACnE,SAAS,CACZ;IAOD;;OAEG;IACU,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzE;;;;;OAKG;cACa,IAAI,CAClB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;IAe3C;;;;OAIG;cACa,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,OAAO,GACjB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CAGhD;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}