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

package/node_modules/@aws-lambda-powertools/commons/lib/esm/LRUCache.d.ts

@@ -0,0 +1,109 @@
+import type { LRUCacheOptions } from './types/LRUCache.js';
+/**
+ * A simple LRU cache implementation that uses a doubly linked list to track the order of items in
+ * an hash map.
+ *
+ * Illustration of the design:
+ *```text
+ *   oldest                                                   newest
+ *    entry             entry             entry             entry
+ *    ______            ______            ______            ______
+ *   | head |.newer => |      |.newer => |      |.newer => | tail |
+ *   |  A   |          |  B   |          |  C   |          |  D   |
+ *   |______| <= older.|______| <= older.|______| <= older.|______|
+ *
+ *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+ * ```
+ *
+ * Items are added to the cache using the `add()` method. When an item is added, it's marked
+ * as the most recently used item. If the cache is full, the oldest item is removed from the
+ * cache.
+ *
+ * Each item also tracks the item that was added before it, and the item that was added after
+ * it. This allows us to quickly remove the oldest item from the cache without having to
+ * iterate through the entire cache.
+ *
+ * **Note**: This implementation is loosely based on the implementation found in the lru_map package
+ * which is licensed under the MIT license and [recommends users to copy the code into their
+ * own projects](https://github.com/rsms/js-lru/tree/master#usage).
+ *
+ * @typeParam K - The type of the key
+ * @typeParam V - The type of the value
+ */
+declare class LRUCache<K, V> {
+    private leastRecentlyUsed?;
+    private readonly map;
+    private readonly maxSize;
+    private mostRecentlyUsed?;
+    /**
+     * A simple LRU cache implementation that uses a doubly linked list to track the order of items in
+     * an hash map.
+     *
+     * When instatiating the cache, you can optionally specify the type of the key and value, as well
+     * as the maximum size of the cache. If no maximum size is specified, the cache will default to
+     * a size of 100.
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>({ maxSize: 100 });
+     * // or
+     * // const cache = new LRUCache();
+     *
+     * cache.add('a', 1);
+     * cache.add('b', 2);
+     *
+     * cache.get('a');
+     *
+     * console.log(cache.size()); // 2
+     * ```
+     *
+     * @param config - The configuration options for the cache
+     */
+    constructor(config?: LRUCacheOptions);
+    /**
+     * Adds a new item to the cache.
+     *
+     * If the key already exists, it updates the value and marks the item as the most recently used.
+     * If inserting the new item would exceed the max size, the oldest item is removed from the cache.
+     *
+     * @param key - The key to add to the cache
+     * @param value - The value to add to the cache
+     */
+    add(key: K, value: V): void;
+    /**
+     * Returns a value from the cache, or undefined if it's not in the cache.
+     *
+     * When a value is returned, it's marked as the most recently used item in the cache.
+     *
+     * @param key - The key to retrieve from the cache
+     */
+    get(key: K): V | undefined;
+    /**
+     * Returns `true` if the key exists in the cache, `false` otherwise.
+     *
+     * @param key - The key to check for in the cache
+     */
+    has(key: K): boolean;
+    /**
+     * Removes an item from the cache, while doing so it also reconciles the linked list.
+     *
+     * @param key - The key to remove from the cache
+     */
+    remove(key: K): void;
+    /**
+     * Returns the current size of the cache.
+     */
+    size(): number;
+    /**
+     * Removes the oldest item from the cache and unlinks it from the linked list.
+     */
+    private shift;
+    /**
+     * Marks an item as the most recently used item in the cache.
+     *
+     * @param item - The item to mark as the most recently used
+     */
+    private trackItemUse;
+}
+export { LRUCache };
+//# sourceMappingURL=LRUCache.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/LRUCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LRUCache.d.ts","sourceRoot":"","sources":["../../src/LRUCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAoB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,cAAM,QAAQ,CAAC,CAAC,EAAE,CAAC;IACjB,OAAO,CAAC,iBAAiB,CAAC,CAAa;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,gBAAgB,CAAC,CAAa;IAEtC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;gBACgB,MAAM,CAAC,EAAE,eAAe;IAM3C;;;;;;;;OAQG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAiClC;;;;;;OAMG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAQjC;;;;OAIG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAI3B;;;;OAIG;IACI,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;IAwB3B;;OAEG;IACI,IAAI,IAAI,MAAM;IAIrB;;OAEG;IACH,OAAO,CAAC,KAAK;IAgBb;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAqBrB;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/LRUCache.js

