@liflig/cdk 2.18.5 → 2.18.7

package/lib/webapp/webapp.d.ts

@@ -0,0 +1,116 @@
+import * as constructs from "constructs";
+import * as certificatemanager from "aws-cdk-lib/aws-certificatemanager";
+import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
+import * as origins from "aws-cdk-lib/aws-cloudfront-origins";
+import * as r53 from "aws-cdk-lib/aws-route53";
+import * as s3 from "aws-cdk-lib/aws-s3";
+import * as webappDeploy from "@capraconsulting/webapp-deploy-lambda";
+import { WebappSecurityHeadersProps } from "./security-headers";
+export interface WebappProps {
+    /**
+     * ACM certificate that covers the specifeid domain names.
+     *
+     * This certificate must be created in the region us-east-1.
+     *
+     * @default - The CloudFront wildcard certificate (*.cloudfront.net) will be used.
+     */
+    cloudfrontCertificate?: certificatemanager.ICertificate;
+    /**
+     * List of domain names the CloudFront distribution should use.
+     *
+     * @default - Generated name (e.g., d111111abcdef8.cloudfront.net)
+     */
+    domainNames?: string[];
+    /**
+     * AWS WAF web ACL to associate with the CloudFront distribution.
+     *
+     * To specify a web ACL created using the latest version of AWS WAF, use the ACL ARN, for example
+     * `arn:aws:wafv2:us-east-1:123456789012:global/webacl/ExampleWebACL/473e64fd-f30b-4765-81a0-62ad96dd167a`.
+     * To specify a web ACL created using AWS WAF Classic, use the ACL ID, for example `473e64fd-f30b-4765-81a0-62ad96dd167a`.
+     *
+     * @default - No AWS Web Application Firewall web access control list (web ACL).
+     */
+    webAclId?: string;
+    /**
+     * The path to the page that will be served for users not allowed to access
+     * the site when using WAF. E.g. "/4xx-errors/403-forbidden.html".
+     *
+     * Note that this wil catch any 403 errors from the origin(s), that might
+     * cover any other behaviors is added.
+     *
+     * @default - No custom page for 403 errors.
+     */
+    webAclErrorPagePath?: string;
+    /**
+     *  Enable, disable or configure security headers for the web application
+     * @default - a set of strict security headers are configured by default
+     */
+    securityHeaders?: {
+        /**
+         * Enable adding common security headers to CloudFront responses
+         *
+         * If enabled, the default behavior is to add the following headers with fairly strict defaults. Most of the headers can be customized:
+         * - Content-Security-Policy
+         * - Referrer-Policy
+         * - Strict-Transport-Security
+         * - X-Content-Type-Options
+         * - X-Frame-Options
+         * - X-XSS-Protection
+         *
+         *
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Security headers overrides.
+         *
+         * Used to override certain default security header values if the webapp requires different settings than the defaults.
+         *
+         * NOTE: If you need to disable certain headers, you must explicitly set them to undefined
+         *
+         * @default - A set of strict security header values will be used
+         */
+        behaviorOverrides?: WebappSecurityHeadersProps;
+    };
+    /**
+     * Cloudfront behavior overrides.
+     *
+     * Used to override cloudfront behavior
+     *
+     * NOTE: ResponseHeadersPolicy defined here will overwrite BOTH the default security headers policy and
+     * any values specified in securityHeaders.behaviorOverrides.
+     */
+    overrideCloudFrontBehaviourOptions?: Partial<cloudfront.BehaviorOptions>;
+}
+/**
+ * CloudFront for a Single-Page-Application.
+ *
+ * A bucket will be created and its prefix "web" is used to
+ * serve files. Use the addDeployment method to automatically
+ * deploy files as part the the CDK deployment.
+ */
+export declare class Webapp extends constructs.Construct {
+    readonly distribution: cloudfront.Distribution;
+    readonly webappBucket: s3.Bucket;
+    readonly webappOrigin: origins.S3Origin;
+    constructor(scope: constructs.Construct, id: string, props: WebappProps);
+    addDnsRecord(hostedZone: r53.IHostedZone, domainName: string): void;
+    /**
+     * Add a deployment using webapp-deploy-lambda.
+     *
+     * See https://github.com/capraconsulting/webapp-deploy-lambda
+     * for details about how this works.
+     */
+    addDeployment(
+    /**
+     * The deployment source.
+     */
+    source: webappDeploy.ISource, props?: {
+        /**
+         * Include source maps in the deployment.
+         *
+         * @default false
+         */
+        deploySourceMaps?: boolean;
+    }): void;
+}

