@inizioevoke/evosynth 2.1.0 → 2.1.1

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

@@ -4,50 +4,55 @@ import { CloudFrontErrorResponse, CloudFrontFunctionRedirects } from '../constru
 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 AppConfigDnsProps {
+    record: string;
+    zone: string;
+}
+export interface AppConfigSecurityProps {
+    basicAuth?: string;
+    basicAuthParam?: string;
+    webAcl?: string | false;
+    webAclParam?: string;
+}
+export interface AppConfigCloudFrontProps {
+    responseHeaders?: AWSManagedResponseHeadersPolicy | UUID | false;
+    responseHeadersParam?: string;
+    responseHeadersPolicy?: ResponseHeadersPolicyProps;
+    cspHeaders?: CspHeaders;
+    redirects?: CloudFrontFunctionRedirects;
+    function?: string | {
+        code: string;
+        eventType: CloudFrontFunctionEventType[];
+    };
+    errorResponses?: CloudFrontErrorResponse[];
+}
+export interface AppConfigPipelineSourceProps {
+    codestarConnection?: string;
+    codestarConnectionParam?: string;
+    owner: 'evokegroup' | 'meltmedia' | (string & {});
+    repo: string;
+    branch: string;
+    fullClone?: boolean;
+}
+export interface AppConfigPipelineBuildProps {
+    buildSpec?: string | object;
+    buildImage?: IBuildImage;
+    buildImageEcr?: EcrBuildImage;
+    buildImageNodeJS?: CodeBuildNodeJs;
+    buildImageId?: CodeBuildImageId;
+    computeType?: CodeBuildComputeType;
+    environmentVariables?: EnvironmentVariables;
+    ssmParameters?: CodeBuildSsmParameter[];
+}
 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[];
-        };
-        errors?: CloudFrontErrorResponse[];
-    };
+    dns: AppConfigDnsProps;
+    security?: AppConfigSecurityProps;
+    cloudfront?: AppConfigCloudFrontProps;
     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[];
-        };
+        source: AppConfigPipelineSourceProps;
+        build?: AppConfigPipelineBuildProps;
     };
 }
 export declare function runWebStaticServerlessApp(cmd: CdkCommand, config: WebStaticServerlessAppConfig): Promise<void>;

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

