@gemeentenijmegen/webapp 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './webapp/Webapp';
+export * from './webapp/WebappOptions';
+export * from './webapp/OIDCConnectionProfile';
+export * from './webapp/Webpage';

package/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./webapp/Webapp"), exports);
+__exportStar(require("./webapp/WebappOptions"), exports);
+__exportStar(require("./webapp/OIDCConnectionProfile"), exports);
+__exportStar(require("./webapp/Webpage"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsa0RBQWdDO0FBQ2hDLHlEQUF1QztBQUN2QyxpRUFBK0M7QUFDL0MsbURBQWlDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi93ZWJhcHAvV2ViYXBwJztcbmV4cG9ydCAqIGZyb20gJy4vd2ViYXBwL1dlYmFwcE9wdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi93ZWJhcHAvT0lEQ0Nvbm5lY3Rpb25Qcm9maWxlJztcbmV4cG9ydCAqIGZyb20gJy4vd2ViYXBwL1dlYnBhZ2UnO1xuIl19

package/lib/webapp/Api.d.ts

@@ -0,0 +1,63 @@
+import { aws_lambda as lambda, aws_apigatewayv2 as apigatewayv2 } from 'aws-cdk-lib';
+import { HttpMethod } from 'aws-cdk-lib/aws-apigatewayv2';
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { Construct } from 'constructs';
+import { OpenIdConnectConnectionProfile } from './OIDCConnectionProfile';
+import { SessionsTable } from './SessionsTable';
+import { WebappConfigurable } from './WebappOptions';
+import { Webpage } from './Webpage';
+export interface ApiProps extends WebappConfigurable {
+    /**
+     * The dynamodb session table
+     */
+    sessionsTable: SessionsTable;
+}
+/**
+ * The API Stack creates the API Gateway and related
+ * lambda's. It requires supporting resources (such as the
+ * DynamoDB sessions table to be provided and thus created first)
+ */
+export declare class Api extends Construct {
+    private sessionsTable;
+    private customLambdaLayer?;
+    private configurationLambdaLayer;
+    private props;
+    api: apigatewayv2.HttpApi;
+    role: Role;
+    constructor(scope: Construct, id: string, props: ApiProps);
+    /**
+     * Create a lambda layer that incldues templates overwrites
+     * and configuration files. It is made available to all lambda
+     * registerd in this webapp.
+     * @param props
+     */
+    setupCustomLambdaLayer(customLambdaLayerDir?: string): lambda.LayerVersion | undefined;
+    /**
+     * Create a configuration lambda layer that contains the configuration files
+     * for the lambda.
+     * @param profiles
+     */
+    setupConfigurationLambdaLayer(profiles: OpenIdConnectConnectionProfile[]): lambda.LayerVersion;
+    /**
+     * Create and configure lambda's for all api routes, and
+     * add routes to the gateway.
+     */
+    setFunctions(props: ApiProps): void;
+    /**
+     * Add a new page to the webapp
+     * @param id
+     * @param handler
+     * @param path
+     * @param methods
+     */
+    addRoute(id: string, handler: Webpage, path: string, methods: HttpMethod[]): void;
+    /**
+     * Clean and return the apigateway subdomain placeholder
+     * https://${Token[TOKEN.246]}.execute-api.eu-west-1.${Token[AWS.URLSuffix.3]}/
+     * which can't be parsed by the URL class.
+     *
+     * @returns a domain-like string cleaned of protocol and trailing slash
+     */
+    domain(): string;
+    private setupLambdaExecutionRole;
+}

package/lib/webapp/Api.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = void 0;
+const fs = require("fs");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_apigatewayv2_integrations_1 = require("aws-cdk-lib/aws-apigatewayv2-integrations");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const constructs_1 = require("constructs");
+const auth_function_1 = require("./auth/auth-function");
+const login_function_1 = require("./login/login-function");
+const logout_function_1 = require("./logout/logout-function");
+const Webpage_1 = require("./Webpage");
+/**
+ * The API Stack creates the API Gateway and related
+ * lambda's. It requires supporting resources (such as the
+ * DynamoDB sessions table to be provided and thus created first)
+ */
+class Api extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.sessionsTable = props.sessionsTable.table;
+        this.customLambdaLayer = this.setupCustomLambdaLayer(props.webappOptions.additionalSourceFilesDir);
+        this.configurationLambdaLayer = this.setupConfigurationLambdaLayer(props.webappOptions.oidcProfiles);
+        this.role = this.setupLambdaExecutionRole(props.webappOptions.applicationName);
+        this.api = new aws_cdk_lib_1.aws_apigatewayv2.HttpApi(this, 'gateway', {
+            description: `API Gateway webapp: ${props.webappOptions.applicationName}`,
+        });
+        this.setFunctions(props);
+    }
+    /**
+     * Create a lambda layer that incldues templates overwrites
+     * and configuration files. It is made available to all lambda
+     * registerd in this webapp.
+     * @param props
+     */
+    setupCustomLambdaLayer(customLambdaLayerDir) {
+        if (!customLambdaLayerDir) {
+            return;
+        }
+        return new aws_cdk_lib_1.aws_lambda.LayerVersion(this, 'layer', {
+            code: aws_cdk_lib_1.aws_lambda.Code.fromAsset(customLambdaLayerDir),
+        });
+    }
+    /**
+     * Create a configuration lambda layer that contains the configuration files
+     * for the lambda.
+     * @param profiles
+     */
+    setupConfigurationLambdaLayer(profiles) {
+        // Create temp directory (use projen assets dir)
+        const tempDir = './assets/webapp/configuration-layer';
+        fs.mkdirSync(tempDir, { recursive: true });
+        // Write configuration objects to JSON files in temp dir
+        const authenticationJson = JSON.stringify(profiles);
+        fs.writeFileSync(`${tempDir}/authentication.json`, authenticationJson);
+        // Make layer using the temp directory
+        return new aws_cdk_lib_1.aws_lambda.LayerVersion(this, 'configuration-layer', {
+            code: aws_cdk_lib_1.aws_lambda.Code.fromAsset(tempDir),
+            description: 'Webapp construct managed layer to inject configuration files in lambdas',
+        });
+    }
+    /**
+     * Create and configure lambda's for all api routes, and
+     * add routes to the gateway.
+     */
+    setFunctions(props) {
+        const loginFunction = new Webpage_1.Webpage(this, 'login-function', {
+            description: `Login page for webapp ${props.webappOptions.applicationName}.`,
+            apiFunction: login_function_1.LoginFunction,
+            role: this.role,
+        });
+        this.addRoute('login', loginFunction, '/login', [aws_cdk_lib_1.aws_apigatewayv2.HttpMethod.GET]);
+        const logoutFunction = new Webpage_1.Webpage(this, 'logout-function', {
+            description: `Logout page for webapp ${props.webappOptions.applicationName}.`,
+            apiFunction: logout_function_1.LogoutFunction,
+            role: this.role,
+        });
+        this.addRoute('logout', logoutFunction, '/logout', [aws_cdk_lib_1.aws_apigatewayv2.HttpMethod.GET]);
+        const authFunction = new Webpage_1.Webpage(this, 'auth-function', {
+            description: `Auth landingpoint for webapp ${props.webappOptions.applicationName}.`,
+            role: this.role,
+            apiFunction: auth_function_1.AuthFunction,
+            environment: {
+                REDIRECT_TO_POST_LOGIN_HOOK: props.webappOptions.postLoginProcessor ? 'true' : 'false',
+            },
+        });
+        this.addRoute('auth', authFunction, '/auth', [aws_cdk_lib_1.aws_apigatewayv2.HttpMethod.GET]);
+    }
+    /**
+     * Add a new page to the webapp
+     * @param id
+     * @param handler
+     * @param path
+     * @param methods
+     */
+    addRoute(id, handler, path, methods) {
+        handler.allowSessionAccess(this.sessionsTable);
+        if (this.customLambdaLayer) {
+            handler.addLambdaLayer(this.customLambdaLayer);
+        }
+        handler.addLambdaLayer(this.configurationLambdaLayer);
+        handler.overwriteSessionLifetime(this.props.webappOptions.sessionLifetime ?? 15);
+        handler.monitor(this.props.webappOptions.applicationName);
+        handler.addStandardEnvironment(this.props.webappOptions.applicationName);
+        this.api.addRoutes({
+            path,
+            methods,
+            integration: new aws_apigatewayv2_integrations_1.HttpLambdaIntegration(id, handler.lambda),
+        });
+    }
+    /**
+     * Clean and return the apigateway subdomain placeholder
+     * https://${Token[TOKEN.246]}.execute-api.eu-west-1.${Token[AWS.URLSuffix.3]}/
+     * which can't be parsed by the URL class.
+     *
+     * @returns a domain-like string cleaned of protocol and trailing slash
+     */
+    domain() {
+        const url = this.api.url;
+        if (!url) {
+            return '';
+        }
+        let cleanedUrl = url
+            .replace(/^https?:\/\//, '') //protocol
+            .replace(/\/$/, ''); //optional trailing slash
+        return cleanedUrl;
+    }
+    setupLambdaExecutionRole(applicationName) {
+        return new aws_iam_1.Role(this, 'role', {
+            assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+            description: `Role used for lambdas in webapp ${applicationName}`,
+            managedPolicies: [
+                aws_iam_1.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),
+            ],
+        });
+    }
+}
+exports.Api = Api;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Api.js","sourceRoot":"","sources":["../../src/webapp/Api.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport {\n  aws_lambda as lambda,\n  aws_apigatewayv2 as apigatewayv2,\n} from 'aws-cdk-lib';\nimport { HttpMethod } from 'aws-cdk-lib/aws-apigatewayv2';\nimport { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';\nimport { Table } from 'aws-cdk-lib/aws-dynamodb';\nimport { ManagedPolicy, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';\nimport { LayerVersion } from 'aws-cdk-lib/aws-lambda';\nimport { Construct } from 'constructs';\nimport { AuthFunction } from './auth/auth-function';\nimport { LoginFunction } from './login/login-function';\nimport { LogoutFunction } from './logout/logout-function';\nimport { OpenIdConnectConnectionProfile } from './OIDCConnectionProfile';\nimport { SessionsTable } from './SessionsTable';\nimport { WebappConfigurable } from './WebappOptions';\nimport { Webpage } from './Webpage';\n\nexport interface ApiProps extends WebappConfigurable {\n  /**\n   * The dynamodb session table\n   */\n  sessionsTable: SessionsTable;\n}\n\n/**\n * The API Stack creates the API Gateway and related\n * lambda's. It requires supporting resources (such as the\n * DynamoDB sessions table to be provided and thus created first)\n */\nexport class Api extends Construct {\n\n  private sessionsTable: Table;\n  private customLambdaLayer?: LayerVersion;\n  private configurationLambdaLayer: LayerVersion;\n  private props: ApiProps;\n  api: apigatewayv2.HttpApi;\n  role: Role;\n\n  constructor(scope: Construct, id: string, props: ApiProps) {\n    super(scope, id);\n    this.props = props;\n    this.sessionsTable = props.sessionsTable.table;\n    this.customLambdaLayer = this.setupCustomLambdaLayer(props.webappOptions.additionalSourceFilesDir);\n    this.configurationLambdaLayer = this.setupConfigurationLambdaLayer(props.webappOptions.oidcProfiles);\n\n    this.role = this.setupLambdaExecutionRole(props.webappOptions.applicationName);\n    this.api = new apigatewayv2.HttpApi(this, 'gateway', {\n      description: `API Gateway webapp: ${props.webappOptions.applicationName}`,\n    });\n\n    this.setFunctions(props);\n  }\n\n  /**\n   * Create a lambda layer that incldues templates overwrites\n   * and configuration files. It is made available to all lambda\n   * registerd in this webapp.\n   * @param props\n   */\n  setupCustomLambdaLayer(customLambdaLayerDir?: string) {\n    if (!customLambdaLayerDir) { return; }\n    return new lambda.LayerVersion(this, 'layer', {\n      code: lambda.Code.fromAsset(customLambdaLayerDir),\n    });\n  }\n\n  /**\n   * Create a configuration lambda layer that contains the configuration files\n   * for the lambda.\n   * @param profiles\n   */\n  setupConfigurationLambdaLayer(profiles: OpenIdConnectConnectionProfile[]) {\n    // Create temp directory (use projen assets dir)\n    const tempDir = './assets/webapp/configuration-layer';\n    fs.mkdirSync(tempDir, { recursive: true });\n\n    // Write configuration objects to JSON files in temp dir\n    const authenticationJson = JSON.stringify(profiles);\n    fs.writeFileSync(`${tempDir}/authentication.json`, authenticationJson);\n\n    // Make layer using the temp directory\n    return new lambda.LayerVersion(this, 'configuration-layer', {\n      code: lambda.Code.fromAsset(tempDir),\n      description: 'Webapp construct managed layer to inject configuration files in lambdas',\n    });\n  }\n\n  /**\n   * Create and configure lambda's for all api routes, and\n   * add routes to the gateway.\n   */\n  setFunctions(props: ApiProps) {\n    const loginFunction = new Webpage(this, 'login-function', {\n      description: `Login page for webapp ${props.webappOptions.applicationName}.`,\n      apiFunction: LoginFunction,\n      role: this.role,\n    });\n    this.addRoute('login', loginFunction, '/login', [apigatewayv2.HttpMethod.GET]);\n\n    const logoutFunction = new Webpage(this, 'logout-function', {\n      description: `Logout page for webapp ${props.webappOptions.applicationName}.`,\n      apiFunction: LogoutFunction,\n      role: this.role,\n    });\n    this.addRoute('logout', logoutFunction, '/logout', [apigatewayv2.HttpMethod.GET]);\n\n    const authFunction = new Webpage(this, 'auth-function', {\n      description: `Auth landingpoint for webapp ${props.webappOptions.applicationName}.`,\n      role: this.role,\n      apiFunction: AuthFunction,\n      environment: {\n        REDIRECT_TO_POST_LOGIN_HOOK: props.webappOptions.postLoginProcessor ? 'true' : 'false',\n      },\n    });\n    this.addRoute('auth', authFunction, '/auth', [apigatewayv2.HttpMethod.GET]);\n  }\n\n  /**\n   * Add a new page to the webapp\n   * @param id\n   * @param handler\n   * @param path\n   * @param methods\n   */\n  addRoute(id: string, handler: Webpage, path: string, methods: HttpMethod[]) {\n    handler.allowSessionAccess(this.sessionsTable);\n    if (this.customLambdaLayer) { handler.addLambdaLayer(this.customLambdaLayer); }\n    handler.addLambdaLayer(this.configurationLambdaLayer);\n    handler.overwriteSessionLifetime(this.props.webappOptions.sessionLifetime ?? 15);\n    handler.monitor(this.props.webappOptions.applicationName);\n    handler.addStandardEnvironment(this.props.webappOptions.applicationName);\n    this.api.addRoutes({\n      path,\n      methods,\n      integration: new HttpLambdaIntegration(id, handler.lambda),\n    });\n  }\n\n  /**\n   * Clean and return the apigateway subdomain placeholder\n   * https://${Token[TOKEN.246]}.execute-api.eu-west-1.${Token[AWS.URLSuffix.3]}/\n   * which can't be parsed by the URL class.\n   *\n   * @returns a domain-like string cleaned of protocol and trailing slash\n   */\n  domain(): string {\n    const url = this.api.url;\n    if (!url) { return ''; }\n    let cleanedUrl = url\n      .replace(/^https?:\\/\\//, '') //protocol\n      .replace(/\\/$/, ''); //optional trailing slash\n    return cleanedUrl;\n  }\n\n  private setupLambdaExecutionRole(applicationName: string) {\n    return new Role(this, 'role', {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      description: `Role used for lambdas in webapp ${applicationName}`,\n      managedPolicies: [\n        ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),\n      ],\n    });\n  }\n\n}"]}

package/lib/webapp/Cloudfront.d.ts

@@ -0,0 +1,86 @@
+import { aws_s3 as S3 } from 'aws-cdk-lib';
+import { Distribution, ResponseHeadersPolicy, OriginAccessIdentity } from 'aws-cdk-lib/aws-cloudfront';
+import { Construct } from 'constructs';
+import { WebappConfigurable } from './WebappOptions';
+export interface CloudFrontProps extends WebappConfigurable {
+    /**
+     * The domain name of the API gateway to forward requests to.
+     */
+    apiGatewayDomain: string;
+}
+export declare class Cloudfront extends Construct {
+    cloudfront: Distribution;
+    constructor(scope: Construct, id: string, props: CloudFrontProps);
+    /**
+     * Add static contents to cloudfront
+     *
+     * Creates a bucket, deploys contents from a folder and adds it to
+     * the cloudfront distribution.
+     *
+     * @param cloudfrontDistribution the distribution for these resources
+     */
+    private addStaticResources;
+    /**
+     * Create a cloudfront distribution for the application
+     *
+     * Do not forward the Host header to API Gateway. This results in
+     * an HTTP 403 because API Gateway won't be able to find an endpoint
+     * on the cloudfront domain.
+     *
+     * @param {string} apiGatewayDomain the domain the api gateway can be reached at
+     * @returns {Distribution} the cloudfront distribution
+     */
+    setupCloudfront(props: CloudFrontProps): Distribution;
+    private errorResponses;
+    /**
+     * Add DNS records for cloudfront to the Route53 Zone
+     *
+     * Requests to the custom domain will correctly use cloudfront.
+     *
+     * @param distribution the cloudfront distribution
+     */
+    addDnsRecords(distribution: Distribution, props: CloudFrontProps): void;
+    /**
+     * Create a bucket to hold cloudfront logs
+     * @returns s3.Bucket
+     */
+    logBucket(): S3.Bucket;
+    /**
+     * Get a set of (security) response headers to inject into the response
+     * @returns {ResponseHeadersPolicy} cloudfront responseHeadersPolicy
+     */
+    responseHeadersPolicy(props: CloudFrontProps): ResponseHeadersPolicy;
+    /**
+     * Get the cleaned, trimmed header values for the csp header
+     *
+     * @returns string csp header values
+     */
+    cspHeaderValue(): string;
+    /**
+     * Create an s3 bucket to hold static resources.
+     * Must be unencrypted to allow cloudfront to serve
+     * these resources.
+     *
+     * @returns S3.Bucket
+     */
+    staticResourcesBucket(): S3.Bucket;
+    /**
+     * Allow listBucket to the origin access identity
+     *
+     * Necessary so cloudfront receives 404's as 404 instead of 403. This also allows
+     * a listing of the bucket if no /index.html is present in the bucket.
+     *
+     * @param originAccessIdentity
+     * @param bucket
+     */
+    allowOriginAccessIdentityAccessToBucket(originAccessIdentity: OriginAccessIdentity, bucket: S3.Bucket): void;
+    /**
+     * Deploy contents of folder to the s3 bucket
+     *
+     * Invalidates the correct cloudfront path
+     * @param bucket s3.Bucket
+     * @param distribution Distribution
+     */
+    deployBucket(props: CloudFrontProps, bucket: S3.Bucket, distribution: Distribution): void;
+    private domainNames;
+}

package/lib/webapp/Cloudfront.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cloudfront = void 0;
+const fs = require("fs");
+const path = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const aws_cloudfront_origins_1 = require("aws-cdk-lib/aws-cloudfront-origins");
+const constructs_1 = require("constructs");
+class Cloudfront extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.cloudfront = this.setupCloudfront(props);
+        this.addStaticResources(props, this.cloudfront);
+        this.addDnsRecords(this.cloudfront, props);
+    }
+    /**
+     * Add static contents to cloudfront
+     *
+     * Creates a bucket, deploys contents from a folder and adds it to
+     * the cloudfront distribution.
+     *
+     * @param cloudfrontDistribution the distribution for these resources
+     */
+    addStaticResources(props, cloudfrontDistribution) {
+        const staticResourcesBucket = this.staticResourcesBucket();
+        const originAccessIdentity = new aws_cloudfront_1.OriginAccessIdentity(this, 'publicresourcesbucket-oia');
+        this.allowOriginAccessIdentityAccessToBucket(originAccessIdentity, staticResourcesBucket);
+        const origin = new aws_cloudfront_origins_1.S3Origin(staticResourcesBucket, {
+            originAccessIdentity: originAccessIdentity,
+        });
+        cloudfrontDistribution.addBehavior('/static/*', origin, {
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+        });
+        cloudfrontDistribution.addBehavior('/.well-known/*', origin, {
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+        });
+        this.deployBucket(props, staticResourcesBucket, cloudfrontDistribution);
+    }
+    /**
+     * Create a cloudfront distribution for the application
+     *
+     * Do not forward the Host header to API Gateway. This results in
+     * an HTTP 403 because API Gateway won't be able to find an endpoint
+     * on the cloudfront domain.
+     *
+     * @param {string} apiGatewayDomain the domain the api gateway can be reached at
+     * @returns {Distribution} the cloudfront distribution
+     */
+    setupCloudfront(props) {
+        let defaultPath = props.webappOptions.defaultPath;
+        if (defaultPath.startsWith('/')) {
+            defaultPath = defaultPath.substring(1); // Strip leading /
+        }
+        const distribution = new aws_cloudfront_1.Distribution(this, 'cf-distribution', {
+            priceClass: aws_cloudfront_1.PriceClass.PRICE_CLASS_100,
+            domainNames: this.domainNames(props),
+            certificate: props.webappOptions.cloudFrontCertificate,
+            defaultBehavior: {
+                origin: new aws_cloudfront_origins_1.HttpOrigin(props.apiGatewayDomain),
+                originRequestPolicy: new aws_cloudfront_1.OriginRequestPolicy(this, 'cf-originrequestpolicy', {
+                    originRequestPolicyName: 'cfOriginRequestPolicyMijnUitkering',
+                    headerBehavior: aws_cloudfront_1.OriginRequestHeaderBehavior.allowList('Accept-Charset', 'Origin', 'Accept', 'Referer', 'Accept-Language', 'Accept-Datetime', 'Authoriz'),
+                }),
+                viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+                allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_ALL,
+                cachePolicy: new aws_cloudfront_1.CachePolicy(this, 'cf-caching', {
+                    cachePolicyName: 'cfCachingSessionsMijnUitkering',
+                    cookieBehavior: aws_cloudfront_1.CacheCookieBehavior.all(),
+                    headerBehavior: aws_cloudfront_1.CacheHeaderBehavior.allowList('Authorization'),
+                    queryStringBehavior: aws_cloudfront_1.CacheQueryStringBehavior.all(),
+                    defaultTtl: aws_cdk_lib_1.Duration.seconds(0),
+                    minTtl: aws_cdk_lib_1.Duration.seconds(0),
+                    maxTtl: aws_cdk_lib_1.Duration.seconds(1),
+                }),
+                responseHeadersPolicy: this.responseHeadersPolicy(props),
+            },
+            errorResponses: this.errorResponses(),
+            logBucket: this.logBucket(),
+            minimumProtocolVersion: aws_cloudfront_1.SecurityPolicyProtocol.TLS_V1_2_2021,
+            defaultRootObject: defaultPath,
+        });
+        return distribution;
+    }
+    errorResponses() {
+        const errorCodes = [403, 404, 500, 503];
+        return errorCodes.map(code => {
+            return {
+                httpStatus: code,
+                responseHttpStatus: code,
+                responsePagePath: `/static/http-errors/${code}.html`,
+            };
+        });
+    }
+    /**
+     * Add DNS records for cloudfront to the Route53 Zone
+     *
+     * Requests to the custom domain will correctly use cloudfront.
+     *
+     * @param distribution the cloudfront distribution
+     */
+    addDnsRecords(distribution, props) {
+        new aws_cdk_lib_1.aws_route53.ARecord(this, 'a-record', {
+            zone: props.webappOptions.hostedZone,
+            target: aws_cdk_lib_1.aws_route53.RecordTarget.fromAlias(new aws_cdk_lib_1.aws_route53_targets.CloudFrontTarget(distribution)),
+        });
+        new aws_cdk_lib_1.aws_route53.AaaaRecord(this, 'aaaa-record', {
+            zone: props.webappOptions.hostedZone,
+            target: aws_cdk_lib_1.aws_route53.RecordTarget.fromAlias(new aws_cdk_lib_1.aws_route53_targets.CloudFrontTarget(distribution)),
+        });
+    }
+    /**
+     * Create a bucket to hold cloudfront logs
+     * @returns s3.Bucket
+     */
+    logBucket() {
+        const cfLogBucket = new aws_cdk_lib_1.aws_s3.Bucket(this, 'CloudfrontLogs', {
+            blockPublicAccess: aws_cdk_lib_1.aws_s3.BlockPublicAccess.BLOCK_ALL,
+            eventBridgeEnabled: true,
+            enforceSSL: true,
+            encryption: aws_cdk_lib_1.aws_s3.BucketEncryption.S3_MANAGED,
+            objectOwnership: aws_cdk_lib_1.aws_s3.ObjectOwnership.OBJECT_WRITER,
+            lifecycleRules: [
+                {
+                    id: 'delete objects after 180 days',
+                    enabled: true,
+                    expiration: aws_cdk_lib_1.Duration.days(180),
+                },
+            ],
+        });
+        return cfLogBucket;
+    }
+    /**
+     * Get a set of (security) response headers to inject into the response
+     * @returns {ResponseHeadersPolicy} cloudfront responseHeadersPolicy
+     */
+    responseHeadersPolicy(props) {
+        const csp = props.webappOptions.cspHeaderValue ?? this.cspHeaderValue();
+        const responseHeadersPolicy = new aws_cloudfront_1.ResponseHeadersPolicy(this, 'headers', {
+            securityHeadersBehavior: {
+                contentSecurityPolicy: { contentSecurityPolicy: csp, override: true },
+                contentTypeOptions: { override: true },
+                frameOptions: { frameOption: aws_cloudfront_1.HeadersFrameOption.DENY, override: true },
+                referrerPolicy: { referrerPolicy: aws_cloudfront_1.HeadersReferrerPolicy.NO_REFERRER, override: true },
+                strictTransportSecurity: { accessControlMaxAge: aws_cdk_lib_1.Duration.days(366), includeSubdomains: true, override: true },
+            },
+            customHeadersBehavior: {
+                customHeaders: [
+                    {
+                        header: 'Cache-Control',
+                        value: 'no-cache, no-store, must-revalidate',
+                        override: false,
+                    },
+                    {
+                        header: 'Pragma',
+                        value: 'no-cache',
+                        override: false,
+                    },
+                    {
+                        header: 'Expires',
+                        value: '0',
+                        override: false,
+                    },
+                ],
+            },
+        });
+        return responseHeadersPolicy;
+    }
+    /**
+     * Get the cleaned, trimmed header values for the csp header
+     *
+     * @returns string csp header values
+     */
+    cspHeaderValue() {
+        const cspValues = 'default-src \'self\';\
+    frame-ancestors \'self\';\
+    frame-src \'self\';\
+    connect-src \'self\' https://componenten.nijmegen.nl;\
+    style-src \'self\' https://componenten.nijmegen.nl https://fonts.googleapis.com https://fonts.gstatic.com \
+    \'sha256-hS1LM/30PjUBJK3kBX9Vm9eOAhQNCiNhf/SCDnUqu14=\' \'sha256-47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\' \'sha256-OTeu7NEHDo6qutIWo0F2TmYrDhsKWCzrUgGoxxHGJ8o=\';\
+    script-src \'self\' https://componenten.nijmegen.nl https://siteimproveanalytics.com;\
+    font-src \'self\' https://componenten.nijmegen.nl https://fonts.gstatic.com;\
+    img-src \'self\' https://componenten.nijmegen.nl data: https://*.siteimproveanalytics.io;\
+    object-src \'none\';\
+    ';
+        return cspValues.replace(/[ ]+/g, ' ').trim();
+    }
+    /**
+     * Create an s3 bucket to hold static resources.
+     * Must be unencrypted to allow cloudfront to serve
+     * these resources.
+     *
+     * @returns S3.Bucket
+     */
+    staticResourcesBucket() {
+        const bucket = new aws_cdk_lib_1.aws_s3.Bucket(this, 'resources-bucket', {
+            blockPublicAccess: aws_cdk_lib_1.aws_s3.BlockPublicAccess.BLOCK_ALL,
+            eventBridgeEnabled: true,
+            enforceSSL: true,
+            encryption: aws_cdk_lib_1.aws_s3.BucketEncryption.UNENCRYPTED,
+        });
+        return bucket;
+    }
+    /**
+     * Allow listBucket to the origin access identity
+     *
+     * Necessary so cloudfront receives 404's as 404 instead of 403. This also allows
+     * a listing of the bucket if no /index.html is present in the bucket.
+     *
+     * @param originAccessIdentity
+     * @param bucket
+     */
+    allowOriginAccessIdentityAccessToBucket(originAccessIdentity, bucket) {
+        bucket.addToResourcePolicy(new aws_cdk_lib_1.aws_iam.PolicyStatement({
+            resources: [
+                `${bucket.bucketArn}`,
+                `${bucket.bucketArn}/*`,
+            ],
+            actions: [
+                's3:GetObject',
+                's3:ListBucket',
+            ],
+            effect: aws_cdk_lib_1.aws_iam.Effect.ALLOW,
+            principals: [originAccessIdentity.grantPrincipal],
+        }));
+    }
+    /**
+     * Deploy contents of folder to the s3 bucket
+     *
+     * Invalidates the correct cloudfront path
+     * @param bucket s3.Bucket
+     * @param distribution Distribution
+     */
+    deployBucket(props, bucket, distribution) {
+        // Do some synth time validation on the directory provided!
+        const staticDir = path.join(props.webappOptions.staticResourcesDirectory, 'static');
+        if (!fs.existsSync(staticDir)) {
+            throw Error(`Thers no directory for statics. Expected: ${staticDir}`);
+        }
+        const wellKnown = path.join(props.webappOptions.staticResourcesDirectory, '.well-known');
+        if (!fs.existsSync(wellKnown)) {
+            throw Error(`Thers no directory for .well-known. Expected: ${wellKnown}`);
+        }
+        //Deploy static resources to s3
+        new aws_cdk_lib_1.aws_s3_deployment.BucketDeployment(this, 'staticResources', {
+            sources: [aws_cdk_lib_1.aws_s3_deployment.Source.asset(props.webappOptions.staticResourcesDirectory)],
+            destinationBucket: bucket,
+            distribution: distribution,
+            distributionPaths: ['/static/*', '/.well-known/'],
+        });
+    }
+    domainNames(props) {
+        let cloudfrontDomainNames = props.webappOptions.alternativeDomainNames ?? [];
+        cloudfrontDomainNames.push(props.webappOptions.domainName);
+        return cloudfrontDomainNames;
+    }
+}
+exports.Cloudfront = Cloudfront;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Cloudfront.js","sourceRoot":"","sources":["../../src/webapp/Cloudfront.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport {\n  Duration,\n  aws_route53 as Route53,\n  aws_route53_targets as Route53Targets,\n  aws_s3 as S3,\n  aws_s3_deployment,\n  aws_iam as IAM,\n} from 'aws-cdk-lib';\nimport {\n  Distribution,\n  PriceClass,\n  OriginRequestPolicy,\n  ViewerProtocolPolicy,\n  AllowedMethods,\n  ResponseHeadersPolicy,\n  HeadersFrameOption,\n  HeadersReferrerPolicy,\n  CachePolicy,\n  OriginRequestHeaderBehavior,\n  CacheCookieBehavior,\n  CacheHeaderBehavior,\n  CacheQueryStringBehavior,\n  SecurityPolicyProtocol,\n  OriginAccessIdentity,\n} from 'aws-cdk-lib/aws-cloudfront';\nimport { HttpOrigin, S3Origin } from 'aws-cdk-lib/aws-cloudfront-origins';\nimport { Construct } from 'constructs';\nimport { WebappConfigurable } from './WebappOptions';\n\nexport interface CloudFrontProps extends WebappConfigurable {\n  /**\n   * The domain name of the API gateway to forward requests to.\n   */\n  apiGatewayDomain: string;\n}\n\nexport class Cloudfront extends Construct {\n\n  cloudfront: Distribution;\n\n  constructor(scope: Construct, id: string, props: CloudFrontProps) {\n    super(scope, id);\n    this.cloudfront = this.setupCloudfront(props);\n    this.addStaticResources(props, this.cloudfront);\n    this.addDnsRecords(this.cloudfront, props);\n  }\n\n  /**\n   * Add static contents to cloudfront\n   *\n   * Creates a bucket, deploys contents from a folder and adds it to\n   * the cloudfront distribution.\n   *\n   * @param cloudfrontDistribution the distribution for these resources\n   */\n  private addStaticResources(props: CloudFrontProps, cloudfrontDistribution: Distribution) {\n    const staticResourcesBucket = this.staticResourcesBucket();\n    const originAccessIdentity = new OriginAccessIdentity(this, 'publicresourcesbucket-oia');\n    this.allowOriginAccessIdentityAccessToBucket(originAccessIdentity, staticResourcesBucket);\n    const origin = new S3Origin(staticResourcesBucket, {\n      originAccessIdentity: originAccessIdentity,\n    });\n    cloudfrontDistribution.addBehavior(\n      '/static/*',\n      origin,\n      {\n        viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      },\n    );\n    cloudfrontDistribution.addBehavior(\n      '/.well-known/*',\n      origin,\n      {\n        viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      },\n    );\n    this.deployBucket(props, staticResourcesBucket, cloudfrontDistribution);\n  }\n\n  /**\n   * Create a cloudfront distribution for the application\n   *\n   * Do not forward the Host header to API Gateway. This results in\n   * an HTTP 403 because API Gateway won't be able to find an endpoint\n   * on the cloudfront domain.\n   *\n   * @param {string} apiGatewayDomain the domain the api gateway can be reached at\n   * @returns {Distribution} the cloudfront distribution\n   */\n  setupCloudfront(props: CloudFrontProps): Distribution {\n\n    let defaultPath = props.webappOptions.defaultPath;\n    if (defaultPath.startsWith('/')) {\n      defaultPath = defaultPath.substring(1); // Strip leading /\n    }\n\n    const distribution = new Distribution(this, 'cf-distribution', {\n      priceClass: PriceClass.PRICE_CLASS_100,\n      domainNames: this.domainNames(props),\n      certificate: props.webappOptions.cloudFrontCertificate,\n      defaultBehavior: {\n        origin: new HttpOrigin(props.apiGatewayDomain),\n        originRequestPolicy: new OriginRequestPolicy(this, 'cf-originrequestpolicy', {\n          originRequestPolicyName: 'cfOriginRequestPolicyMijnUitkering',\n          headerBehavior: OriginRequestHeaderBehavior.allowList(\n            'Accept-Charset',\n            'Origin',\n            'Accept',\n            'Referer',\n            'Accept-Language',\n            'Accept-Datetime',\n            'Authoriz',\n          ),\n        }),\n        viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n        allowedMethods: AllowedMethods.ALLOW_ALL,\n        cachePolicy: new CachePolicy(this, 'cf-caching', {\n          cachePolicyName: 'cfCachingSessionsMijnUitkering',\n          cookieBehavior: CacheCookieBehavior.all(),\n          headerBehavior: CacheHeaderBehavior.allowList('Authorization'),\n          queryStringBehavior: CacheQueryStringBehavior.all(),\n          defaultTtl: Duration.seconds(0),\n          minTtl: Duration.seconds(0),\n          maxTtl: Duration.seconds(1),\n        }),\n        responseHeadersPolicy: this.responseHeadersPolicy(props),\n      },\n      errorResponses: this.errorResponses(),\n      logBucket: this.logBucket(),\n      minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2021,\n      defaultRootObject: defaultPath,\n    });\n    return distribution;\n  }\n\n  private errorResponses() {\n    const errorCodes = [403, 404, 500, 503];\n    return errorCodes.map(code => {\n      return {\n        httpStatus: code,\n        responseHttpStatus: code,\n        responsePagePath: `/static/http-errors/${code}.html`,\n      };\n    });\n  }\n\n  /**\n   * Add DNS records for cloudfront to the Route53 Zone\n   *\n   * Requests to the custom domain will correctly use cloudfront.\n   *\n   * @param distribution the cloudfront distribution\n   */\n  addDnsRecords(distribution: Distribution, props: CloudFrontProps) {\n\n    new Route53.ARecord(this, 'a-record', {\n      zone: props.webappOptions.hostedZone,\n      target: Route53.RecordTarget.fromAlias(new Route53Targets.CloudFrontTarget(distribution)),\n    });\n\n    new Route53.AaaaRecord(this, 'aaaa-record', {\n      zone: props.webappOptions.hostedZone,\n      target: Route53.RecordTarget.fromAlias(new Route53Targets.CloudFrontTarget(distribution)),\n    });\n  }\n\n  /**\n   * Create a bucket to hold cloudfront logs\n   * @returns s3.Bucket\n   */\n  logBucket() {\n    const cfLogBucket = new S3.Bucket(this, 'CloudfrontLogs', {\n      blockPublicAccess: S3.BlockPublicAccess.BLOCK_ALL,\n      eventBridgeEnabled: true,\n      enforceSSL: true,\n      encryption: S3.BucketEncryption.S3_MANAGED,\n      objectOwnership: S3.ObjectOwnership.OBJECT_WRITER,\n      lifecycleRules: [\n        {\n          id: 'delete objects after 180 days',\n          enabled: true,\n          expiration: Duration.days(180),\n        },\n      ],\n    });\n    return cfLogBucket;\n  }\n\n\n  /**\n   * Get a set of (security) response headers to inject into the response\n   * @returns {ResponseHeadersPolicy} cloudfront responseHeadersPolicy\n   */\n  responseHeadersPolicy(props: CloudFrontProps): ResponseHeadersPolicy {\n\n    const csp = props.webappOptions.cspHeaderValue ?? this.cspHeaderValue();\n    const responseHeadersPolicy = new ResponseHeadersPolicy(this, 'headers', {\n      securityHeadersBehavior: {\n        contentSecurityPolicy: { contentSecurityPolicy: csp, override: true },\n        contentTypeOptions: { override: true },\n        frameOptions: { frameOption: HeadersFrameOption.DENY, override: true },\n        referrerPolicy: { referrerPolicy: HeadersReferrerPolicy.NO_REFERRER, override: true },\n        strictTransportSecurity: { accessControlMaxAge: Duration.days(366), includeSubdomains: true, override: true },\n      },\n      customHeadersBehavior: {\n        customHeaders: [\n          {\n            header: 'Cache-Control',\n            value: 'no-cache, no-store, must-revalidate',\n            override: false,\n          },\n          {\n            header: 'Pragma',\n            value: 'no-cache',\n            override: false,\n          },\n          {\n            header: 'Expires',\n            value: '0',\n            override: false,\n          },\n        ],\n      },\n    });\n    return responseHeadersPolicy;\n  }\n\n  /**\n   * Get the cleaned, trimmed header values for the csp header\n   *\n   * @returns string csp header values\n   */\n  cspHeaderValue() {\n    const cspValues = 'default-src \\'self\\';\\\n    frame-ancestors \\'self\\';\\\n    frame-src \\'self\\';\\\n    connect-src \\'self\\' https://componenten.nijmegen.nl;\\\n    style-src \\'self\\' https://componenten.nijmegen.nl https://fonts.googleapis.com https://fonts.gstatic.com \\\n    \\'sha256-hS1LM/30PjUBJK3kBX9Vm9eOAhQNCiNhf/SCDnUqu14=\\' \\'sha256-47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\\' \\'sha256-OTeu7NEHDo6qutIWo0F2TmYrDhsKWCzrUgGoxxHGJ8o=\\';\\\n    script-src \\'self\\' https://componenten.nijmegen.nl https://siteimproveanalytics.com;\\\n    font-src \\'self\\' https://componenten.nijmegen.nl https://fonts.gstatic.com;\\\n    img-src \\'self\\' https://componenten.nijmegen.nl data: https://*.siteimproveanalytics.io;\\\n    object-src \\'none\\';\\\n    ';\n    return cspValues.replace(/[ ]+/g, ' ').trim();\n  }\n\n  /**\n   * Create an s3 bucket to hold static resources.\n   * Must be unencrypted to allow cloudfront to serve\n   * these resources.\n   *\n   * @returns S3.Bucket\n   */\n  staticResourcesBucket() {\n    const bucket = new S3.Bucket(this, 'resources-bucket', {\n      blockPublicAccess: S3.BlockPublicAccess.BLOCK_ALL,\n      eventBridgeEnabled: true,\n      enforceSSL: true,\n      encryption: S3.BucketEncryption.UNENCRYPTED,\n    });\n\n    return bucket;\n  }\n\n  /**\n   * Allow listBucket to the origin access identity\n   *\n   * Necessary so cloudfront receives 404's as 404 instead of 403. This also allows\n   * a listing of the bucket if no /index.html is present in the bucket.\n   *\n   * @param originAccessIdentity\n   * @param bucket\n   */\n  allowOriginAccessIdentityAccessToBucket(originAccessIdentity: OriginAccessIdentity, bucket: S3.Bucket) {\n    bucket.addToResourcePolicy(new IAM.PolicyStatement({\n      resources: [\n        `${bucket.bucketArn}`,\n        `${bucket.bucketArn}/*`,\n      ],\n      actions: [\n        's3:GetObject',\n        's3:ListBucket',\n      ],\n      effect: IAM.Effect.ALLOW,\n      principals: [originAccessIdentity.grantPrincipal],\n    }),\n    );\n  }\n\n  /**\n   * Deploy contents of folder to the s3 bucket\n   *\n   * Invalidates the correct cloudfront path\n   * @param bucket s3.Bucket\n   * @param distribution Distribution\n   */\n  deployBucket(props: CloudFrontProps, bucket: S3.Bucket, distribution: Distribution) {\n\n    // Do some synth time validation on the directory provided!\n    const staticDir = path.join(props.webappOptions.staticResourcesDirectory, 'static');\n    if (!fs.existsSync(staticDir)) {\n      throw Error(`Thers no directory for statics. Expected: ${staticDir}`);\n    }\n\n    const wellKnown = path.join(props.webappOptions.staticResourcesDirectory, '.well-known');\n    if (!fs.existsSync(wellKnown)) {\n      throw Error(`Thers no directory for .well-known. Expected: ${wellKnown}`);\n    }\n\n    //Deploy static resources to s3\n    new aws_s3_deployment.BucketDeployment(this, 'staticResources', {\n      sources: [aws_s3_deployment.Source.asset(props.webappOptions.staticResourcesDirectory)],\n      destinationBucket: bucket,\n      distribution: distribution,\n      distributionPaths: ['/static/*', '/.well-known/'],\n    });\n  }\n\n  private domainNames(props: CloudFrontProps) {\n    let cloudfrontDomainNames = props.webappOptions.alternativeDomainNames ?? [];\n    cloudfrontDomainNames.push(props.webappOptions.domainName);\n    return cloudfrontDomainNames;\n  }\n\n}\n"]}