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

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

@@ -0,0 +1,16 @@
+import { GetOptions } from './GetOptions.js';
+/**
+ * Options for the `getMultiple` method.
+ *
+ * Extends the `GetOptions` class and adds the `throwOnTransformError` option.
+ */
+class GetMultipleOptions extends GetOptions {
+    throwOnTransformError = false;
+    constructor(envVarsService, options = {}) {
+        super(envVarsService, options);
+        if (options.throwOnTransformError !== undefined) {
+            this.throwOnTransformError = options.throwOnTransformError;
+        }
+    }
+}
+export { GetMultipleOptions };

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

@@ -0,0 +1,16 @@
+import type { EnvironmentVariablesService } from '../config/EnvironmentVariablesService.js';
+import type { GetOptionsInterface, TransformOptions } from '../types/BaseProvider.js';
+/**
+ * Options for the `get` method.
+ *
+ * It merges the default options with the provided options.
+ */
+declare class GetOptions implements GetOptionsInterface {
+    forceFetch: boolean;
+    maxAge: number;
+    sdkOptions?: unknown;
+    transform?: TransformOptions;
+    constructor(envVarsService: EnvironmentVariablesService, options?: GetOptionsInterface);
+}
+export { GetOptions };
+//# sourceMappingURL=GetOptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GetOptions.d.ts","sourceRoot":"","sources":["../../../src/base/GetOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AAE5F,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,0BAA0B,CAAC;AAElC;;;;GAIG;AACH,cAAM,UAAW,YAAW,mBAAmB;IACtC,UAAU,UAAS;IACnB,MAAM,EAAG,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,gBAAgB,CAAC;gBAGlC,cAAc,EAAE,2BAA2B,EAC3C,OAAO,GAAE,mBAAwB;CASpC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

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

@@ -0,0 +1,20 @@
+import { DEFAULT_MAX_AGE_SECS } from '../constants.js';
+/**
+ * Options for the `get` method.
+ *
+ * It merges the default options with the provided options.
+ */
+class GetOptions {
+    forceFetch = false;
+    maxAge;
+    sdkOptions;
+    transform;
+    constructor(envVarsService, options = {}) {
+        Object.assign(this, options);
+        if (options.maxAge === undefined) {
+            this.maxAge =
+                envVarsService.getParametersMaxAge() ?? DEFAULT_MAX_AGE_SECS;
+        }
+    }
+}
+export { GetOptions };

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

@@ -0,0 +1,5 @@
+export { BaseProvider } from './BaseProvider.js';
+export { DEFAULT_PROVIDERS } from './DefaultProviders.js';
+export { GetOptions } from './GetOptions.js';
+export { GetMultipleOptions } from './GetMultipleOptions.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/base/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

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

@@ -0,0 +1,4 @@
+export { BaseProvider } from './BaseProvider.js';
+export { DEFAULT_PROVIDERS } from './DefaultProviders.js';
+export { GetOptions } from './GetOptions.js';
+export { GetMultipleOptions } from './GetMultipleOptions.js';

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

@@ -0,0 +1,28 @@
+import type { JSONValue } from '@aws-lambda-powertools/commons/types';
+import type { TransformOptions } from '../types/BaseProvider.js';
+/**
+ * Utility function to transform a value.
+ *
+ * It supports JSON and binary transformations, as well as an `auto` mode that will try to transform the value based on the key.
+ *
+ * The function supports both `string` and `Uint8Array` values as input. Other types will be returned as-is.
+ *
+ * If the value is a `Uint8Array`, it will be decoded to a string first. Then, when the transform is `json` or `auto` and the key ends with `.json`,
+ * the value will be parsed as JSON using the `JSON.parse` function.
+ *
+ * When the transform is `binary` or `auto` and the key ends with `.binary`, the value will be decoded from base64 using the `fromBase64` function
+ * from the `@aws-lambda-powertools/commons/utils/base64` package.
+ *
+ * If the transformation fails, the function will return the value as-is unless `throwOnTransformError` is set to `true`.
+ *
+ * When using `auto` mode, the key must end with either `.json` or `.binary` to be transformed. Automatic transformation is supported only for
+ * `getMultiple` calls.
+ *
+ * @param {string | Uint8Array} value - Value to be transformed
+ * @param {TransformOptions} transform - Transform to be applied, can be `json`, `binary`, or `auto`
+ * @param {boolean} throwOnTransformError - Whether to throw an error if the transformation fails, when transforming multiple values this can be set to false
+ * @param {string} key - Key of the value to be transformed, used to determine the transformation method when using 'auto'
+ */
+declare const transformValue: (value: string | Uint8Array, transform: TransformOptions, throwOnTransformError: boolean, key: string) => string | JSONValue | Uint8Array | undefined;
+export { transformValue };
+//# sourceMappingURL=transformValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformValue.d.ts","sourceRoot":"","sources":["../../../src/base/transformValue.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAOtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,QAAA,MAAM,cAAc,UACX,MAAM,GAAG,UAAU,aACf,gBAAgB,yBACJ,OAAO,OACzB,MAAM,KACV,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SA2CpC,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,CAAC"}

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

