@digitraffic/common 2022.10.5

package/aws/infra/canaries/url-checker.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderChecker = exports.GeoJsonChecker = exports.ContentTypeChecker = exports.ContentChecker = exports.ResponseChecker = exports.UrlChecker = exports.API_KEY_HEADER = void 0;
+const http2_1 = require("http2");
+const asserter_1 = require("../../../test/asserter");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const synthetics = require('Synthetics');
+const zlib = require("zlib");
+const mediatypes_1 = require("../../types/mediatypes");
+const apikey_1 = require("../../runtime/apikey");
+const geometry_1 = require("../../../utils/geometry");
+exports.API_KEY_HEADER = "x-api-key";
+const baseHeaders = {
+    "Digitraffic-User": "internal-digitraffic-canary",
+    "Accept-Encoding": "gzip",
+    "Accept": "*/*",
+};
+class UrlChecker {
+    constructor(hostname, apiKey) {
+        const headers = { ...baseHeaders };
+        if (apiKey) {
+            headers[exports.API_KEY_HEADER] = apiKey;
+        }
+        this.requestOptions = {
+            hostname,
+            method: 'GET',
+            protocol: 'https:',
+            headers,
+        };
+        synthetics.getConfiguration()
+            .disableRequestMetrics();
+        synthetics.getConfiguration()
+            .withIncludeRequestBody(false)
+            .withIncludeRequestHeaders(false)
+            .withIncludeResponseBody(false)
+            .withIncludeResponseHeaders(false)
+            .withFailedCanaryMetric(true);
+    }
+    static create(hostname, apiKeyId) {
+        return (0, apikey_1.getApiKeyFromAPIGateway)(apiKeyId).then(apiKey => {
+            return new UrlChecker(hostname, apiKey.value);
+        });
+    }
+    static createV2() {
+        return this.create(process.env.hostname, process.env.apiKeyId);
+    }
+    expectStatus(statusCode, url, callback) {
+        const requestOptions = { ...this.requestOptions, ...{
+                path: url,
+            } };
+        return synthetics.executeHttpStep(`Verify ${statusCode} for ${url.replace(/auth=.*/, '')}`, requestOptions, callback);
+    }
+    expect200(url, ...callbacks) {
+        const callback = async (json, body, res) => {
+            await Promise.allSettled(callbacks.map(c => c(json, body, res)));
+        };
+        return this.expectStatus(200, url, callback);
+    }
+    expect404(url) {
+        const requestOptions = { ...this.requestOptions, ...{
+                path: url,
+            } };
+        return synthetics.executeHttpStep(`Verify 404 for ${url}`, requestOptions, validateStatusCodeAndContentType(404, mediatypes_1.MediaType.TEXT_PLAIN));
+    }
+    expect400(url) {
+        const requestOptions = { ...this.requestOptions, ...{
+                path: url,
+            } };
+        return synthetics.executeHttpStep(`Verify 400 for ${url}`, requestOptions, validateStatusCodeAndContentType(400, mediatypes_1.MediaType.TEXT_PLAIN));
+    }
+    expect403WithoutApiKey(url, mediaType) {
+        if (!this.requestOptions.headers || !this.requestOptions.headers[exports.API_KEY_HEADER]) {
+            console.error("No api key defined");
+        }
+        const requestOptions = { ...this.requestOptions, ...{
+                path: url,
+                headers: baseHeaders,
+            } };
+        return synthetics.executeHttpStep(`Verify 403 for ${url}`, requestOptions, validateStatusCodeAndContentType(403, mediaType || mediatypes_1.MediaType.APPLICATION_JSON));
+    }
+    done() {
+        return "Canary successful";
+    }
+}
+exports.UrlChecker = UrlChecker;
+async function getResponseBody(response) {
+    const body = await getBodyFromResponse(response);
+    if (response.headers[http2_1.constants.HTTP2_HEADER_CONTENT_ENCODING] === 'gzip') {
+        try {
+            return zlib.gunzipSync(body).toString();
+        }
+        catch (e) {
+            console.info("error " + JSON.stringify(e));
+        }
+    }
+    return body.toString();
+}
+function getBodyFromResponse(response) {
+    return new Promise((resolve) => {
+        const buffers = [];
+        response.on('data', (data) => {
+            buffers.push(data);
+        });
+        response.on('end', () => {
+            resolve(Buffer.concat(buffers).toString());
+        });
+    });
+}
+/**
+ * Returns function, that validates that the status code and content-type from response are the given values
+ * @param statusCode
+ * @param contentType
+ */
+function validateStatusCodeAndContentType(statusCode, contentType) {
+    return (res) => {
+        return new Promise(resolve => {
+            if (res.statusCode !== statusCode) {
+                throw new Error(`${res.statusCode} ${res.statusMessage}`);
+            }
+            if (res.headers[http2_1.constants.HTTP2_HEADER_CONTENT_TYPE] !== contentType) {
+                throw new Error('Wrong content-type ' + res.headers[http2_1.constants.HTTP2_HEADER_CONTENT_TYPE]);
+            }
+            resolve();
+        });
+    };
+}
+// DEPRECATED
+class ResponseChecker {
+    constructor(contentType) {
+        this.checkCors = true;
+        this.contentType = contentType;
+    }
+    static forJson() {
+        return new ResponseChecker(mediatypes_1.MediaType.APPLICATION_JSON);
+    }
+    static forCSV() {
+        return new ResponseChecker(mediatypes_1.MediaType.TEXT_CSV);
+    }
+    static forGeojson() {
+        return new ResponseChecker(mediatypes_1.MediaType.APPLICATION_GEOJSON);
+    }
+    static forJpeg() {
+        return new ResponseChecker(mediatypes_1.MediaType.IMAGE_JPEG);
+    }
+    check() {
+        return this.responseChecker(() => {
+            // no need to do anything
+        });
+    }
+    checkJson(fn) {
+        return this.responseChecker((body, res) => {
+            fn(JSON.parse(body), body, res);
+        });
+    }
+    responseChecker(fn) {
+        return async (res) => {
+            if (!res.statusCode) {
+                throw new Error('statusCode missing');
+            }
+            if (res.statusCode < 200 || res.statusCode > 299) {
+                throw new Error(`${res.statusCode} ${res.statusMessage}`);
+            }
+            if (this.checkCors && !res.headers[http2_1.constants.HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]) {
+                throw new Error('CORS missing');
+            }
+            if (res.headers[http2_1.constants.HTTP2_HEADER_CONTENT_TYPE] !== this.contentType) {
+                throw new Error('Wrong content-type ' + res.headers[http2_1.constants.HTTP2_HEADER_CONTENT_TYPE]);
+            }
+            const body = await getResponseBody(res);
+            fn(body, res);
+        };
+    }
+}
+exports.ResponseChecker = ResponseChecker;
+class ContentChecker {
+    static checkJson(fn) {
+        return async (res) => {
+            const body = await getResponseBody(res);
+            fn(JSON.parse(body), body, res);
+        };
+    }
+    static checkResponse(fn) {
+        return async (res) => {
+            const body = await getResponseBody(res);
+            fn(body, res);
+        };
+    }
+}
+exports.ContentChecker = ContentChecker;
+class ContentTypeChecker {
+    static checkContentType(contentType) {
+        return (res) => {
+            if (!res.statusCode) {
+                throw new Error('statusCode missing');
+            }
+            if (res.statusCode < 200 || res.statusCode > 299) {
+                throw new Error(`${res.statusCode} ${res.statusMessage}`);
+            }
+            if (!res.headers[http2_1.constants.HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]) {
+                throw new Error('CORS missing');
+            }
+            if (res.headers[http2_1.constants.HTTP2_HEADER_CONTENT_TYPE] !== contentType) {
+                throw new Error('Wrong content-type ' + res.headers[http2_1.constants.HTTP2_HEADER_CONTENT_TYPE]);
+            }
+        };
+    }
+}
+exports.ContentTypeChecker = ContentTypeChecker;
+class GeoJsonChecker {
+    static validFeatureCollection(fn) {
+        return ResponseChecker.forGeojson().checkJson((json) => {
+            asserter_1.Asserter.assertEquals(json.type, 'FeatureCollection');
+            asserter_1.Asserter.assertTrue((0, geometry_1.isValidGeoJson)(json));
+            if (fn) {
+                fn(json);
+            }
+        });
+    }
+}
+exports.GeoJsonChecker = GeoJsonChecker;
+class HeaderChecker {
+    static checkHeaderExists(headerName) {
+        return (res) => {
+            if (!res.headers[headerName]) {
+                throw new Error('Missing header: ' + headerName);
+            }
+        };
+    }
+    static checkHeaderMissing(headerName) {
+        return (res) => {
+            if (res.headers[headerName]) {
+                throw new Error('Header should not exist: ' + headerName);
+            }
+        };
+    }
+}
+exports.HeaderChecker = HeaderChecker;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"url-checker.js","sourceRoot":"","sources":["../../../../src/aws/infra/canaries/url-checker.ts"],"names":[],"mappings":"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","sourcesContent":["import {constants} from \"http2\";\nimport {IncomingMessage, RequestOptions} from \"http\";\nimport {Asserter} from \"../../../test/asserter\";\n\n// eslint-disable-next-line @typescript-eslint/no-var-requires\nconst synthetics = require('Synthetics');\nimport zlib = require('zlib');\nimport {MediaType} from \"../../types/mediatypes\";\nimport {getApiKeyFromAPIGateway} from \"../../runtime/apikey\";\nimport {FeatureCollection} from \"geojson\";\nimport {isValidGeoJson} from \"../../../utils/geometry\";\n\nexport const API_KEY_HEADER = \"x-api-key\";\n\nconst baseHeaders = {\n    \"Digitraffic-User\" : \"internal-digitraffic-canary\",\n    \"Accept-Encoding\" : \"gzip\",\n    \"Accept\": \"*/*\",\n} as Record<string, string>;\n\ntype CheckerFunction = (Res: IncomingMessage) => void;\ntype JsonCheckerFunction<T> = (json: T, body: string, message: IncomingMessage) => void;\n\nexport class UrlChecker {\n    private readonly requestOptions: RequestOptions;\n\n    constructor(hostname: string, apiKey?: string) {\n        const headers = {...baseHeaders};\n\n        if (apiKey) {\n            headers[API_KEY_HEADER] = apiKey;\n        }\n\n        this.requestOptions = {\n            hostname,\n            method: 'GET',\n            protocol: 'https:',\n            headers,\n        };\n\n        synthetics.getConfiguration()\n            .disableRequestMetrics();\n\n        synthetics.getConfiguration()\n            .withIncludeRequestBody(false)\n            .withIncludeRequestHeaders(false)\n            .withIncludeResponseBody(false)\n            .withIncludeResponseHeaders(false)\n            .withFailedCanaryMetric(true);\n    }\n\n    static create(hostname: string, apiKeyId: string): Promise<UrlChecker> {\n        return getApiKeyFromAPIGateway(apiKeyId).then(apiKey => {\n            return new UrlChecker(hostname, apiKey.value);\n        });\n    }\n\n    static createV2(): Promise<UrlChecker> {\n        return this.create(process.env.hostname as string, process.env.apiKeyId as string);\n    }\n\n    expectStatus<T>(statusCode: number, url: string, callback: JsonCheckerFunction<T>): Promise<void> {\n        const requestOptions = {...this.requestOptions, ...{\n            path: url,\n        }};\n\n        return synthetics.executeHttpStep(`Verify ${statusCode} for ${url.replace(/auth=.*/, '')}`,\n            requestOptions,\n            callback);\n    }\n\n    expect200<T>(url: string, ...callbacks: JsonCheckerFunction<T>[]): Promise<void> {\n        const callback = async (json: T, body: string, res: IncomingMessage) => {\n            await Promise.allSettled(callbacks.map(c => c(json, body, res)));\n        };\n\n        return this.expectStatus(200, url, callback);\n    }\n\n    expect404(url: string): Promise<void> {\n        const requestOptions = {...this.requestOptions, ...{\n            path: url,\n        }};\n\n        return synthetics.executeHttpStep(`Verify 404 for ${url}`, requestOptions, validateStatusCodeAndContentType(404, MediaType.TEXT_PLAIN));\n    }\n\n    expect400(url: string): Promise<void> {\n        const requestOptions = {...this.requestOptions, ...{\n            path: url,\n        }};\n\n        return synthetics.executeHttpStep(`Verify 400 for ${url}`, requestOptions, validateStatusCodeAndContentType(400, MediaType.TEXT_PLAIN));\n    }\n\n    expect403WithoutApiKey(url: string, mediaType?: MediaType): Promise<void> {\n        if (!this.requestOptions.headers || !this.requestOptions.headers[API_KEY_HEADER]) {\n            console.error(\"No api key defined\");\n        }\n\n        const requestOptions = {...this.requestOptions, ...{\n            path: url,\n            headers: baseHeaders,\n        }};\n\n        return synthetics.executeHttpStep(`Verify 403 for ${url}`,\n            requestOptions,\n            validateStatusCodeAndContentType(403, mediaType || MediaType.APPLICATION_JSON));\n    }\n\n    done(): string {\n        return \"Canary successful\";\n    }\n}\n\nasync function getResponseBody(response: IncomingMessage): Promise<string> {\n    const body = await getBodyFromResponse(response);\n\n    if (response.headers[constants.HTTP2_HEADER_CONTENT_ENCODING] === 'gzip') {\n        try {\n            return zlib.gunzipSync(body).toString();\n        } catch (e) {\n            console.info(\"error \" + JSON.stringify(e));\n        }\n    }\n\n    return body.toString();\n}\n\nfunction getBodyFromResponse(response: IncomingMessage): Promise<string> {\n    return new Promise((resolve: ((value: string) => void)) => {\n        const buffers: Buffer[] = [];\n\n        response.on('data', (data: Buffer) => {\n            buffers.push(data);\n        });\n\n        response.on('end', () => {\n            resolve(Buffer.concat(buffers).toString());\n        });\n    });\n}\n\n/**\n * Returns function, that validates that the status code and content-type from response are the given values\n * @param statusCode\n * @param contentType\n */\nfunction validateStatusCodeAndContentType(statusCode: number, contentType: MediaType): (Res: IncomingMessage) => Promise<void> {\n    return (res: IncomingMessage) => {\n        return new Promise(resolve => {\n            if (res.statusCode !== statusCode) {\n                throw new Error(`${res.statusCode} ${res.statusMessage}`);\n            }\n\n            if (res.headers[constants.HTTP2_HEADER_CONTENT_TYPE] !== contentType) {\n                throw new Error('Wrong content-type ' + res.headers[constants.HTTP2_HEADER_CONTENT_TYPE]);\n            }\n\n            resolve();\n        });\n    };\n}\n\n// DEPRECATED\nexport class ResponseChecker {\n    private readonly contentType;\n    private checkCors = true;\n\n    constructor(contentType: string) {\n        this.contentType = contentType;\n    }\n\n    static forJson(): ResponseChecker {\n        return new ResponseChecker(MediaType.APPLICATION_JSON);\n    }\n\n    static forCSV(): ResponseChecker {\n        return new ResponseChecker(MediaType.TEXT_CSV);\n    }\n\n    static forGeojson(): ResponseChecker {\n        return new ResponseChecker(MediaType.APPLICATION_GEOJSON);\n    }\n\n    static forJpeg(): ResponseChecker {\n        return new ResponseChecker(MediaType.IMAGE_JPEG);\n    }\n\n    check(): CheckerFunction {\n        return this.responseChecker(() => {\n            // no need to do anything\n        });\n    }\n\n    checkJson<T>(fn: (json: T, body: string, res: IncomingMessage) => void): CheckerFunction {\n        return this.responseChecker((body: string, res: IncomingMessage) => {\n            fn(JSON.parse(body), body, res);\n        });\n    }\n\n    responseChecker(fn: (body: string, res: IncomingMessage) => void): CheckerFunction {\n        return async (res: IncomingMessage): Promise<void> => {\n            if (!res.statusCode) {\n                throw new Error('statusCode missing');\n            }\n\n            if (res.statusCode < 200 || res.statusCode > 299) {\n                throw new Error(`${res.statusCode} ${res.statusMessage}`);\n            }\n\n            if (this.checkCors && !res.headers[constants.HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]) {\n                throw new Error('CORS missing');\n            }\n\n            if (res.headers[constants.HTTP2_HEADER_CONTENT_TYPE] !== this.contentType) {\n                throw new Error('Wrong content-type ' + res.headers[constants.HTTP2_HEADER_CONTENT_TYPE]);\n            }\n\n            const body = await getResponseBody(res);\n\n            fn(body, res);\n        };\n    }\n}\n\nexport class ContentChecker {\n    static checkJson<T>(fn: (json: T, body: string, res: IncomingMessage) => void): CheckerFunction {\n        return async (res: IncomingMessage): Promise<void> => {\n            const body = await getResponseBody(res);\n\n            fn(JSON.parse(body), body, res);\n        };\n    }\n\n    static checkResponse(fn: (body: string, res: IncomingMessage) => void): CheckerFunction {\n        return async (res: IncomingMessage): Promise<void> => {\n            const body = await getResponseBody(res);\n\n            fn(body, res);\n        };\n    }\n}\n\nexport class ContentTypeChecker {\n    static checkContentType(contentType: MediaType) {\n        return (res: IncomingMessage) => {\n            if (!res.statusCode) {\n                throw new Error('statusCode missing');\n            }\n\n            if (res.statusCode < 200 || res.statusCode > 299) {\n                throw new Error(`${res.statusCode} ${res.statusMessage}`);\n            }\n\n            if (!res.headers[constants.HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]) {\n                throw new Error('CORS missing');\n            }\n\n            if (res.headers[constants.HTTP2_HEADER_CONTENT_TYPE] !== contentType) {\n                throw new Error('Wrong content-type ' + res.headers[constants.HTTP2_HEADER_CONTENT_TYPE]);\n            }\n        };\n    }\n}\n\nexport class GeoJsonChecker {\n    static validFeatureCollection(fn?: (json: FeatureCollection) => void): CheckerFunction {\n        return ResponseChecker.forGeojson().checkJson((json: FeatureCollection) => {\n            Asserter.assertEquals(json.type, 'FeatureCollection');\n            Asserter.assertTrue(isValidGeoJson(json));\n\n            if (fn) {\n                fn(json);\n            }\n        });\n    }\n}\n\nexport class HeaderChecker {\n    static checkHeaderExists(headerName: string): CheckerFunction {\n        return (res: IncomingMessage) => {\n            if (!res.headers[headerName]) {\n                throw new Error('Missing header: ' + headerName);\n            }\n        };\n    }\n\n    static checkHeaderMissing(headerName: string): CheckerFunction {\n        return (res: IncomingMessage) => {\n            if (res.headers[headerName]) {\n                throw new Error('Header should not exist: ' + headerName);\n            }\n        };\n    }\n}\n"]}

