@rio-cloud/cdk-v2-constructs 8.4.0 → 8.6.0

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/constants.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The indent level for JSON logs.
+ *
+ * By default Logger will use the `LogJsonIndent.COMPACT` indent level, which
+ * produces logs on a single line. This is the most efficient option for
+ * CloudWatch Logs.
+ *
+ * When enabling the `POWERTOOLS_DEV` environment variable, Logger will use the
+ * `LogJsonIndent.PRETTY` indent level, which indents the JSON logs for easier
+ * reading.
+ */
+declare const LogJsonIndent: {
+    readonly PRETTY: 4;
+    readonly COMPACT: 0;
+};
+declare const LogLevel: {
+    readonly TRACE: "TRACE";
+    readonly DEBUG: "DEBUG";
+    readonly INFO: "INFO";
+    readonly WARN: "WARN";
+    readonly ERROR: "ERROR";
+    readonly SILENT: "SILENT";
+    readonly CRITICAL: "CRITICAL";
+};
+/**
+ * Numeric values for each log level.
+ */
+declare const LogLevelThreshold: {
+    readonly TRACE: 6;
+    readonly DEBUG: 8;
+    readonly INFO: 12;
+    readonly WARN: 16;
+    readonly ERROR: 20;
+    readonly CRITICAL: 24;
+    readonly SILENT: 28;
+};
+/**
+ * Reserved keys that are included in every log item when using the default log formatter.
+ *
+ * These keys are reserved and cannot be overwritten by custom log attributes.
+ */
+declare const ReservedKeys: string[];
+/**
+ * Message logged when an uncaught error occurs in a Lambda function.
+ */
+declare const UncaughtErrorLogMessage = "Uncaught error detected, flushing log buffer before exit";
+export { LogJsonIndent, LogLevel, LogLevelThreshold, ReservedKeys, UncaughtErrorLogMessage, };
+//# sourceMappingURL=constants.d.ts.map

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,QAAA,MAAM,aAAa;;;CAGT,CAAC;AAEX,QAAA,MAAM,QAAQ;;;;;;;;CAQJ,CAAC;AAEX;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;CAQb,CAAC;AAEX;;;;GAIG;AACH,QAAA,MAAM,YAAY,UAMjB,CAAC;AAEF;;GAEG;AACH,QAAA,MAAM,uBAAuB,6DAC+B,CAAC;AAE7D,OAAO,EACL,aAAa,EACb,QAAQ,EACR,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,GACxB,CAAC"}

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/constants.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncaughtErrorLogMessage = exports.ReservedKeys = exports.LogLevelThreshold = exports.LogLevel = exports.LogJsonIndent = void 0;
+/**
+ * The indent level for JSON logs.
+ *
+ * By default Logger will use the `LogJsonIndent.COMPACT` indent level, which
+ * produces logs on a single line. This is the most efficient option for
+ * CloudWatch Logs.
+ *
+ * When enabling the `POWERTOOLS_DEV` environment variable, Logger will use the
+ * `LogJsonIndent.PRETTY` indent level, which indents the JSON logs for easier
+ * reading.
+ */
+const LogJsonIndent = {
+    PRETTY: 4,
+    COMPACT: 0,
+};
+exports.LogJsonIndent = LogJsonIndent;
+const LogLevel = {
+    TRACE: 'TRACE',
+    DEBUG: 'DEBUG',
+    INFO: 'INFO',
+    WARN: 'WARN',
+    ERROR: 'ERROR',
+    SILENT: 'SILENT',
+    CRITICAL: 'CRITICAL',
+};
+exports.LogLevel = LogLevel;
+/**
+ * Numeric values for each log level.
+ */
+const LogLevelThreshold = {
+    TRACE: 6,
+    DEBUG: 8,
+    INFO: 12,
+    WARN: 16,
+    ERROR: 20,
+    CRITICAL: 24,
+    SILENT: 28,
+};
+exports.LogLevelThreshold = LogLevelThreshold;
+/**
+ * Reserved keys that are included in every log item when using the default log formatter.
+ *
+ * These keys are reserved and cannot be overwritten by custom log attributes.
+ */
+const ReservedKeys = [
+    'level',
+    'message',
+    'sampling_rate',
+    'service',
+    'timestamp',
+];
+exports.ReservedKeys = ReservedKeys;
+/**
+ * Message logged when an uncaught error occurs in a Lambda function.
+ */
+const UncaughtErrorLogMessage = 'Uncaught error detected, flushing log buffer before exit';
+exports.UncaughtErrorLogMessage = UncaughtErrorLogMessage;

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/correlationId.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This function is used to search for a correlation ID in the event data and is a wrapper
+ * around the JMESPath search function. It allows you to specify a JMESPath expression
+ * to extract the correlation ID from the event data.
+ * @param expression - The JMESPath expression to use for searching the correlation ID.
+ * @param data - The event data to search in.
+ */
+declare const search: (expression: string, data: unknown) => unknown;
+/**
+ * The correlationPaths object contains the JMESPath expressions for extracting the correlation ID for various AWS services.
+ */
+declare const correlationPaths: {
+    /**
+     * API Gateway REST API request ID
+     */
+    readonly API_GATEWAY_REST: "requestContext.requestId";
+    /**
+     * API Gateway HTTP API request ID
+     */
+    readonly API_GATEWAY_HTTP: "requestContext.requestId";
+    /**
+     * AppSync API request ID
+     */
+    readonly APPSYNC_AUTHORIZER: "requestContext.requestId";
+    /**
+     * AppSync resolver X-Ray trace ID
+     */
+    readonly APPSYNC_RESOLVER: "request.headers.\"x-amzn-trace-id\"";
+    /**
+     * ALB X-Ray trace ID
+     */
+    readonly APPLICATION_LOAD_BALANCER: "headers.\"x-amzn-trace-id\"";
+    /**
+     * EventBridge event ID
+     */
+    readonly EVENT_BRIDGE: "id";
+    /**
+     * Lambda Function URL request ID
+     */
+    readonly LAMBDA_FUNCTION_URL: "requestContext.requestId";
+    /**
+     * S3 Object trigger request ID
+     */
+    readonly S3_OBJECT_LAMBDA: "xAmzRequestId";
+    /**
+     * VPC Lattice X-Ray trace ID
+     */
+    readonly VPC_LATTICE: "headers.\"x-amzn-trace-id\"";
+};
+export { correlationPaths, search };
+//# sourceMappingURL=correlationId.d.ts.map

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/correlationId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlationId.d.ts","sourceRoot":"","sources":["../../src/correlationId.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,QAAA,MAAM,MAAM,GAAI,YAAY,MAAM,EAAE,MAAM,OAAO,YAIhD,CAAC;AAEF;;GAEG;AACH,QAAA,MAAM,gBAAgB;IACpB;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;CAEK,CAAC;AAEX,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/correlationId.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = exports.correlationPaths = void 0;
+const jmespath_1 = require("@aws-lambda-powertools/jmespath");
+const functions_1 = require("@aws-lambda-powertools/jmespath/functions");
+/**
+ * This function is used to search for a correlation ID in the event data and is a wrapper
+ * around the JMESPath search function. It allows you to specify a JMESPath expression
+ * to extract the correlation ID from the event data.
+ * @param expression - The JMESPath expression to use for searching the correlation ID.
+ * @param data - The event data to search in.
+ */
+const search = (expression, data) => {
+    return (0, jmespath_1.search)(expression, data, {
+        customFunctions: new functions_1.PowertoolsFunctions(),
+    });
+};
+exports.search = search;
+/**
+ * The correlationPaths object contains the JMESPath expressions for extracting the correlation ID for various AWS services.
+ */
+const correlationPaths = {
+    /**
+     * API Gateway REST API request ID
+     */
+    API_GATEWAY_REST: 'requestContext.requestId',
+    /**
+     * API Gateway HTTP API request ID
+     */
+    API_GATEWAY_HTTP: 'requestContext.requestId',
+    /**
+     * AppSync API request ID
+     */
+    APPSYNC_AUTHORIZER: 'requestContext.requestId',
+    /**
+     * AppSync resolver X-Ray trace ID
+     */
+    APPSYNC_RESOLVER: 'request.headers."x-amzn-trace-id"',
+    /**
+     * ALB X-Ray trace ID
+     */
+    APPLICATION_LOAD_BALANCER: 'headers."x-amzn-trace-id"',
+    /**
+     * EventBridge event ID
+     */
+    EVENT_BRIDGE: 'id',
+    /**
+     * Lambda Function URL request ID
+     */
+    LAMBDA_FUNCTION_URL: 'requestContext.requestId',
+    /**
+     * S3 Object trigger request ID
+     */
+    S3_OBJECT_LAMBDA: 'xAmzRequestId',
+    /**
+     * VPC Lattice X-Ray trace ID
+     */
+    VPC_LATTICE: 'headers."x-amzn-trace-id"',
+};
+exports.correlationPaths = correlationPaths;

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogFormatter.d.ts