@@ -0,0 +1,62 @@
+import { isString } from '@aws-lambda-powertools/commons';
+import { fromBase64 } from '@aws-lambda-powertools/commons/utils/base64';
+import { TRANSFORM_METHOD_BINARY, TRANSFORM_METHOD_JSON, } from '../constants.js';
+import { TransformParameterError } from '../errors.js';
+/**
+ * Utility function to transform a value.
+ *
+ * It supports JSON and binary transformations, as well as an `auto` mode that will try to transform the value based on the key.
+ *
+ * The function supports both `string` and `Uint8Array` values as input. Other types will be returned as-is.
+ *
+ * If the value is a `Uint8Array`, it will be decoded to a string first. Then, when the transform is `json` or `auto` and the key ends with `.json`,
+ * the value will be parsed as JSON using the `JSON.parse` function.
+ *
+ * When the transform is `binary` or `auto` and the key ends with `.binary`, the value will be decoded from base64 using the `fromBase64` function
+ * from the `@aws-lambda-powertools/commons/utils/base64` package.
+ *
+ * If the transformation fails, the function will return the value as-is unless `throwOnTransformError` is set to `true`.
+ *
+ * When using `auto` mode, the key must end with either `.json` or `.binary` to be transformed. Automatic transformation is supported only for
+ * `getMultiple` calls.
+ *
+ * @param {string | Uint8Array} value - Value to be transformed
+ * @param {TransformOptions} transform - Transform to be applied, can be `json`, `binary`, or `auto`
+ * @param {boolean} throwOnTransformError - Whether to throw an error if the transformation fails, when transforming multiple values this can be set to false
+ * @param {string} key - Key of the value to be transformed, used to determine the transformation method when using 'auto'
+ */
+const transformValue = (value, transform, throwOnTransformError, key) => {
+    const normalizedTransform = transform.toLowerCase();
+    const isAutoTransform = normalizedTransform === 'auto';
+    const isAutoJsonTransform = isAutoTransform && key.toLowerCase().endsWith(`.${TRANSFORM_METHOD_JSON}`);
+    const isAutoBinaryTransform = isAutoTransform &&
+        key.toLowerCase().endsWith(`.${TRANSFORM_METHOD_BINARY}`);
+    const isJsonTransform = normalizedTransform === TRANSFORM_METHOD_JSON;
+    const isBinaryTransform = normalizedTransform === TRANSFORM_METHOD_BINARY;
+    // If the value is not a string or Uint8Array, or if the transform is `auto`
+    // and the key does not end with `.json` or `.binary`, return the value as-is
+    if (!(value instanceof Uint8Array || isString(value)) ||
+        (isAutoTransform && !isAutoJsonTransform && !isAutoBinaryTransform)) {
+        return value;
+    }
+    try {
+        // If the value is a Uint8Array, decode it to a string first
+        const valueToTransform = value instanceof Uint8Array
+            ? new TextDecoder('utf-8').decode(value)
+            : value;
+        // If the transform is `json` or `auto` and the key ends with `.json`, parse the value as JSON
+        if (isJsonTransform || isAutoJsonTransform) {
+            return JSON.parse(valueToTransform);
+            // If the transform is `binary` or `auto` and the key ends with `.binary`, decode the value from base64
+        }
+        if (isBinaryTransform || isAutoBinaryTransform) {
+            return new TextDecoder('utf-8').decode(fromBase64(valueToTransform, 'base64'));
+        }
+    }
+    catch (error) {
+        if (throwOnTransformError)
+            throw new TransformParameterError(transform, error.message);
+        return;
+    }
+};
+export { transformValue };

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/config/EnvironmentVariablesService.d.ts