@@ -0,0 +1,220 @@
+const DEFAULT_MAX_SIZE = 100;
+const NEWER = Symbol('newer');
+const OLDER = Symbol('older');
+class Item {
+    key;
+    value;
+    [NEWER];
+    [OLDER];
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+        this[NEWER] = undefined;
+        this[OLDER] = undefined;
+    }
+}
+/**
+ * A simple LRU cache implementation that uses a doubly linked list to track the order of items in
+ * an hash map.
+ *
+ * Illustration of the design:
+ *```text
+ *   oldest                                                   newest
+ *    entry             entry             entry             entry
+ *    ______            ______            ______            ______
+ *   | head |.newer => |      |.newer => |      |.newer => | tail |
+ *   |  A   |          |  B   |          |  C   |          |  D   |
+ *   |______| <= older.|______| <= older.|______| <= older.|______|
+ *
+ *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+ * ```
+ *
+ * Items are added to the cache using the `add()` method. When an item is added, it's marked
+ * as the most recently used item. If the cache is full, the oldest item is removed from the
+ * cache.
+ *
+ * Each item also tracks the item that was added before it, and the item that was added after
+ * it. This allows us to quickly remove the oldest item from the cache without having to
+ * iterate through the entire cache.
+ *
+ * **Note**: This implementation is loosely based on the implementation found in the lru_map package
+ * which is licensed under the MIT license and [recommends users to copy the code into their
+ * own projects](https://github.com/rsms/js-lru/tree/master#usage).
+ *
+ * @typeParam K - The type of the key
+ * @typeParam V - The type of the value
+ */
+class LRUCache {
+    leastRecentlyUsed;
+    map;
+    maxSize;
+    mostRecentlyUsed;
+    /**
+     * A simple LRU cache implementation that uses a doubly linked list to track the order of items in
+     * an hash map.
+     *
+     * When instatiating the cache, you can optionally specify the type of the key and value, as well
+     * as the maximum size of the cache. If no maximum size is specified, the cache will default to
+     * a size of 100.
+     *
+     * @example
+     * ```typescript
+     * const cache = new LRUCache<string, number>({ maxSize: 100 });
+     * // or
+     * // const cache = new LRUCache();
+     *
+     * cache.add('a', 1);
+     * cache.add('b', 2);
+     *
+     * cache.get('a');
+     *
+     * console.log(cache.size()); // 2
+     * ```
+     *
+     * @param config - The configuration options for the cache
+     */
+    constructor(config) {
+        this.maxSize =
+            config?.maxSize !== undefined ? config.maxSize : DEFAULT_MAX_SIZE;
+        this.map = new Map();
+    }
+    /**
+     * Adds a new item to the cache.
+     *
+     * If the key already exists, it updates the value and marks the item as the most recently used.
+     * If inserting the new item would exceed the max size, the oldest item is removed from the cache.
+     *
+     * @param key - The key to add to the cache
+     * @param value - The value to add to the cache
+     */
+    add(key, value) {
+        // If the key already exists, we just update the value and mark it as the most recently used
+        if (this.map.has(key)) {
+            // biome-ignore lint/style/noNonNullAssertion: At this point, we know that the key exists in the map, so we can safely use the non-null
+            const item = this.map.get(key);
+            item.value = value;
+            this.trackItemUse(item);
+            return;
+        }
+        // If the key doesn't exist, we add it to the map
+        const item = new Item(key, value);
+        this.map.set(key, item);
+        // If there's an existing newest item, link it to the new item
+        if (this.mostRecentlyUsed) {
+            this.mostRecentlyUsed[NEWER] = item;
+            item[OLDER] = this.mostRecentlyUsed;
+            // If there's no existing newest item, this is the first item (oldest and newest)
+        }
+        else {
+            this.leastRecentlyUsed = item;
+        }
+        // The new item is now the newest item
+        this.mostRecentlyUsed = item;
+        // If the map is full, we remove the oldest entry
+        if (this.map.size > this.maxSize) {
+            this.shift();
+        }
+    }
+    /**
+     * Returns a value from the cache, or undefined if it's not in the cache.
+     *
+     * When a value is returned, it's marked as the most recently used item in the cache.
+     *
+     * @param key - The key to retrieve from the cache
+     */
+    get(key) {
+        const item = this.map.get(key);
+        if (!item)
+            return;
+        this.trackItemUse(item);
+        return item.value;
+    }
+    /**
+     * Returns `true` if the key exists in the cache, `false` otherwise.
+     *
+     * @param key - The key to check for in the cache
+     */
+    has(key) {
+        return this.map.has(key);
+    }
+    /**
+     * Removes an item from the cache, while doing so it also reconciles the linked list.
+     *
+     * @param key - The key to remove from the cache
+     */
+    remove(key) {
+        const item = this.map.get(key);
+        if (!item)
+            return;
+        this.map.delete(key);
+        if (item[NEWER] && item[OLDER]) {
+            // relink the older entry with the newer entry
+            item[OLDER][NEWER] = item[NEWER];
+            item[NEWER][OLDER] = item[OLDER];
+        }
+        else if (item[NEWER]) {
+            // remove the link to us
+            item[NEWER][OLDER] = undefined;
+            // link the newer entry to head
+            this.leastRecentlyUsed = item[NEWER];
+        }
+        else if (item[OLDER]) {
+            // remove the link to us
+            item[OLDER][NEWER] = undefined;
+            // link the newer entry to head
+            this.mostRecentlyUsed = item[OLDER];
+        }
+        else {
+            this.leastRecentlyUsed = this.mostRecentlyUsed = undefined;
+        }
+    }
+    /**
+     * Returns the current size of the cache.
+     */
+    size() {
+        return this.map.size;
+    }
+    /**
+     * Removes the oldest item from the cache and unlinks it from the linked list.
+     */
+    shift() {
+        // biome-ignore lint/style/noNonNullAssertion: If this function is called, we know that the least recently used item exists
+        const item = this.leastRecentlyUsed;
+        // If there's a newer item, make it the oldest
+        if (item[NEWER]) {
+            this.leastRecentlyUsed = item[NEWER];
+            this.leastRecentlyUsed[OLDER] = undefined;
+        }
+        // Remove the item from the map
+        this.map.delete(item.key);
+        item[NEWER] = undefined;
+        item[OLDER] = undefined;
+    }
+    /**
+     * Marks an item as the most recently used item in the cache.
+     *
+     * @param item - The item to mark as the most recently used
+     */
+    trackItemUse(item) {
+        // If the item is already the newest, we don't need to do anything
+        if (this.mostRecentlyUsed === item)
+            return;
+        // If the item is not the newest, we need to mark it as the newest
+        if (item[NEWER]) {
+            if (item === this.leastRecentlyUsed) {
+                this.leastRecentlyUsed = item[NEWER];
+            }
+            item[NEWER][OLDER] = item[OLDER];
+        }
+        if (item[OLDER]) {
+            item[OLDER][NEWER] = item[NEWER];
+        }
+        item[NEWER] = undefined;
+        item[OLDER] = this.mostRecentlyUsed;
+        if (this.mostRecentlyUsed) {
+            this.mostRecentlyUsed[NEWER] = item;
+        }
+        this.mostRecentlyUsed = item;
+    }
+}
+export { LRUCache };