@@ -0,0 +1,116 @@
+import type { LogAttributes } from '../types/Logger.js';
+import type { UnformattedAttributes } from '../types/logKeys.js';
+import type { LogItem } from './LogItem.js';
+/**
+ * Class that defines and implements common methods for the formatting of log attributes.
+ *
+ * When creating a custom log formatter, you should extend this class and implement the
+ * {@link formatAttributes | formatAttributes()} method to define the structure of the log item.
+ *
+ * @abstract
+ */
+declare abstract class LogFormatter {
+    #private;
+    /**
+     * Format key-value pairs of log attributes.
+     *
+     * You should implement this method in a subclass to define the structure of the log item
+     * and instantiate a new {@link LogItem} object with the formatted attributes.
+     *
+     * Note that when implementing this method, you should avoid mutating the `attributes` and
+     * `additionalLogAttributes` objects directly. Instead, create a new object with the desired
+     * structure and return it.
+     *
+     * If mutation is necessary, you can create a `structuredClone` of the object to avoid side effects.
+     *
+     * @example
+     * ```typescript
+     * import { LogFormatter, LogItem } from '@aws-lambda-powertools/logger';
+     * import type {
+     *   LogAttributes,
+     *   UnformattedAttributes,
+     * } from '@aws-lambda-powertools/logger/types';
+     *
+     * class MyCompanyLogFormatter extends LogFormatter {
+     *   public formatAttributes(
+     *     attributes: UnformattedAttributes,
+     *     additionalLogAttributes: LogAttributes
+     *   ): LogItem {
+     *     const baseAttributes = {
+     *       message: attributes.message,
+     *       service: attributes.serviceName,
+     *       environment: attributes.environment,
+     *       awsRegion: attributes.awsRegion,
+     *       correlationIds: {
+     *         awsRequestId: attributes.lambdaContext?.awsRequestId,
+     *         xRayTraceId: attributes.xRayTraceId,
+     *       },
+     *       lambdaFunction: {
+     *         name: attributes.lambdaContext?.functionName,
+     *         arn: attributes.lambdaContext?.invokedFunctionArn,
+     *         memoryLimitInMB: attributes.lambdaContext?.memoryLimitInMB,
+     *         version: attributes.lambdaContext?.functionVersion,
+     *         coldStart: attributes.lambdaContext?.coldStart,
+     *       },
+     *       logLevel: attributes.logLevel,
+     *       timestamp: this.formatTimestamp(attributes.timestamp), // You can extend this function
+     *       logger: {
+     *         sampleRateValue: attributes.sampleRateValue,
+     *       },
+     *     };
+     *
+     *     const logItem = new LogItem({ attributes: baseAttributes });
+     *     // add any attributes not explicitly defined
+     *     logItem.addAttributes(additionalLogAttributes);
+     *
+     *     return logItem;
+     *   }
+     * }
+     *
+     * export { MyCompanyLogFormatter };
+     * ```
+     *
+     * @param attributes - Unformatted attributes
+     * @param additionalLogAttributes - Additional log attributes
+     */
+    abstract formatAttributes(attributes: UnformattedAttributes, additionalLogAttributes: LogAttributes): LogItem;
+    /**
+     * Format an error into a loggable object.
+     *
+     * @example
+     * ```json
+     * {
+     *   "name": "Error",
+     *   "location": "file.js:1",
+     *   "message": "An error occurred",
+     *   "stack": "Error: An error occurred\n    at file.js:1\n    at file.js:2\n    at file.js:3",
+     *   "cause": {
+     *     "name": "OtherError",
+     *     "location": "file.js:2",
+     *     "message": "Another error occurred",
+     *     "stack": "Error: Another error occurred\n    at file.js:2\n    at file.js:3\n    at file.js:4"
+     *   }
+     * }
+     * ```
+     *
+     * @param error - Error to format
+     */
+    formatError(error: Error): LogAttributes;
+    /**
+     * Format a date into an ISO 8601 string with the configured timezone.
+     *
+     * The timezone is read from the `TZ` environment variable, if present.
+     * Otherwise, the timezone defaults to ':UTC'.
+     *
+     * @param now - The date to format
+     */
+    formatTimestamp(now: Date): string;
+    /**
+     * Get the location of an error from a stack trace.
+     *
+     * @param stack - stack trace to parse
+     */
+    getCodeLocation(stack?: string): string;
+}
+export { LogFormatter };
+//# sourceMappingURL=LogFormatter.d.ts.map

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogFormatter.d.ts","sourceRoot":"","sources":["../../../src/formatter/LogFormatter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;;;;GAOG;AACH,uBAAe,YAAY;;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6DG;aACa,gBAAgB,CAC9B,UAAU,EAAE,qBAAqB,EACjC,uBAAuB,EAAE,aAAa,GACrC,OAAO;IAEV;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa;IAsB/C;;;;;;;OAOG;IACI,eAAe,CAAC,GAAG,EAAE,IAAI,GAAG,MAAM;IAkBzC;;;;OAIG;IACI,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;CA8E/C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogFormatter.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogFormatter = void 0;
+const env_1 = require("@aws-lambda-powertools/commons/utils/env");
+/**
+ * Class that defines and implements common methods for the formatting of log attributes.
+ *
+ * When creating a custom log formatter, you should extend this class and implement the
+ * {@link formatAttributes | formatAttributes()} method to define the structure of the log item.
+ *
+ * @abstract
+ */
+class LogFormatter {
+    /**
+     * Format an error into a loggable object.
+     *
+     * @example
+     * ```json
+     * {
+     *   "name": "Error",
+     *   "location": "file.js:1",
+     *   "message": "An error occurred",
+     *   "stack": "Error: An error occurred\n    at file.js:1\n    at file.js:2\n    at file.js:3",
+     *   "cause": {
+     *     "name": "OtherError",
+     *     "location": "file.js:2",
+     *     "message": "Another error occurred",
+     *     "stack": "Error: Another error occurred\n    at file.js:2\n    at file.js:3\n    at file.js:4"
+     *   }
+     * }
+     * ```
+     *
+     * @param error - Error to format
+     */
+    formatError(error) {
+        const { name, message, stack, cause, ...errorAttributes } = error;
+        const formattedError = {
+            name,
+            location: this.getCodeLocation(error.stack),
+            message,
+            stack: (0, env_1.isDevMode)() && typeof stack === 'string' ? stack?.split('\n') : stack,
+            cause: cause instanceof Error ? this.formatError(cause) : cause,
+        };
+        for (const key in error) {
+            if (typeof key === 'string' &&
+                !['name', 'message', 'stack', 'cause'].includes(key)) {
+                formattedError[key] = errorAttributes[key];
+            }
+        }
+        return formattedError;
+    }
+    /**
+     * Format a date into an ISO 8601 string with the configured timezone.
+     *
+     * The timezone is read from the `TZ` environment variable, if present.
+     * Otherwise, the timezone defaults to ':UTC'.
+     *
+     * @param now - The date to format
+     */
+    formatTimestamp(now) {
+        const defaultTimezone = 'UTC';
+        /**
+         * If a specific timezone is configured and it's not the default `UTC`,
+         * format the timestamp with the appropriate timezone offset.
+         */
+        const configuredTimezone = (0, env_1.getStringFromEnv)({
+            key: 'TZ',
+            defaultValue: '',
+        });
+        if (configuredTimezone && !configuredTimezone.includes(defaultTimezone))
+            return this.#generateISOTimestampWithOffset(now, configuredTimezone);
+        return now.toISOString();
+    }
+    /**
+     * Get the location of an error from a stack trace.
+     *
+     * @param stack - stack trace to parse
+     */
+    getCodeLocation(stack) {
+        if (!stack) {
+            return '';
+        }
+        const stackLines = stack.split('\n');
+        const regex = /\(([^()]*?):(\d+?):(\d+?)\)\\?$/;
+        for (const item of stackLines) {
+            const match = regex.exec(item);
+            if (Array.isArray(match)) {
+                return `${match[1]}:${Number(match[2])}`;
+            }
+        }
+        return '';
+    }
+    /**
+     * Create a new Intl.DateTimeFormat object configured with the specified time zone
+     * and formatting options.
+     *
+     * The time is displayed in 24-hour format (hour12: false).
+     *
+     * @param timezone - IANA time zone identifier (e.g., "Asia/Dhaka").
+     */
+    #getDateFormatter = (timezone) => {
+        const twoDigitFormatOption = '2-digit';
+        const validTimeZone = Intl.supportedValuesOf('timeZone').includes(timezone)
+            ? timezone
+            : 'UTC';
+        return new Intl.DateTimeFormat('en', {
+            hourCycle: 'h23',
+            year: 'numeric',
+            month: twoDigitFormatOption,
+            day: twoDigitFormatOption,
+            hour: twoDigitFormatOption,
+            minute: twoDigitFormatOption,
+            second: twoDigitFormatOption,
+            timeZone: validTimeZone,
+        });
+    };
+    /**
+     * Generate an ISO 8601 timestamp string with the specified time zone and the local time zone offset.
+     *
+     * @param date - date to format
+     * @param timezone - IANA time zone identifier (e.g., "Asia/Dhaka").
+     */
+    #generateISOTimestampWithOffset(date, timezone) {
+        const { year, month, day, hour, minute, second } = this.#getDateFormatter(timezone)
+            .formatToParts(date)
+            .reduce((acc, item) => {
+            acc[item.type] = item.value;
+            return acc;
+        }, {});
+        const datePart = `${year}-${month}-${day}T${hour}:${minute}:${second}`;
+        const offset = -date.getTimezoneOffset();
+        const offsetSign = offset >= 0 ? '+' : '-';
+        const offsetHours = Math.abs(Math.floor(offset / 60))
+            .toString()
+            .padStart(2, '0');
+        const offsetMinutes = Math.abs(offset % 60)
+            .toString()
+            .padStart(2, '0');
+        const millisecondPart = date.getMilliseconds().toString().padStart(3, '0');
+        const offsetPart = `${offsetSign}${offsetHours}:${offsetMinutes}`;
+        return `${datePart}.${millisecondPart}${offsetPart}`;
+    }
+}
+exports.LogFormatter = LogFormatter;

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogItem.d.ts

