@allthings/cloud-toolkit 2.2.1 → 2.3.0-dev.1

package/dist/lib.esm.js

@@ -1,14 +1,664 @@
+import * as querystring from 'querystring';
+import * as zlib from 'zlib';
+import * as crypto from 'crypto';
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocumentClient, UpdateCommand, ScanCommand, QueryCommand, PutCommand, GetCommand, DeleteCommand, BatchWriteCommand } from '@aws-sdk/lib-dynamodb';
 import Bottleneck from 'bottleneck';
 import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
 import { SSMClient, GetParametersCommand, GetParameterCommand } from '@aws-sdk/client-ssm';
-import * as aws from '@aws-sdk/client-ses';
+import * as aws$1 from '@aws-sdk/client-ses';
 import { createTransport } from 'nodemailer';
 import { SQSClient, SendMessageCommand, GetQueueUrlCommand, ReceiveMessageCommand, DeleteMessageCommand } from '@aws-sdk/client-sqs';
 import { format, createLogger, transports } from 'winston';
 export { Logger } from 'winston';
 
+const defaultErrorHandler = (request, response, error) => {
+    const { requestId } = request.requestContext;
+    const errorName = error.name && typeof error.name === 'string'
+        ? error.name.replace(/([A-Z])([A-Z])([a-z])|([a-z])([A-Z])/g, '$1$4 $2$3$5')
+        : 'Error';
+    const errorMessage = error.message || '';
+    const statusCode = error.statusCode ? ` ${error.statusCode}` : '';
+    return error.name === 'ClientError' ||
+        (error.statusCode >= 400 && error.statusCode < 500)
+        ? response.respondTo({
+            html: `<html><body><strong>${errorName}${statusCode}</strong>: ${errorMessage}<br/>Request ID: ${requestId}</body></html>`,
+            json: { error: error.name, message: errorMessage, requestId },
+        }, error.statusCode || 400)
+        : response.respondTo({
+            html: `<html><body>An internal server error occurred.<br/>Request ID: ${requestId}</body></html>`,
+            json: {
+                error: 'Internal server error',
+                message: 'An internal server error occurred',
+                requestId,
+            },
+        }, 500);
+};
+
+class ClientError extends Error {
+    name = 'ClientError';
+    statusCode = 400;
+    constructor(message, name, statusCode = 400) {
+        super(String(message));
+        this.name = name || this.name;
+        this.statusCode = statusCode;
+    }
+}
+
+class ServerError extends Error {
+    name = 'ServerError';
+    statusCode = 500;
+    constructor(message, name, statusCode = 500) {
+        super(String(message));
+        this.name = name || this.name;
+        this.statusCode = statusCode;
+    }
+}
+
+const applyMiddleware = async (middlewareList, initialData, ...arguments_) => middlewareList.reduce(async (applied, middleware) => middleware(await applied, ...arguments_), Promise.resolve(initialData));
+
+const decodeBase64 = (encoded) => {
+    const bodyBuffer = Buffer.from(encoded, 'base64');
+    return bodyBuffer.toString('utf8');
+};
+const decodeBase64Body = (request) => request.isBase64Encoded && typeof request.body === 'string'
+    ? {
+        ...request,
+        body: decodeBase64(request.body),
+    }
+    : request;
+
+const parseCookiePair = (pair) => {
+    const indexOfEqualCharacter = pair.indexOf('=');
+    const looksLikeKeyValue = indexOfEqualCharacter >= 0;
+    const key = looksLikeKeyValue &&
+        pair.slice(0, Math.max(0, indexOfEqualCharacter)).trim();
+    const value = looksLikeKeyValue &&
+        pair.substr(indexOfEqualCharacter + 1, pair.length).trim();
+    const cleanValue = value && '"' === value[0] ? value.slice(1, -1) : value;
+    return key ? { [key]: cleanValue ? decodeURIComponent(cleanValue) : '' } : {};
+};
+const parseCookieHeader = (cookieHeader) => {
+    const pairs = cookieHeader.split(/; */);
+    return pairs.reduce((parsedCookies, pair) => ({ ...parsedCookies, ...parseCookiePair(pair) }), {});
+};
+const cookies = (request) => ({
+    ...request,
+    cookies: parseCookieHeader((request.headers && request.headers.cookie) || ''),
+});
+
+const setHostname = (request) => ({
+    ...request,
+    hostname: (request.headers && request.headers.host) || undefined,
+});
+
+const parseJson = (stringified) => {
+    try {
+        return JSON.parse(stringified);
+    }
+    catch {
+        return {};
+    }
+};
+const parseJsonBody = (request) => {
+    const { headers, body } = request;
+    return headers['content-type'] &&
+        headers['content-type'].split(';').shift() === 'application/json' &&
+        typeof body === 'string'
+        ? { ...request, body: parseJson(body) }
+        : request;
+};
+
+const state = new Map([['invocationCount', 0]]);
+const meta = (request) => {
+    const invocationCount = Number(state.get('invocationCount'));
+    return {
+        ...request,
+        meta: {
+            ...request.meta,
+            coldStart: !invocationCount,
+            invocationCount: state
+                .set('invocationCount', invocationCount + 1)
+                .get('invocationCount'),
+        },
+    };
+};
+
+const normalizeHeaders = ({ headers = {}, ...request }) => ({
+    ...request,
+    headers: Object.keys(headers).reduce((normalizedHeaders, key) => {
+        const normalizedHeaderKey = key.toLowerCase();
+        return request.provider === 'aws' &&
+            Reflect.has(normalizedHeaders, normalizedHeaderKey) &&
+            normalizedHeaderKey === 'content-type' &&
+            headers[key] === 'application/json'
+            ? normalizedHeaders
+            : {
+                ...normalizedHeaders,
+                [normalizedHeaderKey]: headers[key],
+            };
+    }, {}),
+});
+
+const normalizeProgrammingModel = (request) => ({
+    ...request,
+    method: request.httpMethod || '',
+    provider: 'aws',
+    query: request.queryStringParameters || {},
+    source: request.requestContext ? 'api-gateway' : request.source,
+});
+
+const addTimestamp = (request) => ({
+    ...request,
+    timestamp: Date.now(),
+});
+
+const parseUrlEncodedBody = (request) => {
+    const { headers, body } = request;
+    return headers['content-type'] &&
+        headers['content-type'].split(';').shift() ===
+            'application/x-www-form-urlencoded' &&
+        typeof body === 'string'
+        ? { ...request, body: querystring.parse(body) }
+        : request;
+};
+
+var makeRequest = async (event, context, options = {}) => applyMiddleware([
+    addTimestamp,
+    normalizeProgrammingModel,
+    normalizeHeaders,
+    decodeBase64Body,
+    cookies,
+    parseUrlEncodedBody,
+    parseJsonBody,
+    setHostname,
+    meta,
+    ...(options.requestMiddleware || []),
+], Object.freeze({
+    ...event,
+    context,
+}), options);
+
+const setHeader = (response, responseData, key, value) => {
+    Object.assign(responseData.headers, { [key]: value });
+    return response;
+};
+
+const makeResponseObject = (responseData, body = '', statusCode = 200, { headers = {}, ...options } = {}, contentType) => Object.freeze({
+    ...responseData,
+    body: body || '',
+    headers: {
+        ...(responseData && responseData.headers),
+        'content-type': contentType,
+        ...headers,
+    },
+    statusCode,
+    ...options,
+});
+
+const html = (responseData, _, body, statusCode, options) => makeResponseObject(responseData, body, statusCode, options, 'text/html');
+
+const stringifyIfNotStringifiedJson = (data) => {
+    const maybeTrimmedDataString = typeof data === 'string' ? data.trim() : data;
+    const isStringifiedJson = typeof data === 'string' &&
+        ['{', '"'].includes(maybeTrimmedDataString[0]) &&
+        ['}', '"'].includes(maybeTrimmedDataString.at(-1));
+    return isStringifiedJson ? maybeTrimmedDataString : JSON.stringify(data);
+};
+const json = (responseData, _, body, statusCode, options) => makeResponseObject(responseData, stringifyIfNotStringifiedJson(body), statusCode, options, 'application/json');
+
+const COMPRESSIBLE = [
+    'application/activity+json',
+    'application/alto-costmap+json',
+    'application/alto-costmapfilter+json',
+    'application/alto-directory+json',
+    'application/alto-endpointcost+json',
+    'application/alto-endpointcostparams+json',
+    'application/alto-endpointprop+json',
+    'application/alto-endpointpropparams+json',
+    'application/alto-error+json',
+    'application/alto-networkmap+json',
+    'application/alto-networkmapfilter+json',
+    'application/atom+xml',
+    'application/calendar+json',
+    'application/coap-group+json',
+    'application/csvm+json',
+    'application/dart',
+    'application/dicom+json',
+    'application/ecmascript',
+    'application/fhir+json',
+    'application/fido.trusted-apps+json',
+    'application/geo+json',
+    'application/javascript',
+    'application/jf2feed+json',
+    'application/jose+json',
+    'application/jrd+json',
+    'application/json',
+    'application/json-patch+json',
+    'application/jsonml+json',
+    'application/jwk+json',
+    'application/jwk-set+json',
+    'application/ld+json',
+    'application/manifest+json',
+    'application/merge-patch+json',
+    'application/mud+json',
+    'application/postscript',
+    'application/ppsp-tracker+json',
+    'application/problem+json',
+    'application/raml+yaml',
+    'application/rdap+json',
+    'application/rdf+xml',
+    'application/reputon+json',
+    'application/rss+xml',
+    'application/rtf',
+    'application/scim+json',
+    'application/soap+xml',
+    'application/tar',
+    'application/vcard+json',
+    'application/vnd.amadeus+json',
+    'application/vnd.api+json',
+    'application/vnd.apothekende.reservation+json',
+    'application/vnd.avalon+json',
+    'application/vnd.bbf.usp.msg+json',
+    'application/vnd.bekitzur-stech+json',
+    'application/vnd.capasystems-pg+json',
+    'application/vnd.collection+json',
+    'application/vnd.collection.doc+json',
+    'application/vnd.collection.next+json',
+    'application/vnd.coreos.ignition+json',
+    'application/vnd.dart',
+    'application/vnd.datapackage+json',
+    'application/vnd.dataresource+json',
+    'application/vnd.document+json',
+    'application/vnd.drive+json',
+    'application/vnd.geo+json',
+    'application/vnd.google-earth.kml+xml',
+    'application/vnd.hal+json',
+    'application/vnd.hc+json',
+    'application/vnd.heroku+json',
+    'application/vnd.hyper+json',
+    'application/vnd.hyper-item+json',
+    'application/vnd.hyperdrive+json',
+    'application/vnd.ims.lis.v2.result+json',
+    'application/vnd.ims.lti.v2.toolconsumerprofile+json',
+    'application/vnd.ims.lti.v2.toolproxy+json',
+    'application/vnd.ims.lti.v2.toolproxy.id+json',
+    'application/vnd.ims.lti.v2.toolsettings+json',
+    'application/vnd.ims.lti.v2.toolsettings.simple+json',
+    'application/vnd.las.las+json',
+    'application/vnd.mason+json',
+    'application/vnd.micro+json',
+    'application/vnd.miele+json',
+    'application/vnd.mozilla.xul+xml',
+    'application/vnd.ms-fontobject',
+    'application/vnd.ms-opentype',
+    'application/vnd.nearst.inv+json',
+    'application/vnd.oftn.l10n+json',
+    'application/vnd.oma.lwm2m+json',
+    'application/vnd.oracle.resource+json',
+    'application/vnd.pagerduty+json',
+    'application/vnd.restful+json',
+    'application/vnd.siren+json',
+    'application/vnd.sun.wadl+xml',
+    'application/vnd.tableschema+json',
+    'application/vnd.vel+json',
+    'application/vnd.xacml+json',
+    'application/voucher-cms+json',
+    'application/wasm',
+    'application/webpush-options+json',
+    'application/x-httpd-php',
+    'application/x-javascript',
+    'application/x-ns-proxy-autoconfig',
+    'application/x-sh',
+    'application/x-tar',
+    'application/x-virtualbox-hdd',
+    'application/x-virtualbox-ova',
+    'application/x-virtualbox-ovf',
+    'application/x-virtualbox-vbox',
+    'application/x-virtualbox-vdi',
+    'application/x-virtualbox-vhd',
+    'application/x-virtualbox-vmdk',
+    'application/x-web-app-manifest+json',
+    'application/x-www-form-urlencoded',
+    'application/xhtml+xml',
+    'application/xml',
+    'application/xml-dtd',
+    'application/xop+xml',
+    'application/yang-data+json',
+    'application/yang-patch+json',
+    'font/otf',
+    'image/bmp',
+    'image/svg+xml',
+    'image/vnd.adobe.photoshop',
+    'image/x-icon',
+    'image/x-ms-bmp',
+    'message/imdn+xml',
+    'message/rfc822',
+    'model/gltf+json',
+    'model/gltf-binary',
+    'model/x3d+xml',
+    'text/cache-manifest',
+    'text/calender',
+    'text/cmd',
+    'text/css',
+    'text/csv',
+    'text/html',
+    'text/javascript',
+    'text/jsx',
+    'text/markdown',
+    'text/n3',
+    'text/plain',
+    'text/richtext',
+    'text/rtf',
+    'text/tab-separated-values',
+    'text/uri-list',
+    'text/vcard',
+    'text/vtt',
+    'text/x-gwt-rpc',
+    'text/x-jquery-tmpl',
+    'text/x-markdown',
+    'text/x-org',
+    'text/x-processing',
+    'text/x-suse-ymp',
+    'text/xml',
+    'x-shader/x-fragment',
+    'x-shader/x-vertex',
+];
+const ZLIB_DEFAULT_OPTIONS = {
+    level: 5,
+};
+const acceptEncoding = (accepts, encodings) => accepts.find((accept) => encodings.some((encoding) => accept === encoding));
+const getBestAcceptEncoding = (request) => {
+    const { headers } = request;
+    const acceptEncodings = (headers['accept-encoding'] || '').split(/, */);
+    const encoding = acceptEncoding(acceptEncodings, [
+        'gzip',
+        'deflate',
+        'identity',
+    ]);
+    return encoding === 'deflate' && acceptEncoding(acceptEncodings, ['gzip'])
+        ? acceptEncoding(acceptEncodings, ['gzip', 'identity'])
+        : encoding;
+};
+const compressResponse = (response, encoding) => {
+    const { body, headers, ...rest } = response;
+    const compressed = encoding === 'gzip'
+        ? zlib.gzipSync(body, ZLIB_DEFAULT_OPTIONS)
+        : zlib.deflateSync(body, ZLIB_DEFAULT_OPTIONS);
+    return {
+        ...rest,
+        body: compressed.toString('base64'),
+        headers: {
+            ...headers,
+            'content-encoding': encoding,
+            'content-length': compressed.byteLength,
+        },
+        isBase64Encoded: true,
+    };
+};
+const compress = (response, request) => {
+    const { body, headers } = response;
+    const encoding = getBestAcceptEncoding(request);
+    const weShouldCompress = COMPRESSIBLE.includes(headers['content-type']) &&
+        encoding !== undefined &&
+        encoding !== 'identity' &&
+        body &&
+        body.length > 256;
+    return weShouldCompress && encoding
+        ? compressResponse(response, encoding)
+        : response;
+};
+
+const contentLengthHeader = (response) => {
+    const { body, headers, ...rest } = response;
+    return {
+        ...rest,
+        body,
+        headers: {
+            ...headers,
+            'content-length': headers['content-length'] || Buffer.byteLength(body),
+        },
+    };
+};
+
+const DEFAULT_POLICIES = {
+    'default-src': "'self' https: 'unsafe-inline'",
+    'img-src': '* data: blob:',
+};
+const cspHeaders = (response, _, options) => {
+    const { headers = {}, ...rest } = response;
+    const cspPolicies = {
+        ...DEFAULT_POLICIES,
+        ...options.cspPolicies,
+    };
+    const cspPolicy = Object.keys(cspPolicies)
+        .map((policy) => `${policy} ${cspPolicies[policy]}`)
+        .join(';');
+    return {
+        ...rest,
+        headers: {
+            ...headers,
+            'content-security-policy': cspPolicy,
+            'referrer-policy': 'strict-origin-when-cross-origin',
+            'x-content-type-options': 'nosniff',
+            'x-frame-options': {
+                "'none'": 'DENY',
+                "'self'": 'SAMEORIGIN',
+            }[cspPolicies['frame-ancestors']] || undefined,
+            'x-xss-protection': '1; mode=block',
+        },
+    };
+};
+
+const enforcedHeaders = (response, _, options) => ({
+    ...response,
+    headers: {
+        ...response.headers,
+        ...(options.headers ?? {}),
+    },
+});
+
+const EMPTY_ENTITY_TAG = '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
+const entitytag = (entity) => {
+    const hash = crypto
+        .createHash('sha1')
+        .update(entity, 'utf8')
+        .digest('base64')
+        .slice(0, 27);
+    const length = typeof entity === 'string'
+        ? Buffer.byteLength(entity, 'utf8')
+        : entity.length;
+    return `"${length.toString(16)}-${hash}"`;
+};
+const etag = (entity) => entity.length === 0 ? EMPTY_ENTITY_TAG : entitytag(entity);
+const etagHeader = (response) => ({
+    ...response,
+    headers: {
+        ...response.headers,
+        etag: etag(response.body),
+    },
+});
+
+const aws = (request) => {
+    const { headers: requestHeaders, requestContext, context } = request;
+    return {
+        apig: {
+            requestId: requestContext.requestId,
+            resourcePath: requestContext.resourcePath,
+        },
+        awsAccountId: requestContext.accountId,
+        cloudfront: {
+            country: requestHeaders['cloudfront-viewer-country'],
+            desktop: requestHeaders['cloudfront-is-desktop-viewer'] === 'true',
+            mobile: requestHeaders['cloudfront-is-mobile-viewer'] === 'true',
+            smarttv: requestHeaders['cloudfront-is-smarttv-viewer'] === 'true',
+            tablet: requestHeaders['cloudfront-is-tablet-viewer'] === 'true',
+        },
+        deploymentStage: requestContext.stage,
+        lambda: {
+            functionName: context.functionName,
+            memoryLimit: Number(context.memoryLimitInMB),
+            remainingExecutionTime: context.getRemainingTimeInMillis && context.getRemainingTimeInMillis(),
+            requestId: context.awsRequestId,
+        },
+        sourceIp: requestContext.identity.sourceIp,
+    };
+};
+const logger$1 = (request, response) => {
+    const { source, headers: requestHeaders, meta, requestContext, provider, hostname, body, timestamp, path, query, } = request;
+    const error = response.statusCode >= 500 && response.statusCode < 600;
+    const logEntry = {
+        dateTime: new Date().toISOString(),
+        eventSource: source,
+        hostname,
+        httpMethod: requestContext.httpMethod,
+        httpProtocol: requestHeaders.via && requestHeaders.via.split(' ')[0],
+        httpReferrer: requestHeaders.referer,
+        httpUserAgent: requestHeaders['user-agent'],
+        requestContentLength: (body && body.length > 0) || 0,
+        requestTime: Date.now() - timestamp,
+        requestUri: path +
+            (query && Object.keys(query).length > 0
+                ? `?${querystring.stringify(query)}`
+                : ''),
+        responseContentLength: response.headers['content-length'],
+        statusCode: response.statusCode,
+        xForwardedHost: requestHeaders['x-forwarded-host'],
+        ...meta,
+        ...(provider === 'aws' && aws(request)),
+    };
+    return ((error ? process.stderr : process.stdout).write(JSON.stringify(logEntry)) &&
+        logEntry);
+};
+const logResponse = (response, request, options) => (options.enableLogger &&
+    (typeof options.logger === 'function'
+        ? options.logger(request, response)
+        : logger$1(request, response)) &&
+    response) ||
+    response;
+
+const redirect = (responseData, _, location, statusCode = 302, options = {}) => makeResponseObject(responseData, '', statusCode, {
+    ...options,
+    headers: {
+        ...options.headers,
+        location,
+    },
+});
+
+const getBestMatchedFormat = (formats, accept) => {
+    const fallback = formats.default || 'html';
+    const acceptFormats = accept &&
+        typeof accept === 'string' &&
+        accept
+            .split(';')[0]
+            .split(',')
+            .map((type) => {
+            const mimeParts = type.split('/');
+            return mimeParts.at(-1);
+        });
+    return ((acceptFormats &&
+        acceptFormats.find((type) => Reflect.has(formats, type))) ||
+        fallback);
+};
+const getBestMatchedResponseHelper = (format) => {
+    switch (format) {
+        case 'html':
+            return html;
+        case 'json':
+            return json;
+    }
+    throw new TypeError(`"${format}" is not a valid Alagarr respondTo() format.`);
+};
+const getBestMatchedFormatBody = (formats, format) => {
+    switch (format) {
+        case 'html':
+            return formats.html;
+        case 'json':
+            return formats.json;
+    }
+    throw new TypeError(`"${format}" is not a valid Alagarr respondTo() format.`);
+};
+const respondTo = (responseData, request, formats, statusCode, options) => {
+    const { headers: { accept }, } = request;
+    const format = getBestMatchedFormat(formats, accept);
+    const responseHelper = getBestMatchedResponseHelper(format);
+    const body = getBestMatchedFormatBody(formats, format);
+    return responseHelper(responseData, request, body, statusCode, options);
+};
+
+const text = (responseData, _, body, statusCode, options) => makeResponseObject(responseData, body, statusCode, options, 'text/plain');
+
+const middlewareMap = {
+    enableCompression: compress,
+    enableContentLength: contentLengthHeader,
+    enableCspHeaders: cspHeaders,
+    enableETagHeader: etagHeader,
+    enableEnforcedHeaders: enforcedHeaders,
+};
+var makeResponse = async (request, callback, options) => {
+    const responseData = makeResponseObject();
+    const responseWithHelpers = [
+        text,
+        html,
+        json,
+        redirect,
+        respondTo,
+    ].reduce((methods, method) => ({
+        ...methods,
+        [method.name]: async (...arguments_) => callback(null, await applyMiddleware(Object.keys(middlewareMap).reduce((middlewareList, middleware) => options[middleware]
+            ? [...middlewareList, middlewareMap[middleware]]
+            : middlewareList, [
+            ...(options.responseMiddleware || []),
+            ...(options.enableLogger ? [logResponse] : []),
+        ]), method(responseData, request, ...arguments_), request, options)),
+    }), { raw: callback });
+    const response = [setHeader].reduce((responseMethods, method) => ({
+        ...responseMethods,
+        [method.name]: (...arguments_) => method(response, responseData, ...arguments_),
+    }), responseWithHelpers);
+    return response;
+};
+
+const DEFAULT_OPTIONS = {
+    cspPolicies: [],
+    enableCompression: true,
+    enableContentLength: true,
+    enableCspHeaders: true,
+    enableETagHeader: true,
+    enableEnforcedHeaders: true,
+    enableLogger: true,
+    enableStrictTransportSecurity: true,
+    errorHandler: defaultErrorHandler,
+    requestMiddleware: [],
+    responseMiddleware: [],
+};
+const noopHandler = (_, _1) => {
+    throw new ServerError('Misconfiguration in Alagarr setup. No handler function was provided.');
+};
+const alagarr = (handler = noopHandler, options = DEFAULT_OPTIONS) => async (event, context, callback) => {
+    const mergedOptions = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+    };
+    const request = await makeRequest(event, context, mergedOptions);
+    const response = await makeResponse(request, callback, mergedOptions);
+    try {
+        return await handler(request, response, context);
+    }
+    catch (handlerError) {
+        const errorHandler = typeof mergedOptions.errorHandler === 'function'
+            ? mergedOptions.errorHandler
+            : defaultErrorHandler;
+        try {
+            return await errorHandler(request, response, handlerError);
+        }
+        catch (error) {
+            console.error('There was an error in the error handler provided to Alagaar', error, errorHandler.toString());
+            return defaultErrorHandler(request, response, error);
+        }
+    }
+};
+
 const DEFAULT_AWS_CONFIGURATION = {
     region: 'eu-central-2',
 };