package/node_modules/@aws-lambda-powertools/commons/lib/esm/Utility.d.ts

@@ -0,0 +1,98 @@
+/**
+ * `Utility` is a base class that other Powertools for AWS Lambda (TypeScript) utilites can extend to inherit shared logic.
+ *
+ * Its main purpose is to encapsulate the cold start heuristic logic. Cold start is a term commonly used to describe the `Init` phase of a Lambda function.
+ * In this phase, Lambda creates or unfreezes an execution environment with the configured resources, downloads the code for the function and all layers,
+ * initializes any extensions, initializes the runtime, and then runs the function’s initialization code (the code outside the main handler).
+ *
+ * The Init phase happens either during the first invocation, or in advance of function invocations if you have enabled provisioned concurrency.
+ *
+ * To learn more about the Lambda execution environment lifecycle, see the [Execution environment section](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-context.html) of the AWS Lambda documentation.
+ *
+ * As a Powertools for AWS Lambda (TypeScript) user you probably won't be using this class directly, in fact if you use other Powertools for AWS utilities the cold start heuristic found here is already used to:
+ * * Add a `coldStart` key to the structured logs when injecting context information in `Logger`
+ * * Emit a metric during a cold start function invocation in `Metrics`
+ * * Annotate the invocation segment with a `coldStart` key in `Tracer`
+ *
+ * If you want to use this logic in your own utilities, `Utility` provides two methods:
+ *
+ * `Utility.getColdStart()`
+ *
+ * Since the `Utility` class is instantiated outside of the Lambda handler it will persist across invocations of the same execution environment. This means that if you call `getColdStart()` multiple times, it will return `true` during the first invocation, and `false` afterwards.
+ *
+ * @example
+ * ```typescript
+ * import { Utility } from '@aws-lambda-powertools/commons';
+ *
+ * const utility = new Utility();
+ *
+ * export const handler = async (_event: any, _context: any) => {
+ *   utility.getColdStart();
+ * };
+ * ```
+ *
+ * `Utility.isColdStart()`
+ *
+ * This method is an alias of `getColdStart()` and is exposed for convenience and better readability in certain usages.
+ *
+ * @example
+ * ```typescript
+ * import { Utility } from '@aws-lambda-powertools/commons';
+ *
+ * const utility = new Utility();
+ *
+ * export const handler = async (_event: any, _context: any) => {
+ *   if (utility.isColdStart()) {
+ *     // do something, this block is only executed on the first invocation of the function
+ *   } else {
+ *     // do something else, this block gets executed on all subsequent invocations
+ *   }
+ * };
+ * ```
+ */
+export declare class Utility {
+    private coldStart;
+    private readonly defaultServiceName;
+    /**
+     * Get the cold start status of the current execution environment.
+     *
+     * @example
+     * ```typescript
+     * import { Utility } from '@aws-lambda-powertools/commons';
+     *
+     * const utility = new Utility();
+     * utility.isColdStart(); // true
+     * utility.isColdStart(); // false
+     * ```
+     *
+     * The method also flips the cold start status to `false` after the first invocation.
+     */
+    getColdStart(): boolean;
+    /**
+     * Get the cold start status of the current execution environment.
+     *
+     * @example
+     * ```typescript
+     * import { Utility } from '@aws-lambda-powertools/commons';
+     *
+     * const utility = new Utility();
+     * utility.isColdStart(); // true
+     * utility.isColdStart(); // false
+     * ```
+     *
+     * @see {@link getColdStart}
+     */
+    isColdStart(): boolean;
+    /**
+     * Get the default service name.
+     */
+    protected getDefaultServiceName(): string;
+    /**
+     * Validate that the service name provided is valid.
+     * Used internally during initialization.
+     *
+     * @param serviceName Service name to validate
+     */
+    protected isValidServiceName(serviceName?: string): boolean;
+}
+//# sourceMappingURL=Utility.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/Utility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utility.d.ts","sourceRoot":"","sources":["../../src/Utility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA+B;IAElE;;;;;;;;;;;;;OAaG;IACI,YAAY,IAAI,OAAO;IAU9B;;;;;;;;;;;;;OAaG;IACI,WAAW,IAAI,OAAO;IAI7B;;OAEG;IACH,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO;CAG5D"}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/Utility.js