@@ -0,0 +1,56 @@
+import type { LogAttributes } from '../types/Logger.js';
+/**
+ * LogItem is a class that holds the attributes of a log item.
+ *
+ * It is used by {@link LogFormatter} to store the attributes of a log item and to add additional attributes to it.
+ */
+declare class LogItem {
+    /**
+     * The attributes of the log item.
+     */
+    private attributes;
+    /**
+     * Constructor for LogItem.
+     *
+     * Attributes are added in the following order:
+     * - Standard keys provided by the logger (e.g. `message`, `level`, `timestamp`)
+     * - Persistent attributes provided by developer, not formatted (done later)
+     * - Ephemeral attributes provided as parameters for a single log item (done later)
+     *
+     * @param params - The parameters for the LogItem.
+     */
+    constructor(params: {
+        attributes: LogAttributes;
+    });
+    /**
+     * Add attributes to the log item.
+     *
+     * @param attributes - The attributes to add to the log item.
+     */
+    addAttributes(attributes: LogAttributes): this;
+    /**
+     * Get the attributes of the log item.
+     */
+    getAttributes(): LogAttributes;
+    /**
+     * Prepare the log item for printing.
+     *
+     * This operation removes empty keys from the log item, see {@link removeEmptyKeys | removeEmptyKeys()} for more information.
+     */
+    prepareForPrint(): void;
+    /**
+     * Remove empty keys from the log item, where empty keys are defined as keys with
+     * values of `undefined`, empty strings (`''`), or `null`.
+     *
+     * @param attributes - The attributes to remove empty keys from.
+     */
+    removeEmptyKeys(attributes: LogAttributes): LogAttributes;
+    /**
+     * Replace the attributes of the log item.
+     *
+     * @param attributes - The attributes to set for the log item.
+     */
+    setAttributes(attributes: LogAttributes): void;
+}
+export { LogItem };
+//# sourceMappingURL=LogItem.d.ts.map

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogItem.d.ts","sourceRoot":"","sources":["../../../src/formatter/LogItem.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;;;GAIG;AACH,cAAM,OAAO;IACX;;OAEG;IACH,OAAO,CAAC,UAAU,CAAqB;IAEvC;;;;;;;;;OASG;gBACgB,MAAM,EAAE;QAAE,UAAU,EAAE,aAAa,CAAA;KAAE;IAIxD;;;;OAIG;IACI,aAAa,CAAC,UAAU,EAAE,aAAa,GAAG,IAAI;IAMrD;;OAEG;IACI,aAAa,IAAI,aAAa;IAIrC;;;;OAIG;IACI,eAAe,IAAI,IAAI;IAI9B;;;;;OAKG;IACI,eAAe,CAAC,UAAU,EAAE,aAAa,GAAG,aAAa;IAehE;;;;OAIG;IACI,aAAa,CAAC,UAAU,EAAE,aAAa,GAAG,IAAI;CAGtD;AAED,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogItem.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogItem = void 0;
+const commons_1 = require("@aws-lambda-powertools/commons");
+/**
+ * LogItem is a class that holds the attributes of a log item.
+ *
+ * It is used by {@link LogFormatter} to store the attributes of a log item and to add additional attributes to it.
+ */
+class LogItem {
+    /**
+     * The attributes of the log item.
+     */
+    attributes = {};
+    /**
+     * Constructor for LogItem.
+     *
+     * Attributes are added in the following order:
+     * - Standard keys provided by the logger (e.g. `message`, `level`, `timestamp`)
+     * - Persistent attributes provided by developer, not formatted (done later)
+     * - Ephemeral attributes provided as parameters for a single log item (done later)
+     *
+     * @param params - The parameters for the LogItem.
+     */
+    constructor(params) {
+        this.setAttributes(params.attributes);
+    }
+    /**
+     * Add attributes to the log item.
+     *
+     * @param attributes - The attributes to add to the log item.
+     */
+    addAttributes(attributes) {
+        (0, commons_1.deepMerge)(this.attributes, attributes);
+        return this;
+    }
+    /**
+     * Get the attributes of the log item.
+     */
+    getAttributes() {
+        return this.attributes;
+    }
+    /**
+     * Prepare the log item for printing.
+     *
+     * This operation removes empty keys from the log item, see {@link removeEmptyKeys | removeEmptyKeys()} for more information.
+     */
+    prepareForPrint() {
+        this.attributes = this.removeEmptyKeys(this.getAttributes());
+    }
+    /**
+     * Remove empty keys from the log item, where empty keys are defined as keys with
+     * values of `undefined`, empty strings (`''`), or `null`.
+     *
+     * @param attributes - The attributes to remove empty keys from.
+     */
+    removeEmptyKeys(attributes) {
+        const newAttributes = {};
+        for (const key in attributes) {
+            if (attributes[key] !== undefined &&
+                attributes[key] !== '' &&
+                attributes[key] !== null) {
+                newAttributes[key] = attributes[key];
+            }
+        }
+        return newAttributes;
+    }
+    /**
+     * Replace the attributes of the log item.
+     *
+     * @param attributes - The attributes to set for the log item.
+     */
+    setAttributes(attributes) {
+        this.attributes = attributes;
+    }
+}
+exports.LogItem = LogItem;

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/PowertoolsLogFormatter.d.ts