@@ -333,9 +983,9 @@ const ses = (fromEmailAddress, userConfig) => {
         ...DEFAULT_CLIENT_CONFIG,
         ...userConfig,
     };
-    const sesClient = new aws.SESClient(clientConfig);
+    const sesClient = new aws$1.SESClient(clientConfig);
     const transport = createTransport(userConfig.customSMTPConfig ?? {
-        SES: { aws, ses: sesClient },
+        SES: { aws: aws$1, ses: sesClient },
     });
     return {
         sendMail: (options, responseCallback) => sendMail(config, transport, options, fromEmailAddress, responseCallback),
@@ -449,4 +1099,4 @@ const logger = (config) => {
     });
 };
 
-export { DEFAULT_CLIENT_CONFIG$1 as DEFAULT_PARAMETER_STORE_CLIENT_CONFIG, DEFAULT_CLIENT_CONFIG as DEFAULT_SES_CLIENT_CONFIG, dynamodb, lambda, logger, parameterStore, ses, sqs };
+export { ClientError, DEFAULT_CLIENT_CONFIG$1 as DEFAULT_PARAMETER_STORE_CLIENT_CONFIG, DEFAULT_CLIENT_CONFIG as DEFAULT_SES_CLIENT_CONFIG, ServerError, alagarr, dynamodb, lambda, logger, parameterStore, ses, sqs };