@allthings/cloud-toolkit 5.1.0 → 5.2.0-beta.2

package/dist/alagarr.cjs.js

@@ -0,0 +1,690 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var querystring = require('querystring');
+var zlib = require('zlib');
+var crypto = require('crypto');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var querystring__namespace = /*#__PURE__*/_interopNamespaceDefault(querystring);
+var zlib__namespace = /*#__PURE__*/_interopNamespaceDefault(zlib);
+var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
+
+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 !== -1;
+    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?.cookie || ''),
+});
+
+const setHostname = (request) => ({
+    ...request,
+    hostname: 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']?.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 ??
+        request.requestContext?.http?.method ??
+        '',
+    path: request.path ??
+        request.requestContext?.http?.path ??
+        '',
+    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']?.split(';').shift() ===
+        'application/x-www-form-urlencoded' && typeof body === 'string'
+        ? { ...request, body: querystring__namespace.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?.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__namespace.gzipSync(body, ZLIB_DEFAULT_OPTIONS)
+        : zlib__namespace.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__namespace
+        .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?.(),
+            requestId: context.awsRequestId,
+        },
+        sourceIp: requestContext.identity
+            ?.sourceIp ??
+            requestContext?.http?.sourceIp,
+    };
+};
+const logger = (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?.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__namespace.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(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) => (event, context) => new Promise((resolve, reject) => {
+    const settleResponse = (error, result) => error
+        ? reject(error instanceof Error ? error : new Error(String(error)))
+        : resolve(result);
+    const runHandler = async () => {
+        const mergedOptions = {
+            ...DEFAULT_OPTIONS,
+            ...options,
+        };
+        const request = await makeRequest(event, context, mergedOptions);
+        const response = await makeResponse(request, settleResponse, 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);
+            }
+        }
+    };
+    runHandler().then(resolve, reject);
+});
+
+exports.ClientError = ClientError;
+exports.ServerError = ServerError;
+exports.default = alagarr;