@@ -26,7 +26,8 @@ export async function runWebStaticServerlessApp(cmd, config) {
             cloudfrontFunction: config.cloudfront?.function && typeof config.cloudfront.function == 'string' ? {
                 code: config.cloudfront.function,
                 eventType: ['VIEWER_REQUEST', 'VIEWER_RESPONSE'],
-            } : config.cloudfront?.function
+            } : config.cloudfront?.function,
+            errorResponses: config.cloudfront?.errorResponses
         };
         if (config.pipeline) {
             stageProps.pipeline = {
@@ -70,4 +71,4 @@ export async function runWebStaticServerlessApp(cmd, config) {
             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 { Toolkit } from '@aws-cdk/toolkit-lib';\nimport { ResponseHeadersPolicyProps } from 'aws-cdk-lib/aws-cloudfront';\nimport { IBuildImage } from 'aws-cdk-lib/aws-codebuild';\nimport { CloudFrontErrorResponse, 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    errors?: CloudFrontErrorResponse[]\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-static-serverless.js","sourceRoot":"","sources":["../../src/cli/web-static-serverless.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAO/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,wBAAwB,EAAiC,MAAM,0CAA0C,CAAC;AAEnH,MAAM,GAAG,GAAG,IAAI,OAAO,EAAE,CAAC;AA2D1B,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,GAAe,EAAE,MAAoC;IACnG,MAAM,EAAE,GAAG,MAAM,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QACvD,MAAM,GAAG,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;YACvB,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,WAAW,CAAC;SACzC,CAAC,CAAC;QAEH,MAAM,UAAU,GAAoD;YAClE,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;YAC1B,SAAS,EAAE,GAAG,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;YACxE,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,OAAO,EAAE,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU;YACxD,WAAW,EAAE,GAAG,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;YAC/F,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI;YAC3B,UAAU,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE;YACrD,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS;YACnH,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;YACtG,SAAS,EAAE,MAAM,CAAC,UAAU,EAAE,SAAS;YACvC,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,UAAU;YACjD,qBAAqB,EAAE,MAAM,CAAC,UAAU,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,UAAU,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,EAAE,eAAe;YACtJ,0BAA0B,EAAE,MAAM,CAAC,UAAU,EAAE,qBAAqB;YACpE,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,QAAQ,IAAI,OAAO,MAAM,CAAC,UAAU,CAAC,QAAQ,IAAI,QAAQ,CAAC,CAAC,CAAC;gBACjG,IAAI,EAAE,MAAM,CAAC,UAAU,CAAC,QAAQ;gBAChC,SAAS,EAAE,CAAC,gBAAgB,EAAC,iBAAiB,CAAC;aAChD,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,EAAE,QAAe;YACtC,cAAc,EAAE,MAAM,CAAC,UAAU,EAAE,cAAc;SAClD,CAAA;QACD,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;YACpB,UAAU,CAAC,QAAQ,GAAG;gBACpB,WAAW,EAAE;oBACX,kBAAkB,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,uBAAuB,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,uBAAuB,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,kBAA4B;oBACnL,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK;oBACvC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI;oBACjC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM;oBACrC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS;iBAC5C;aACF,CAAA;YACD,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;gBAC1B,UAAU,CAAC,QAAQ,CAAC,UAAU,GAAG;oBAC/B,oBAAoB,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,oBAAoB;iBACjE,CAAC;gBACF,UAAU,CAAC,QAAQ,CAAC,gBAAgB,GAAG;oBACrC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU;oBAC5C,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,YAAY;oBAChD,gBAAgB,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,gBAAgB;oBACxD,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS;oBAC1C,WAAW,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW;oBAC9C,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa;oBAClD,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa;iBACnD,CAAC;YACJ,CAAC;QACH,CAAC;QAED,IAAI,wBAAwB,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAE3D,OAAO,GAAG,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC,CAAC,CAAC;IAEH,QAAQ,GAAG,EAAE,CAAC;QACZ,oBAAoB;QACpB,wHAAwH;QACxH,WAAW;QACX,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS,CAAC;QACf,KAAK,MAAM,CAAC;QACZ,KAAK,OAAO,CAAC;QACb,KAAK,UAAU,CAAC;QAChB,KAAK,OAAO;YACV,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;YACnB,MAAM;IACV,CAAC;AACH,CAAC","sourcesContent":["import { join } from 'node:path';\nimport * as core from 'aws-cdk-lib/core';\nimport { Toolkit } from '@aws-cdk/toolkit-lib';\nimport { ResponseHeadersPolicyProps } from 'aws-cdk-lib/aws-cloudfront';\nimport { IBuildImage } from 'aws-cdk-lib/aws-codebuild';\nimport { CloudFrontErrorResponse, 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 AppConfigDnsProps {\n  record: string;\n  zone: string;\n}\n\nexport interface AppConfigSecurityProps {\n  basicAuth?: string;\n  basicAuthParam?: string;\n  webAcl?: string | false;\n  webAclParam?: string;\n}\n\nexport interface AppConfigCloudFrontProps {\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  errorResponses?: CloudFrontErrorResponse[]\n}\n\nexport interface AppConfigPipelineSourceProps {\n  codestarConnection?: string;\n  codestarConnectionParam?: string;\n  owner: 'evokegroup' | 'meltmedia' | (string & {});\n  repo: string;\n  branch: string;\n  fullClone?: boolean;\n}\n\nexport interface AppConfigPipelineBuildProps {\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\nexport interface WebStaticServerlessAppConfig extends EvosynthAppConfig {\n  type: Extract<EvosynthAppType, 'web-static-serverless'>,\n  description?: string;\n  dns: AppConfigDnsProps,\n  security?: AppConfigSecurityProps,\n  cloudfront?: AppConfigCloudFrontProps,\n  pipeline?: {\n    source: AppConfigPipelineSourceProps,\n    build?: AppConfigPipelineBuildProps\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      errorResponses: config.cloudfront?.errorResponses\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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inizioevoke/evosynth",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "author": "",
   "license": "ISC",
   "description": "",

package/readme.md

@@ -3,7 +3,6 @@
 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)
 - Node version 22+
 - AWS Account ID, a configured profile, or other credentials
 - CodeConnection ARN or SSM Parameter Store path of a shared connection ARN
@@ -15,8 +14,160 @@ EvoSynth is an npm package providing reusable AWS CDK stacks for deploying stati
 - Copy the buildspec.yml on your Bitbucket Repo and the build configuration
 - Update/Configure the Stack example below
 
+## Version 2 - evosynth cli (preferred)
 
-## Example App
+This library includes a cli tool `evosynth` to support a more streamlined configuration approach than the version 1 process, although the version 1 process is still supported.
+
+### Instructions
+
+In your project: 
+
+1. **Install the library**
+   ```bash
+   > npm install @inizioevoke/evosynth
+   ```
+2. **Create the config file in your project root directory.** `[ENV]` should be your environment name *(e.g. `.evosynth.dev.ts`)*
+   ```bash
+   .evosynth.[ENV].(js|mjs|ts|mts)
+   ```
+   It is also possible to use 1 config file for multiple environments.
+   ```bash
+   .evosynth.(js|mjs|ts|mts)
+   ```
+   
+3. **Compile your config.** Add standard AWS flags like `--profile` if necessary.
+   ```bash
+   > npx evosynth synth [ENV]
+   ```
+    ```bash
+   > npx evosynth synth [ENV] --profile my-profile
+   ```
+4. **Deploy**
+   ```bash
+   > npx evosynth deploy [ENV]
+   ```
+5. **Destroy**
+   ```bash
+   > npx evosynth destroy [ENV]
+   ```
+
+### Example config file - single environment
+
+```typescript
+// .evosynth.dev.ts
+import type { WebStaticServerlessAppConfig } from '@inizioevoke/evosynth';
+
+export default async function(): Promise<WebStaticServerlessAppConfig> {
+  return {
+    type: 'web-static-serverless',
+    envType: 'dev',
+    name: 'my-project',
+    description: 'My Project',
+    region: 'us-east-1',
+    tags: {
+      Account: 'Account Name',
+      Brand: 'Brand Name'
+    },
+    dns: {
+      record: 'my-project.dev.client',
+      zone: 'evodev.net'
+    },
+    security: {
+      basicAuthParam: '/evosynth/web/security/basicauth',
+      webAclParam: '/evosynth/web/security/webacl'
+    },
+    pipeline: {
+      source: {
+        codestarConnectionParam: '/evosynth/bitbucket/codeconnection',
+        owner: 'evokegroup',
+        repo: 'my-project',
+        branch: 'develop'
+      }
+    }
+  }
+}
+```
+
+### Example config file - multiple environments
+
+```typescript
+// .evosynth.dev.ts
+import type { WebStaticServerlessAppConfig } from '@inizioevoke/evosynth';
+
+const name = 'my-project';
+const description = 'My Project';
+const region = 'us-east-1';
+const tags: Record<string, string> = {
+  Account: 'Account Name',
+  Brand: 'Brand Name'
+};
+const basicAuthParam = '/evosynth/web/security/basicauth';
+const webAclParam = '/evosynth/web/security/webacl';
+const codestarConnectionParam = '/evosynth/bitbucket/codeconnection';
+const owner = 'evokegroup';
+const repo = 'my-project';
+
+export default async function dev(): Promise<WebStaticServerlessAppConfig> {
+  return {
+    type: 'web-static-serverless',
+    envType: 'dev',
+    name,
+    description,
+    region,
+    tags,
+    dns: {
+      record: 'my-project.dev.client',
+      zone: 'evodev.net'
+    },
+    security: {
+      basicAuthParam,
+      webAclParam
+    },
+    pipeline: {
+      source: {
+        codestarConnectionParam,
+        owner,
+        repo,
+        branch: 'develop'
+      }
+    }
+  }
+}
+export default async function uat(): Promise<WebStaticServerlessAppConfig> {
+  return {
+    type: 'web-static-serverless',
+    envType: 'uat',
+    name,
+    description,
+    region,
+    tags,
+    dns: {
+      record: 'my-project.uat.client',
+      zone: 'evodev.net'
+    },
+    security: {
+      basicAuthParam,
+      webAclParam
+    },
+    pipeline: {
+      source: {
+        codestarConnectionParam,
+        owner,
+        repo,
+        branch: 'develop'
+      }
+    }
+  }
+}
+```
+
+## Version 1
+
+*Requires [CDK v2.238.x](https://docs.aws.amazon.com/cdk/v2/guide/home.html) installed locally*
+
+
+
+### Example App (legacy)
 
 ```typescript
 import * as cdk from 'aws-cdk-lib/core';

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

@@ -12,50 +12,60 @@ import { WebStaticServerlessStage, WebStaticServerlessStageProps } from '../stag
 
 const cdk = new Toolkit();
 
+export interface AppConfigDnsProps {
+  record: string;
+  zone: string;
+}
+
+export interface AppConfigSecurityProps {
+  basicAuth?: string;
+  basicAuthParam?: string;
+  webAcl?: string | false;
+  webAclParam?: string;
+}
+
+export interface AppConfigCloudFrontProps {
+  responseHeaders?: AWSManagedResponseHeadersPolicy | UUID | false;
+  responseHeadersParam?: string;
+  responseHeadersPolicy?: ResponseHeadersPolicyProps;
+  cspHeaders?: CspHeaders;
+  redirects?: CloudFrontFunctionRedirects;
+  function?: string | {
+    code: string;
+    eventType: CloudFrontFunctionEventType[];
+  },
+  errorResponses?: CloudFrontErrorResponse[]
+}
+
+export interface AppConfigPipelineSourceProps {
+  codestarConnection?: string;
+  codestarConnectionParam?: string;
+  owner: 'evokegroup' | 'meltmedia' | (string & {});
+  repo: string;
+  branch: string;
+  fullClone?: boolean;
+}
+
+export interface AppConfigPipelineBuildProps {
+  buildSpec?: string | object;
+  buildImage?: IBuildImage;
+  buildImageEcr?: EcrBuildImage;
+  buildImageNodeJS?: CodeBuildNodeJs;
+  buildImageId?: CodeBuildImageId;
+  computeType?: CodeBuildComputeType;
+  environmentVariables?: EnvironmentVariables;
+  ssmParameters?: CodeBuildSsmParameter[]
+}
+
 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[];
-    },
-    errors?: CloudFrontErrorResponse[]
-  },
+  dns: AppConfigDnsProps,
+  security?: AppConfigSecurityProps,
+  cloudfront?: AppConfigCloudFrontProps,
   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[]
-    }
+    source: AppConfigPipelineSourceProps,
+    build?: AppConfigPipelineBuildProps
   }
 }
 
@@ -82,7 +92,8 @@ export async function runWebStaticServerlessApp(cmd: CdkCommand, config: WebStat
       cloudfrontFunction: config.cloudfront?.function && typeof config.cloudfront.function == 'string' ? {
         code: config.cloudfront.function,
         eventType: ['VIEWER_REQUEST','VIEWER_RESPONSE'],
-      } : config.cloudfront?.function as any
+      } : config.cloudfront?.function as any,
+      errorResponses: config.cloudfront?.errorResponses
     }
     if (config.pipeline) {
       stageProps.pipeline = {