@@ -0,0 +1,20 @@
+import { EnvironmentVariablesService as CommonEnvironmentVariablesService } from '@aws-lambda-powertools/commons';
+import type { ConfigServiceInterface } from '../types/ConfigServiceInterface.js';
+declare class EnvironmentVariablesService extends CommonEnvironmentVariablesService implements ConfigServiceInterface {
+    private parametersMaxAgeVariable;
+    private ssmDecryptVariable;
+    /**
+     * It returns the value of the POWERTOOLS_PARAMETERS_MAX_AGE environment variable.
+     *
+     * @returns {number|undefined}
+     */
+    getParametersMaxAge(): number | undefined;
+    /**
+     * It returns the value of the POWERTOOLS_PARAMETERS_SSM_DECRYPT environment variable.
+     *
+     * @returns {string}
+     */
+    getSSMDecrypt(): string;
+}
+export { EnvironmentVariablesService };
+//# sourceMappingURL=EnvironmentVariablesService.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/config/EnvironmentVariablesService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentVariablesService.d.ts","sourceRoot":"","sources":["../../../src/config/EnvironmentVariablesService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,IAAI,iCAAiC,EAAE,MAAM,gCAAgC,CAAC;AAElH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAEjF,cAAM,2BACJ,SAAQ,iCACR,YAAW,sBAAsB;IAGjC,OAAO,CAAC,wBAAwB,CAAmC;IACnE,OAAO,CAAC,kBAAkB,CAAuC;IAEjE;;;;OAIG;IACI,mBAAmB,IAAI,MAAM,GAAG,SAAS;IAehD;;;;OAIG;IACI,aAAa,IAAI,MAAM;CAG/B;AAED,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/config/EnvironmentVariablesService.js

@@ -0,0 +1,33 @@
+import { EnvironmentVariablesService as CommonEnvironmentVariablesService } from '@aws-lambda-powertools/commons';
+import { DEFAULT_MAX_AGE_SECS } from '../constants.js';
+class EnvironmentVariablesService extends CommonEnvironmentVariablesService {
+    // Environment variables
+    parametersMaxAgeVariable = 'POWERTOOLS_PARAMETERS_MAX_AGE';
+    ssmDecryptVariable = 'POWERTOOLS_PARAMETERS_SSM_DECRYPT';
+    /**
+     * It returns the value of the POWERTOOLS_PARAMETERS_MAX_AGE environment variable.
+     *
+     * @returns {number|undefined}
+     */
+    getParametersMaxAge() {
+        const maxAge = this.get(this.parametersMaxAgeVariable);
+        if (maxAge.length === 0)
+            return undefined;
+        const maxAgeAsNumber = Number.parseInt(maxAge, 10);
+        if (Number.isNaN(maxAgeAsNumber)) {
+            console.warn(`Invalid value for ${this.parametersMaxAgeVariable} environment variable: [${maxAge}], using default value of ${DEFAULT_MAX_AGE_SECS} seconds`);
+        }
+        else {
+            return maxAgeAsNumber;
+        }
+    }
+    /**
+     * It returns the value of the POWERTOOLS_PARAMETERS_SSM_DECRYPT environment variable.
+     *
+     * @returns {string}
+     */
+    getSSMDecrypt() {
+        return this.get(this.ssmDecryptVariable);
+    }
+}
+export { EnvironmentVariablesService };

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

@@ -0,0 +1,24 @@
+declare const DEFAULT_MAX_AGE_SECS = 5;
+declare const TRANSFORM_METHOD_JSON = "json";
+declare const TRANSFORM_METHOD_BINARY = "binary";
+declare const TRANSFORM_METHOD_AUTO = "auto";
+declare const APPCONFIG_TOKEN_EXPIRATION: number;
+/**
+ * Transform methods for values retrieved by parameter providers.
+ */
+declare const Transform: {
+    /**
+     * Transform the retrieved value using `JSON.parse`.
+     */
+    readonly JSON: "json";
+    /**
+     * Transform a base64-encoded value from `Uint8Array` to `string`.
+     */
+    readonly BINARY: "binary";
+    /**
+     * Automatically detect the transform method based on the parameter' name suffix.
+     */
+    readonly AUTO: "auto";
+};
+export { APPCONFIG_TOKEN_EXPIRATION, DEFAULT_MAX_AGE_SECS, TRANSFORM_METHOD_JSON, TRANSFORM_METHOD_BINARY, TRANSFORM_METHOD_AUTO, Transform, };
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,oBAAoB,IAAI,CAAC;AAC/B,QAAA,MAAM,qBAAqB,SAAS,CAAC;AACrC,QAAA,MAAM,uBAAuB,WAAW,CAAC;AACzC,QAAA,MAAM,qBAAqB,SAAS,CAAC;AACrC,QAAA,MAAM,0BAA0B,QAAuC,CAAC;AAExE;;GAEG;AACH,QAAA,MAAM,SAAS;IACb;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;CAEK,CAAC;AAEX,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,SAAS,GACV,CAAC"}

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

