@aligent/cdk-header-change-detection 1.0.0

package/index.d.ts

@@ -0,0 +1,2 @@
+import { HeaderChangeDetection, HeaderChangeDetectionProps } from "./lib/header-change-detection";
+export { HeaderChangeDetection, HeaderChangeDetectionProps };

package/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderChangeDetection = void 0;
+const header_change_detection_1 = require("./lib/header-change-detection");
+Object.defineProperty(exports, "HeaderChangeDetection", { enumerable: true, get: function () { return header_change_detection_1.HeaderChangeDetection; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9wYWNrYWdlcy9oZWFkZXItY2hhbmdlLWRldGVjdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyRUFHdUM7QUFFOUIsc0dBSlAsK0NBQXFCLE9BSU8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBIZWFkZXJDaGFuZ2VEZXRlY3Rpb24sXG4gIEhlYWRlckNoYW5nZURldGVjdGlvblByb3BzLFxufSBmcm9tIFwiLi9saWIvaGVhZGVyLWNoYW5nZS1kZXRlY3Rpb25cIjtcblxuZXhwb3J0IHsgSGVhZGVyQ2hhbmdlRGV0ZWN0aW9uLCBIZWFkZXJDaGFuZ2VEZXRlY3Rpb25Qcm9wcyB9O1xuIl19

package/lib/header-change-detection.d.ts

@@ -0,0 +1,38 @@
+import { RuleProps, Schedule } from "aws-cdk-lib/aws-events";
+import { SnsTopic } from "aws-cdk-lib/aws-events-targets";
+import { Construct } from "constructs";
+export interface HeaderChangeDetectionProps {
+    /**
+     * List of URLs to monitor for header changes
+     */
+    urls: string[];
+    /**
+     * Optional list of additional headers to monitor
+     *
+     * @default []
+     */
+    additionalHeaders?: string[];
+    /**
+     * Optionally disable all the default headers
+     *
+     * @default false
+     */
+    disableDefaults?: boolean;
+    /**
+     * SNS Topic to send change detection notifications to
+     */
+    snsTopic: SnsTopic;
+    /**
+     * The schedule for performing the header check
+     *
+     * @default Schedule.rate(Duration.hours(1))
+     */
+    schedule?: Schedule;
+    /**
+     * Optionally pass any rule properties
+     */
+    ruleProps?: Partial<RuleProps>;
+}
+export declare class HeaderChangeDetection extends Construct {
+    constructor(scope: Construct, id: string, props: HeaderChangeDetectionProps);
+}

package/lib/header-change-detection.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderChangeDetection = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_dynamodb_1 = require("aws-cdk-lib/aws-dynamodb");
+const aws_events_1 = require("aws-cdk-lib/aws-events");
+const aws_events_targets_1 = require("aws-cdk-lib/aws-events-targets");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const constructs_1 = require("constructs");
+const path_1 = require("path");
+const cdk_esbuild_1 = require("@aligent/cdk-esbuild");
+const command = [
+    "sh",
+    "-c",
+    'echo "Docker build not supported. Please install esbuild."',
+];
+const defaultHeaders = [
+    "content-security-policy",
+    "content-security-policy-report-only",
+    "reporting-endpoints",
+    "strict-transport-security",
+    "x-frame-options",
+    "x-content-type-options",
+    "cross-origin-opener-policy",
+    "cross-origin-embedder-policy",
+    "cross-origin-resource-policy",
+    "referrer-policy",
+    "permission-policy",
+    "cache-control",
+    "set-cookie",
+];
+class HeaderChangeDetection extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        var _a;
+        super(scope, id);
+        const headers = props.disableDefaults ? [] : defaultHeaders;
+        headers.push(...(((_a = props.additionalHeaders) === null || _a === void 0 ? void 0 : _a.map(header => header.toLowerCase())) || []));
+        const table = new aws_dynamodb_1.Table(this, "Table", {
+            partitionKey: {
+                name: "Url",
+                type: aws_dynamodb_1.AttributeType.STRING,
+            },
+            billingMode: aws_dynamodb_1.BillingMode.PAY_PER_REQUEST,
+        });
+        const schedule = new aws_events_1.Rule(this, "EventRule", {
+            schedule: props.schedule || aws_events_1.Schedule.rate(aws_cdk_lib_1.Duration.hours(1)),
+            ...props.ruleProps,
+        });
+        const lambda = new aws_lambda_1.Function(this, "HeaderCheck", {
+            architecture: aws_lambda_1.Architecture.X86_64,
+            runtime: aws_lambda_1.Runtime.NODEJS_20_X,
+            handler: "header-check.handler",
+            code: aws_lambda_1.Code.fromAsset((0, path_1.join)(__dirname, "lambda"), {
+                bundling: {
+                    command,
+                    image: aws_cdk_lib_1.DockerImage.fromRegistry("busybox"),
+                    local: new cdk_esbuild_1.Esbuild({
+                        entryPoints: [(0, path_1.join)(__dirname, "lambda/header-check.ts")],
+                    }),
+                },
+            }),
+            environment: {
+                URLS: props.urls.join(","),
+                HEADERS: headers.join(","),
+                TABLE: table.tableName,
+                TOPIC_ARN: props.snsTopic.topic.topicArn,
+            },
+        });
+        schedule.addTarget(new aws_events_targets_1.LambdaFunction(lambda));
+        table.grantWriteData(lambda);
+        table.grantReadData(lambda);
+        props.snsTopic.topic.grantPublish(lambda);
+    }
+}
+exports.HeaderChangeDetection = HeaderChangeDetection;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambda/header-check.d.ts

@@ -0,0 +1 @@
+export declare const handler: () => Promise<void>;

package/lib/lambda/header-check.js

@@ -0,0 +1,267 @@
+"use strict";
+// We know the environment variables will exist so safe to ignore this
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const axios_1 = __importDefault(require("axios"));
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const client_sns_1 = require("@aws-sdk/client-sns");
+const URLS = process.env.URLS;
+const HEADERS = process.env.HEADERS;
+const TABLE = process.env.TABLE;
+const config = "";
+const DB_CLIENT = new client_dynamodb_1.DynamoDBClient(config);
+const securityHeaders = (HEADERS === null || HEADERS === void 0 ? void 0 : HEADERS.split(",")) || [];
+const handler = async () => {
+    const urls = (URLS === null || URLS === void 0 ? void 0 : URLS.split(",")) || [];
+    // Fetch stored headers
+    const [storedUrlHeaders, currentUrlHeaders] = await Promise.all([
+        getStoredValues(urls),
+        fetchHeaders(urls),
+    ]);
+    // Find any differences between the headers
+    const headerDifferences = new Map();
+    let differencesDetected = false;
+    const dbUpdates = urls.map(url => {
+        var _a;
+        const currentHeaders = currentUrlHeaders.get(url);
+        const storedHeaders = storedUrlHeaders.get(url) || new Map();
+        if (!currentHeaders)
+            throw new Error(`Could not get current headers for ${url}`);
+        // Check all headers that we care about
+        headerDifferences.set(url, compareHeaders(securityHeaders, storedHeaders, currentHeaders));
+        const headersToUpdate = new Map();
+        (_a = headerDifferences.get(url)) === null || _a === void 0 ? void 0 : _a.forEach(difference => {
+            headersToUpdate.set(difference.header, difference.currentValue);
+            differencesDetected = true;
+        });
+        return updateStoredValues(url, headersToUpdate);
+    });
+    await Promise.all(dbUpdates);
+    if (differencesDetected)
+        await sendToSns(formatDifferences(headerDifferences));
+};
+exports.handler = handler;
+/**
+ * Fetch security headers for the given urls
+ *
+ * @param urls list of urls to fetch headers from
+ */
+const fetchHeaders = async (urls) => {
+    const currentUrlHeaders = new Map();
+    // Make an axios request for each url
+    await Promise.all(urls.map(url => axios_1.default.get(url).then(response => {
+        // Then get all the security headers from each response
+        const headers = new Map();
+        Object.entries(response.headers).forEach(([headerName, value]) => {
+            if (securityHeaders === null || securityHeaders === void 0 ? void 0 : securityHeaders.includes(headerName))
+                headers.set(headerName, value);
+        });
+        currentUrlHeaders.set(url, headers);
+    })));
+    return currentUrlHeaders;
+};
+/**
+ * Get values stored in DynamoDB table from a list of string keys.
+ * Assumes the call is made to the header change detection table.
+ * This table has a primary key of Url (string) with an unknown
+ * number of string fields.
+ *
+ * @param keys array of strings
+ */
+const getStoredValues = async (keys) => {
+    if (keys.length === 0) {
+        console.log("No keys were passed");
+        return new Map();
+    }
+    // Construct the command input
+    const primaryKeys = keys.map(url => {
+        return {
+            Url: {
+                S: url,
+            },
+        };
+    });
+    const requestItems = {
+        [TABLE]: {
+            Keys: primaryKeys,
+        },
+    };
+    return dynamoBatchRequest(requestItems);
+};
+/**
+ * Update stored headers for the given url.
+ * If the header no longer has a value, delete it. Otherwise update it.
+ *
+ * @param url the url to update - this is the primary key
+ * @param headers record of headers to update
+ */
+const updateStoredValues = async (url, headers) => {
+    // Convert headers to attribute value update attributes
+    const attributes = {};
+    headers.forEach((value, headerName) => {
+        // If the value exists update it, otherwise remove it
+        if (value) {
+            attributes[headerName] = {
+                Value: {
+                    S: value,
+                },
+                Action: "PUT",
+            };
+        }
+        else {
+            attributes[headerName] = {
+                Action: "DELETE",
+            };
+        }
+    });
+    if (Object.values(attributes).length === 0) {
+        console.log(`No attribute value changes for ${url}`);
+        return;
+    }
+    return dynamoUpdateRequest(url, attributes);
+};
+/**
+ * Recursive function to get multiple items from a DynamoDB table
+ *
+ * @param requestItems
+ * @returns Promise<URLHeaders>
+ */
+const dynamoBatchRequest = async (requestItems) => {
+    var _a, _b;
+    console.log(`Starting batch request with items: ${JSON.stringify(requestItems)}`);
+    // Validate that request items has values
+    if (((_a = Object.keys(requestItems || {})) === null || _a === void 0 ? void 0 : _a.length) === 0)
+        return new Map();
+    const batchGetInput = {
+        RequestItems: requestItems,
+    };
+    const batchGetCommand = new client_dynamodb_1.BatchGetItemCommand(batchGetInput);
+    // Fetch stored stored headers
+    const response = await DB_CLIENT.send(batchGetCommand);
+    const responses = (_b = response.Responses) === null || _b === void 0 ? void 0 : _b[TABLE];
+    if (!responses)
+        return new Map();
+    console.log(`Got following data from dynamo table: ${JSON.stringify(responses)}`);
+    const storedUrlHeaders = new Map();
+    Object.values(responses).forEach(headers => {
+        const urlHeaders = new Map();
+        let url = "";
+        Object.entries(headers).forEach(([headerName, value]) => {
+            if (headerName === "Url") {
+                url = value.S;
+            }
+            else {
+                urlHeaders.set(headerName, value.S);
+            }
+        });
+        storedUrlHeaders.set(url, urlHeaders);
+    });
+    // Process any remaining keys
+    const nextUrlHeaders = await dynamoBatchRequest(response.UnprocessedKeys);
+    // Merge data into one object and return
+    return new Map([...storedUrlHeaders, ...nextUrlHeaders]);
+};
+/**
+ * Send an update command to DynamoDB
+ *
+ * @param url the url to update - this is the primary key
+ * @param attributes Record<string, AttributeValueUpdate>
+ */
+const dynamoUpdateRequest = async (url, attributes) => {
+    console.log(`Updating ${url} in table with: ${JSON.stringify(Object.entries(attributes))}`);
+    const updateItemInput = {
+        TableName: TABLE,
+        Key: {
+            Url: {
+                S: url,
+            },
+        },
+        AttributeUpdates: attributes,
+    };
+    const updateItemCommand = new client_dynamodb_1.UpdateItemCommand(updateItemInput);
+    return DB_CLIENT.send(updateItemCommand);
+};
+/**
+ * Compare values of two lists of headers. Return any headers that have differences
+ * along with their stored and current values.
+ *
+ * @param headers list of headers we want to compare
+ * @param stored list of headers that were last found on the site
+ * @param current list of headers currently on the site
+ * @returns
+ */
+const compareHeaders = (headers, stored, current) => {
+    const differences = [];
+    headers.forEach(header => {
+        const currentValue = current.get(header);
+        const storedValue = stored.get(header);
+        if (currentValue !== storedValue) {
+            differences.push({
+                header,
+                storedValue: storedValue,
+                currentValue: currentValue,
+            });
+        }
+    });
+    return differences;
+};
+/**
+ * Format the differences so they can be easily read in an email.
+ *
+ * Outputs a string that looks like this:
+ *
+ * Headers differences found:
+ * == https://aligent.com.au/ ===
+ *
+ * Header: example-header-name
+ * Stored Value: No stored value
+ * Current Value: example-value
+ *
+ * === https://aligent.com.au/contact ===
+ *
+ * Header: example-header-name
+ * Stored Value: No stored value
+ * Current Value: example-value
+ *
+ * Header: example-header-name-2
+ * Stored Value: previous-value
+ * Current Value: new-example-value
+ *
+ * @param differences Map<string, Difference[]> where the key is the URL
+ */
+const formatDifferences = (differences) => {
+    const message = Array.from(differences.keys()).reduce((text, url) => {
+        var _a, _b;
+        console.log(text, url);
+        // Skip the url if there are no differences
+        if (((_a = differences.get(url)) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+            return text;
+        }
+        // Format headers nicely
+        const headers = (_b = differences.get(url)) === null || _b === void 0 ? void 0 : _b.reduce((headerText, header) => {
+            return (headerText += `\r\nHeader: ${header.header}\r\nStored Value: ${header.storedValue}\r\nCurrent Value: ${header.currentValue}\r\n`);
+        }, "");
+        return `${text}\r\n=== ${url} ===\r\n ${headers}`;
+    }, "");
+    return `Header differences found${message}`;
+};
+const TOPIC_ARN = process.env.TOPIC_ARN;
+const SNS_CLIENT = new client_sns_1.SNSClient();
+/**
+ * Send a message to the SNS topic
+ *
+ * @param message string to send to sns
+ */
+const sendToSns = async (message) => {
+    const publishInput = {
+        TopicArn: TOPIC_ARN,
+        Message: message,
+    };
+    const publishCommand = new client_sns_1.PublishCommand(publishInput);
+    await SNS_CLIENT.send(publishCommand);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header-check.js","sourceRoot":"","sources":["../../../../packages/header-change-detection/lib/lambda/header-check.ts"],"names":[],"mappings":"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","sourcesContent":["// We know the environment variables will exist so safe to ignore this\n/* eslint-disable @typescript-eslint/no-non-null-assertion */\n\nimport axios from \"axios\";\nimport {\n  DynamoDBClient,\n  BatchGetItemCommand,\n  BatchGetItemCommandInput,\n  KeysAndAttributes,\n  UpdateItemCommandInput,\n  UpdateItemCommand,\n  AttributeValueUpdate,\n  UpdateItemCommandOutput,\n} from \"@aws-sdk/client-dynamodb\";\nimport { PublishCommand, PublishInput, SNSClient } from \"@aws-sdk/client-sns\";\n\nconst URLS = process.env.URLS;\nconst HEADERS = process.env.HEADERS;\nconst TABLE = process.env.TABLE!;\n\nconst config = \"\";\nconst DB_CLIENT = new DynamoDBClient(config);\n\nconst securityHeaders = HEADERS?.split(\",\") || [];\n\ntype Headers = Map<string, string | undefined>;\n\n// A map of URLs and their headers\ntype URLHeaders = Map<string, Headers>;\n\nexport const handler = async () => {\n  const urls = URLS?.split(\",\") || [];\n\n  // Fetch stored headers\n  const [storedUrlHeaders, currentUrlHeaders] = await Promise.all([\n    getStoredValues(urls),\n    fetchHeaders(urls),\n  ]);\n\n  // Find any differences between the headers\n  const headerDifferences = new Map<string, Difference[]>();\n  let differencesDetected = false;\n  const dbUpdates = urls.map(url => {\n    const currentHeaders = currentUrlHeaders.get(url);\n    const storedHeaders =\n      storedUrlHeaders.get(url) || new Map<string, string | undefined>();\n\n    if (!currentHeaders)\n      throw new Error(`Could not get current headers for ${url}`);\n\n    // Check all headers that we care about\n    headerDifferences.set(\n      url,\n      compareHeaders(securityHeaders, storedHeaders, currentHeaders)\n    );\n\n    const headersToUpdate: Headers = new Map<string, string | undefined>();\n    headerDifferences.get(url)?.forEach(difference => {\n      headersToUpdate.set(difference.header, difference.currentValue);\n      differencesDetected = true;\n    });\n\n    return updateStoredValues(url, headersToUpdate);\n  });\n\n  await Promise.all(dbUpdates);\n\n  if (differencesDetected)\n    await sendToSns(formatDifferences(headerDifferences));\n};\n\n/**\n * Fetch security headers for the given urls\n *\n * @param urls list of urls to fetch headers from\n */\nconst fetchHeaders = async (urls: string[]): Promise<URLHeaders> => {\n  const currentUrlHeaders: URLHeaders = new Map<string, Headers>();\n\n  // Make an axios request for each url\n  await Promise.all(\n    urls.map(url =>\n      axios.get(url).then(response => {\n        // Then get all the security headers from each response\n        const headers: Headers = new Map<string, string | undefined>();\n\n        Object.entries(response.headers).forEach(([headerName, value]) => {\n          if (securityHeaders?.includes(headerName))\n            headers.set(headerName, value as string);\n        });\n\n        currentUrlHeaders.set(url, headers);\n      })\n    )\n  );\n\n  return currentUrlHeaders;\n};\n\n/**\n * Get values stored in DynamoDB table from a list of string keys.\n * Assumes the call is made to the header change detection table.\n * This table has a primary key of Url (string) with an unknown\n * number of string fields.\n *\n * @param keys array of strings\n */\nconst getStoredValues = async (keys: string[]): Promise<URLHeaders> => {\n  if (keys.length === 0) {\n    console.log(\"No keys were passed\");\n    return new Map<string, Headers>();\n  }\n\n  // Construct the command input\n  const primaryKeys = keys.map(url => {\n    return {\n      Url: {\n        S: url,\n      },\n    };\n  });\n  const requestItems = {\n    [TABLE]: {\n      Keys: primaryKeys,\n    },\n  };\n\n  return dynamoBatchRequest(requestItems);\n};\n\n/**\n * Update stored headers for the given url.\n * If the header no longer has a value, delete it. Otherwise update it.\n *\n * @param url the url to update - this is the primary key\n * @param headers record of headers to update\n */\nconst updateStoredValues = async (\n  url: string,\n  headers: Headers\n): Promise<UpdateItemCommandOutput | undefined> => {\n  // Convert headers to attribute value update attributes\n  const attributes: Record<string, AttributeValueUpdate> = {};\n  headers.forEach((value, headerName) => {\n    // If the value exists update it, otherwise remove it\n    if (value) {\n      attributes[headerName] = {\n        Value: {\n          S: value,\n        },\n        Action: \"PUT\",\n      };\n    } else {\n      attributes[headerName] = {\n        Action: \"DELETE\",\n      };\n    }\n  });\n\n  if (Object.values(attributes).length === 0) {\n    console.log(`No attribute value changes for ${url}`);\n    return;\n  }\n\n  return dynamoUpdateRequest(url, attributes);\n};\n\n/**\n * Recursive function to get multiple items from a DynamoDB table\n *\n * @param requestItems\n * @returns Promise<URLHeaders>\n */\nconst dynamoBatchRequest = async (\n  requestItems: Record<string, KeysAndAttributes> | undefined\n): Promise<URLHeaders> => {\n  console.log(\n    `Starting batch request with items: ${JSON.stringify(requestItems)}`\n  );\n\n  // Validate that request items has values\n  if (Object.keys(requestItems || {})?.length === 0)\n    return new Map<string, Headers>();\n\n  const batchGetInput: BatchGetItemCommandInput = {\n    RequestItems: requestItems,\n  };\n  const batchGetCommand = new BatchGetItemCommand(batchGetInput);\n\n  // Fetch stored stored headers\n  const response = await DB_CLIENT.send(batchGetCommand);\n  const responses = response.Responses?.[TABLE];\n\n  if (!responses) return new Map<string, Headers>();\n\n  console.log(\n    `Got following data from dynamo table: ${JSON.stringify(responses)}`\n  );\n\n  const storedUrlHeaders: URLHeaders = new Map<string, Headers>();\n  Object.values(responses).forEach(headers => {\n    const urlHeaders: Headers = new Map<string, string | undefined>();\n\n    let url = \"\";\n    Object.entries(headers).forEach(([headerName, value]) => {\n      if (headerName === \"Url\") {\n        url = value.S!;\n      } else {\n        urlHeaders.set(headerName, value.S!);\n      }\n    });\n    storedUrlHeaders.set(url, urlHeaders);\n  });\n\n  // Process any remaining keys\n  const nextUrlHeaders = await dynamoBatchRequest(response.UnprocessedKeys);\n\n  // Merge data into one object and return\n  return new Map<string, Headers>([...storedUrlHeaders, ...nextUrlHeaders]);\n};\n\n/**\n * Send an update command to DynamoDB\n *\n * @param url the url to update - this is the primary key\n * @param attributes Record<string, AttributeValueUpdate>\n */\nconst dynamoUpdateRequest = async (\n  url: string,\n  attributes: Record<string, AttributeValueUpdate>\n): Promise<UpdateItemCommandOutput> => {\n  console.log(\n    `Updating ${url} in table with: ${JSON.stringify(Object.entries(attributes))}`\n  );\n\n  const updateItemInput: UpdateItemCommandInput = {\n    TableName: TABLE,\n    Key: {\n      Url: {\n        S: url,\n      },\n    },\n    AttributeUpdates: attributes,\n  };\n  const updateItemCommand = new UpdateItemCommand(updateItemInput);\n\n  return DB_CLIENT.send(updateItemCommand);\n};\n\ninterface Difference {\n  header: string;\n  storedValue: string | undefined;\n  currentValue: string | undefined;\n}\n\n/**\n * Compare values of two lists of headers. Return any headers that have differences\n * along with their stored and current values.\n *\n * @param headers list of headers we want to compare\n * @param stored list of headers that were last found on the site\n * @param current list of headers currently on the site\n * @returns\n */\nconst compareHeaders = (\n  headers: string[],\n  stored: Headers,\n  current: Headers\n): Difference[] => {\n  const differences: Difference[] = [];\n\n  headers.forEach(header => {\n    const currentValue = current.get(header);\n    const storedValue = stored.get(header);\n\n    if (currentValue !== storedValue) {\n      differences.push({\n        header,\n        storedValue: storedValue,\n        currentValue: currentValue,\n      });\n    }\n  });\n\n  return differences;\n};\n\n/**\n * Format the differences so they can be easily read in an email.\n *\n * Outputs a string that looks like this:\n *\n * Headers differences found:\n * == https://aligent.com.au/ ===\n *\n * Header: example-header-name\n * Stored Value: No stored value\n * Current Value: example-value\n *\n * === https://aligent.com.au/contact ===\n *\n * Header: example-header-name\n * Stored Value: No stored value\n * Current Value: example-value\n *\n * Header: example-header-name-2\n * Stored Value: previous-value\n * Current Value: new-example-value\n *\n * @param differences Map<string, Difference[]> where the key is the URL\n */\nconst formatDifferences = (differences: Map<string, Difference[]>): string => {\n  const message = Array.from(differences.keys()).reduce((text, url) => {\n    console.log(text, url);\n    // Skip the url if there are no differences\n    if (differences.get(url)?.length === 0) {\n      return text;\n    }\n\n    // Format headers nicely\n    const headers = differences.get(url)?.reduce((headerText, header) => {\n      return (headerText += `\\r\\nHeader: ${header.header}\\r\\nStored Value: ${header.storedValue}\\r\\nCurrent Value: ${header.currentValue}\\r\\n`);\n    }, \"\");\n\n    return `${text}\\r\\n=== ${url} ===\\r\\n ${headers}`;\n  }, \"\");\n\n  return `Header differences found${message}`;\n};\n\nconst TOPIC_ARN = process.env.TOPIC_ARN!;\nconst SNS_CLIENT = new SNSClient();\n\n/**\n * Send a message to the SNS topic\n *\n * @param message string to send to sns\n */\nconst sendToSns = async (message: string) => {\n  const publishInput: PublishInput = {\n    TopicArn: TOPIC_ARN,\n    Message: message,\n  };\n  const publishCommand = new PublishCommand(publishInput);\n  await SNS_CLIENT.send(publishCommand);\n};\n"]}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@aligent/cdk-header-change-detection",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "GPL-3.0-only",
+  "homepage": "https://github.com/aligent/cdk-constructs/packages/header-change-detection-stack#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aligent/aws-cdk-header-change-detection-stack"
+  },
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.10",
+    "@types/node": "20.6.3",
+    "aws-cdk": "2.113.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "~5.3.2"
+  },
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.726.1",
+    "@aws-sdk/client-sns": "3.732.0",
+    "aws-cdk-lib": "2.113.0",
+    "axios": "^1.7.9",
+    "constructs": "^10.3.0",
+    "source-map-support": "^0.5.21"
+  },
+  "type": "commonjs"
+}