package/lib/webapp/webapp.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webapp = void 0;
+const constructs = require("constructs");
+const cloudfront = require("aws-cdk-lib/aws-cloudfront");
+const origins = require("aws-cdk-lib/aws-cloudfront-origins");
+const iam = require("aws-cdk-lib/aws-iam");
+const r53 = require("aws-cdk-lib/aws-route53");
+const r53t = require("aws-cdk-lib/aws-route53-targets");
+const s3 = require("aws-cdk-lib/aws-s3");
+const webappDeploy = require("@capraconsulting/webapp-deploy-lambda");
+const security_headers_1 = require("./security-headers");
+/**
+ * CloudFront for a Single-Page-Application.
+ *
+ * A bucket will be created and its prefix "web" is used to
+ * serve files. Use the addDeployment method to automatically
+ * deploy files as part the the CDK deployment.
+ */
+class Webapp extends constructs.Construct {
+    constructor(scope, id, props) {
+        var _a, _b, _c, _d, _e;
+        super(scope, id);
+        if (props.webAclErrorPagePath != null && props.webAclId == null) {
+            throw new Error("webAclErrorPagePath set but webAclId is missing");
+        }
+        this.webappBucket = new s3.Bucket(this, "Bucket", {
+            encryption: s3.BucketEncryption.S3_MANAGED,
+        });
+        const originAccessIdentity = new cloudfront.OriginAccessIdentity(this, "OriginAccessIdentity");
+        this.webappBucket.addToResourcePolicy(new iam.PolicyStatement({
+            resources: [this.webappBucket.arnForObjects("*")],
+            actions: ["s3:GetObject"],
+            principals: [originAccessIdentity.grantPrincipal],
+        }));
+        this.webappBucket.addToResourcePolicy(new iam.PolicyStatement({
+            resources: [this.webappBucket.bucketArn],
+            // Grant s3:ListBucket so that CloudFront receives 404 from
+            // the origin rather than 403 when accessing files that
+            // does not exist. We cannot fallback to index.html for 403
+            // errors since it would also be served if using a WAF.
+            // See https://aws.amazon.com/premiumsupport/knowledge-center/s3-website-cloudfront-error-403/#The_requested_objects_must_exist_in_the_bucket
+            actions: ["s3:ListBucket"],
+            principals: [originAccessIdentity.grantPrincipal],
+        }));
+        this.webappOrigin = new origins.S3Origin(this.webappBucket, {
+            // webapp-deploy-lambda will upload files to this folder
+            // since it keeps some other administrative files outside.
+            originPath: "/web",
+            originAccessIdentity,
+        });
+        const errorResponses = [
+            {
+                httpStatus: 404,
+                responseHttpStatus: 200,
+                responsePagePath: "/index.html",
+            },
+        ];
+        if (props.webAclErrorPagePath != null) {
+            errorResponses.push({
+                httpStatus: 403,
+                responseHttpStatus: 403,
+                responsePagePath: props.webAclErrorPagePath,
+            });
+        }
+        let responseHeadersPolicy;
+        if (((_b = (_a = props.securityHeaders) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : true) &&
+            !((_d = (_c = props.overrideCloudFrontBehaviourOptions) === null || _c === void 0 ? void 0 : _c.responseHeadersPolicy) === null || _d === void 0 ? void 0 : _d.responseHeadersPolicyId)) {
+            const securityHeaders = new security_headers_1.WebappSecurityHeaders(this, "SecurityHeaders", {
+                ...(_e = props.securityHeaders) === null || _e === void 0 ? void 0 : _e.behaviorOverrides,
+            });
+            responseHeadersPolicy = securityHeaders.responseHeadersPolicy;
+        }
+        this.distribution = new cloudfront.Distribution(this, "Distribution", {
+            defaultBehavior: {
+                origin: this.webappOrigin,
+                viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+                responseHeadersPolicy: responseHeadersPolicy,
+                ...props.overrideCloudFrontBehaviourOptions,
+            },
+            defaultRootObject: "index.html",
+            priceClass: cloudfront.PriceClass.PRICE_CLASS_100,
+            certificate: props.cloudfrontCertificate,
+            domainNames: props.domainNames,
+            errorResponses,
+            webAclId: props.webAclId,
+        });
+    }
+    addDnsRecord(hostedZone, domainName) {
+        new r53.ARecord(this, `DnsRecord${domainName}`, {
+            zone: hostedZone,
+            recordName: `${domainName}.`,
+            target: r53.RecordTarget.fromAlias(new r53t.CloudFrontTarget(this.distribution)),
+        });
+    }
+    /**
+     * Add a deployment using webapp-deploy-lambda.
+     *
+     * See https://github.com/capraconsulting/webapp-deploy-lambda
+     * for details about how this works.
+     */
+    addDeployment(
+    /**
+     * The deployment source.
+     */
+    source, props) {
+        var _a;
+        const deploySourceMaps = (_a = props === null || props === void 0 ? void 0 : props.deploySourceMaps) !== null && _a !== void 0 ? _a : false;
+        new webappDeploy.WebappDeploy(this, "Deploy", {
+            source: source,
+            webBucket: this.webappBucket,
+            distribution: this.distribution,
+            excludePattern: deploySourceMaps ? undefined : "\\.map$",
+        });
+    }
+}
+exports.Webapp = Webapp;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webapp.js","sourceRoot":"","sources":["../../src/webapp/webapp.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as certificatemanager from \"aws-cdk-lib/aws-certificatemanager\"\nimport * as cloudfront from \"aws-cdk-lib/aws-cloudfront\"\nimport * as origins from \"aws-cdk-lib/aws-cloudfront-origins\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as r53 from \"aws-cdk-lib/aws-route53\"\nimport * as r53t from \"aws-cdk-lib/aws-route53-targets\"\nimport * as s3 from \"aws-cdk-lib/aws-s3\"\nimport * as webappDeploy from \"@capraconsulting/webapp-deploy-lambda\"\nimport {\n  WebappSecurityHeaders,\n  WebappSecurityHeadersProps,\n} from \"./security-headers\"\n\nexport interface WebappProps {\n  /**\n   * ACM certificate that covers the specifeid domain names.\n   *\n   * This certificate must be created in the region us-east-1.\n   *\n   * @default - The CloudFront wildcard certificate (*.cloudfront.net) will be used.\n   */\n  cloudfrontCertificate?: certificatemanager.ICertificate\n  /**\n   * List of domain names the CloudFront distribution should use.\n   *\n   * @default - Generated name (e.g., d111111abcdef8.cloudfront.net)\n   */\n  domainNames?: string[]\n  /**\n   * AWS WAF web ACL to associate with the CloudFront distribution.\n   *\n   * To specify a web ACL created using the latest version of AWS WAF, use the ACL ARN, for example\n   * `arn:aws:wafv2:us-east-1:123456789012:global/webacl/ExampleWebACL/473e64fd-f30b-4765-81a0-62ad96dd167a`.\n   * To specify a web ACL created using AWS WAF Classic, use the ACL ID, for example `473e64fd-f30b-4765-81a0-62ad96dd167a`.\n   *\n   * @default - No AWS Web Application Firewall web access control list (web ACL).\n   */\n  webAclId?: string\n  /**\n   * The path to the page that will be served for users not allowed to access\n   * the site when using WAF. E.g. \"/4xx-errors/403-forbidden.html\".\n   *\n   * Note that this wil catch any 403 errors from the origin(s), that might\n   * cover any other behaviors is added.\n   *\n   * @default - No custom page for 403 errors.\n   */\n  webAclErrorPagePath?: string\n  /**\n   *  Enable, disable or configure security headers for the web application\n   * @default - a set of strict security headers are configured by default\n   */\n  securityHeaders?: {\n    /**\n     * Enable adding common security headers to CloudFront responses\n     *\n     * If enabled, the default behavior is to add the following headers with fairly strict defaults. Most of the headers can be customized:\n     * - Content-Security-Policy\n     * - Referrer-Policy\n     * - Strict-Transport-Security\n     * - X-Content-Type-Options\n     * - X-Frame-Options\n     * - X-XSS-Protection\n     *\n     *\n     * @default true\n     */\n    enabled?: boolean\n    /**\n     * Security headers overrides.\n     *\n     * Used to override certain default security header values if the webapp requires different settings than the defaults.\n     *\n     * NOTE: If you need to disable certain headers, you must explicitly set them to undefined\n     *\n     * @default - A set of strict security header values will be used\n     */\n    behaviorOverrides?: WebappSecurityHeadersProps\n  }\n  /**\n   * Cloudfront behavior overrides.\n   *\n   * Used to override cloudfront behavior\n   *\n   * NOTE: ResponseHeadersPolicy defined here will overwrite BOTH the default security headers policy and\n   * any values specified in securityHeaders.behaviorOverrides.\n   */\n  overrideCloudFrontBehaviourOptions?: Partial<cloudfront.BehaviorOptions>\n}\n\n/**\n * CloudFront for a Single-Page-Application.\n *\n * A bucket will be created and its prefix \"web\" is used to\n * serve files. Use the addDeployment method to automatically\n * deploy files as part the the CDK deployment.\n */\nexport class Webapp extends constructs.Construct {\n  public readonly distribution: cloudfront.Distribution\n  public readonly webappBucket: s3.Bucket\n  public readonly webappOrigin: origins.S3Origin\n\n  constructor(scope: constructs.Construct, id: string, props: WebappProps) {\n    super(scope, id)\n\n    if (props.webAclErrorPagePath != null && props.webAclId == null) {\n      throw new Error(\"webAclErrorPagePath set but webAclId is missing\")\n    }\n\n    this.webappBucket = new s3.Bucket(this, \"Bucket\", {\n      encryption: s3.BucketEncryption.S3_MANAGED,\n    })\n\n    const originAccessIdentity = new cloudfront.OriginAccessIdentity(\n      this,\n      \"OriginAccessIdentity\",\n    )\n\n    this.webappBucket.addToResourcePolicy(\n      new iam.PolicyStatement({\n        resources: [this.webappBucket.arnForObjects(\"*\")],\n        actions: [\"s3:GetObject\"],\n        principals: [originAccessIdentity.grantPrincipal],\n      }),\n    )\n\n    this.webappBucket.addToResourcePolicy(\n      new iam.PolicyStatement({\n        resources: [this.webappBucket.bucketArn],\n        // Grant s3:ListBucket so that CloudFront receives 404 from\n        // the origin rather than 403 when accessing files that\n        // does not exist. We cannot fallback to index.html for 403\n        // errors since it would also be served if using a WAF.\n        // See https://aws.amazon.com/premiumsupport/knowledge-center/s3-website-cloudfront-error-403/#The_requested_objects_must_exist_in_the_bucket\n        actions: [\"s3:ListBucket\"],\n        principals: [originAccessIdentity.grantPrincipal],\n      }),\n    )\n\n    this.webappOrigin = new origins.S3Origin(this.webappBucket, {\n      // webapp-deploy-lambda will upload files to this folder\n      // since it keeps some other administrative files outside.\n      originPath: \"/web\",\n      originAccessIdentity,\n    })\n\n    const errorResponses: cloudfront.ErrorResponse[] = [\n      {\n        httpStatus: 404,\n        responseHttpStatus: 200,\n        responsePagePath: \"/index.html\",\n      },\n    ]\n\n    if (props.webAclErrorPagePath != null) {\n      errorResponses.push({\n        httpStatus: 403,\n        responseHttpStatus: 403,\n        responsePagePath: props.webAclErrorPagePath,\n      })\n    }\n\n    let responseHeadersPolicy: cloudfront.IResponseHeadersPolicy | undefined\n\n    if (\n      (props.securityHeaders?.enabled ?? true) &&\n      !props.overrideCloudFrontBehaviourOptions?.responseHeadersPolicy\n        ?.responseHeadersPolicyId\n    ) {\n      const securityHeaders = new WebappSecurityHeaders(\n        this,\n        \"SecurityHeaders\",\n        {\n          ...props.securityHeaders?.behaviorOverrides,\n        },\n      )\n      responseHeadersPolicy = securityHeaders.responseHeadersPolicy\n    }\n\n    this.distribution = new cloudfront.Distribution(this, \"Distribution\", {\n      defaultBehavior: {\n        origin: this.webappOrigin,\n        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n        responseHeadersPolicy: responseHeadersPolicy,\n        ...props.overrideCloudFrontBehaviourOptions,\n      },\n      defaultRootObject: \"index.html\",\n      priceClass: cloudfront.PriceClass.PRICE_CLASS_100,\n      certificate: props.cloudfrontCertificate,\n      domainNames: props.domainNames,\n      errorResponses,\n      webAclId: props.webAclId,\n    })\n  }\n\n  addDnsRecord(hostedZone: r53.IHostedZone, domainName: string): void {\n    new r53.ARecord(this, `DnsRecord${domainName}`, {\n      zone: hostedZone,\n      recordName: `${domainName}.`,\n      target: r53.RecordTarget.fromAlias(\n        new r53t.CloudFrontTarget(this.distribution),\n      ),\n    })\n  }\n\n  /**\n   * Add a deployment using webapp-deploy-lambda.\n   *\n   * See https://github.com/capraconsulting/webapp-deploy-lambda\n   * for details about how this works.\n   */\n  addDeployment(\n    /**\n     * The deployment source.\n     */\n    source: webappDeploy.ISource,\n    props?: {\n      /**\n       * Include source maps in the deployment.\n       *\n       * @default false\n       */\n      deploySourceMaps?: boolean\n    },\n  ): void {\n    const deploySourceMaps = props?.deploySourceMaps ?? false\n\n    new webappDeploy.WebappDeploy(this, \"Deploy\", {\n      source: source,\n      webBucket: this.webappBucket,\n      distribution: this.distribution,\n      excludePattern: deploySourceMaps ? undefined : \"\\\\.map$\",\n    })\n  }\n}\n"]}