@@ -0,0 +1,24 @@
+import type { PowertoolsLogFormatterOptions } from '../types/formatters.js';
+import type { LogAttributes, UnformattedAttributes } from '../types/logKeys.js';
+import { LogFormatter } from './LogFormatter.js';
+import { LogItem } from './LogItem.js';
+/**
+ * This class is used to transform a set of log key-value pairs
+ * in the Powertools for AWS Lambda default structure log format.
+ *
+ * @class
+ * @extends {LogFormatter}
+ */
+declare class PowertoolsLogFormatter extends LogFormatter {
+    #private;
+    constructor(options?: PowertoolsLogFormatterOptions);
+    /**
+     * It formats key-value pairs of log attributes.
+     *
+     * @param {UnformattedAttributes} attributes - unformatted attributes
+     * @param {LogAttributes} additionalLogAttributes - additional log attributes
+     */
+    formatAttributes(attributes: UnformattedAttributes, additionalLogAttributes: LogAttributes): LogItem;
+}
+export { PowertoolsLogFormatter };
+//# sourceMappingURL=PowertoolsLogFormatter.d.ts.map

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/PowertoolsLogFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PowertoolsLogFormatter.d.ts","sourceRoot":"","sources":["../../../src/formatter/PowertoolsLogFormatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,6BAA6B,EAC9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EACV,aAAa,EAGb,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;GAMG;AACH,cAAM,sBAAuB,SAAQ,YAAY;;gBAQ5B,OAAO,CAAC,EAAE,6BAA6B;IAK1D;;;;;OAKG;IACI,gBAAgB,CACrB,UAAU,EAAE,qBAAqB,EACjC,uBAAuB,EAAE,aAAa,GACrC,OAAO;CA0DX;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}