@@ -0,0 +1,23 @@
+const DEFAULT_MAX_AGE_SECS = 5;
+const TRANSFORM_METHOD_JSON = 'json';
+const TRANSFORM_METHOD_BINARY = 'binary';
+const TRANSFORM_METHOD_AUTO = 'auto';
+const APPCONFIG_TOKEN_EXPIRATION = 23 * 60 * 60 * 1000 + 45 * 60 * 1000; // 23 hrs 45 min
+/**
+ * Transform methods for values retrieved by parameter providers.
+ */
+const Transform = {
+    /**
+     * Transform the retrieved value using `JSON.parse`.
+     */
+    JSON: TRANSFORM_METHOD_JSON,
+    /**
+     * Transform a base64-encoded value from `Uint8Array` to `string`.
+     */
+    BINARY: TRANSFORM_METHOD_BINARY,
+    /**
+     * Automatically detect the transform method based on the parameter' name suffix.
+     */
+    AUTO: TRANSFORM_METHOD_AUTO,
+};
+export { APPCONFIG_TOKEN_EXPIRATION, DEFAULT_MAX_AGE_SECS, TRANSFORM_METHOD_JSON, TRANSFORM_METHOD_BINARY, TRANSFORM_METHOD_AUTO, Transform, };

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/dynamodb/DynamoDBProvider.d.ts

@@ -0,0 +1,309 @@
+import type { JSONValue } from '@aws-lambda-powertools/commons/types';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { BaseProvider } from '../base/BaseProvider.js';
+import type { DynamoDBGetMultipleOptions, DynamoDBGetMultipleOutput, DynamoDBGetOptions, DynamoDBGetOutput, DynamoDBProviderOptions } from '../types/DynamoDBProvider.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/).
+ */
+declare class DynamoDBProvider extends BaseProvider {
+    client: DynamoDBClient;
+    protected keyAttr: string;
+    protected sortAttr: string;
+    protected tableName: string;
+    protected valueAttr: string;
+    /**
+     * It initializes the DynamoDBProvider class.
+     *
+     * @param {DynamoDBProviderOptions} config - The configuration object.
+     */
+    constructor(config: DynamoDBProviderOptions);
+    /**
+     * 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/
+     */
+    get<ExplicitUserProvidedType = undefined, InferredFromOptionsType extends DynamoDBGetOptions | undefined = DynamoDBGetOptions>(name: string, options?: InferredFromOptionsType & DynamoDBGetOptions): Promise<DynamoDBGetOutput<ExplicitUserProvidedType, InferredFromOptionsType> | undefined>;
+    /**
+     * 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/
+     */
+    getMultiple<ExplicitUserProvidedType = undefined, InferredFromOptionsType extends DynamoDBGetMultipleOptions | undefined = DynamoDBGetMultipleOptions>(path: string, options?: InferredFromOptionsType & DynamoDBGetMultipleOptions): Promise<DynamoDBGetMultipleOutput<ExplicitUserProvidedType, InferredFromOptionsType> | undefined>;
+    /**
+     * 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
+     */
+    protected _get(name: string, options?: DynamoDBGetOptions): Promise<JSONValue | 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
+     */
+    protected _getMultiple(path: string, options?: DynamoDBGetMultipleOptions): Promise<Record<string, JSONValue>>;
+}
+export { DynamoDBProvider };
+//# sourceMappingURL=DynamoDBProvider.d.ts.map

package/node_modules/@aws-lambda-powertools/parameters/lib/esm/dynamodb/DynamoDBProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamoDBProvider.d.ts","sourceRoot":"","sources":["../../../src/dynamodb/DynamoDBProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,EACL,cAAc,EAIf,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EACV,0BAA0B,EAC1B,yBAAyB,EACzB,kBAAkB,EAClB,iBAAiB,EACjB,uBAAuB,EACxB,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsNG;AACH,cAAM,gBAAiB,SAAQ,YAAY;IAC1B,MAAM,EAAE,cAAc,CAAC;IACtC,SAAS,CAAC,OAAO,SAAQ;IACzB,SAAS,CAAC,QAAQ,SAAQ;IAC1B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,SAAS,SAAW;IAE9B;;;;OAIG;gBACgB,MAAM,EAAE,uBAAuB;IAalD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACU,GAAG,CACd,wBAAwB,GAAG,SAAS,EACpC,uBAAuB,SACnB,kBAAkB,GAClB,SAAS,GAAG,kBAAkB,EAElC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,uBAAuB,GAAG,kBAAkB,GACrD,OAAO,CACN,iBAAiB,CAAC,wBAAwB,EAAE,uBAAuB,CAAC,GACpE,SAAS,CACZ;IAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACU,WAAW,CACtB,wBAAwB,GAAG,SAAS,EACpC,uBAAuB,SACnB,0BAA0B,GAC1B,SAAS,GAAG,0BAA0B,EAE1C,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,uBAAuB,GAAG,0BAA0B,GAC7D,OAAO,CACN,yBAAyB,CACvB,wBAAwB,EACxB,uBAAuB,CACxB,GACD,SAAS,CACZ;IAUD;;;;;OAKG;cACa,IAAI,CAClB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAejC;;;;;OAKG;cACa,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CA6BtC;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}