@@ -0,0 +1,109 @@
+/**
+ * `Utility` is a base class that other Powertools for AWS Lambda (TypeScript) utilites can extend to inherit shared logic.
+ *
+ * Its main purpose is to encapsulate the cold start heuristic logic. Cold start is a term commonly used to describe the `Init` phase of a Lambda function.
+ * In this phase, Lambda creates or unfreezes an execution environment with the configured resources, downloads the code for the function and all layers,
+ * initializes any extensions, initializes the runtime, and then runs the function’s initialization code (the code outside the main handler).
+ *
+ * The Init phase happens either during the first invocation, or in advance of function invocations if you have enabled provisioned concurrency.
+ *
+ * To learn more about the Lambda execution environment lifecycle, see the [Execution environment section](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-context.html) of the AWS Lambda documentation.
+ *
+ * As a Powertools for AWS Lambda (TypeScript) user you probably won't be using this class directly, in fact if you use other Powertools for AWS utilities the cold start heuristic found here is already used to:
+ * * Add a `coldStart` key to the structured logs when injecting context information in `Logger`
+ * * Emit a metric during a cold start function invocation in `Metrics`
+ * * Annotate the invocation segment with a `coldStart` key in `Tracer`
+ *
+ * If you want to use this logic in your own utilities, `Utility` provides two methods:
+ *
+ * `Utility.getColdStart()`
+ *
+ * Since the `Utility` class is instantiated outside of the Lambda handler it will persist across invocations of the same execution environment. This means that if you call `getColdStart()` multiple times, it will return `true` during the first invocation, and `false` afterwards.
+ *
+ * @example
+ * ```typescript
+ * import { Utility } from '@aws-lambda-powertools/commons';
+ *
+ * const utility = new Utility();
+ *
+ * export const handler = async (_event: any, _context: any) => {
+ *   utility.getColdStart();
+ * };
+ * ```
+ *
+ * `Utility.isColdStart()`
+ *
+ * This method is an alias of `getColdStart()` and is exposed for convenience and better readability in certain usages.
+ *
+ * @example
+ * ```typescript
+ * import { Utility } from '@aws-lambda-powertools/commons';
+ *
+ * const utility = new Utility();
+ *
+ * export const handler = async (_event: any, _context: any) => {
+ *   if (utility.isColdStart()) {
+ *     // do something, this block is only executed on the first invocation of the function
+ *   } else {
+ *     // do something else, this block gets executed on all subsequent invocations
+ *   }
+ * };
+ * ```
+ */
+export class Utility {
+    coldStart = true;
+    defaultServiceName = 'service_undefined';
+    /**
+     * Get the cold start status of the current execution environment.
+     *
+     * @example
+     * ```typescript
+     * import { Utility } from '@aws-lambda-powertools/commons';
+     *
+     * const utility = new Utility();
+     * utility.isColdStart(); // true
+     * utility.isColdStart(); // false
+     * ```
+     *
+     * The method also flips the cold start status to `false` after the first invocation.
+     */
+    getColdStart() {
+        if (this.coldStart) {
+            this.coldStart = false;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get the cold start status of the current execution environment.
+     *
+     * @example
+     * ```typescript
+     * import { Utility } from '@aws-lambda-powertools/commons';
+     *
+     * const utility = new Utility();
+     * utility.isColdStart(); // true
+     * utility.isColdStart(); // false
+     * ```
+     *
+     * @see {@link getColdStart}
+     */
+    isColdStart() {
+        return this.getColdStart();
+    }
+    /**
+     * Get the default service name.
+     */
+    getDefaultServiceName() {
+        return this.defaultServiceName;
+    }
+    /**
+     * Validate that the service name provided is valid.
+     * Used internally during initialization.
+     *
+     * @param serviceName Service name to validate
+     */
+    isValidServiceName(serviceName) {
+        return typeof serviceName === 'string' && serviceName.trim().length > 0;
+    }
+}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/awsSdkUtils.d.ts

@@ -0,0 +1,33 @@
+import type { MiddlewareArgsLike, SdkClient } from './types/awsSdk.js';
+/**
+ * Type guard to check if the client provided is a valid AWS SDK v3 client.
+ *
+ * @internal
+ */
+declare const isSdkClient: (client: unknown) => client is SdkClient;
+/**
+ * Helper function to create a custom user agent middleware for the AWS SDK v3 clients.
+ *
+ * The middleware will append the provided feature name and the current version of
+ * the Powertools for AWS Lambda library to the user agent string.
+ *
+ * @example "PT/Tracer/2.1.0 PTEnv/nodejs20x"
+ *
+ * @param feature The feature name to be added to the user agent
+ *
+ * @internal
+ */
+declare const customUserAgentMiddleware: (feature: string) => <T extends MiddlewareArgsLike>(next: (arg0: T) => Promise<T>) => (args: T) => Promise<T>;
+/**
+ * Add the Powertools for AWS Lambda user agent middleware to the
+ * AWS SDK v3 client provided.
+ *
+ * We use this middleware to unbotrusively track the usage of the library
+ * and secure continued investment in the project.
+ *
+ * @param client The AWS SDK v3 client to add the middleware to
+ * @param feature The feature name to be added to the user agent
+ */
+declare const addUserAgentMiddleware: (client: unknown, feature: string) => void;
+export { customUserAgentMiddleware, addUserAgentMiddleware, isSdkClient };
+//# sourceMappingURL=awsSdkUtils.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/awsSdkUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"awsSdkUtils.d.ts","sourceRoot":"","sources":["../../src/awsSdkUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWvE;;;;GAIG;AACH,QAAA,MAAM,WAAW,WAAY,OAAO,KAAG,MAAM,IAAI,SAgBW,CAAC;AAE7D;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,yBAAyB,YAAa,MAAM,MACxC,CAAC,SAAS,kBAAkB,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,YACpD,CAAC,eAOjB,CAAC;AAqBF;;;;;;;;;GASG;AACH,QAAA,MAAM,sBAAsB,WAAY,OAAO,WAAW,MAAM,KAAG,IAkBlE,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,WAAW,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/awsSdkUtils.js

@@ -0,0 +1,93 @@
+import { PT_VERSION } from './version.js';
+const EXEC_ENV = process.env.AWS_EXECUTION_ENV || 'NA';
+const middlewareOptions = {
+    relation: 'after',
+    toMiddleware: 'getUserAgentMiddleware',
+    name: 'addPowertoolsToUserAgent',
+    tags: ['POWERTOOLS', 'USER_AGENT'],
+};
+/**
+ * Type guard to check if the client provided is a valid AWS SDK v3 client.
+ *
+ * @internal
+ */
+const isSdkClient = (client) => typeof client === 'object' &&
+    client !== null &&
+    'send' in client &&
+    typeof client.send === 'function' &&
+    'config' in client &&
+    client.config !== undefined &&
+    typeof client.config === 'object' &&
+    client.config !== null &&
+    'middlewareStack' in client &&
+    client.middlewareStack !== undefined &&
+    typeof client.middlewareStack === 'object' &&
+    client.middlewareStack !== null &&
+    'identify' in client.middlewareStack &&
+    typeof client.middlewareStack.identify === 'function' &&
+    'addRelativeTo' in client.middlewareStack &&
+    typeof client.middlewareStack.addRelativeTo === 'function';
+/**
+ * Helper function to create a custom user agent middleware for the AWS SDK v3 clients.
+ *
+ * The middleware will append the provided feature name and the current version of
+ * the Powertools for AWS Lambda library to the user agent string.
+ *
+ * @example "PT/Tracer/2.1.0 PTEnv/nodejs20x"
+ *
+ * @param feature The feature name to be added to the user agent
+ *
+ * @internal
+ */
+const customUserAgentMiddleware = (feature) => {
+    return (next) => async (args) => {
+        const powertoolsUserAgent = `PT/${feature}/${PT_VERSION} PTEnv/${EXEC_ENV}`;
+        args.request.headers['user-agent'] =
+            `${args.request.headers['user-agent']} ${powertoolsUserAgent}`;
+        return await next(args);
+    };
+};
+/**
+ * Check if the provided middleware stack already has the Powertools for AWS Lambda
+ * user agent middleware.
+ *
+ * @param middlewareStack The middleware stack to check
+ *
+ * @internal
+ */
+const hasPowertools = (middlewareStack) => {
+    let found = false;
+    for (const middleware of middlewareStack) {
+        if (middleware.includes('addPowertoolsToUserAgent')) {
+            found = true;
+        }
+    }
+    return found;
+};
+/**
+ * Add the Powertools for AWS Lambda user agent middleware to the
+ * AWS SDK v3 client provided.
+ *
+ * We use this middleware to unbotrusively track the usage of the library
+ * and secure continued investment in the project.
+ *
+ * @param client The AWS SDK v3 client to add the middleware to
+ * @param feature The feature name to be added to the user agent
+ */
+const addUserAgentMiddleware = (client, feature) => {
+    try {
+        if (isSdkClient(client)) {
+            if (hasPowertools(client.middlewareStack.identify())) {
+                return;
+            }
+            client.middlewareStack.addRelativeTo(customUserAgentMiddleware(feature), middlewareOptions);
+        }
+        else {
+            throw new Error('The client provided does not match the expected interface');
+        }
+    }
+    catch (error) {
+        console.warn('Failed to add user agent middleware', error);
+    }
+};
+export { customUserAgentMiddleware, addUserAgentMiddleware, isSdkClient };