package/aws/infra/documentation.d.ts

@@ -0,0 +1,56 @@
+import { Construct } from "constructs";
+import { Resource } from "aws-cdk-lib/aws-apigateway";
+/**
+ * Add description to a query parameter
+ * @param name query parameter name
+ * @param description query parameter description
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ */
+export declare function addQueryParameterDescription(name: string, description: string, resource: Resource, stack: Construct): void;
+/**
+ * Add a documentation part to a method
+ * @param methodDescription
+ * @param documentationProperties
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addDocumentation(methodDescription: string, documentationProperties: object, resource: Resource, stack: Construct): void;
+/**
+ * Adds OpenAPI tags to an API method
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addTags(methodDescription: string, tags: string[], resource: Resource, stack: Construct): void;
+/**
+ * Adds OpenAPI tags and a method summary to an API method
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ *
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param summary OpenAPI summary
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addTagsAndSummary(methodDescription: string, tags: string[], summary: string, resource: Resource, stack: Construct): void;
+export interface DocumentationProperties {
+    description?: string;
+    tags?: string[];
+    summary?: string;
+    deprecated?: boolean;
+}
+export declare class DocumentationPart {
+    readonly parameterName: string;
+    readonly type: string;
+    readonly documentationProperties: DocumentationProperties;
+    private constructor();
+    deprecated(note: string): DocumentationPart;
+    static queryParameter(parameterName: string, description: string): DocumentationPart;
+    static pathParameter(parameterName: string, description: string): DocumentationPart;
+    static method(tags: string[], name: string, summary: string): DocumentationPart;
+}

package/aws/infra/documentation.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentationPart = exports.addTagsAndSummary = exports.addTags = exports.addDocumentation = exports.addQueryParameterDescription = void 0;
+const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
+// Documentation parts are objects that describe an API Gateway API or parts of an API
+// https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-documenting-api.html
+/**
+ * Add description to a query parameter
+ * @param name query parameter name
+ * @param description query parameter description
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ */
+function addQueryParameterDescription(name, description, resource, stack) {
+    new aws_apigateway_1.CfnDocumentationPart(stack, `${name}Documentation`, {
+        restApiId: resource.api.restApiId,
+        location: {
+            type: 'QUERY_PARAMETER',
+            name,
+            path: resource.path,
+        },
+        properties: JSON.stringify({ description }),
+    });
+}
+exports.addQueryParameterDescription = addQueryParameterDescription;
+/**
+ * Add a documentation part to a method
+ * @param methodDescription
+ * @param documentationProperties
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+function addDocumentation(methodDescription, documentationProperties, resource, stack) {
+    new aws_apigateway_1.CfnDocumentationPart(stack, `${methodDescription}Documentation`, {
+        restApiId: resource.api.restApiId,
+        location: {
+            type: 'METHOD',
+            path: resource.path,
+        },
+        properties: JSON.stringify(documentationProperties),
+    });
+}
+exports.addDocumentation = addDocumentation;
+/**
+ * Adds OpenAPI tags to an API method
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+function addTags(methodDescription, tags, resource, stack) {
+    addDocumentation(methodDescription, { tags }, resource, stack);
+}
+exports.addTags = addTags;
+/**
+ * Adds OpenAPI tags and a method summary to an API method
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ *
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param summary OpenAPI summary
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+function addTagsAndSummary(methodDescription, tags, summary, resource, stack) {
+    addDocumentation(methodDescription, { tags, summary }, resource, stack);
+}
+exports.addTagsAndSummary = addTagsAndSummary;
+class DocumentationPart {
+    constructor(parameterName, documentationProperties, type) {
+        this.parameterName = parameterName;
+        this.documentationProperties = documentationProperties;
+        this.type = type;
+    }
+    deprecated(note) {
+        // deprecated is not supported ATM: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html
+        this.documentationProperties.deprecated = true;
+        this.documentationProperties.summary += '. ' + note;
+        return this;
+    }
+    static queryParameter(parameterName, description) {
+        return new DocumentationPart(parameterName, { description }, "QUERY_PARAMETER");
+    }
+    static pathParameter(parameterName, description) {
+        return new DocumentationPart(parameterName, { description }, "PATH_PARAMETER");
+    }
+    static method(tags, name, summary) {
+        return new DocumentationPart(name, { tags, summary }, "METHOD");
+    }
+}
+exports.DocumentationPart = DocumentationPart;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documentation.js","sourceRoot":"","sources":["../../../src/aws/infra/documentation.ts"],"names":[],"mappings":";;;AACA,+DAA0E;AAE1E,sFAAsF;AACtF,gGAAgG;AAEhG;;;;;;;;GAQG;AACH,SAAgB,4BAA4B,CAAC,IAAY,EACrD,WAAmB,EACnB,QAAkB,EAClB,KAAgB;IAChB,IAAI,qCAAoB,CAAC,KAAK,EAAE,GAAG,IAAI,eAAe,EAAE;QACpD,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,SAAS;QACjC,QAAQ,EAAE;YACN,IAAI,EAAE,iBAAiB;YACvB,IAAI;YACJ,IAAI,EAAE,QAAQ,CAAC,IAAI;SACtB;QACD,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,EAAC,WAAW,EAAC,CAAC;KAC5C,CAAC,CAAC;AACP,CAAC;AAbD,oEAaC;AAED;;;;;;GAMG;AACH,SAAgB,gBAAgB,CAAC,iBAAyB,EACtD,uBAA+B,EAC/B,QAAkB,EAClB,KAAgB;IAChB,IAAI,qCAAoB,CAAC,KAAK,EAAE,GAAG,iBAAiB,eAAe,EAAE;QACjE,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,SAAS;QACjC,QAAQ,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,QAAQ,CAAC,IAAI;SACtB;QACD,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;KACtD,CAAC,CAAC;AACP,CAAC;AAZD,4CAYC;AAED;;;;;;GAMG;AACH,SAAgB,OAAO,CAAC,iBAAyB,EAC7C,IAAc,EACd,QAAkB,EAClB,KAAgB;IAChB,gBAAgB,CAAC,iBAAiB,EAAE,EAAC,IAAI,EAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AACjE,CAAC;AALD,0BAKC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,iBAAiB,CAC7B,iBAAyB,EACzB,IAAc,EACd,OAAe,EACf,QAAkB,EAClB,KAAgB;IAEhB,gBAAgB,CAAC,iBAAiB,EAAE,EAAC,IAAI,EAAE,OAAO,EAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AAC1E,CAAC;AARD,8CAQC;AASD,MAAa,iBAAiB;IAK1B,YAAoB,aAAqB,EAAE,uBAAgD,EAAE,IAAY;QACrG,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,uBAAuB,GAAG,uBAAuB,CAAC;QACvD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACrB,CAAC;IAED,UAAU,CAAC,IAAY;QACnB,8HAA8H;QAC9H,IAAI,CAAC,uBAAuB,CAAC,UAAU,GAAG,IAAI,CAAC;QAC/C,IAAI,CAAC,uBAAuB,CAAC,OAAO,IAAG,IAAI,GAAG,IAAI,CAAC;QAEnD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,aAAqB,EAAE,WAAmB;QAC5D,OAAO,IAAI,iBAAiB,CAAC,aAAa,EAAE,EAAC,WAAW,EAAC,EAAE,iBAAiB,CAAC,CAAC;IAClF,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,aAAqB,EAAE,WAAmB;QAC3D,OAAO,IAAI,iBAAiB,CAAC,aAAa,EAAE,EAAC,WAAW,EAAC,EAAE,gBAAgB,CAAC,CAAC;IACjF,CAAC;IAED,MAAM,CAAC,MAAM,CAAC,IAAc,EAAE,IAAY,EAAE,OAAe;QACvD,OAAO,IAAI,iBAAiB,CAAC,IAAI,EAAE,EAAC,IAAI,EAAE,OAAO,EAAC,EAAE,QAAQ,CAAC,CAAC;IAClE,CAAC;CACJ;AA9BD,8CA8BC","sourcesContent":["import {Construct} from \"constructs\";\nimport {CfnDocumentationPart, Resource} from \"aws-cdk-lib/aws-apigateway\";\n\n// Documentation parts are objects that describe an API Gateway API or parts of an API\n// https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-documenting-api.html\n\n/**\n * Add description to a query parameter\n * @param name query parameter name\n * @param description query parameter description\n * @param resource REST API resource\n * @param stack CloudFormation stack\n *\n * @deprecated Use DigitrafficRestApi.documentResource\n */\nexport function addQueryParameterDescription(name: string,\n    description: string,\n    resource: Resource,\n    stack: Construct) {\n    new CfnDocumentationPart(stack, `${name}Documentation`, {\n        restApiId: resource.api.restApiId,\n        location: {\n            type: 'QUERY_PARAMETER',\n            name,\n            path: resource.path,\n        },\n        properties: JSON.stringify({description}),\n    });\n}\n\n/**\n * Add a documentation part to a method\n * @param methodDescription\n * @param documentationProperties\n * @param resource REST API resource\n * @param stack CloudFormation stack\n */\nexport function addDocumentation(methodDescription: string,\n    documentationProperties: object,\n    resource: Resource,\n    stack: Construct) {\n    new CfnDocumentationPart(stack, `${methodDescription}Documentation`, {\n        restApiId: resource.api.restApiId,\n        location: {\n            type: 'METHOD',\n            path: resource.path,\n        },\n        properties: JSON.stringify(documentationProperties),\n    });\n}\n\n/**\n * Adds OpenAPI tags to an API method\n * @param methodDescription Description of API method\n * @param tags OpenAPI tags\n * @param resource REST API resource\n * @param stack CloudFormation stack\n */\nexport function addTags(methodDescription: string,\n    tags: string[],\n    resource: Resource,\n    stack: Construct) {\n    addDocumentation(methodDescription, {tags}, resource, stack);\n}\n\n/**\n * Adds OpenAPI tags and a method summary to an API method\n *\n * @deprecated Use DigitrafficRestApi.documentResource\n *\n * @param methodDescription Description of API method\n * @param tags OpenAPI tags\n * @param summary OpenAPI summary\n * @param resource REST API resource\n * @param stack CloudFormation stack\n */\nexport function addTagsAndSummary(\n    methodDescription: string,\n    tags: string[],\n    summary: string,\n    resource: Resource,\n    stack: Construct,\n) {\n    addDocumentation(methodDescription, {tags, summary}, resource, stack);\n}\n\nexport interface DocumentationProperties {\n    description?: string\n    tags?: string[]\n    summary?: string\n    deprecated?: boolean\n}\n\nexport class DocumentationPart {\n    readonly parameterName: string;\n    readonly type: string;\n    readonly documentationProperties: DocumentationProperties;\n\n    private constructor(parameterName: string, documentationProperties: DocumentationProperties, type: string) {\n        this.parameterName = parameterName;\n        this.documentationProperties = documentationProperties;\n        this.type = type;\n    }\n\n    deprecated(note: string): DocumentationPart {\n        // deprecated is not supported ATM: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html\n        this.documentationProperties.deprecated = true;\n        this.documentationProperties.summary+= '. ' + note;\n\n        return this;\n    }\n\n    static queryParameter(parameterName: string, description: string) {\n        return new DocumentationPart(parameterName, {description}, \"QUERY_PARAMETER\");\n    }\n\n    static pathParameter(parameterName: string, description: string) {\n        return new DocumentationPart(parameterName, {description}, \"PATH_PARAMETER\");\n    }\n\n    static method(tags: string[], name: string, summary: string) {\n        return new DocumentationPart(name, {tags, summary}, \"METHOD\");\n    }\n}\n"]}

package/aws/infra/scheduler.d.ts

@@ -0,0 +1,12 @@
+import { Rule, Schedule } from "aws-cdk-lib/aws-events";
+import { Duration } from "aws-cdk-lib";
+import { Function } from 'aws-cdk-lib/aws-lambda';
+import { Construct } from "constructs";
+export declare class Scheduler extends Rule {
+    constructor(stack: Construct, ruleName: string, schedule: Schedule, lambda?: Function);
+    static everyMinute(stack: Construct, ruleName: string, lambda?: Function): Scheduler;
+    static everyMinutes(stack: Construct, ruleName: string, minutes: number, lambda?: Function): Scheduler;
+    static everyHour(stack: Construct, ruleName: string, lambda?: Function): Scheduler;
+    static everyDay(stack: Construct, ruleName: string, lambda?: Function): Scheduler;
+    static every(stack: Construct, ruleName: string, duration: Duration, lambda?: Function): Scheduler;
+}

package/aws/infra/scheduler.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+const aws_events_1 = require("aws-cdk-lib/aws-events");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_events_targets_1 = require("aws-cdk-lib/aws-events-targets");
+class Scheduler extends aws_events_1.Rule {
+    constructor(stack, ruleName, schedule, lambda) {
+        super(stack, ruleName, { ruleName, schedule });
+        if (lambda) {
+            this.addTarget(new aws_events_targets_1.LambdaFunction(lambda));
+        }
+    }
+    static everyMinute(stack, ruleName, lambda) {
+        return Scheduler.every(stack, ruleName, aws_cdk_lib_1.Duration.minutes(1), lambda);
+    }
+    static everyMinutes(stack, ruleName, minutes, lambda) {
+        return Scheduler.every(stack, ruleName, aws_cdk_lib_1.Duration.minutes(minutes), lambda);
+    }
+    static everyHour(stack, ruleName, lambda) {
+        return Scheduler.every(stack, ruleName, aws_cdk_lib_1.Duration.hours(1), lambda);
+    }
+    static everyDay(stack, ruleName, lambda) {
+        return Scheduler.every(stack, ruleName, aws_cdk_lib_1.Duration.days(1), lambda);
+    }
+    static every(stack, ruleName, duration, lambda) {
+        return new Scheduler(stack, ruleName, aws_events_1.Schedule.rate(duration), lambda);
+    }
+}
+exports.Scheduler = Scheduler;
+//# sourceMappingURL=data:application/json;base64,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

package/aws/infra/security-rule.d.ts

@@ -0,0 +1,12 @@
+import { Construct } from "constructs";
+import { Rule } from "aws-cdk-lib/aws-events";
+import { ITopic } from "aws-cdk-lib/aws-sns";
+/**
+ * Automatic rule for Security Hub.  Send notification to given topic if the following conditions apply:
+ * * There is a finding with a status of NEW
+ * * It has severity of HIGH or CRITICAL
+ * * It is in a FAILED state
+ */
+export declare class DigitrafficSecurityRule extends Rule {
+    constructor(scope: Construct, topic: ITopic);
+}

package/aws/infra/security-rule.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitrafficSecurityRule = void 0;
+const aws_events_1 = require("aws-cdk-lib/aws-events");
+const aws_events_targets_1 = require("aws-cdk-lib/aws-events-targets");
+/**
+ * Automatic rule for Security Hub.  Send notification to given topic if the following conditions apply:
+ * * There is a finding with a status of NEW
+ * * It has severity of HIGH or CRITICAL
+ * * It is in a FAILED state
+ */
+class DigitrafficSecurityRule extends aws_events_1.Rule {
+    constructor(scope, topic) {
+        const ruleName = 'SecurityHubRule';
+        super(scope, ruleName, {
+            ruleName,
+            eventPattern: {
+                source: ['aws.securityhub'],
+                detailType: ["Security Hub Findings - Imported"],
+                detail: {
+                    findings: {
+                        "Compliance": {
+                            "Status": ["FAILED"],
+                        },
+                        "Workflow": {
+                            "Status": ["NEW"],
+                        },
+                        "Severity": {
+                            "Label": ["HIGH", "CRITICAL"],
+                        },
+                    },
+                },
+            },
+        });
+        this.addTarget(new aws_events_targets_1.SnsTopic(topic));
+    }
+}
+exports.DigitrafficSecurityRule = DigitrafficSecurityRule;
+//# sourceMappingURL=data:application/json;base64,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

package/aws/infra/sqs-integration.d.ts

@@ -0,0 +1,7 @@
+import { RequestValidator, Resource } from "aws-cdk-lib/aws-apigateway";
+import { Queue } from "aws-cdk-lib/aws-sqs";
+import { IModel } from "aws-cdk-lib/aws-apigateway/lib/model";
+import { Construct } from "constructs";
+export declare function attachQueueToApiGatewayResource(stack: Construct, queue: Queue, resource: Resource, requestValidator: RequestValidator, resourceName: string, apiKeyRequired: boolean, requestModels?: {
+    [param: string]: IModel;
+}): void;