@inizioevoke/evosynth 1.8.1 → 2.0.0

package/dist/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { evosynth } from './evosynth.js';
+program
+    .name('evosynth')
+    .description('CDK utility')
+    .version('2.0.0')
+    .option('--profile <profile>', 'The AWS profile');
+// program
+//   .command('bootstrap')
+//   .action(bootstrap);
+['deploy', 'destroy', 'diff', 'drift', 'rollback', 'synth']
+    .forEach((cmd) => {
+    program.command(`${cmd} <env>`).action(action);
+});
+program.parse();
+// async function bootstrap(options: Record<string, string>, command: Command) {
+//   await evosynth('bootstrap', )
+// }
+async function action(env, options, command) {
+    await evosynth(command.name(), env, program.opts());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cli/evosynth.d.ts

@@ -0,0 +1,17 @@
+import type { EvosynthTagKey } from '../types.js';
+import { WebStaticServerlessAppConfig } from './web-static-serverless.js';
+export { WebStaticServerlessAppConfig };
+export type EnvironmentType = 'dev' | 'test' | 'stage' | 'uat' | 'preprod' | 'prod' | (string & {});
+export type CdkCommand = 'deploy' | 'destroy' | 'diff' | 'drift' | 'rollback' | 'synth';
+export type EvosynthAppType = 'str8r-clm' | 'web-static-serverless';
+export interface EvosynthAppConfig {
+    type: EvosynthAppType;
+    envType?: EnvironmentType;
+    name: string;
+    region: 'us-east-1' | 'us-east-2' | 'us-west-1' | 'us-west-2' | (string & {});
+    tags?: Record<EvosynthTagKey, string>;
+}
+export interface EvosynthProps {
+    profile?: string;
+}
+export declare function evosynth(cmd: CdkCommand, env: string, props: EvosynthProps): Promise<void>;

package/dist/cli/evosynth.js

@@ -0,0 +1,61 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { runWebStaticServerlessApp } from './web-static-serverless.js';
+export async function evosynth(cmd, env, props) {
+    const files = await readdir(process.cwd(), { withFileTypes: true });
+    const configFiles = files
+        .filter((dirent) => {
+        if (dirent.isFile()) {
+            return /^\.evosynth(.*?)\.(?:js|mjs|ts|mts)$/i.test(dirent.name);
+        }
+        else {
+            return false;
+        }
+    })
+        .map((dirent) => {
+        const parts = dirent.name.split('.').filter(p => p !== '');
+        return {
+            name: dirent.name,
+            env: parts.length > 2 ? parts[1] : undefined,
+            dir: dirent.parentPath
+        };
+    });
+    let configIndex = configFiles.findIndex(c => c.env && env && c.env.toLowerCase() === env.toLowerCase());
+    if (configIndex === -1) {
+        configIndex = configFiles.findIndex(c => c.env === undefined);
+    }
+    if (configIndex != -1) {
+        const configFile = configFiles[configIndex];
+        const module = await import(__rewriteRelativeImportExtension(pathToFileURL(join(configFile.dir, configFile.name)).toString()));
+        let config = undefined;
+        if (configFile.env) {
+            config = module.default;
+        }
+        else {
+            config = module[env]?.();
+        }
+        if (config) {
+            if (props.profile) {
+                process.env.AWS_PROFILE = props.profile;
+            }
+            switch (config.type) {
+                case 'web-static-serverless':
+                    await runWebStaticServerlessApp(cmd, config);
+                    break;
+            }
+        }
+    }
+    else {
+        console.error('evosynth config not found!');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export * from './evosynth.js';
+export * from './web-static-serverless.js';

package/dist/cli/index.js

@@ -0,0 +1,3 @@
+export * from './evosynth.js';
+export * from './web-static-serverless.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2V2b3N5bnRoLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vd2ViLXN0YXRpYy1zZXJ2ZXJsZXNzLmpzJzsiXX0=

package/dist/cli/web-static-serverless.d.ts

@@ -0,0 +1,52 @@
+import { ResponseHeadersPolicyProps } from 'aws-cdk-lib/aws-cloudfront';
+import { IBuildImage } from 'aws-cdk-lib/aws-codebuild';
+import { CloudFrontFunctionRedirects } from '../constructs/cloudfront.js';
+import { CodeBuildImageId, EcrBuildImage, CodeBuildSsmParameter, CodeBuildComputeType, CodeBuildNodeJs, EnvironmentVariables } from '../constructs/codebuild.ts';
+import type { EvosynthAppConfig, CdkCommand, EvosynthAppType } from './evosynth.ts';
+import type { CloudFrontFunctionEventType, CspHeaders, UUID, AWSManagedResponseHeadersPolicy } from '../types.d.ts';
+export interface WebStaticServerlessAppConfig extends EvosynthAppConfig {
+    type: Extract<EvosynthAppType, 'web-static-serverless'>;
+    description?: string;
+    dns: {
+        record: string;
+        zone: string;
+    };
+    security?: {
+        basicAuth?: string;
+        basicAuthParam?: string;
+        webAcl?: string | false;
+        webAclParam?: string;
+    };
+    cloudfront?: {
+        responseHeaders?: AWSManagedResponseHeadersPolicy | UUID | false;
+        responseHeadersParam?: string;
+        responseHeadersPolicy?: ResponseHeadersPolicyProps;
+        cspHeaders?: CspHeaders;
+        redirects?: CloudFrontFunctionRedirects;
+        function?: string | {
+            code: string;
+            eventType: CloudFrontFunctionEventType[];
+        };
+    };
+    pipeline?: {
+        source: {
+            codestarConnection?: string;
+            codestarConnectionParam?: string;
+            owner: 'evokegroup' | 'meltmedia' | (string & {});
+            repo: string;
+            branch: string;
+            fullClone?: boolean;
+        };
+        build?: {
+            buildSpec?: string | object;
+            buildImage?: IBuildImage;
+            buildImageEcr?: EcrBuildImage;
+            buildImageNodeJS?: CodeBuildNodeJs;
+            buildImageId?: CodeBuildImageId;
+            computeType?: CodeBuildComputeType;
+            environmentVariables?: EnvironmentVariables;
+            ssmParameters?: CodeBuildSsmParameter[];
+        };
+    };
+}
+export declare function runWebStaticServerlessApp(cmd: CdkCommand, config: WebStaticServerlessAppConfig): Promise<void>;

package/dist/cli/web-static-serverless.js

@@ -0,0 +1,73 @@
+import { join } from 'node:path';
+import * as core from 'aws-cdk-lib/core';
+import { Toolkit } from '@aws-cdk/toolkit-lib';
+import { getEnv } from '../index.js';
+import { WebStaticServerlessStage } from '../stages/web-static-serverless-stage.js';
+const cdk = new Toolkit();
+export async function runWebStaticServerlessApp(cmd, config) {
+    const cx = await cdk.fromAssemblyBuilder(async (props) => {
+        const app = new core.App({
+            outdir: join(process.cwd(), '.evosynth'),
+        });
+        const stageProps = {
+            env: getEnv(config.region),
+            stageName: `${config.name}${config.envType ? `-${config.envType}` : ''}`,
+            tags: config.tags,
+            envType: config.envType === 'prod' ? 'PROD' : 'NOT_PROD',
+            description: `${config.description}${config.envType ? ` ${config.envType.toUpperCase()}` : ''}`,
+            hostedZone: config.dns.zone,
+            domainName: `${config.dns.record}.${config.dns.zone}`,
+            basicAuth: config.security?.basicAuthParam ? { path: config.security?.basicAuthParam } : config.security?.basicAuth,
+            webAcl: config.security?.webAclParam ? { path: config.security.webAclParam } : config.security?.webAcl,
+            redirects: config.cloudfront?.redirects,
+            responseCspHeaders: config.cloudfront?.cspHeaders,
+            responseHeadersPolicy: config.cloudfront?.responseHeadersParam ? { path: config.cloudfront.responseHeadersParam } : config.cloudfront?.responseHeaders,
+            responseHeadersPolicyProps: config.cloudfront?.responseHeadersPolicy,
+            cloudfrontFunction: config.cloudfront?.function && typeof config.cloudfront.function == 'string' ? {
+                code: config.cloudfront.function,
+                eventType: ['VIEWER_REQUEST', 'VIEWER_RESPONSE'],
+            } : config.cloudfront?.function
+        };
+        if (config.pipeline) {
+            stageProps.pipeline = {
+                sourceStage: {
+                    codestarConnection: config.pipeline.source.codestarConnectionParam ? { path: config.pipeline.source.codestarConnectionParam } : config.pipeline.source.codestarConnection,
+                    repoOwner: config.pipeline.source.owner,
+                    repo: config.pipeline.source.repo,
+                    branch: config.pipeline.source.branch,
+                    fullClone: config.pipeline.source.fullClone
+                }
+            };
+            if (config.pipeline.build) {
+                stageProps.pipeline.buildStage = {
+                    environmentVariables: config.pipeline.build.environmentVariables
+                };
+                stageProps.pipeline.codeBuildProject = {
+                    buildImage: config.pipeline.build.buildImage,
+                    buildImageId: config.pipeline.build.buildImageId,
+                    buildImageNodeJS: config.pipeline.build.buildImageNodeJS,
+                    buildSpec: config.pipeline.build.buildSpec,
+                    computeType: config.pipeline.build.computeType,
+                    ecrBuildImage: config.pipeline.build.buildImageEcr,
+                    ssmParameters: config.pipeline.build.ssmParameters
+                };
+            }
+        }
+        new WebStaticServerlessStage(app, config.type, stageProps);
+        return app.synth();
+    });
+    switch (cmd) {
+        // case 'bootstrap':
+        //   await cdk.bootstrap(BootstrapEnvironments.fromList([`aws://${process.env.CDK_DEFAULT_ACCOUNT}/${config.region}`]));
+        //   break;
+        case 'deploy':
+        case 'destroy':
+        case 'diff':
+        case 'drift':
+        case 'rollback':
+        case 'synth':
+            await cdk[cmd](cx);
+            break;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-static-serverless.js","sourceRoot":"","sources":["../../src/cli/web-static-serverless.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from 'node:path';\nimport * as core from 'aws-cdk-lib/core';\nimport { BootstrapEnvironments, ICloudAssemblySource, Toolkit } from '@aws-cdk/toolkit-lib';\nimport { ResponseHeadersPolicyProps } from 'aws-cdk-lib/aws-cloudfront';\nimport { IBuildImage } from 'aws-cdk-lib/aws-codebuild';\nimport { CloudFrontFunctionRedirects } from '../constructs/cloudfront.js';\nimport { CodeBuildImageId, EcrBuildImage, CodeBuildSsmParameter, CodeBuildComputeType, CodeBuildNodeJs, EnvironmentVariables } from '../constructs/codebuild.ts';\nimport type { EvosynthAppConfig, CdkCommand, EvosynthAppType } from './evosynth.ts';\nimport type { CloudFrontFunctionEventType, CspHeaders, UUID, AWSManagedResponseHeadersPolicy } from '../types.d.ts';\nimport { getEnv } from '../index.js';\nimport { WebStaticServerlessStage, WebStaticServerlessStageProps } from '../stages/web-static-serverless-stage.js';\n\nconst cdk = new Toolkit();\n\nexport interface WebStaticServerlessAppConfig extends EvosynthAppConfig {\n  type: Extract<EvosynthAppType, 'web-static-serverless'>,\n  description?: string;\n  dns: {\n    record: string;\n    zone: string;\n  },\n  security?: {\n    basicAuth?: string;\n    basicAuthParam?: string;\n    webAcl?: string | false;\n    webAclParam?: string;\n  },\n  cloudfront?: {\n    responseHeaders?: AWSManagedResponseHeadersPolicy | UUID | false;\n    responseHeadersParam?: string;\n    responseHeadersPolicy?: ResponseHeadersPolicyProps;\n    cspHeaders?: CspHeaders;\n    redirects?: CloudFrontFunctionRedirects;\n    function?: string | {\n      code: string;\n      eventType: CloudFrontFunctionEventType[];\n    }\n  },\n  pipeline?: {\n    source: {\n      codestarConnection?: string;\n      codestarConnectionParam?: string;\n      owner: 'evokegroup' | 'meltmedia' | (string & {});\n      repo: string;\n      branch: string;\n      fullClone?: boolean;\n    },\n    build?: {\n      buildSpec?: string | object;\n      buildImage?: IBuildImage;\n      buildImageEcr?: EcrBuildImage;\n      buildImageNodeJS?: CodeBuildNodeJs;\n      buildImageId?: CodeBuildImageId;\n      computeType?: CodeBuildComputeType;\n      environmentVariables?: EnvironmentVariables;\n      ssmParameters?: CodeBuildSsmParameter[]\n    }\n  }\n}\n\nexport async function runWebStaticServerlessApp(cmd: CdkCommand, config: WebStaticServerlessAppConfig) {\n  const cx = await cdk.fromAssemblyBuilder(async (props) => {\n    const app = new core.App({\n      outdir: join(process.cwd(), '.evosynth'),\n    });\n\n    const stageProps: WebStaticServerlessStageProps & core.StageProps = {\n      env: getEnv(config.region),\n      stageName: `${config.name}${config.envType ? `-${config.envType}` : ''}`,\n      tags: config.tags,\n      envType: config.envType === 'prod' ? 'PROD' : 'NOT_PROD',\n      description: `${config.description}${config.envType ? ` ${config.envType.toUpperCase()}` : ''}`,\n      hostedZone: config.dns.zone,\n      domainName: `${config.dns.record}.${config.dns.zone}`,\n      basicAuth: config.security?.basicAuthParam ? { path: config.security?.basicAuthParam } : config.security?.basicAuth,\n      webAcl: config.security?.webAclParam ? { path: config.security.webAclParam } : config.security?.webAcl,\n      redirects: config.cloudfront?.redirects,\n      responseCspHeaders: config.cloudfront?.cspHeaders,\n      responseHeadersPolicy: config.cloudfront?.responseHeadersParam ? { path: config.cloudfront.responseHeadersParam } : config.cloudfront?.responseHeaders,\n      responseHeadersPolicyProps: config.cloudfront?.responseHeadersPolicy,\n      cloudfrontFunction: config.cloudfront?.function && typeof config.cloudfront.function == 'string' ? {\n        code: config.cloudfront.function,\n        eventType: ['VIEWER_REQUEST','VIEWER_RESPONSE'],\n      } : config.cloudfront?.function as any\n    }\n    if (config.pipeline) {\n      stageProps.pipeline = {\n        sourceStage: {\n          codestarConnection: config.pipeline.source.codestarConnectionParam ? { path: config.pipeline.source.codestarConnectionParam } : config.pipeline.source.codestarConnection as string,\n          repoOwner: config.pipeline.source.owner,\n          repo: config.pipeline.source.repo,\n          branch: config.pipeline.source.branch,\n          fullClone: config.pipeline.source.fullClone\n        }\n      }\n      if (config.pipeline.build) {\n        stageProps.pipeline.buildStage = {\n          environmentVariables: config.pipeline.build.environmentVariables\n        };\n        stageProps.pipeline.codeBuildProject = {\n          buildImage: config.pipeline.build.buildImage,\n          buildImageId: config.pipeline.build.buildImageId,\n          buildImageNodeJS: config.pipeline.build.buildImageNodeJS,\n          buildSpec: config.pipeline.build.buildSpec,\n          computeType: config.pipeline.build.computeType,\n          ecrBuildImage: config.pipeline.build.buildImageEcr,\n          ssmParameters: config.pipeline.build.ssmParameters\n        };\n      }\n    }\n\n    new WebStaticServerlessStage(app, config.type, stageProps);\n\n    return app.synth();\n  });\n\n  switch (cmd) {\n    // case 'bootstrap':\n    //   await cdk.bootstrap(BootstrapEnvironments.fromList([`aws://${process.env.CDK_DEFAULT_ACCOUNT}/${config.region}`]));\n    //   break;\n    case 'deploy':\n    case 'destroy':\n    case 'diff':\n    case 'drift':\n    case 'rollback':\n    case 'synth':\n      await cdk[cmd](cx);\n      break;\n  }\n}\n"]}

package/dist/constructs/codebuild.d.ts

@@ -6,7 +6,14 @@ export type EnvironmentVariables = Record<string, {
     value: any;
     type?: BuildEnvironmentVariableType;
 }>;
-interface SsmParameter extends SsmStringParameter {
+export type CodeBuildImageId = 'aws/codebuild/amazonlinux2-aarch64-standard:1.0' | 'aws/codebuild/amazonlinux2-x86_64-standard:2.0' | 'aws/codebuild/amazonlinux2-x86_64-standard:3.0' | 'aws/codebuild/amazonlinux-x86_64-standard:4.0' | 'aws/codebuild/amazonlinux-x86_64-standard:5.0' | 'aws/codebuild/amazonlinux-x86_64-standard:6.0' | 'aws/codebuild/amazonlinux-x86_64-standard:corretto8' | 'aws/codebuild/amazonlinux-x86_64-standard:corretto11' | 'aws/codebuild/amazonlinux-aarch64-standard:2.0' | 'aws/codebuild/amazonlinux-aarch64-standard:3.0' | 'aws/codebuild/standard:3.0' | 'aws/codebuild/standard:4.0' | 'aws/codebuild/standard:5.0' | // nodejs 12, 14
+'aws/codebuild/standard:6.0' | // nodejs 16
+'aws/codebuild/standard:7.0' | // nodejs 18, 20, 22, 24
+'aws/codebuild/standard:8.0' | // nodejs 22, 24
+'aws/codebuild/windows-base:2019-1.0' | 'aws/codebuild/windows-base:2019-2.0' | 'aws/codebuild/windows-base:2019-3.0' | 'aws/codebuild/windows-base:2022-1.0' | (string & {});
+export type CodeBuildComputeType = 'SMALL' | 'MEDIUM' | 'LARGE' | 'X_LARGE' | 'X2_LARGE' | (string & {});
+export type CodeBuildNodeJs = 12 | 14 | 16 | 18 | 20 | 22 | 24 | (number & {});
+export interface CodeBuildSsmParameter extends SsmStringParameter {
     encrypted?: boolean;
 }
 export interface EcrBuildImage {
@@ -16,16 +23,17 @@ export interface EcrBuildImage {
 export interface CodeBuildPipelineProjectProps extends ResourceProps {
     projectName?: string;
     buildSpec?: string | object;
-    buildImage?: ('STANDARD_5_0' | 'STANDARD_6_0' | 'STANDARD_7_0') | IBuildImage;
     ecrBuildImage?: EcrBuildImage;
-    computeType?: ('SMALL' | 'MEDIUM' | 'LARGE' | 'X_LARGE' | 'X2_LARGE') | string;
+    buildImage?: IBuildImage;
+    buildImageNodeJS?: CodeBuildNodeJs;
+    buildImageId?: CodeBuildImageId;
+    computeType?: CodeBuildComputeType;
     environmentVariables?: EnvironmentVariables;
     cloudFrontDistributionArn?: string;
     s3BucketName?: string;
-    ssmParameters?: SsmParameter[];
+    ssmParameters?: CodeBuildSsmParameter[];
 }
 export declare class CodeBuildPipelineProject extends Construct {
     readonly project: PipelineProject;
     constructor(scope: Construct, id: string, props: CodeBuildPipelineProjectProps);
 }
-export {};

package/dist/constructs/codebuild.js

@@ -31,12 +31,27 @@ export class CodeBuildPipelineProject extends Construct {
             buildImage = LinuxBuildImage.fromEcrRepository(repository, props.ecrBuildImage.tag);
         }
         else if (props.buildImage) {
-            if (typeof props.buildImage == 'string') {
-                buildImage = LinuxBuildImage[props.buildImage ?? 'STANDARD_7_0'];
-            }
-            else {
-                buildImage = props.buildImage;
+            buildImage = props.buildImage;
+        }
+        else if (props.buildImageNodeJS) {
+            let standard = 8;
+            switch (props.buildImageNodeJS) {
+                case 12:
+                case 14:
+                    standard = 5;
+                    break;
+                case 16:
+                    standard = 6;
+                    break;
+                case 18:
+                case 20:
+                    standard = 7;
+                    break;
             }
+            buildImage = LinuxBuildImage.fromCodeBuildImageId(`aws/codebuild/standard:${standard}.0`);
+        }
+        else if (props.buildImageId) {
+            buildImage = LinuxBuildImage.fromCodeBuildImageId(props.buildImageId);
         }
         this.project = new PipelineProject(this, 'CodeBuildPipelineProjectProps', {
             projectName: props.projectName,
@@ -96,4 +111,4 @@ export class CodeBuildPipelineProject extends Construct {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codebuild.js","sourceRoot":"","sources":["../../src/constructs/codebuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAgC,SAAS,EAAE,WAAW,EAAe,eAAe,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAChJ,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAoB,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAwB7C,MAAM,OAAO,wBAAyB,SAAQ,SAAS;IACrC,OAAO,CAAkB;IAEzC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAoC;QAC5E,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,KAAK,CAAC,oBAAoB,EAAE,CAAC;YAChC,KAAK,CAAC,oBAAoB,GAAG,EAAE,CAAC;QAClC,CAAC;QACD,IAAI,KAAK,CAAC,yBAAyB,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,0BAA0B,EAAE,CAAC;YAC9F,KAAK,CAAC,oBAAoB,CAAC,0BAA0B,GAAG;gBACtD,KAAK,EAAE,KAAK,CAAC,yBAAyB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE;aACxD,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,cAAc,EAAE,CAAC;YACrE,KAAK,CAAC,oBAAoB,CAAC,cAAc,GAAG;gBAC1C,KAAK,EAAE,KAAK,CAAC,YAAY;aAC1B,CAAC;QACJ,CAAC;QAED,IAAI,UAAU,GAA4B,SAAS,CAAC;QACpD,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;YACxB,MAAM,UAAU,GAAG,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC;gBACvE,UAAU,CAAC,iBAAiB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC;gBACrF,UAAU,CAAC,kBAAkB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YACvF,UAAU,GAAG,eAAe,CAAC,iBAAiB,CAAC,UAAU,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QACtF,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YAC5B,IAAI,OAAO,KAAK,CAAC,UAAU,IAAI,QAAQ,EAAE,CAAC;gBACxC,UAAU,GAAG,eAAe,CAAC,KAAK,CAAC,UAAU,IAAI,cAAc,CAAC,CAAA;YAClE,CAAC;iBAAM,CAAC;gBACN,UAAU,GAAG,KAAK,CAAC,UAAyB,CAAC;YAC/C,CAAC;QACH,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,CAAC,IAAI,EAAE,+BAA+B,EAAE;YACxE,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,SAAS,IAAI,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,kBAAkB,CAAC,KAAK,CAAC,SAAS,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC,SAAS;YAC5L,WAAW,EAAE;gBACX,UAAU,EAAE,UAAU,IAAI,eAAe,CAAC,YAAY;gBACtD,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,WAAqD,IAAI,OAAO,CAAC;gBAChG,oBAAoB,EAAE,KAAK,CAAC,oBAAoB;aACjD;SACF,CAAC,CAAC;QACH,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,OAAO,KAAK,CAAC,OAAO,IAAI,SAAS,EAAE,CAAC;YACtC,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAChG,CAAC;QAED,iCAAiC;QACjC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,eAAe,CAAC;YAC/C,OAAO,EAAE;gBACP,qBAAqB;gBACrB,sBAAsB;gBACtB,mBAAmB;aACpB;YACD,SAAS,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;SACrC,CAAC,CAAC,CAAC;QAEJ,8CAA8C;QAC9C,IAAI,KAAK,CAAC,yBAAyB,EAAE,CAAC;YACpC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,eAAe,CAAC;gBAC/C,OAAO,EAAE,CAAC,+BAA+B,CAAC;gBAC1C,SAAS,EAAE,CAAC,KAAK,CAAC,yBAAyB,CAAC;aAC7C,CAAC,CAAC,CAAC;QACN,CAAC;QAED,wCAAwC;QACxC,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YACvB,MAAM,QAAQ,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;YACnF,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxC,CAAC;QAED,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;YACxB,QAAQ;YACR,KAAK,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC3D,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnD,CAAC,CAAC,CAAC;YACH,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;gBACxC,IAAI,QAA0B,CAAC;gBAC/B,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;oBACpB,QAAQ,GAAG,eAAe,CAAC,mCAAmC,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE;wBAC/E,aAAa,EAAE,KAAK,CAAC,IAAI;wBACzB,OAAO,EAAE,KAAK,CAAC,OAAO;qBACvB,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,QAAQ,GAAG,eAAe,CAAC,6BAA6B,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE;wBACzE,aAAa,EAAE,KAAK,CAAC,IAAI;wBACzB,OAAO,EAAE,KAAK,CAAC,OAAO;qBACvB,CAAC,CAAC;gBACL,CAAC;gBACD,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;QACH,CAAC;IACH,CAAC;CACF","sourcesContent":["import { RemovalPolicy } from \"aws-cdk-lib\";\nimport { Construct } from 'constructs';\nimport { BuildEnvironmentVariableType, BuildSpec, ComputeType, IBuildImage, LinuxBuildImage, PipelineProject } from 'aws-cdk-lib/aws-codebuild';\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Bucket } from 'aws-cdk-lib/aws-s3';\nimport { IStringParameter, StringParameter } from 'aws-cdk-lib/aws-ssm';\nimport type { SsmStringParameter } from \"./ssm.ts\";\nimport { tagResource } from \"../lib/tags.js\";\nimport type { ResourceProps } from \"../types.d.ts\";\n\nexport type EnvironmentVariables = Record<string, { value: any, type?: BuildEnvironmentVariableType }>;\n\ninterface SsmParameter extends SsmStringParameter {\n  encrypted?: boolean;\n}\nexport interface EcrBuildImage {\n  repository: string;\n  tag: string;\n}\nexport interface CodeBuildPipelineProjectProps extends ResourceProps {\n  projectName?: string;\n  buildSpec?: string | object;\n  buildImage?: ('STANDARD_5_0' | 'STANDARD_6_0' | 'STANDARD_7_0') | IBuildImage;\n  ecrBuildImage?: EcrBuildImage,\n  computeType?: ('SMALL' | 'MEDIUM' | 'LARGE' | 'X_LARGE' | 'X2_LARGE') | string;\n  environmentVariables?: EnvironmentVariables;\n  cloudFrontDistributionArn?: string;\n  s3BucketName?: string;\n  ssmParameters?: SsmParameter[];\n}\n\nexport class CodeBuildPipelineProject extends Construct {\n  public readonly project: PipelineProject;\n\n  constructor(scope: Construct, id: string, props: CodeBuildPipelineProjectProps) {\n    super(scope, id);\n\n    if (!props.environmentVariables) {\n      props.environmentVariables = {};\n    }\n    if (props.cloudFrontDistributionArn && !props.environmentVariables.CLOUDFRONT_DISTRIBUTION_ID) {\n      props.environmentVariables.CLOUDFRONT_DISTRIBUTION_ID = {\n        value: props.cloudFrontDistributionArn.split('/').pop()\n      };\n    }\n\n    if (props.s3BucketName && !props.environmentVariables.S3_BUCKET_NAME) {\n      props.environmentVariables.S3_BUCKET_NAME = {\n        value: props.s3BucketName\n      };\n    }\n\n    let buildImage: IBuildImage | undefined = undefined;\n    if (props.ecrBuildImage) {\n      const repository = props.ecrBuildImage.repository.startsWith('arn:aws') ? \n        Repository.fromRepositoryArn(this, 'EcrRepository', props.ecrBuildImage.repository) :\n        Repository.fromRepositoryName(this, 'EcrRepository', props.ecrBuildImage.repository);\n      buildImage = LinuxBuildImage.fromEcrRepository(repository, props.ecrBuildImage.tag);\n    } else if (props.buildImage) {\n      if (typeof props.buildImage == 'string') {\n        buildImage = LinuxBuildImage[props.buildImage ?? 'STANDARD_7_0']\n      } else {\n        buildImage = props.buildImage as IBuildImage;\n      }\n    }\n\n    this.project = new PipelineProject(this, 'CodeBuildPipelineProjectProps', {\n      projectName: props.projectName,\n      buildSpec: props.buildSpec ? typeof props.buildSpec == 'object' ? BuildSpec.fromObjectToYaml(props.buildSpec) : BuildSpec.fromSourceFilename(props.buildSpec ?? 'buildspec.yml') : undefined,\n      environment: {\n        buildImage: buildImage ?? LinuxBuildImage.STANDARD_7_0,\n        computeType: ComputeType[props.computeType as (keyof typeof ComputeType | undefined) ?? 'SMALL'],\n        environmentVariables: props.environmentVariables\n      }\n    });\n    tagResource(this.project, props.tags);\n    if (typeof props.destroy == 'boolean') {\n      this.project.applyRemovalPolicy(props.destroy ? RemovalPolicy.DESTROY : RemovalPolicy.RETAIN);\n    }\n\n    // Add CloudWatch log permissions\n    this.project.addToRolePolicy(new PolicyStatement({\n      actions: [\n        'logs:CreateLogGroup',\n        'logs:CreateLogStream',\n        'logs:PutLogEvents'\n      ],\n      resources: [this.project.projectArn]\n    }));\n\n    // Allow the project to create an invalidation\n    if (props.cloudFrontDistributionArn) {\n      this.project.addToRolePolicy(new PolicyStatement({\n        actions: ['cloudfront:CreateInvalidation'],\n        resources: [props.cloudFrontDistributionArn]\n      }));\n    }\n\n    // Allow the project to sync files to S3\n    if (props.s3BucketName) {\n      const s3Bucket = Bucket.fromBucketName(this, 'S3BucketByName', props.s3BucketName);\n      s3Bucket.grantReadWrite(this.project);\n    }\n\n    if (props.ssmParameters) {\n      // dedup\n      props.ssmParameters = props.ssmParameters.filter((v, i, a) => {\n        return a.findIndex(p => p.path === v.path) === i;\n      });\n      for (const param of props.ssmParameters) {\n        let strParam: IStringParameter;\n        if (param.encrypted) {\n          strParam = StringParameter.fromSecureStringParameterAttributes(this, param.path, {\n            parameterName: param.path,\n            version: param.version\n          });\n        } else {\n          strParam = StringParameter.fromStringParameterAttributes(this, param.path, {\n            parameterName: param.path,\n            version: param.version\n          });\n        }\n        strParam.grantRead(this.project);\n      }\n    }\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codebuild.js","sourceRoot":"","sources":["../../src/constructs/codebuild.ts"],"names":[],"mappings":"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","sourcesContent":["import { RemovalPolicy } from \"aws-cdk-lib\";\nimport { Construct } from 'constructs';\nimport { BuildEnvironmentVariableType, BuildSpec, ComputeType, IBuildImage, LinuxBuildImage, PipelineProject } from 'aws-cdk-lib/aws-codebuild';\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Bucket } from 'aws-cdk-lib/aws-s3';\nimport { IStringParameter, StringParameter } from 'aws-cdk-lib/aws-ssm';\nimport type { SsmStringParameter } from \"./ssm.ts\";\nimport { tagResource } from \"../lib/tags.js\";\nimport type { ResourceProps } from \"../types.d.ts\";\n\nexport type EnvironmentVariables = Record<string, { value: any, type?: BuildEnvironmentVariableType }>;\n\nexport type CodeBuildImageId = \n  'aws/codebuild/amazonlinux2-aarch64-standard:1.0' | \n  'aws/codebuild/amazonlinux2-x86_64-standard:2.0' |\n  'aws/codebuild/amazonlinux2-x86_64-standard:3.0' |\n  'aws/codebuild/amazonlinux-x86_64-standard:4.0' |\n  'aws/codebuild/amazonlinux-x86_64-standard:5.0' |\n  'aws/codebuild/amazonlinux-x86_64-standard:6.0' |\n  'aws/codebuild/amazonlinux-x86_64-standard:corretto8' |\n  'aws/codebuild/amazonlinux-x86_64-standard:corretto11' |\n  'aws/codebuild/amazonlinux-aarch64-standard:2.0' |\n  'aws/codebuild/amazonlinux-aarch64-standard:3.0' |\n  'aws/codebuild/standard:3.0' |\n  'aws/codebuild/standard:4.0' | \n  'aws/codebuild/standard:5.0' | // nodejs 12, 14\n  'aws/codebuild/standard:6.0' | // nodejs 16\n  'aws/codebuild/standard:7.0' | // nodejs 18, 20, 22, 24\n  'aws/codebuild/standard:8.0' | // nodejs 22, 24\n  'aws/codebuild/windows-base:2019-1.0' |\n  'aws/codebuild/windows-base:2019-2.0' |\n  'aws/codebuild/windows-base:2019-3.0' |\n  'aws/codebuild/windows-base:2022-1.0' |\n  (string & {});\n\nexport type CodeBuildComputeType = 'SMALL' | 'MEDIUM' | 'LARGE' | 'X_LARGE' | 'X2_LARGE' | (string & {});\nexport type CodeBuildNodeJs = 12 | 14 | 16 | 18 | 20 | 22 | 24 | (number & {});\n\nexport interface CodeBuildSsmParameter extends SsmStringParameter {\n  encrypted?: boolean;\n}\nexport interface EcrBuildImage {\n  repository: string;\n  tag: string;\n}\nexport interface CodeBuildPipelineProjectProps extends ResourceProps {\n  projectName?: string;\n  buildSpec?: string | object;\n  ecrBuildImage?: EcrBuildImage,\n  buildImage?: IBuildImage;\n  buildImageNodeJS?: CodeBuildNodeJs;\n  buildImageId?: CodeBuildImageId;\n  computeType?: CodeBuildComputeType;\n  environmentVariables?: EnvironmentVariables;\n  cloudFrontDistributionArn?: string;\n  s3BucketName?: string;\n  ssmParameters?: CodeBuildSsmParameter[];\n}\n\nexport class CodeBuildPipelineProject extends Construct {\n  public readonly project: PipelineProject;\n\n  constructor(scope: Construct, id: string, props: CodeBuildPipelineProjectProps) {\n    super(scope, id);\n\n    if (!props.environmentVariables) {\n      props.environmentVariables = {};\n    }\n    if (props.cloudFrontDistributionArn && !props.environmentVariables.CLOUDFRONT_DISTRIBUTION_ID) {\n      props.environmentVariables.CLOUDFRONT_DISTRIBUTION_ID = {\n        value: props.cloudFrontDistributionArn.split('/').pop()\n      };\n    }\n\n    if (props.s3BucketName && !props.environmentVariables.S3_BUCKET_NAME) {\n      props.environmentVariables.S3_BUCKET_NAME = {\n        value: props.s3BucketName\n      };\n    }\n\n    let buildImage: IBuildImage | undefined = undefined;\n    if (props.ecrBuildImage) {\n      const repository = props.ecrBuildImage.repository.startsWith('arn:aws') ? \n        Repository.fromRepositoryArn(this, 'EcrRepository', props.ecrBuildImage.repository) :\n        Repository.fromRepositoryName(this, 'EcrRepository', props.ecrBuildImage.repository);\n      buildImage = LinuxBuildImage.fromEcrRepository(repository, props.ecrBuildImage.tag);\n    } else if (props.buildImage) {\n      buildImage = props.buildImage as IBuildImage;\n    } else if (props.buildImageNodeJS) {\n      let standard = 8;\n      switch (props.buildImageNodeJS) {\n        case 12:\n        case 14:\n          standard = 5;\n          break;\n        case 16:\n          standard = 6;\n          break;\n        case 18:\n        case 20:\n          standard = 7;\n          break;\n      }\n      buildImage = LinuxBuildImage.fromCodeBuildImageId(`aws/codebuild/standard:${standard}.0`);\n    } else if (props.buildImageId) {\n      buildImage = LinuxBuildImage.fromCodeBuildImageId(props.buildImageId);\n    } \n    \n\n    this.project = new PipelineProject(this, 'CodeBuildPipelineProjectProps', {\n      projectName: props.projectName,\n      buildSpec: props.buildSpec ? typeof props.buildSpec == 'object' ? BuildSpec.fromObjectToYaml(props.buildSpec) : BuildSpec.fromSourceFilename(props.buildSpec ?? 'buildspec.yml') : undefined,\n      environment: {\n        buildImage: buildImage ?? LinuxBuildImage.STANDARD_7_0,\n        computeType: ComputeType[props.computeType as (keyof typeof ComputeType | undefined) ?? 'SMALL'],\n        environmentVariables: props.environmentVariables\n      }\n    });\n    tagResource(this.project, props.tags);\n    if (typeof props.destroy == 'boolean') {\n      this.project.applyRemovalPolicy(props.destroy ? RemovalPolicy.DESTROY : RemovalPolicy.RETAIN);\n    }\n\n    // Add CloudWatch log permissions\n    this.project.addToRolePolicy(new PolicyStatement({\n      actions: [\n        'logs:CreateLogGroup',\n        'logs:CreateLogStream',\n        'logs:PutLogEvents'\n      ],\n      resources: [this.project.projectArn]\n    }));\n\n    // Allow the project to create an invalidation\n    if (props.cloudFrontDistributionArn) {\n      this.project.addToRolePolicy(new PolicyStatement({\n        actions: ['cloudfront:CreateInvalidation'],\n        resources: [props.cloudFrontDistributionArn]\n      }));\n    }\n\n    // Allow the project to sync files to S3\n    if (props.s3BucketName) {\n      const s3Bucket = Bucket.fromBucketName(this, 'S3BucketByName', props.s3BucketName);\n      s3Bucket.grantReadWrite(this.project);\n    }\n\n    if (props.ssmParameters) {\n      // dedup\n      props.ssmParameters = props.ssmParameters.filter((v, i, a) => {\n        return a.findIndex(p => p.path === v.path) === i;\n      });\n      for (const param of props.ssmParameters) {\n        let strParam: IStringParameter;\n        if (param.encrypted) {\n          strParam = StringParameter.fromSecureStringParameterAttributes(this, param.path, {\n            parameterName: param.path,\n            version: param.version\n          });\n        } else {\n          strParam = StringParameter.fromStringParameterAttributes(this, param.path, {\n            parameterName: param.path,\n            version: param.version\n          });\n        }\n        strParam.grantRead(this.project);\n      }\n    }\n  }\n}"]}

package/dist/constructs/codepipeline.js

@@ -1,6 +1,6 @@
 import { RemovalPolicy, PhysicalName } from "aws-cdk-lib";
 import { Construct } from 'constructs';
-import { Artifact, Pipeline } from "aws-cdk-lib/aws-codepipeline";
+import { Artifact, Pipeline, PipelineType } from "aws-cdk-lib/aws-codepipeline";
 import { CodeBuildAction, CodeStarConnectionsSourceAction } from "aws-cdk-lib/aws-codepipeline-actions";
 import { Bucket } from 'aws-cdk-lib/aws-s3';
 import { StringParameter } from 'aws-cdk-lib/aws-ssm';
@@ -18,7 +18,8 @@ export class CodePipelineProject extends Construct {
         tagResource(this.s3Bucket, props.tags);
         this.pipeline = new Pipeline(this, 'CodePipelineProject', {
             pipelineName: props.pipelineName,
-            artifactBucket: this.s3Bucket
+            artifactBucket: this.s3Bucket,
+            pipelineType: PipelineType.V2
         });
         tagResource(this.pipeline, props.tags);
         if (typeof props.destroy == 'boolean') {
@@ -60,4 +61,4 @@ export class CodePipelineProject extends Construct {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { Environment } from "aws-cdk-lib";
-export * from './lib/tags.ts';
+export * from './lib/tags.js';
+export * from './cli/index.js';
 interface GetEnvParams {
     account?: number | string;
     region?: string;

package/dist/index.js

@@ -1,4 +1,5 @@
-export * from "./lib/tags.js";
+export * from './lib/tags.js';
+export * from './cli/index.js';
 export function getEnv(env) {
     let account = process.env.CDK_DEFAULT_ACCOUNT || '';
     let region = process.env.CDK_DEFAULT_REGION || 'us-east-1';
@@ -23,4 +24,4 @@ export function getEnv(env) {
     }
     return { account, region };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsY0FBYyxlQUFlLENBQUM7QUFVOUIsTUFBTSxVQUFVLE1BQU0sQ0FBQyxHQUFrRDtJQUN2RSxJQUFJLE9BQU8sR0FBVyxPQUFPLENBQUMsR0FBRyxDQUFDLG1CQUFtQixJQUFJLEVBQUUsQ0FBQztJQUM1RCxJQUFJLE1BQU0sR0FBVyxPQUFPLENBQUMsR0FBRyxDQUFDLGtCQUFrQixJQUFJLFdBQVcsQ0FBQztJQUNuRSxJQUFJLEdBQUcsRUFBRSxDQUFDO1FBQ1IsUUFBUSxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ25CLEtBQUssUUFBUTtnQkFDWCxPQUFPLEdBQUcsR0FBRyxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUN6QixNQUFNO1lBQ1IsS0FBSyxRQUFRO2dCQUNYLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO29CQUN0QixPQUFPLEdBQUcsR0FBRyxDQUFDO2dCQUNoQixDQUFDO3FCQUFNLENBQUM7b0JBQ04sTUFBTSxHQUFHLEdBQUcsQ0FBQztnQkFDZixDQUFDO2dCQUNELE1BQU07WUFDUjtnQkFDRSxPQUFPLEdBQUksR0FBbUIsQ0FBQyxPQUFPLElBQUksRUFBRSxDQUFDO2dCQUM3QyxNQUFNLEdBQUksR0FBbUIsQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDO2dCQUMvQyxNQUFNO1FBQ1YsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBQzdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbnZpcm9ubWVudCB9IGZyb20gXCJhd3MtY2RrLWxpYlwiO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi90YWdzLnRzJztcblxuaW50ZXJmYWNlIEdldEVudlBhcmFtcyB7IFxuICBhY2NvdW50PzogbnVtYmVyIHwgc3RyaW5nO1xuICByZWdpb24/OiBzdHJpbmc7IFxufVxuZXhwb3J0IGZ1bmN0aW9uIGdldEVudihyZWdpb24/OiBzdHJpbmcpOiBFbnZpcm9ubWVudDtcbmV4cG9ydCBmdW5jdGlvbiBnZXRFbnYoYWNjb3VudD86IHN0cmluZyB8IG51bWJlcik6IEVudmlyb25tZW50O1xuZXhwb3J0IGZ1bmN0aW9uIGdldEVudih7IGFjY291bnQsIHJlZ2lvbiB9OiBHZXRFbnZQYXJhbXMpOiBFbnZpcm9ubWVudDtcbmV4cG9ydCBmdW5jdGlvbiBnZXRFbnYoZW52PzogRW52aXJvbm1lbnQpOiBFbnZpcm9ubWVudDtcbmV4cG9ydCBmdW5jdGlvbiBnZXRFbnYoZW52Pzogc3RyaW5nIHwgbnVtYmVyIHwgR2V0RW52UGFyYW1zIHwgRW52aXJvbm1lbnQpIHtcbiAgbGV0IGFjY291bnQ6IHN0cmluZyA9IHByb2Nlc3MuZW52LkNES19ERUZBVUxUX0FDQ09VTlQgfHwgJyc7XG4gIGxldCByZWdpb246IHN0cmluZyA9IHByb2Nlc3MuZW52LkNES19ERUZBVUxUX1JFR0lPTiB8fCAndXMtZWFzdC0xJztcbiAgaWYgKGVudikge1xuICAgIHN3aXRjaCAodHlwZW9mIGVudikge1xuICAgICAgY2FzZSAnbnVtYmVyJzpcbiAgICAgICAgYWNjb3VudCA9IGVudi50b1N0cmluZygpO1xuICAgICAgICBicmVhaztcbiAgICAgIGNhc2UgJ3N0cmluZyc6XG4gICAgICAgIGlmICgvXlxcZCskLy50ZXN0KGVudikpIHtcbiAgICAgICAgICBhY2NvdW50ID0gZW52O1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgIHJlZ2lvbiA9IGVudjtcbiAgICAgICAgfVxuICAgICAgICBicmVhaztcbiAgICAgIGRlZmF1bHQ6XG4gICAgICAgIGFjY291bnQgPSAoZW52IGFzIEVudmlyb25tZW50KS5hY2NvdW50ID8/ICcnO1xuICAgICAgICByZWdpb24gPSAoZW52IGFzIEVudmlyb25tZW50KS5yZWdpb24gPz8gcmVnaW9uO1xuICAgICAgICBicmVhaztcbiAgICB9XG4gIH1cbiAgcmV0dXJuIHsgYWNjb3VudCwgcmVnaW9uIH07XG59Il19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/stacks/web-static-serverless/web-global-stack.d.ts

@@ -1,16 +1,13 @@
 import { Stack, StackProps } from 'aws-cdk-lib/core';
 import { Construct } from 'constructs';
 import { Certificate } from "aws-cdk-lib/aws-certificatemanager";
-import { Distribution, Function, FunctionEventType, IResponseHeadersPolicy, ResponseHeadersPolicyProps } from 'aws-cdk-lib/aws-cloudfront';
+import { Distribution, Function, IResponseHeadersPolicy, ResponseHeadersPolicyProps } from 'aws-cdk-lib/aws-cloudfront';
 import { ARecord, AaaaRecord } from "aws-cdk-lib/aws-route53";
 import { Bucket } from "aws-cdk-lib/aws-s3";
 import { CfnWebACL } from 'aws-cdk-lib/aws-wafv2';
 import { CloudFrontFunctionRedirects } from '../../constructs/cloudfront.js';
 import type { SsmStringParameter } from '../../constructs/ssm.ts';
-import type { BasicAuthCredentials, CspHeaders } from '../../types.d.ts';
-type AWSManagedResponseHeadersPolicy = 'CORS_ALLOW_ALL_ORIGINS' | 'CORS_ALLOW_ALL_ORIGINS_AND_SECURITY_HEADERS' | 'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT' | 'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT_AND_SECURITY_HEADERS' | 'SECURITY_HEADERS';
-type UUID = `${string}-${string}-${string}-${string}-${string}`;
-type CloudFrontFunctionEventType = keyof typeof FunctionEventType;
+import type { BasicAuthCredentials, CspHeaders, CloudFrontFunctionEventType, UUID, AWSManagedResponseHeadersPolicy } from '../../types.d.ts';
 export interface WebGlobalStackProps {
     envType: 'NOT_PROD' | 'PROD';
     description?: string;
@@ -19,8 +16,8 @@ export interface WebGlobalStackProps {
     domainName: string;
     basicAuth?: string | BasicAuthCredentials | SsmStringParameter;
     cloudfrontFunction?: {
-        eventType: CloudFrontFunctionEventType[];
         code: string;
+        eventType: CloudFrontFunctionEventType[];
     };
     redirects?: CloudFrontFunctionRedirects;
     redirectsCsvPath?: string;
@@ -42,4 +39,3 @@ export declare class WebGlobalStack extends Stack {
     readonly aaaaRecord: AaaaRecord;
     constructor(scope: Construct, id: string, props: WebGlobalStackProps & StackProps);
 }
-export {};

package/dist/stacks/web-static-serverless/web-global-stack.js

@@ -93,6 +93,7 @@ export class WebGlobalStack extends Stack {
                 });
             }
         }
+        // TODO: Figure out why the the policy is not getting updated in the CloudFront behavior
         this.responseHeadersPolicy = responseHeadersPolicy;
         const defaultBehavior = {
             origin: S3BucketOrigin.withOriginAccessControl(this.s3Bucket),
@@ -191,4 +192,4 @@ export class WebGlobalStack extends Stack {
         this.aaaaRecord = cfAlias.aaaaRecord;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-global-stack.js","sourceRoot":"","sources":["../../../src/stacks/web-static-serverless/web-global-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack, StackProps, PhysicalName, Duration } from 'aws-cdk-lib/core';\nimport { Construct } from 'constructs';\n\nimport { Certificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport { Distribution, Function, FunctionEventType, IResponseHeadersPolicy, ResponseHeadersPolicyProps, ResponseSecurityHeadersBehavior, BehaviorOptions, ResponseHeadersPolicy, HeadersFrameOption, HeadersReferrerPolicy } from 'aws-cdk-lib/aws-cloudfront';\nimport { ARecord, AaaaRecord } from \"aws-cdk-lib/aws-route53\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { StringParameter } from 'aws-cdk-lib/aws-ssm';\nimport { CfnWebACL } from 'aws-cdk-lib/aws-wafv2';\n\nimport { SSLCertificate } from '../../constructs/certificatemanager.js';\nimport { CloudFrontFunctionRedirects, CloudFrontFunction, CloudFrontDistribution } from '../../constructs/cloudfront.js';\nimport { getHostedZone, CloudFrontAlias } from '../../constructs/route53.js';\nimport { S3Bucket } from '../../constructs/s3.js';\nimport type { SsmStringParameter } from '../../constructs/ssm.ts';\nimport { CloudFrontWebAcl } from '../../constructs/waf.js';\nimport { domainAsId } from '../../lib/utils.js';\nimport { addEvoStackTags } from '../../lib/tags.ts';\nimport { S3BucketOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';\nimport type { BasicAuthCredentials, CspHeaders } from '../../types.d.ts';\n\n\ntype AWSManagedResponseHeadersPolicy = \n  'CORS_ALLOW_ALL_ORIGINS' |\n  'CORS_ALLOW_ALL_ORIGINS_AND_SECURITY_HEADERS' |\n  'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT' |\n  'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT_AND_SECURITY_HEADERS' |\n  'SECURITY_HEADERS';\n\ntype UUID = `${string}-${string}-${string}-${string}-${string}`;\ntype CloudFrontFunctionEventType = keyof typeof FunctionEventType;\n\nexport interface WebGlobalStackProps {\n  envType: 'NOT_PROD' | 'PROD';\n  description?: string;\n  bucketName?: string;\n  hostedZone: string;\n  domainName: string;\n  basicAuth?: string | BasicAuthCredentials | SsmStringParameter;\n  cloudfrontFunction?: {\n    eventType: CloudFrontFunctionEventType[];\n    code: string;\n  }\n  redirects?: CloudFrontFunctionRedirects;\n  redirectsCsvPath?: string;\n  // attachWebAcl?: boolean | string;\n  webAcl?: boolean | string | SsmStringParameter;\n  responseHeadersPolicy?: false | AWSManagedResponseHeadersPolicy | UUID | SsmStringParameter;\n  responseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  responseCspHeaders?: CspHeaders;\n  destroy?: boolean;\n  tags?: Record<string, string>;\n}\n\nexport class WebGlobalStack extends Stack {\n  public readonly sslCertificate: Certificate;\n  public readonly s3Bucket: Bucket;\n  public readonly cloudFrontFunction: Function;\n  public readonly cloudFrontDistribution: Distribution;\n  public readonly webAcl: CfnWebACL | undefined;\n  public readonly responseHeadersPolicy: IResponseHeadersPolicy | undefined;\n  public readonly aRecord: ARecord;\n  public readonly aaaaRecord: AaaaRecord;\n\n  constructor(scope: Construct, id: string, props: WebGlobalStackProps & StackProps) {\n    super(scope, id, props);\n    addEvoStackTags(this, 'WebGlobalStack');\n\n    const hostedZone = getHostedZone(this, 'getHostedZone', props.hostedZone);\n\n    const _sslCert = new SSLCertificate(this, 'SSLCertificate', {\n      hostedZone: hostedZone,\n      domainName: props.domainName,\n      destroy: props.destroy\n    });\n    this.sslCertificate = _sslCert.certificate;\n\n    const _s3Bucket = new S3Bucket(this, 'S3Bucket', {\n      bucketName: props.bucketName ?? PhysicalName.GENERATE_IF_NEEDED,\n      destroy: props.destroy\n    });\n    this.s3Bucket = _s3Bucket.bucket;\n\n    let responseHeadersPolicy: IResponseHeadersPolicy | undefined = undefined;\n    if (props.responseHeadersPolicy) {\n      if (typeof props.responseHeadersPolicy == 'string') {\n        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(props.responseHeadersPolicy)) {\n          responseHeadersPolicy = ResponseHeadersPolicy.fromResponseHeadersPolicyId(this, 'response-headers-policy-by-id', props.responseHeadersPolicy);\n        } else {\n          responseHeadersPolicy = ResponseHeadersPolicy[props.responseHeadersPolicy as keyof typeof ResponseHeadersPolicy] as IResponseHeadersPolicy ?? ResponseHeadersPolicy.SECURITY_HEADERS;\n        }\n      } else if (props.responseHeadersPolicy.path) {\n        responseHeadersPolicy = ResponseHeadersPolicy.fromResponseHeadersPolicyId(this, 'response-headers-policy-by-id', StringParameter.valueForStringParameter(this, props.responseHeadersPolicy.path, props.responseHeadersPolicy.version));\n      }\n    } else {\n      const baseHeadersBehavior: ResponseSecurityHeadersBehavior = {\n        strictTransportSecurity: {\n          override: true,\n          accessControlMaxAge: Duration.seconds(31536000)\n        },\n        contentTypeOptions: {\n          override: true\n        },\n        frameOptions: {\n          override: true,\n          frameOption: HeadersFrameOption.SAMEORIGIN,\n        },\n        referrerPolicy: {\n          override: true,\n          referrerPolicy: HeadersReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN\n        },\n        xssProtection: {\n          override: true,\n          protection: true,\n          modeBlock: true\n        }\n      };\n\n      const responseHeadersPolicyName = `${domainAsId(props.domainName)}-response-headers-policy`;\n      \n      if (props.responseHeadersPolicyProps) {\n        responseHeadersPolicy = new ResponseHeadersPolicy(this, 'response-headers-policy', {\n          ...baseHeadersBehavior,\n          ...props.responseHeadersPolicyProps,\n          responseHeadersPolicyName: props.responseHeadersPolicyProps.responseHeadersPolicyName || responseHeadersPolicyName\n        });\n      } else if (props.responseCspHeaders) {\n        responseHeadersPolicy = new ResponseHeadersPolicy(this, 'response-headers-policy', {\n          securityHeadersBehavior: {\n            ...baseHeadersBehavior,\n            contentSecurityPolicy: {\n              override: true,\n              contentSecurityPolicy: Object.entries(props.responseCspHeaders).map(([directive, values]) => {\n                return `${directive} ${values.join(' ')};`\n              }).join(' ')\n            },\n          },\n          responseHeadersPolicyName\n        });\n      }\n    }\n    this.responseHeadersPolicy = responseHeadersPolicy;\n\n    const defaultBehavior: BehaviorOptions = {\n      origin: S3BucketOrigin.withOriginAccessControl(this.s3Bucket),\n      functionAssociations: [],\n      responseHeadersPolicy: responseHeadersPolicy ?? props.responseHeadersPolicy !== false ? ResponseHeadersPolicy.SECURITY_HEADERS : undefined\n    };\n\n    let cffn: CloudFrontFunction;\n    if (props.basicAuth) {\n      if (typeof props.basicAuth != 'string') {\n        if ((props.basicAuth as BasicAuthCredentials).user && (props.basicAuth as BasicAuthCredentials).password) {\n          props.basicAuth = Buffer.from(`${(props.basicAuth as BasicAuthCredentials).user}:${(props.basicAuth as BasicAuthCredentials).password}`).toString('base64');\n        } else if ((props.basicAuth as SsmStringParameter).path) {\n          props.basicAuth = StringParameter.valueForStringParameter(this, (props.basicAuth as SsmStringParameter).path, (props.basicAuth as SsmStringParameter).version);\n        } else {\n          props.basicAuth = undefined;\n        }\n      }\n    }\n    if (props.cloudfrontFunction) {\n      cffn = CloudFrontFunction.createFunction(this, null, {\n        credentials: props.basicAuth,\n        redirects: props.redirects,\n        redirectsCsvPath: props.redirectsCsvPath,\n        code: props.cloudfrontFunction.code,\n        destroy: props.destroy\n      });\n    } else if (props.basicAuth) {\n      cffn = CloudFrontFunction.createBasicAuthDefaultDoc(this, {\n        credentials: props.basicAuth,\n        redirects: props.redirects,\n        redirectsCsvPath: props.redirectsCsvPath,\n        destroy: props.destroy\n      });\n    } else {\n      cffn = CloudFrontFunction.createDefaultDoc(this, {\n        redirects: props.redirects,\n        redirectsCsvPath: props.redirectsCsvPath,\n        destroy: props.destroy\n      });\n    }\n    this.cloudFrontFunction = cffn.fn;\n\n    // const eventTypes: CloudFrontFunctionEventType[] = props.cloudfrontFunction?.eventType && props.cloudfrontFunction.eventType.length > 0 ? props.cloudfrontFunction.eventType : ['VIEWER_REQUEST', 'VIEWER_RESPONSE'];\n\n    let eventTypes: CloudFrontFunctionEventType[] = ['VIEWER_REQUEST', 'VIEWER_RESPONSE'];\n    if (Array.isArray(props.cloudfrontFunction?.eventType) && props.cloudfrontFunction.eventType.length > 0) {\n      const ets = props.cloudfrontFunction.eventType\n        .filter((v, i, a) => {\n          return (\n            typeof v == 'string' &&\n            (v === 'VIEWER_REQUEST' || v === 'VIEWER_RESPONSE') &&\n            a.indexOf(v) === i // dedup\n          );\n        });\n      if (ets.length > 0) {\n        eventTypes = ets;\n      }\n    }\n\n    for (const eventType of eventTypes) {\n      defaultBehavior.functionAssociations!.push({\n        eventType: FunctionEventType[eventType],\n        function: this.cloudFrontFunction\n      });\n    }\n    \n    let webAclId: string | undefined = undefined;\n    if (typeof props.webAcl == 'string' && props.webAcl.startsWith('arn:aws')) {\n      webAclId = props.webAcl;\n    } else if ((props.webAcl as SsmStringParameter).path) {\n      webAclId = StringParameter.valueForStringParameter(this, (props.webAcl as SsmStringParameter).path, (props.webAcl as SsmStringParameter).version);\n    } else if (props.webAcl === true) {\n      const waf = new CloudFrontWebAcl(this, 'CloudFrontWebAcl', {\n        name: `${domainAsId(props.domainName)}`,\n        destroy: props.destroy\n      });\n      this.webAcl = waf.acl;\n      webAclId = waf.acl.attrArn;\n    }\n\n    const cfDistribution = new CloudFrontDistribution(this, 'CloudFrontDistribution', {\n      domainName: props.domainName,\n      description: props.description ?? props.domainName,\n      priceClass: props.envType,\n      certificate: this.sslCertificate,\n      defaultBehavior,\n      webAclId\n    });\n    this.cloudFrontDistribution = cfDistribution.distribution;\n\n    const cfAlias = new CloudFrontAlias(this, 'CloudFrontAlias', {\n      distribution: cfDistribution.distribution,\n      domainName: props.domainName,\n      hostedZone: hostedZone\n    });\n    this.aRecord = cfAlias.aRecord;\n    this.aaaaRecord = cfAlias.aaaaRecord;\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-global-stack.js","sourceRoot":"","sources":["../../../src/stacks/web-static-serverless/web-global-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack, StackProps, PhysicalName, Duration } from 'aws-cdk-lib/core';\nimport { Construct } from 'constructs';\n\nimport { Certificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport { Distribution, Function, FunctionEventType, IResponseHeadersPolicy, ResponseHeadersPolicyProps, ResponseSecurityHeadersBehavior, BehaviorOptions, ResponseHeadersPolicy, HeadersFrameOption, HeadersReferrerPolicy } from 'aws-cdk-lib/aws-cloudfront';\nimport { ARecord, AaaaRecord } from \"aws-cdk-lib/aws-route53\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { StringParameter } from 'aws-cdk-lib/aws-ssm';\nimport { CfnWebACL } from 'aws-cdk-lib/aws-wafv2';\n\nimport { SSLCertificate } from '../../constructs/certificatemanager.js';\nimport { CloudFrontFunctionRedirects, CloudFrontFunction, CloudFrontDistribution } from '../../constructs/cloudfront.js';\nimport { getHostedZone, CloudFrontAlias } from '../../constructs/route53.js';\nimport { S3Bucket } from '../../constructs/s3.js';\nimport type { SsmStringParameter } from '../../constructs/ssm.ts';\nimport { CloudFrontWebAcl } from '../../constructs/waf.js';\nimport { domainAsId } from '../../lib/utils.js';\nimport { addEvoStackTags } from '../../lib/tags.ts';\nimport { S3BucketOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';\nimport type { BasicAuthCredentials, CspHeaders, CloudFrontFunctionEventType, UUID, AWSManagedResponseHeadersPolicy } from '../../types.d.ts';\n\nexport interface WebGlobalStackProps {\n  envType: 'NOT_PROD' | 'PROD';\n  description?: string;\n  bucketName?: string;\n  hostedZone: string;\n  domainName: string;\n  basicAuth?: string | BasicAuthCredentials | SsmStringParameter;\n  cloudfrontFunction?: {\n    code: string;\n    eventType: CloudFrontFunctionEventType[];\n  }\n  redirects?: CloudFrontFunctionRedirects;\n  redirectsCsvPath?: string;\n  // attachWebAcl?: boolean | string;\n  webAcl?: boolean | string | SsmStringParameter;\n  responseHeadersPolicy?: false | AWSManagedResponseHeadersPolicy | UUID | SsmStringParameter;\n  responseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  responseCspHeaders?: CspHeaders;\n  destroy?: boolean;\n  tags?: Record<string, string>;\n}\n\nexport class WebGlobalStack extends Stack {\n  public readonly sslCertificate: Certificate;\n  public readonly s3Bucket: Bucket;\n  public readonly cloudFrontFunction: Function;\n  public readonly cloudFrontDistribution: Distribution;\n  public readonly webAcl: CfnWebACL | undefined;\n  public readonly responseHeadersPolicy: IResponseHeadersPolicy | undefined;\n  public readonly aRecord: ARecord;\n  public readonly aaaaRecord: AaaaRecord;\n\n  constructor(scope: Construct, id: string, props: WebGlobalStackProps & StackProps) {\n    super(scope, id, props);\n    addEvoStackTags(this, 'WebGlobalStack');\n\n    const hostedZone = getHostedZone(this, 'getHostedZone', props.hostedZone);\n\n    const _sslCert = new SSLCertificate(this, 'SSLCertificate', {\n      hostedZone: hostedZone,\n      domainName: props.domainName,\n      destroy: props.destroy\n    });\n    this.sslCertificate = _sslCert.certificate;\n\n    const _s3Bucket = new S3Bucket(this, 'S3Bucket', {\n      bucketName: props.bucketName ?? PhysicalName.GENERATE_IF_NEEDED,\n      destroy: props.destroy\n    });\n    this.s3Bucket = _s3Bucket.bucket;\n\n    let responseHeadersPolicy: IResponseHeadersPolicy | undefined = undefined;\n    if (props.responseHeadersPolicy) {\n      if (typeof props.responseHeadersPolicy == 'string') {\n        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(props.responseHeadersPolicy)) {\n          responseHeadersPolicy = ResponseHeadersPolicy.fromResponseHeadersPolicyId(this, 'response-headers-policy-by-id', props.responseHeadersPolicy);\n        } else {\n          responseHeadersPolicy = ResponseHeadersPolicy[props.responseHeadersPolicy as keyof typeof ResponseHeadersPolicy] as IResponseHeadersPolicy ?? ResponseHeadersPolicy.SECURITY_HEADERS;\n        }\n      } else if (props.responseHeadersPolicy.path) {\n        responseHeadersPolicy = ResponseHeadersPolicy.fromResponseHeadersPolicyId(this, 'response-headers-policy-by-id', StringParameter.valueForStringParameter(this, props.responseHeadersPolicy.path, props.responseHeadersPolicy.version));\n      }\n    } else {\n      const baseHeadersBehavior: ResponseSecurityHeadersBehavior = {\n        strictTransportSecurity: {\n          override: true,\n          accessControlMaxAge: Duration.seconds(31536000)\n        },\n        contentTypeOptions: {\n          override: true\n        },\n        frameOptions: {\n          override: true,\n          frameOption: HeadersFrameOption.SAMEORIGIN,\n        },\n        referrerPolicy: {\n          override: true,\n          referrerPolicy: HeadersReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN\n        },\n        xssProtection: {\n          override: true,\n          protection: true,\n          modeBlock: true\n        }\n      };\n\n      const responseHeadersPolicyName = `${domainAsId(props.domainName)}-response-headers-policy`;\n      \n      if (props.responseHeadersPolicyProps) {\n        responseHeadersPolicy = new ResponseHeadersPolicy(this, 'response-headers-policy', {\n          ...baseHeadersBehavior,\n          ...props.responseHeadersPolicyProps,\n          responseHeadersPolicyName: props.responseHeadersPolicyProps.responseHeadersPolicyName || responseHeadersPolicyName\n        });\n      } else if (props.responseCspHeaders) {\n        responseHeadersPolicy = new ResponseHeadersPolicy(this, 'response-headers-policy', {\n          securityHeadersBehavior: {\n            ...baseHeadersBehavior,\n            contentSecurityPolicy: {\n              override: true,\n              contentSecurityPolicy: Object.entries(props.responseCspHeaders).map(([directive, values]) => {\n                return `${directive} ${values.join(' ')};`\n              }).join(' ')\n            },\n          },\n          responseHeadersPolicyName\n        });\n      }\n    }\n    // TODO: Figure out why the the policy is not getting updated in the CloudFront behavior\n    this.responseHeadersPolicy = responseHeadersPolicy;\n\n    const defaultBehavior: BehaviorOptions = {\n      origin: S3BucketOrigin.withOriginAccessControl(this.s3Bucket),\n      functionAssociations: [],\n      responseHeadersPolicy: responseHeadersPolicy ?? props.responseHeadersPolicy !== false ? ResponseHeadersPolicy.SECURITY_HEADERS : undefined\n    };\n\n    let cffn: CloudFrontFunction;\n    if (props.basicAuth) {\n      if (typeof props.basicAuth != 'string') {\n        if ((props.basicAuth as BasicAuthCredentials).user && (props.basicAuth as BasicAuthCredentials).password) {\n          props.basicAuth = Buffer.from(`${(props.basicAuth as BasicAuthCredentials).user}:${(props.basicAuth as BasicAuthCredentials).password}`).toString('base64');\n        } else if ((props.basicAuth as SsmStringParameter).path) {\n          props.basicAuth = StringParameter.valueForStringParameter(this, (props.basicAuth as SsmStringParameter).path, (props.basicAuth as SsmStringParameter).version);\n        } else {\n          props.basicAuth = undefined;\n        }\n      }\n    }\n    if (props.cloudfrontFunction) {\n      cffn = CloudFrontFunction.createFunction(this, null, {\n        credentials: props.basicAuth,\n        redirects: props.redirects,\n        redirectsCsvPath: props.redirectsCsvPath,\n        code: props.cloudfrontFunction.code,\n        destroy: props.destroy\n      });\n    } else if (props.basicAuth) {\n      cffn = CloudFrontFunction.createBasicAuthDefaultDoc(this, {\n        credentials: props.basicAuth,\n        redirects: props.redirects,\n        redirectsCsvPath: props.redirectsCsvPath,\n        destroy: props.destroy\n      });\n    } else {\n      cffn = CloudFrontFunction.createDefaultDoc(this, {\n        redirects: props.redirects,\n        redirectsCsvPath: props.redirectsCsvPath,\n        destroy: props.destroy\n      });\n    }\n    this.cloudFrontFunction = cffn.fn;\n\n    // const eventTypes: CloudFrontFunctionEventType[] = props.cloudfrontFunction?.eventType && props.cloudfrontFunction.eventType.length > 0 ? props.cloudfrontFunction.eventType : ['VIEWER_REQUEST', 'VIEWER_RESPONSE'];\n\n    let eventTypes: CloudFrontFunctionEventType[] = ['VIEWER_REQUEST', 'VIEWER_RESPONSE'];\n    if (Array.isArray(props.cloudfrontFunction?.eventType) && props.cloudfrontFunction.eventType.length > 0) {\n      const ets = props.cloudfrontFunction.eventType\n        .filter((v, i, a) => {\n          return (\n            typeof v == 'string' &&\n            (v === 'VIEWER_REQUEST' || v === 'VIEWER_RESPONSE') &&\n            a.indexOf(v) === i // dedup\n          );\n        });\n      if (ets.length > 0) {\n        eventTypes = ets;\n      }\n    }\n\n    for (const eventType of eventTypes) {\n      defaultBehavior.functionAssociations!.push({\n        eventType: FunctionEventType[eventType],\n        function: this.cloudFrontFunction\n      });\n    }\n    \n    let webAclId: string | undefined = undefined;\n    if (typeof props.webAcl == 'string' && props.webAcl.startsWith('arn:aws')) {\n      webAclId = props.webAcl;\n    } else if ((props.webAcl as SsmStringParameter).path) {\n      webAclId = StringParameter.valueForStringParameter(this, (props.webAcl as SsmStringParameter).path, (props.webAcl as SsmStringParameter).version);\n    } else if (props.webAcl === true) {\n      const waf = new CloudFrontWebAcl(this, 'CloudFrontWebAcl', {\n        name: `${domainAsId(props.domainName)}`,\n        destroy: props.destroy\n      });\n      this.webAcl = waf.acl;\n      webAclId = waf.acl.attrArn;\n    }\n\n    const cfDistribution = new CloudFrontDistribution(this, 'CloudFrontDistribution', {\n      domainName: props.domainName,\n      description: props.description ?? props.domainName,\n      priceClass: props.envType,\n      certificate: this.sslCertificate,\n      defaultBehavior,\n      webAclId\n    });\n    this.cloudFrontDistribution = cfDistribution.distribution;\n\n    const cfAlias = new CloudFrontAlias(this, 'CloudFrontAlias', {\n      distribution: cfDistribution.distribution,\n      domainName: props.domainName,\n      hostedZone: hostedZone\n    });\n    this.aRecord = cfAlias.aRecord;\n    this.aaaaRecord = cfAlias.aaaaRecord;\n  }\n}"]}

package/dist/types.d.ts

@@ -1,3 +1,6 @@
+
+import { FunctionEventType } from 'aws-cdk-lib/aws-cloudfront';
+
 export type DeepPartial<T> = T extends object ? {
   [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
@@ -6,6 +9,11 @@ export type WithRequiredProperty<Type, Key extends keyof Type> = Omit<Type, Key>
   [Property in Key]-?: Type[Property];
 };
 
+export type UUID = `${string}-${string}-${string}-${string}-${string}`; // & { readonly __brand: unique symbol };
+
+export type EvosynthTagKey = 'Account' | 'Brand' | (string & {});
+export type CloudFrontFunctionEventType = keyof typeof FunctionEventType;
+
 export interface ResourceProps {
   destroy?: boolean;
   tags?: Record<string, string>;
@@ -18,4 +26,11 @@ export interface BasicAuthCredentials {
 
 export type CspDirective = 'connect-src' | 'default-src' | 'font-src' | 'frame-src' | 'img-src' | 'media-src' | 'object-src' | 'script-src' | 'style-src';
 export type CspDirectiveValue = "'self'" | "'none'" | "'unsafe-inline'" | "https:";
-export type CspHeaders = Partial<Record<CspDirective, CspDirectiveValue[] | string[]>>;
+export type CspHeaders = Partial<Record<CspDirective, CspDirectiveValue[] | string[]>>;
+
+export type AWSManagedResponseHeadersPolicy = 
+  'CORS_ALLOW_ALL_ORIGINS' |
+  'CORS_ALLOW_ALL_ORIGINS_AND_SECURITY_HEADERS' |
+  'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT' |
+  'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT_AND_SECURITY_HEADERS' |
+  'SECURITY_HEADERS';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inizioevoke/evosynth",
-  "version": "1.8.1",
+  "version": "2.0.0",
   "author": "",
   "license": "ISC",
   "description": "",
@@ -12,14 +12,21 @@
     "./stages/*": "./dist/stages/*.js",
     "./types/*": "./dist/types.d.ts"
   },
+  "bin": {
+    "evosynth": "./dist/cli/cli.js"
+  },
   "scripts": {
     "prepublishOnly": "npm run build",
     "build": "node ./tasks/clean.js && npx tsc && node ./tasks/dist.js"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",
-    "aws-cdk-lib": "^2.238.0",
+    "aws-cdk-lib": "^2.253.1",
     "constructs": "^10.5.1",
     "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@aws-cdk/toolkit-lib": "^1.25.2",
+    "commander": "^14.0.3"
   }
 }

package/readme.md

@@ -1,6 +1,6 @@
 # @inizioevoke/evosynth
 
-EvoSynth/EvoGen is an npm package providing reusable AWS CDK stacks for deploying static serverless websites. It targets S3 + CloudFront + Route53 + ACM + WAF + CodePipeline architectures.
+EvoSynth is an npm package providing reusable AWS CDK stacks for deploying static serverless websites. It targets S3 + CloudFront + Route53 + ACM + WAF + CodePipeline architectures.
 
 ## Prerequisites
 - [CDK v2.238.x](https://docs.aws.amazon.com/cdk/v2/guide/home.html)

package/samples/app.ts

@@ -59,7 +59,7 @@ new WebStaticServerlessStage(app, 'dev', {
 
   // responseHeadersPolicyProps: { /* full CDK policy */},
   // responseHeadersPolicy: 'SECURITY_HEADERS', // AWS managed policy
-  // responseHeadersPolicy: 'NONE', // Not recommended
+  // responseHeadersPolicy: false, // Not recommended
   // responseHeadersPolicy: '[UUID from CloudFront > Policies > Response headers]',
   // responseHeadersPolicy: { path: '/evosynth/web/security/response-headers' }, // UUID from Parameter Store
   // responseCspHeaders: { // just CSP headers, extends ResponseHeadersPolicy.SECURITY_HEADERS

package/src/cli/cli.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { Command, program } from 'commander';
+import { evosynth, EvosynthProps, CdkCommand } from './evosynth.js';
+
+program
+  .name('evosynth')
+  .description('CDK utility')
+  .version('2.0.0')
+  .option('--profile <profile>', 'The AWS profile');
+
+
+// program
+//   .command('bootstrap')
+//   .action(bootstrap);
+
+(<CdkCommand[]>['deploy','destroy','diff','drift','rollback','synth'])
+  .forEach((cmd) => {
+    program.command(`${cmd} <env>`).action(action);
+  });
+
+program.parse();
+
+// async function bootstrap(options: Record<string, string>, command: Command) {
+//   await evosynth('bootstrap', )
+// }
+async function action(env: string, options: Record<string, string>, command: Command) {
+  await evosynth(command.name() as CdkCommand, env, program.opts() as EvosynthProps);
+}

package/src/cli/evosynth.ts

@@ -0,0 +1,72 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { EvosynthTagKey } from '../types.js';
+import { runWebStaticServerlessApp, WebStaticServerlessAppConfig } from './web-static-serverless.js';
+
+export { WebStaticServerlessAppConfig };
+
+export type EnvironmentType = 'dev' | 'test' | 'stage' | 'uat' | 'preprod'  | 'prod' | (string & {});
+export type CdkCommand = 'deploy' | 'destroy' | 'diff' | 'drift' | 'rollback' | 'synth'; // 'bootstrap' | 
+export type EvosynthAppType = 'str8r-clm' | 'web-static-serverless';
+
+export interface EvosynthAppConfig {
+  type: EvosynthAppType;
+  envType?: EnvironmentType;
+  name: string;
+  region: 'us-east-1' | 'us-east-2' | 'us-west-1' | 'us-west-2' | (string & {});
+  tags?: Record<EvosynthTagKey, string>,
+}
+
+export interface EvosynthProps {
+  profile?: string;
+}
+export async function evosynth(cmd: CdkCommand, env: string, props: EvosynthProps) {
+  const files = await readdir(process.cwd(), { withFileTypes: true });
+
+  const configFiles = files
+    .filter((dirent) => {
+      if (dirent.isFile()) {
+        return /^\.evosynth(.*?)\.(?:js|mjs|ts|mts)$/i.test(dirent.name);
+      } else {
+        return false;
+      }
+    })
+    .map((dirent) => {
+      const parts = dirent.name.split('.').filter(p => p !== '');
+      return {
+        name: dirent.name,
+        env: parts.length > 2 ? parts[1] : undefined,
+        dir: dirent.parentPath
+      }
+    });
+  
+  let configIndex = configFiles.findIndex(c => c.env && env && c.env.toLowerCase() === env.toLowerCase());
+  if (configIndex === -1) {
+    configIndex = configFiles.findIndex(c => c.env === undefined);
+  }
+  if (configIndex != -1) {
+    const configFile = configFiles[configIndex];
+    const module = await import(pathToFileURL(join(configFile.dir, configFile.name)).toString());
+    let config: EvosynthAppConfig | undefined = undefined;
+    if (configFile.env) {
+      config = module.default;
+    } else {
+      config = module[env]?.();
+    }
+
+    if (config) {
+      if (props.profile) {
+        process.env.AWS_PROFILE = props.profile;
+      }
+      switch (config.type) {
+        case 'web-static-serverless':
+          await runWebStaticServerlessApp(cmd, config as WebStaticServerlessAppConfig);
+          break;
+      }
+    }
+    
+  } else {
+    console.error('evosynth config not found!');
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,2 @@
+export * from './evosynth.js';
+export * from './web-static-serverless.js';

package/src/cli/web-static-serverless.ts

@@ -0,0 +1,130 @@
+import { join } from 'node:path';
+import * as core from 'aws-cdk-lib/core';
+import { BootstrapEnvironments, ICloudAssemblySource, Toolkit } from '@aws-cdk/toolkit-lib';
+import { ResponseHeadersPolicyProps } from 'aws-cdk-lib/aws-cloudfront';
+import { IBuildImage } from 'aws-cdk-lib/aws-codebuild';
+import { CloudFrontFunctionRedirects } from '../constructs/cloudfront.js';
+import { CodeBuildImageId, EcrBuildImage, CodeBuildSsmParameter, CodeBuildComputeType, CodeBuildNodeJs, EnvironmentVariables } from '../constructs/codebuild.ts';
+import type { EvosynthAppConfig, CdkCommand, EvosynthAppType } from './evosynth.ts';
+import type { CloudFrontFunctionEventType, CspHeaders, UUID, AWSManagedResponseHeadersPolicy } from '../types.d.ts';
+import { getEnv } from '../index.js';
+import { WebStaticServerlessStage, WebStaticServerlessStageProps } from '../stages/web-static-serverless-stage.js';
+
+const cdk = new Toolkit();
+
+export interface WebStaticServerlessAppConfig extends EvosynthAppConfig {
+  type: Extract<EvosynthAppType, 'web-static-serverless'>,
+  description?: string;
+  dns: {
+    record: string;
+    zone: string;
+  },
+  security?: {
+    basicAuth?: string;
+    basicAuthParam?: string;
+    webAcl?: string | false;
+    webAclParam?: string;
+  },
+  cloudfront?: {
+    responseHeaders?: AWSManagedResponseHeadersPolicy | UUID | false;
+    responseHeadersParam?: string;
+    responseHeadersPolicy?: ResponseHeadersPolicyProps;
+    cspHeaders?: CspHeaders;
+    redirects?: CloudFrontFunctionRedirects;
+    function?: string | {
+      code: string;
+      eventType: CloudFrontFunctionEventType[];
+    }
+  },
+  pipeline?: {
+    source: {
+      codestarConnection?: string;
+      codestarConnectionParam?: string;
+      owner: 'evokegroup' | 'meltmedia' | (string & {});
+      repo: string;
+      branch: string;
+      fullClone?: boolean;
+    },
+    build?: {
+      buildSpec?: string | object;
+      buildImage?: IBuildImage;
+      buildImageEcr?: EcrBuildImage;
+      buildImageNodeJS?: CodeBuildNodeJs;
+      buildImageId?: CodeBuildImageId;
+      computeType?: CodeBuildComputeType;
+      environmentVariables?: EnvironmentVariables;
+      ssmParameters?: CodeBuildSsmParameter[]
+    }
+  }
+}
+
+export async function runWebStaticServerlessApp(cmd: CdkCommand, config: WebStaticServerlessAppConfig) {
+  const cx = await cdk.fromAssemblyBuilder(async (props) => {
+    const app = new core.App({
+      outdir: join(process.cwd(), '.evosynth'),
+    });
+
+    const stageProps: WebStaticServerlessStageProps & core.StageProps = {
+      env: getEnv(config.region),
+      stageName: `${config.name}${config.envType ? `-${config.envType}` : ''}`,
+      tags: config.tags,
+      envType: config.envType === 'prod' ? 'PROD' : 'NOT_PROD',
+      description: `${config.description}${config.envType ? ` ${config.envType.toUpperCase()}` : ''}`,
+      hostedZone: config.dns.zone,
+      domainName: `${config.dns.record}.${config.dns.zone}`,
+      basicAuth: config.security?.basicAuthParam ? { path: config.security?.basicAuthParam } : config.security?.basicAuth,
+      webAcl: config.security?.webAclParam ? { path: config.security.webAclParam } : config.security?.webAcl,
+      redirects: config.cloudfront?.redirects,
+      responseCspHeaders: config.cloudfront?.cspHeaders,
+      responseHeadersPolicy: config.cloudfront?.responseHeadersParam ? { path: config.cloudfront.responseHeadersParam } : config.cloudfront?.responseHeaders,
+      responseHeadersPolicyProps: config.cloudfront?.responseHeadersPolicy,
+      cloudfrontFunction: config.cloudfront?.function && typeof config.cloudfront.function == 'string' ? {
+        code: config.cloudfront.function,
+        eventType: ['VIEWER_REQUEST','VIEWER_RESPONSE'],
+      } : config.cloudfront?.function as any
+    }
+    if (config.pipeline) {
+      stageProps.pipeline = {
+        sourceStage: {
+          codestarConnection: config.pipeline.source.codestarConnectionParam ? { path: config.pipeline.source.codestarConnectionParam } : config.pipeline.source.codestarConnection as string,
+          repoOwner: config.pipeline.source.owner,
+          repo: config.pipeline.source.repo,
+          branch: config.pipeline.source.branch,
+          fullClone: config.pipeline.source.fullClone
+        }
+      }
+      if (config.pipeline.build) {
+        stageProps.pipeline.buildStage = {
+          environmentVariables: config.pipeline.build.environmentVariables
+        };
+        stageProps.pipeline.codeBuildProject = {
+          buildImage: config.pipeline.build.buildImage,
+          buildImageId: config.pipeline.build.buildImageId,
+          buildImageNodeJS: config.pipeline.build.buildImageNodeJS,
+          buildSpec: config.pipeline.build.buildSpec,
+          computeType: config.pipeline.build.computeType,
+          ecrBuildImage: config.pipeline.build.buildImageEcr,
+          ssmParameters: config.pipeline.build.ssmParameters
+        };
+      }
+    }
+
+    new WebStaticServerlessStage(app, config.type, stageProps);
+
+    return app.synth();
+  });
+
+  switch (cmd) {
+    // case 'bootstrap':
+    //   await cdk.bootstrap(BootstrapEnvironments.fromList([`aws://${process.env.CDK_DEFAULT_ACCOUNT}/${config.region}`]));
+    //   break;
+    case 'deploy':
+    case 'destroy':
+    case 'diff':
+    case 'drift':
+    case 'rollback':
+    case 'synth':
+      await cdk[cmd](cx);
+      break;
+  }
+}

package/src/constructs/codebuild.ts

@@ -11,7 +11,33 @@ import type { ResourceProps } from "../types.d.ts";
 
 export type EnvironmentVariables = Record<string, { value: any, type?: BuildEnvironmentVariableType }>;
 
-interface SsmParameter extends SsmStringParameter {
+export type CodeBuildImageId = 
+  'aws/codebuild/amazonlinux2-aarch64-standard:1.0' | 
+  'aws/codebuild/amazonlinux2-x86_64-standard:2.0' |
+  'aws/codebuild/amazonlinux2-x86_64-standard:3.0' |
+  'aws/codebuild/amazonlinux-x86_64-standard:4.0' |
+  'aws/codebuild/amazonlinux-x86_64-standard:5.0' |
+  'aws/codebuild/amazonlinux-x86_64-standard:6.0' |
+  'aws/codebuild/amazonlinux-x86_64-standard:corretto8' |
+  'aws/codebuild/amazonlinux-x86_64-standard:corretto11' |
+  'aws/codebuild/amazonlinux-aarch64-standard:2.0' |
+  'aws/codebuild/amazonlinux-aarch64-standard:3.0' |
+  'aws/codebuild/standard:3.0' |
+  'aws/codebuild/standard:4.0' | 
+  'aws/codebuild/standard:5.0' | // nodejs 12, 14
+  'aws/codebuild/standard:6.0' | // nodejs 16
+  'aws/codebuild/standard:7.0' | // nodejs 18, 20, 22, 24
+  'aws/codebuild/standard:8.0' | // nodejs 22, 24
+  'aws/codebuild/windows-base:2019-1.0' |
+  'aws/codebuild/windows-base:2019-2.0' |
+  'aws/codebuild/windows-base:2019-3.0' |
+  'aws/codebuild/windows-base:2022-1.0' |
+  (string & {});
+
+export type CodeBuildComputeType = 'SMALL' | 'MEDIUM' | 'LARGE' | 'X_LARGE' | 'X2_LARGE' | (string & {});
+export type CodeBuildNodeJs = 12 | 14 | 16 | 18 | 20 | 22 | 24 | (number & {});
+
+export interface CodeBuildSsmParameter extends SsmStringParameter {
   encrypted?: boolean;
 }
 export interface EcrBuildImage {
@@ -21,13 +47,15 @@ export interface EcrBuildImage {
 export interface CodeBuildPipelineProjectProps extends ResourceProps {
   projectName?: string;
   buildSpec?: string | object;
-  buildImage?: ('STANDARD_5_0' | 'STANDARD_6_0' | 'STANDARD_7_0') | IBuildImage;
   ecrBuildImage?: EcrBuildImage,
-  computeType?: ('SMALL' | 'MEDIUM' | 'LARGE' | 'X_LARGE' | 'X2_LARGE') | string;
+  buildImage?: IBuildImage;
+  buildImageNodeJS?: CodeBuildNodeJs;
+  buildImageId?: CodeBuildImageId;
+  computeType?: CodeBuildComputeType;
   environmentVariables?: EnvironmentVariables;
   cloudFrontDistributionArn?: string;
   s3BucketName?: string;
-  ssmParameters?: SsmParameter[];
+  ssmParameters?: CodeBuildSsmParameter[];
 }
 
 export class CodeBuildPipelineProject extends Construct {
@@ -58,12 +86,27 @@ export class CodeBuildPipelineProject extends Construct {
         Repository.fromRepositoryName(this, 'EcrRepository', props.ecrBuildImage.repository);
       buildImage = LinuxBuildImage.fromEcrRepository(repository, props.ecrBuildImage.tag);
     } else if (props.buildImage) {
-      if (typeof props.buildImage == 'string') {
-        buildImage = LinuxBuildImage[props.buildImage ?? 'STANDARD_7_0']
-      } else {
-        buildImage = props.buildImage as IBuildImage;
+      buildImage = props.buildImage as IBuildImage;
+    } else if (props.buildImageNodeJS) {
+      let standard = 8;
+      switch (props.buildImageNodeJS) {
+        case 12:
+        case 14:
+          standard = 5;
+          break;
+        case 16:
+          standard = 6;
+          break;
+        case 18:
+        case 20:
+          standard = 7;
+          break;
       }
-    }
+      buildImage = LinuxBuildImage.fromCodeBuildImageId(`aws/codebuild/standard:${standard}.0`);
+    } else if (props.buildImageId) {
+      buildImage = LinuxBuildImage.fromCodeBuildImageId(props.buildImageId);
+    } 
+    
 
     this.project = new PipelineProject(this, 'CodeBuildPipelineProjectProps', {
       projectName: props.projectName,

package/src/constructs/codepipeline.ts

@@ -1,7 +1,7 @@
 import { RemovalPolicy, PhysicalName, Aws } from "aws-cdk-lib";
 import { Construct } from 'constructs';
 import { IProject } from "aws-cdk-lib/aws-codebuild";
-import { Artifact, Pipeline } from "aws-cdk-lib/aws-codepipeline";
+import { Artifact, Pipeline, PipelineType } from "aws-cdk-lib/aws-codepipeline";
 import { CodeBuildAction, CodeStarConnectionsSourceAction } from "aws-cdk-lib/aws-codepipeline-actions";
 import { Bucket } from 'aws-cdk-lib/aws-s3';
 import { StringParameter } from 'aws-cdk-lib/aws-ssm';
@@ -45,7 +45,8 @@ export class CodePipelineProject extends Construct {
 
     this.pipeline = new Pipeline(this, 'CodePipelineProject', {
       pipelineName: props.pipelineName,
-      artifactBucket: this.s3Bucket
+      artifactBucket: this.s3Bucket,
+      pipelineType: PipelineType.V2
     });
 
     tagResource(this.pipeline, props.tags);

package/src/index.ts

@@ -1,6 +1,7 @@
 import { Environment } from "aws-cdk-lib";
 
-export * from './lib/tags.ts';
+export * from './lib/tags.js';
+export * from './cli/index.js';
 
 interface GetEnvParams { 
   account?: number | string;

package/src/stacks/web-static-serverless/web-global-stack.ts

@@ -17,18 +17,7 @@ import { CloudFrontWebAcl } from '../../constructs/waf.js';
 import { domainAsId } from '../../lib/utils.js';
 import { addEvoStackTags } from '../../lib/tags.ts';
 import { S3BucketOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';
-import type { BasicAuthCredentials, CspHeaders } from '../../types.d.ts';
-
-
-type AWSManagedResponseHeadersPolicy = 
-  'CORS_ALLOW_ALL_ORIGINS' |
-  'CORS_ALLOW_ALL_ORIGINS_AND_SECURITY_HEADERS' |
-  'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT' |
-  'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT_AND_SECURITY_HEADERS' |
-  'SECURITY_HEADERS';
-
-type UUID = `${string}-${string}-${string}-${string}-${string}`;
-type CloudFrontFunctionEventType = keyof typeof FunctionEventType;
+import type { BasicAuthCredentials, CspHeaders, CloudFrontFunctionEventType, UUID, AWSManagedResponseHeadersPolicy } from '../../types.d.ts';
 
 export interface WebGlobalStackProps {
   envType: 'NOT_PROD' | 'PROD';
@@ -38,8 +27,8 @@ export interface WebGlobalStackProps {
   domainName: string;
   basicAuth?: string | BasicAuthCredentials | SsmStringParameter;
   cloudfrontFunction?: {
-    eventType: CloudFrontFunctionEventType[];
     code: string;
+    eventType: CloudFrontFunctionEventType[];
   }
   redirects?: CloudFrontFunctionRedirects;
   redirectsCsvPath?: string;
@@ -139,6 +128,7 @@ export class WebGlobalStack extends Stack {
         });
       }
     }
+    // TODO: Figure out why the the policy is not getting updated in the CloudFront behavior
     this.responseHeadersPolicy = responseHeadersPolicy;
 
     const defaultBehavior: BehaviorOptions = {

package/src/types.d.ts

@@ -1,3 +1,6 @@
+
+import { FunctionEventType } from 'aws-cdk-lib/aws-cloudfront';
+
 export type DeepPartial<T> = T extends object ? {
   [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
@@ -6,6 +9,11 @@ export type WithRequiredProperty<Type, Key extends keyof Type> = Omit<Type, Key>
   [Property in Key]-?: Type[Property];
 };
 
+export type UUID = `${string}-${string}-${string}-${string}-${string}`; // & { readonly __brand: unique symbol };
+
+export type EvosynthTagKey = 'Account' | 'Brand' | (string & {});
+export type CloudFrontFunctionEventType = keyof typeof FunctionEventType;
+
 export interface ResourceProps {
   destroy?: boolean;
   tags?: Record<string, string>;
@@ -18,4 +26,11 @@ export interface BasicAuthCredentials {
 
 export type CspDirective = 'connect-src' | 'default-src' | 'font-src' | 'frame-src' | 'img-src' | 'media-src' | 'object-src' | 'script-src' | 'style-src';
 export type CspDirectiveValue = "'self'" | "'none'" | "'unsafe-inline'" | "https:";
-export type CspHeaders = Partial<Record<CspDirective, CspDirectiveValue[] | string[]>>;
+export type CspHeaders = Partial<Record<CspDirective, CspDirectiveValue[] | string[]>>;
+
+export type AWSManagedResponseHeadersPolicy = 
+  'CORS_ALLOW_ALL_ORIGINS' |
+  'CORS_ALLOW_ALL_ORIGINS_AND_SECURITY_HEADERS' |
+  'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT' |
+  'CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT_AND_SECURITY_HEADERS' |
+  'SECURITY_HEADERS';