package/lib/webapp-deploy-via-role.d.ts

@@ -0,0 +1,25 @@
+import * as constructs from "constructs";
+import { WebappDeployProps } from "@capraconsulting/webapp-deploy-lambda";
+interface Props {
+    /**
+     * Reference to the IAM Role that will be granted permission to
+     * assume the CI role. This role must have permission to assume
+     * the CI role.
+     */
+    externalRoleArn: string;
+    /**
+     * The name of the role that will be created.
+     */
+    roleName: string;
+    webappDeploy: WebappDeployProps;
+}
+/**
+ * Provide the construct described at
+ * https://github.com/capraconsulting/webapp-deploy-lambda
+ * in combination with a separate role to be used to
+ * trigger the process.
+ */
+export declare class WebappDeployViaRole extends constructs.Construct {
+    constructor(scope: constructs.Construct, id: string, props: Props);
+}
+export {};

package/lib/webapp-deploy-via-role.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebappDeployViaRole = void 0;
+const constructs = require("constructs");
+const iam = require("aws-cdk-lib/aws-iam");
+const cdk = require("aws-cdk-lib");
+const webapp_deploy_lambda_1 = require("@capraconsulting/webapp-deploy-lambda");
+/**
+ * Provide the construct described at
+ * https://github.com/capraconsulting/webapp-deploy-lambda
+ * in combination with a separate role to be used to
+ * trigger the process.
+ */
+class WebappDeployViaRole extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const roleToBeAssumedForDeploy = new iam.Role(this, "Role", {
+            assumedBy: new iam.ArnPrincipal(props.externalRoleArn),
+            roleName: props.roleName,
+        });
+        const webappDeploy = new webapp_deploy_lambda_1.WebappDeploy(this, "Resource", props.webappDeploy);
+        webappDeploy.deployFn.grantInvoke(roleToBeAssumedForDeploy);
+        new cdk.CfnOutput(this, "FunctionArnOutput", {
+            value: webappDeploy.deployFn.functionArn,
+        });
+        new cdk.CfnOutput(this, "RoleArnOutput", {
+            value: roleToBeAssumedForDeploy.roleArn,
+        });
+    }
+}
+exports.WebappDeployViaRole = WebappDeployViaRole;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViYXBwLWRlcGxveS12aWEtcm9sZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy93ZWJhcHAtZGVwbG95LXZpYS1yb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHlDQUF3QztBQUN4QywyQ0FBMEM7QUFDMUMsbUNBQWtDO0FBQ2xDLGdGQUc4QztBQWdCOUM7Ozs7O0dBS0c7QUFDSCxNQUFhLG1CQUFvQixTQUFRLFVBQVUsQ0FBQyxTQUFTO0lBQzNELFlBQVksS0FBMkIsRUFBRSxFQUFVLEVBQUUsS0FBWTtRQUMvRCxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFBO1FBRWhCLE1BQU0sd0JBQXdCLEdBQUcsSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUU7WUFDMUQsU0FBUyxFQUFFLElBQUksR0FBRyxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsZUFBZSxDQUFDO1lBQ3RELFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUTtTQUN6QixDQUFDLENBQUE7UUFFRixNQUFNLFlBQVksR0FBRyxJQUFJLG1DQUFZLENBQUMsSUFBSSxFQUFFLFVBQVUsRUFBRSxLQUFLLENBQUMsWUFBWSxDQUFDLENBQUE7UUFFM0UsWUFBWSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsd0JBQXdCLENBQUMsQ0FBQTtRQUUzRCxJQUFJLEdBQUcsQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLG1CQUFtQixFQUFFO1lBQzNDLEtBQUssRUFBRSxZQUFZLENBQUMsUUFBUSxDQUFDLFdBQVc7U0FDekMsQ0FBQyxDQUFBO1FBQ0YsSUFBSSxHQUFHLENBQUMsU0FBUyxDQUFDLElBQUksRUFBRSxlQUFlLEVBQUU7WUFDdkMsS0FBSyxFQUFFLHdCQUF3QixDQUFDLE9BQU87U0FDeEMsQ0FBQyxDQUFBO0lBQ0osQ0FBQztDQUNGO0FBcEJELGtEQW9CQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGNvbnN0cnVjdHMgZnJvbSBcImNvbnN0cnVjdHNcIlxuaW1wb3J0ICogYXMgaWFtIGZyb20gXCJhd3MtY2RrLWxpYi9hd3MtaWFtXCJcbmltcG9ydCAqIGFzIGNkayBmcm9tIFwiYXdzLWNkay1saWJcIlxuaW1wb3J0IHtcbiAgV2ViYXBwRGVwbG95LFxuICBXZWJhcHBEZXBsb3lQcm9wcyxcbn0gZnJvbSBcIkBjYXByYWNvbnN1bHRpbmcvd2ViYXBwLWRlcGxveS1sYW1iZGFcIlxuXG5pbnRlcmZhY2UgUHJvcHMge1xuICAvKipcbiAgICogUmVmZXJlbmNlIHRvIHRoZSBJQU0gUm9sZSB0aGF0IHdpbGwgYmUgZ3JhbnRlZCBwZXJtaXNzaW9uIHRvXG4gICAqIGFzc3VtZSB0aGUgQ0kgcm9sZS4gVGhpcyByb2xlIG11c3QgaGF2ZSBwZXJtaXNzaW9uIHRvIGFzc3VtZVxuICAgKiB0aGUgQ0kgcm9sZS5cbiAgICovXG4gIGV4dGVybmFsUm9sZUFybjogc3RyaW5nXG4gIC8qKlxuICAgKiBUaGUgbmFtZSBvZiB0aGUgcm9sZSB0aGF0IHdpbGwgYmUgY3JlYXRlZC5cbiAgICovXG4gIHJvbGVOYW1lOiBzdHJpbmdcbiAgd2ViYXBwRGVwbG95OiBXZWJhcHBEZXBsb3lQcm9wc1xufVxuXG4vKipcbiAqIFByb3ZpZGUgdGhlIGNvbnN0cnVjdCBkZXNjcmliZWQgYXRcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9jYXByYWNvbnN1bHRpbmcvd2ViYXBwLWRlcGxveS1sYW1iZGFcbiAqIGluIGNvbWJpbmF0aW9uIHdpdGggYSBzZXBhcmF0ZSByb2xlIHRvIGJlIHVzZWQgdG9cbiAqIHRyaWdnZXIgdGhlIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjbGFzcyBXZWJhcHBEZXBsb3lWaWFSb2xlIGV4dGVuZHMgY29uc3RydWN0cy5Db25zdHJ1Y3Qge1xuICBjb25zdHJ1Y3RvcihzY29wZTogY29uc3RydWN0cy5Db25zdHJ1Y3QsIGlkOiBzdHJpbmcsIHByb3BzOiBQcm9wcykge1xuICAgIHN1cGVyKHNjb3BlLCBpZClcblxuICAgIGNvbnN0IHJvbGVUb0JlQXNzdW1lZEZvckRlcGxveSA9IG5ldyBpYW0uUm9sZSh0aGlzLCBcIlJvbGVcIiwge1xuICAgICAgYXNzdW1lZEJ5OiBuZXcgaWFtLkFyblByaW5jaXBhbChwcm9wcy5leHRlcm5hbFJvbGVBcm4pLFxuICAgICAgcm9sZU5hbWU6IHByb3BzLnJvbGVOYW1lLFxuICAgIH0pXG5cbiAgICBjb25zdCB3ZWJhcHBEZXBsb3kgPSBuZXcgV2ViYXBwRGVwbG95KHRoaXMsIFwiUmVzb3VyY2VcIiwgcHJvcHMud2ViYXBwRGVwbG95KVxuXG4gICAgd2ViYXBwRGVwbG95LmRlcGxveUZuLmdyYW50SW52b2tlKHJvbGVUb0JlQXNzdW1lZEZvckRlcGxveSlcblxuICAgIG5ldyBjZGsuQ2ZuT3V0cHV0KHRoaXMsIFwiRnVuY3Rpb25Bcm5PdXRwdXRcIiwge1xuICAgICAgdmFsdWU6IHdlYmFwcERlcGxveS5kZXBsb3lGbi5mdW5jdGlvbkFybixcbiAgICB9KVxuICAgIG5ldyBjZGsuQ2ZuT3V0cHV0KHRoaXMsIFwiUm9sZUFybk91dHB1dFwiLCB7XG4gICAgICB2YWx1ZTogcm9sZVRvQmVBc3N1bWVkRm9yRGVwbG95LnJvbGVBcm4sXG4gICAgfSlcbiAgfVxufVxuIl19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liflig/cdk",
-  "version": "2.18.5",
+  "version": "2.18.7",
   "description": "CDK library for Liflig",
   "repository": {
     "type": "git",
@@ -35,7 +35,8 @@
   },
   "overrides": {
     "semantic-release": {
-      "@semantic-release/npm": "11.0.1"
+      "@semantic-release/npm": "10.0.6",
+      "@semantic-release/github": "9.2.5"
     }
   },
   "devDependencies": {
@@ -57,7 +58,7 @@
     "jest": "29.7.0",
     "jest-cdk-snapshot": "2.0.1",
     "prettier": "3.1.1",
-    "semantic-release": "22.0.8",
+    "semantic-release": "22.0.12",
     "ts-jest": "29.1.1",
     "ts-node": "10.9.2",
     "typescript": "5.3.3"