truemark-cdk-lib 0.0.35 → 0.0.36-alpha.2

package/aws-codepipeline/lib/cdk-pipeline.js

@@ -38,8 +38,9 @@ class CdkPipeline extends constructs_1.Construct {
                 input,
                 commands: (_d = props.commands) !== null && _d !== void 0 ? _d : [
                     'mkdir /tmp/npm-cache',
+                    'npm config set fund false',
                     'npm config set cache /tmp/npm-cache --location=global',
-                    'npm ci --prefer-offline --no-fund',
+                    'npm ci --prefer-offline',
                     'npm run build',
                     'npm run test',
                     `npx cdk synth ${stackName}`
@@ -81,4 +82,4 @@ class CdkPipeline extends constructs_1.Construct {
     }
 }
 exports.CdkPipeline = CdkPipeline;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-pipeline.js","sourceRoot":"","sources":["cdk-pipeline.ts"],"names":[],"mappings":";;;AAAA,2CAAqC;AACrC,mEAAsD;AACtD,iDAAwC;AACxC,uDAAiD;AACjD,qDAQ+B;AAC/B,6DAAmH;AACnH,6EAAsE;AACtE,6CAAyC;AA6FzC;;GAEG;AACH,MAAa,WAAY,SAAQ,sBAAS;IAKxC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAuB;;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,aAAa,GAAG,aAAG,CAAC,UAAU,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAE1E,MAAM,cAAc,GAAG,IAAI,gCAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE;YAChE,aAAa;YACb,UAAU,EAAE,KAAK,CAAC,UAAU;SAC7B,CAAC,CAAC;QAEH,MAAM,kBAAkB,GAAG,IAAI,2BAAQ,CAAC,IAAI,EAAE,UAAU,EAAE;YACxD,cAAc;SACf,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,8BAAkB,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE;YACpE,aAAa,EAAE,KAAK,CAAC,aAAa;SACnC,CAAC,CAAC;QAEH,MAAM,SAAS,GAAG,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC;QAE3C,IAAI,CAAC,QAAQ,GAAG,IAAI,wBAAY,CAAC,IAAI,EAAE,cAAc,EAAE;YACrD,YAAY,EAAE,kBAAkB;YAChC,YAAY,QAAE,KAAK,CAAC,YAAY,mCAAE,IAAI;YACtC,qBAAqB,QAAE,KAAK,CAAC,qBAAqB,mCAAE,IAAI;YACxD,4BAA4B,QAAE,KAAK,CAAC,4BAA4B,mCAAE,IAAI;YACtE,KAAK,EAAE,IAAI,qBAAS,CAAC,OAAO,EAAE;gBAC5B,sBAAsB,EAAE,SAAS;gBACjC,KAAK;gBACL,QAAQ,QAAE,KAAK,CAAC,QAAQ,mCAAE;oBACxB,sBAAsB;oBACtB,uDAAuD;oBACvD,mCAAmC;oBACnC,eAAe;oBACf,cAAc;oBACd,iBAAiB,SAAS,EAAE;iBAC7B;gBACD,gBAAgB,QAAE,KAAK,CAAC,gBAAgB,mCAAE,EAAE;aAC7C,CAAC;YACF,sBAAsB,EAAE;gBACtB,gBAAgB,EAAE,yBAAS,CAAC,UAAU,CAAC;oBACrC,KAAK,EAAE;wBACL,KAAK,EAAE,gBAAgB;qBACxB;oBACD,MAAM,EAAE;wBACN,OAAO,EAAE;4BACP,QAAQ,EAAE;gCACR,MAAM;gCACN,2CAA2C,CAAC,0BAA0B;6BACvE;yBACF;qBACF;iBACF,CAAC;gBACF,gBAAgB,EAAE;oBAChB,WAAW,QAAE,KAAK,CAAC,WAAW,mCAAE,2BAAW,CAAC,KAAK;oBACjD,UAAU,QAAE,KAAK,CAAC,UAAU,mCAAE,+BAAe,CAAC,gBAAgB;iBAC/D;aACF;SACF,CAAC,CAAC;QACH,IAAI,KAAK,CAAC,4BAA4B,EAAE;YACtC,IAAI,CAAC,wBAAwB,GAAG,IAAI,qDAAwB,CAAC,IAAI,EAAE,cAAc,EAAE;gBACjF,MAAM,EAAE,kBAAkB;gBAC1B,4BAA4B,EAAE,KAAK,CAAC,4BAA4B;aACjE,CAAC,CAAC;SACJ;IACH,CAAC;IAED,QAAQ,CAAC,KAAY,EAAE,OAAsB;QAC3C,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,CAAC,EAAU,EAAE,OAAqB;QACvC,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;CACF;AA9ED,kCA8EC","sourcesContent":["import {Construct} from \"constructs\";\nimport {Pipeline} from \"aws-cdk-lib/aws-codepipeline\";\nimport {Key} from \"aws-cdk-lib/aws-kms\";\nimport {ArtifactBucket} from \"./artifact-bucket\";\nimport {\n  AddStageOpts,\n  CodePipeline,\n  CodePipelineSource,\n  ShellStep,\n  StageDeployment,\n  Wave,\n  WaveOptions\n} from \"aws-cdk-lib/pipelines\";\nimport {BuildSpec, ComputeType, IBuildImage, LinuxArmBuildImage, LinuxBuildImage} from \"aws-cdk-lib/aws-codebuild\";\nimport {PipelineNotificationRule} from \"./pipeline-notification-rule\";\nimport {Stack, Stage} from \"aws-cdk-lib\";\nimport {IFileSetProducer} from \"aws-cdk-lib/pipelines\";\n\n/**\n * Properties for CdkPipeline\n */\nexport interface CdkPipelineProps {\n\n  /**\n   * By default, CDK will create KMS keys for cross account deployments. This\n   * can be costly if you have a large number of pipelines. This property\n   * allows a common key to be shared across pipelines.\n   */\n  readonly keyArn: string;\n\n  /**\n   * List of account IDs this pipeline will deploy into.\n   */\n  readonly accountIds?: string[];\n\n  /**\n   * Arn of the CodeStar connection used to access the source code repository.\n   */\n  readonly connectionArn: string;\n\n  /**\n   * Name of the source code repository.\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to use inside the source code repository.\n   */\n  readonly branch: string;\n\n  /**\n   * Enable or disable self-mutation. Useful for cdk pipeline development.\n   *\n   * @default true\n   */\n  readonly selfMutation?: boolean;\n\n  /**\n   * Enable docker for the 'synth' step.\n   *\n   * @default true\n   */\n  readonly dockerEnabledForSynth?: boolean;\n\n  /**\n   * Enable docker for the self-mutate step.\n   *\n   * @default true\n   */\n  readonly dockerEnabledForSelfMutation?: boolean;\n\n  /**\n   * Type of compute to use for this build.\n   *\n   * @default ComputeType.SMALL\n   */\n  readonly computeType?: ComputeType;\n\n  /**\n   * The image to use for builds.\n   *\n   * @default LinuxBuildImage.AMAZON_LINUX_2_3\n   */\n  readonly buildImage?: IBuildImage;\n\n  /**\n   * The Slack channel configuration to use for notifications.\n   */\n  readonly slackChannelConfigurationArn?: string;\n\n  /**\n   * The list of notification events to receive. By default, this is all notifications.\n   *\n   * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline\n   */\n  readonly notificationEvents?: string[];\n\n  /**\n   * Additional FileSets to put in other directories\n   */\n  readonly additionalInputs?: Record<string, IFileSetProducer>;\n\n  /**\n   * Overrides default commands.\n   */\n  readonly commands?: string[];\n}\n\n/**\n * An abstraction to ease CDK pipeline creation and configuration.\n */\nexport class CdkPipeline extends Construct {\n\n  readonly pipeline: CodePipeline;\n  readonly pipelineNotificationRule: PipelineNotificationRule;\n\n  constructor(scope: Construct, id: string, props: CdkPipelineProps) {\n    super(scope, id);\n\n    const encryptionKey = Key.fromKeyArn(this, 'EncryptionKey', props.keyArn);\n\n    const artifactBucket = new ArtifactBucket(this, 'ArtifactBucket', {\n      encryptionKey,\n      accountIds: props.accountIds\n    });\n\n    const underlyingPipeline = new Pipeline(this, 'Pipeline', {\n      artifactBucket\n    });\n\n    const input = CodePipelineSource.connection(props.repo, props.branch, {\n      connectionArn: props.connectionArn\n    });\n\n    const stackName = Stack.of(this).stackName;\n\n    this.pipeline = new CodePipeline(this, 'CodePipeline', {\n      codePipeline: underlyingPipeline,\n      selfMutation: props.selfMutation??true,\n      dockerEnabledForSynth: props.dockerEnabledForSynth??true,\n      dockerEnabledForSelfMutation: props.dockerEnabledForSelfMutation??true,\n      synth: new ShellStep('Synth', {\n        primaryOutputDirectory: 'cdk.out',\n        input,\n        commands: props.commands??[\n          'mkdir /tmp/npm-cache',\n          'npm config set cache /tmp/npm-cache --location=global',\n          'npm ci --prefer-offline --no-fund',\n          'npm run build',\n          'npm run test',\n          `npx cdk synth ${stackName}`\n        ],\n        additionalInputs: props.additionalInputs??{}\n      }),\n      synthCodeBuildDefaults: {\n        partialBuildSpec: BuildSpec.fromObject({\n          cache: {\n            paths: \"/tmp/npm-cache\"\n          },\n          phases: {\n            install: {\n              commands: [\n                \"n 16\", // Install Node v16\n                \"npm i --location=global --no-fund esbuild\" // Install esbuild locally\n              ]\n            }\n          }\n        }),\n        buildEnvironment: {\n          computeType: props.computeType??ComputeType.SMALL,\n          buildImage: props.buildImage??LinuxBuildImage.AMAZON_LINUX_2_3\n        }\n      }\n    });\n    if (props.slackChannelConfigurationArn) {\n      this.pipelineNotificationRule = new PipelineNotificationRule(this, 'Notification', {\n        source: underlyingPipeline,\n        slackChannelConfigurationArn: props.slackChannelConfigurationArn\n      });\n    }\n  }\n\n  addStage(stage: Stage, options?: AddStageOpts): StageDeployment {\n    return this.pipeline.addStage(stage, options);\n  }\n\n  addWave(id: string, options?: WaveOptions): Wave {\n    return this.pipeline.addWave(id, options);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-pipeline.js","sourceRoot":"","sources":["cdk-pipeline.ts"],"names":[],"mappings":";;;AAAA,2CAAqC;AACrC,mEAAsD;AACtD,iDAAwC;AACxC,uDAAiD;AACjD,qDAQ+B;AAC/B,6DAAmH;AACnH,6EAAsE;AACtE,6CAAyC;AA6FzC;;GAEG;AACH,MAAa,WAAY,SAAQ,sBAAS;IAKxC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAuB;;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,aAAa,GAAG,aAAG,CAAC,UAAU,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAE1E,MAAM,cAAc,GAAG,IAAI,gCAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE;YAChE,aAAa;YACb,UAAU,EAAE,KAAK,CAAC,UAAU;SAC7B,CAAC,CAAC;QAEH,MAAM,kBAAkB,GAAG,IAAI,2BAAQ,CAAC,IAAI,EAAE,UAAU,EAAE;YACxD,cAAc;SACf,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,8BAAkB,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE;YACpE,aAAa,EAAE,KAAK,CAAC,aAAa;SACnC,CAAC,CAAC;QAEH,MAAM,SAAS,GAAG,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC;QAE3C,IAAI,CAAC,QAAQ,GAAG,IAAI,wBAAY,CAAC,IAAI,EAAE,cAAc,EAAE;YACrD,YAAY,EAAE,kBAAkB;YAChC,YAAY,QAAE,KAAK,CAAC,YAAY,mCAAE,IAAI;YACtC,qBAAqB,QAAE,KAAK,CAAC,qBAAqB,mCAAE,IAAI;YACxD,4BAA4B,QAAE,KAAK,CAAC,4BAA4B,mCAAE,IAAI;YACtE,KAAK,EAAE,IAAI,qBAAS,CAAC,OAAO,EAAE;gBAC5B,sBAAsB,EAAE,SAAS;gBACjC,KAAK;gBACL,QAAQ,QAAE,KAAK,CAAC,QAAQ,mCAAE;oBACxB,sBAAsB;oBACtB,2BAA2B;oBAC3B,uDAAuD;oBACvD,yBAAyB;oBACzB,eAAe;oBACf,cAAc;oBACd,iBAAiB,SAAS,EAAE;iBAC7B;gBACD,gBAAgB,QAAE,KAAK,CAAC,gBAAgB,mCAAE,EAAE;aAC7C,CAAC;YACF,sBAAsB,EAAE;gBACtB,gBAAgB,EAAE,yBAAS,CAAC,UAAU,CAAC;oBACrC,KAAK,EAAE;wBACL,KAAK,EAAE,gBAAgB;qBACxB;oBACD,MAAM,EAAE;wBACN,OAAO,EAAE;4BACP,QAAQ,EAAE;gCACR,MAAM;gCACN,2CAA2C,CAAC,0BAA0B;6BACvE;yBACF;qBACF;iBACF,CAAC;gBACF,gBAAgB,EAAE;oBAChB,WAAW,QAAE,KAAK,CAAC,WAAW,mCAAE,2BAAW,CAAC,KAAK;oBACjD,UAAU,QAAE,KAAK,CAAC,UAAU,mCAAE,+BAAe,CAAC,gBAAgB;iBAC/D;aACF;SACF,CAAC,CAAC;QACH,IAAI,KAAK,CAAC,4BAA4B,EAAE;YACtC,IAAI,CAAC,wBAAwB,GAAG,IAAI,qDAAwB,CAAC,IAAI,EAAE,cAAc,EAAE;gBACjF,MAAM,EAAE,kBAAkB;gBAC1B,4BAA4B,EAAE,KAAK,CAAC,4BAA4B;aACjE,CAAC,CAAC;SACJ;IACH,CAAC;IAED,QAAQ,CAAC,KAAY,EAAE,OAAsB;QAC3C,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,CAAC,EAAU,EAAE,OAAqB;QACvC,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;CACF;AA/ED,kCA+EC","sourcesContent":["import {Construct} from \"constructs\";\nimport {Pipeline} from \"aws-cdk-lib/aws-codepipeline\";\nimport {Key} from \"aws-cdk-lib/aws-kms\";\nimport {ArtifactBucket} from \"./artifact-bucket\";\nimport {\n  AddStageOpts,\n  CodePipeline,\n  CodePipelineSource,\n  ShellStep,\n  StageDeployment,\n  Wave,\n  WaveOptions\n} from \"aws-cdk-lib/pipelines\";\nimport {BuildSpec, ComputeType, IBuildImage, LinuxArmBuildImage, LinuxBuildImage} from \"aws-cdk-lib/aws-codebuild\";\nimport {PipelineNotificationRule} from \"./pipeline-notification-rule\";\nimport {Stack, Stage} from \"aws-cdk-lib\";\nimport {IFileSetProducer} from \"aws-cdk-lib/pipelines\";\n\n/**\n * Properties for CdkPipeline\n */\nexport interface CdkPipelineProps {\n\n  /**\n   * By default, CDK will create KMS keys for cross account deployments. This\n   * can be costly if you have a large number of pipelines. This property\n   * allows a common key to be shared across pipelines.\n   */\n  readonly keyArn: string;\n\n  /**\n   * List of account IDs this pipeline will deploy into.\n   */\n  readonly accountIds?: string[];\n\n  /**\n   * Arn of the CodeStar connection used to access the source code repository.\n   */\n  readonly connectionArn: string;\n\n  /**\n   * Name of the source code repository.\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to use inside the source code repository.\n   */\n  readonly branch: string;\n\n  /**\n   * Enable or disable self-mutation. Useful for cdk pipeline development.\n   *\n   * @default true\n   */\n  readonly selfMutation?: boolean;\n\n  /**\n   * Enable docker for the 'synth' step.\n   *\n   * @default true\n   */\n  readonly dockerEnabledForSynth?: boolean;\n\n  /**\n   * Enable docker for the self-mutate step.\n   *\n   * @default true\n   */\n  readonly dockerEnabledForSelfMutation?: boolean;\n\n  /**\n   * Type of compute to use for this build.\n   *\n   * @default ComputeType.SMALL\n   */\n  readonly computeType?: ComputeType;\n\n  /**\n   * The image to use for builds.\n   *\n   * @default LinuxBuildImage.AMAZON_LINUX_2_3\n   */\n  readonly buildImage?: IBuildImage;\n\n  /**\n   * The Slack channel configuration to use for notifications.\n   */\n  readonly slackChannelConfigurationArn?: string;\n\n  /**\n   * The list of notification events to receive. By default, this is all notifications.\n   *\n   * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline\n   */\n  readonly notificationEvents?: string[];\n\n  /**\n   * Additional FileSets to put in other directories\n   */\n  readonly additionalInputs?: Record<string, IFileSetProducer>;\n\n  /**\n   * Overrides default commands.\n   */\n  readonly commands?: string[];\n}\n\n/**\n * An abstraction to ease CDK pipeline creation and configuration.\n */\nexport class CdkPipeline extends Construct {\n\n  readonly pipeline: CodePipeline;\n  readonly pipelineNotificationRule: PipelineNotificationRule;\n\n  constructor(scope: Construct, id: string, props: CdkPipelineProps) {\n    super(scope, id);\n\n    const encryptionKey = Key.fromKeyArn(this, 'EncryptionKey', props.keyArn);\n\n    const artifactBucket = new ArtifactBucket(this, 'ArtifactBucket', {\n      encryptionKey,\n      accountIds: props.accountIds\n    });\n\n    const underlyingPipeline = new Pipeline(this, 'Pipeline', {\n      artifactBucket\n    });\n\n    const input = CodePipelineSource.connection(props.repo, props.branch, {\n      connectionArn: props.connectionArn\n    });\n\n    const stackName = Stack.of(this).stackName;\n\n    this.pipeline = new CodePipeline(this, 'CodePipeline', {\n      codePipeline: underlyingPipeline,\n      selfMutation: props.selfMutation??true,\n      dockerEnabledForSynth: props.dockerEnabledForSynth??true,\n      dockerEnabledForSelfMutation: props.dockerEnabledForSelfMutation??true,\n      synth: new ShellStep('Synth', {\n        primaryOutputDirectory: 'cdk.out',\n        input,\n        commands: props.commands??[\n          'mkdir /tmp/npm-cache',\n          'npm config set fund false',\n          'npm config set cache /tmp/npm-cache --location=global',\n          'npm ci --prefer-offline',\n          'npm run build',\n          'npm run test',\n          `npx cdk synth ${stackName}`\n        ],\n        additionalInputs: props.additionalInputs??{}\n      }),\n      synthCodeBuildDefaults: {\n        partialBuildSpec: BuildSpec.fromObject({\n          cache: {\n            paths: \"/tmp/npm-cache\"\n          },\n          phases: {\n            install: {\n              commands: [\n                \"n 16\", // Install Node v16\n                \"npm i --location=global --no-fund esbuild\" // Install esbuild locally\n              ]\n            }\n          }\n        }),\n        buildEnvironment: {\n          computeType: props.computeType??ComputeType.SMALL,\n          buildImage: props.buildImage??LinuxBuildImage.AMAZON_LINUX_2_3\n        }\n      }\n    });\n    if (props.slackChannelConfigurationArn) {\n      this.pipelineNotificationRule = new PipelineNotificationRule(this, 'Notification', {\n        source: underlyingPipeline,\n        slackChannelConfigurationArn: props.slackChannelConfigurationArn\n      });\n    }\n  }\n\n  addStage(stage: Stage, options?: AddStageOpts): StageDeployment {\n    return this.pipeline.addStage(stage, options);\n  }\n\n  addWave(id: string, options?: WaveOptions): Wave {\n    return this.pipeline.addWave(id, options);\n  }\n}\n"]}

package/aws-route53/lib/domain-name.d.ts

@@ -0,0 +1,119 @@
+import { ARecord, IHostedZone, RecordTarget } from "aws-cdk-lib/aws-route53";
+import { Construct } from "constructs";
+/**
+ * Properties for DomainName
+ */
+export interface DomainNameProps {
+    readonly prefix: string;
+    readonly zone: string | IHostedZone;
+    readonly privateZone?: boolean;
+    readonly vpcId?: string;
+}
+/**
+ * Utility class for holding domain name information and
+ * doing useful things with it.
+ */
+export declare class DomainName {
+    protected readonly prefix: string;
+    protected readonly zone: string;
+    protected hostedZone?: IHostedZone;
+    protected readonly privateZone: boolean;
+    protected readonly vpcId?: string;
+    /**
+     * Creates a new DomainName.
+     *
+     * @param props the properties of the domain name
+     */
+    constructor(props: DomainNameProps);
+    /**
+     * Returns the prefix for this domain name.
+     */
+    getPrefix(): string;
+    /**
+     * Returns true if the zone is private. False if otherwise.
+     */
+    inPrivateZone(): boolean;
+    /**
+     * Returns the vpc ID for this zone or undefined if one does not exist
+     */
+    getVpcId(): string | undefined;
+    /**
+     * Returns true if the props match the domain name. False if otherwise.
+     *
+     * @param props the props to compare
+     */
+    propsMatch(props: DomainNameProps): boolean;
+    /**
+     * Returns the string version of this domain name.
+     */
+    toString(): string;
+    /**
+     * Returns a friendly identifier for this domain name.
+     */
+    toIdentifier(): string;
+    /**
+     * Returns the zone associated with this domain name.
+     *
+     * @param scope the scope to use if a lookup is required
+     * @param id an optional ID if a lookup is required; one is generated if not provided
+     */
+    getHostedZone(scope: Construct, id?: string): IHostedZone;
+    /**
+     * Creates a Route53 ARecord for this domain name.
+     *
+     * @param scope the scope to create the record in
+     * @param target the target of the record
+     */
+    createARecord(scope: Construct, target: RecordTarget): ARecord;
+    /**
+     * Converts an array of DomainNameProps to DomainName. This function will return an empty array
+     * if domainNameProps is undefined.
+     *
+     * @param domainNameProps the DomainNameProps objects to convert
+     */
+    static fromProps(domainNameProps?: DomainNameProps[]): DomainName[];
+    /**
+     * Converts an array of DomainName objects to an array of strings. This function will return an
+     * empty array if domainNames is undefined.
+     *
+     * @param domainNames the DomainName objects to convert
+     */
+    static toStrings(domainNames?: DomainName[]): string[];
+    /**
+     * Converts an array of DomainNameProps to an array of strings. This function will
+     * return an empty array if domainNameProps is undefined.
+     *
+     * @param domainNameProps the DomainNameProps objects to convert
+     */
+    static toStringsFromProps(domainNameProps?: DomainNameProps[]): string[];
+    /**
+     * Converts an array of DomainName objects to a map where the key is the domain name string and the value
+     * is an IHostedZone. This method will return an empty map if domainNames is undefined. This function
+     * is useful when used in conjunction with functions like CertificateValidation.fromDnsMultiZone.
+     *
+     * @param scope the scope used if a zone lookup is required
+     * @param domainNames the DomainName objects to convert
+     */
+    static toZoneMap(scope: Construct, domainNames?: DomainName[]): {
+        [domainName: string]: IHostedZone;
+    };
+    /**
+     * Converts an arry of DomainNameProps objects to a map where the key is the domain name string and the
+     * value is an IHostedZone. This method will return an empty map if domainNameProps is undefined. This
+     * function is useful when used in conjunction with functions like CertificateValidation.fromDnsMultiZone.
+     *
+     * @param scope the scope used if a zone lookup is required
+     * @param domainNameProps the DomainNameProps objects to convert
+     */
+    static toZoneMapFromProps(scope: Construct, domainNameProps: DomainNameProps[]): {
+        [domainName: string]: IHostedZone;
+    };
+    /**
+     * Finds the domain name matching the given properties in an array of DomainName objects.
+     *
+     * @param props the properties to compare
+     * @param domainNames the domain names to search
+     * @return the matching domain name or undefined
+     */
+    static findDomainName(props: DomainNameProps, domainNames?: DomainName[]): DomainName | undefined;
+}

package/aws-route53/lib/domain-name.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainName = void 0;
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+/**
+ * Utility class for holding domain name information and
+ * doing useful things with it.
+ */
+class DomainName {
+    /**
+     * Creates a new DomainName.
+     *
+     * @param props the properties of the domain name
+     */
+    constructor(props) {
+        var _a;
+        this.prefix = props.prefix;
+        if (typeof props.zone === "string") {
+            this.zone = props.zone;
+        }
+        else {
+            this.hostedZone = props.zone;
+            this.zone = this.hostedZone.zoneName;
+        }
+        this.privateZone = (_a = props.privateZone) !== null && _a !== void 0 ? _a : false;
+        this.vpcId = props.vpcId;
+    }
+    /**
+     * Returns the prefix for this domain name.
+     */
+    getPrefix() {
+        return this.prefix;
+    }
+    /**
+     * Returns true if the zone is private. False if otherwise.
+     */
+    inPrivateZone() {
+        return this.privateZone;
+    }
+    /**
+     * Returns the vpc ID for this zone or undefined if one does not exist
+     */
+    getVpcId() {
+        return this.vpcId;
+    }
+    /**
+     * Returns true if the props match the domain name. False if otherwise.
+     *
+     * @param props the props to compare
+     */
+    propsMatch(props) {
+        let propZoneStr = typeof props.zone === "string" ? props.zone : props.zone.zoneName;
+        return this.prefix === props.prefix
+            && this.zone === propZoneStr
+            && this.privateZone === props.privateZone
+            && this.vpcId === props.vpcId;
+    }
+    /**
+     * Returns the string version of this domain name.
+     */
+    toString() {
+        return (this.prefix == "" ? "" : this.prefix + ".") + this.zone;
+    }
+    /**
+     * Returns a friendly identifier for this domain name.
+     */
+    toIdentifier() {
+        return this.toString().replace(".", "-");
+    }
+    /**
+     * Returns the zone associated with this domain name.
+     *
+     * @param scope the scope to use if a lookup is required
+     * @param id an optional ID if a lookup is required; one is generated if not provided
+     */
+    getHostedZone(scope, id) {
+        if (this.hostedZone === undefined) {
+            this.hostedZone = aws_route53_1.HostedZone.fromLookup(scope, id !== null && id !== void 0 ? id : `${this.toIdentifier()}-zone`, {
+                domainName: this.zone,
+                privateZone: this.privateZone,
+                vpcId: this.vpcId
+            });
+        }
+        return this.hostedZone;
+    }
+    /**
+     * Creates a Route53 ARecord for this domain name.
+     *
+     * @param scope the scope to create the record in
+     * @param target the target of the record
+     */
+    createARecord(scope, target) {
+        return new aws_route53_1.ARecord(scope, `${this.toIdentifier()}-arecord`, {
+            zone: this.getHostedZone(scope),
+            recordName: this.toString(),
+            target
+        });
+    }
+    /**
+     * Converts an array of DomainNameProps to DomainName. This function will return an empty array
+     * if domainNameProps is undefined.
+     *
+     * @param domainNameProps the DomainNameProps objects to convert
+     */
+    static fromProps(domainNameProps) {
+        return domainNameProps === undefined ? [] : domainNameProps.map(p => new DomainName(p));
+    }
+    /**
+     * Converts an array of DomainName objects to an array of strings. This function will return an
+     * empty array if domainNames is undefined.
+     *
+     * @param domainNames the DomainName objects to convert
+     */
+    static toStrings(domainNames) {
+        return domainNames === undefined ? [] : domainNames.map(d => d.toString());
+    }
+    /**
+     * Converts an array of DomainNameProps to an array of strings. This function will
+     * return an empty array if domainNameProps is undefined.
+     *
+     * @param domainNameProps the DomainNameProps objects to convert
+     */
+    static toStringsFromProps(domainNameProps) {
+        return domainNameProps === undefined ? [] : DomainName.toStrings(DomainName.fromProps(domainNameProps));
+    }
+    /**
+     * Converts an array of DomainName objects to a map where the key is the domain name string and the value
+     * is an IHostedZone. This method will return an empty map if domainNames is undefined. This function
+     * is useful when used in conjunction with functions like CertificateValidation.fromDnsMultiZone.
+     *
+     * @param scope the scope used if a zone lookup is required
+     * @param domainNames the DomainName objects to convert
+     */
+    static toZoneMap(scope, domainNames) {
+        const map = {};
+        if (domainNames !== undefined) {
+            domainNames.forEach(d => {
+                map[d.toString()] = d.getHostedZone(scope);
+            });
+        }
+        return map;
+    }
+    /**
+     * Converts an arry of DomainNameProps objects to a map where the key is the domain name string and the
+     * value is an IHostedZone. This method will return an empty map if domainNameProps is undefined. This
+     * function is useful when used in conjunction with functions like CertificateValidation.fromDnsMultiZone.
+     *
+     * @param scope the scope used if a zone lookup is required
+     * @param domainNameProps the DomainNameProps objects to convert
+     */
+    static toZoneMapFromProps(scope, domainNameProps) {
+        return DomainName.toZoneMap(scope, DomainName.fromProps(domainNameProps));
+    }
+    /**
+     * Finds the domain name matching the given properties in an array of DomainName objects.
+     *
+     * @param props the properties to compare
+     * @param domainNames the domain names to search
+     * @return the matching domain name or undefined
+     */
+    static findDomainName(props, domainNames) {
+        for (let domainName of domainNames !== null && domainNames !== void 0 ? domainNames : []) {
+            if (domainName.propsMatch(props)) {
+                return domainName;
+            }
+        }
+        return undefined;
+    }
+}
+exports.DomainName = DomainName;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"domain-name.js","sourceRoot":"","sources":["domain-name.ts"],"names":[],"mappings":"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","sourcesContent":["import {ARecord, HostedZone, IHostedZone, RecordTarget} from \"aws-cdk-lib/aws-route53\";\nimport {Construct} from \"constructs\";\n\n/**\n * Properties for DomainName\n */\nexport interface DomainNameProps {\n  readonly prefix: string;\n  readonly zone: string | IHostedZone;\n  readonly privateZone?: boolean;\n  readonly vpcId?: string;\n}\n\n/**\n * Utility class for holding domain name information and\n * doing useful things with it.\n */\nexport class DomainName {\n\n  protected readonly prefix: string;\n  protected readonly zone: string;\n  protected hostedZone?: IHostedZone;\n  protected readonly privateZone: boolean;\n  protected readonly vpcId?: string;\n\n  /**\n   * Creates a new DomainName.\n   *\n   * @param props the properties of the domain name\n   */\n  constructor(props: DomainNameProps) {\n    this.prefix = props.prefix;\n    if (typeof props.zone === \"string\") {\n      this.zone = props.zone;\n    } else {\n      this.hostedZone = props.zone;\n      this.zone = this.hostedZone.zoneName;\n    }\n    this.privateZone = props.privateZone ?? false;\n    this.vpcId = props.vpcId;\n  }\n\n  /**\n   * Returns the prefix for this domain name.\n   */\n  getPrefix(): string {\n    return this.prefix;\n  }\n\n  /**\n   * Returns true if the zone is private. False if otherwise.\n   */\n  inPrivateZone(): boolean {\n    return this.privateZone;\n  }\n\n  /**\n   * Returns the vpc ID for this zone or undefined if one does not exist\n   */\n  getVpcId(): string | undefined {\n    return this.vpcId;\n  }\n\n  /**\n   * Returns true if the props match the domain name. False if otherwise.\n   *\n   * @param props the props to compare\n   */\n  propsMatch(props: DomainNameProps): boolean {\n    let propZoneStr = typeof props.zone === \"string\" ? props.zone : props.zone.zoneName;\n    return this.prefix === props.prefix\n      && this.zone === propZoneStr\n      && this.privateZone === props.privateZone\n      && this.vpcId === props.vpcId\n  }\n\n  /**\n   * Returns the string version of this domain name.\n   */\n  toString(): string {\n    return (this.prefix == \"\" ? \"\" : this.prefix + \".\") + this.zone;\n  }\n\n  /**\n   * Returns a friendly identifier for this domain name.\n   */\n  toIdentifier(): string {\n    return this.toString().replace(\".\", \"-\");\n  }\n\n  /**\n   * Returns the zone associated with this domain name.\n   *\n   * @param scope the scope to use if a lookup is required\n   * @param id an optional ID if a lookup is required; one is generated if not provided\n   */\n  getHostedZone(scope: Construct, id?: string) : IHostedZone {\n    if (this.hostedZone === undefined) {\n      this.hostedZone = HostedZone.fromLookup(scope, id ?? `${this.toIdentifier()}-zone`, {\n        domainName: this.zone,\n        privateZone: this.privateZone,\n        vpcId: this.vpcId\n      });\n    }\n    return this.hostedZone;\n  }\n\n  /**\n   * Creates a Route53 ARecord for this domain name.\n   *\n   * @param scope the scope to create the record in\n   * @param target the target of the record\n   */\n  createARecord(scope: Construct, target: RecordTarget): ARecord {\n    return new ARecord(scope, `${this.toIdentifier()}-arecord`, {\n      zone: this.getHostedZone(scope),\n      recordName: this.toString(),\n      target\n    });\n  }\n\n  /**\n   * Converts an array of DomainNameProps to DomainName. This function will return an empty array\n   * if domainNameProps is undefined.\n   *\n   * @param domainNameProps the DomainNameProps objects to convert\n   */\n  static fromProps(domainNameProps?: DomainNameProps[]) : DomainName[] {\n    return domainNameProps === undefined ? [] : domainNameProps.map(p => new DomainName(p));\n  }\n\n  /**\n   * Converts an array of DomainName objects to an array of strings. This function will return an\n   * empty array if domainNames is undefined.\n   *\n   * @param domainNames the DomainName objects to convert\n   */\n  static toStrings(domainNames?: DomainName[]) : string[] {\n    return domainNames === undefined ? [] : domainNames.map(d => d.toString());\n  }\n\n  /**\n   * Converts an array of DomainNameProps to an array of strings. This function will\n   * return an empty array if domainNameProps is undefined.\n   *\n   * @param domainNameProps the DomainNameProps objects to convert\n   */\n  static toStringsFromProps(domainNameProps?: DomainNameProps[]) : string[] {\n    return domainNameProps === undefined ? [] : DomainName.toStrings(DomainName.fromProps(domainNameProps));\n  }\n\n  /**\n   * Converts an array of DomainName objects to a map where the key is the domain name string and the value\n   * is an IHostedZone. This method will return an empty map if domainNames is undefined. This function\n   * is useful when used in conjunction with functions like CertificateValidation.fromDnsMultiZone.\n   *\n   * @param scope the scope used if a zone lookup is required\n   * @param domainNames the DomainName objects to convert\n   */\n  static toZoneMap(scope: Construct, domainNames?: DomainName[]) : { [domainName: string]: IHostedZone } {\n    const map: {[key: string]: IHostedZone} = {}\n    if (domainNames !== undefined) {\n      domainNames.forEach(d => {\n        map[d.toString()] = d.getHostedZone(scope)\n      });\n    }\n    return map;\n  }\n\n  /**\n   * Converts an arry of DomainNameProps objects to a map where the key is the domain name string and the\n   * value is an IHostedZone. This method will return an empty map if domainNameProps is undefined. This\n   * function is useful when used in conjunction with functions like CertificateValidation.fromDnsMultiZone.\n   *\n   * @param scope the scope used if a zone lookup is required\n   * @param domainNameProps the DomainNameProps objects to convert\n   */\n  static toZoneMapFromProps(scope: Construct, domainNameProps: DomainNameProps[]) : { [domainName: string]: IHostedZone } {\n    return DomainName.toZoneMap(scope, DomainName.fromProps(domainNameProps));\n  }\n\n  /**\n   * Finds the domain name matching the given properties in an array of DomainName objects.\n   *\n   * @param props the properties to compare\n   * @param domainNames the domain names to search\n   * @return the matching domain name or undefined\n   */\n  static findDomainName(props: DomainNameProps, domainNames?: DomainName[]): DomainName | undefined {\n    for (let domainName of domainNames ?? []) {\n      if (domainName.propsMatch(props)) {\n        return domainName;\n      }\n    }\n    return undefined;\n  }\n}\n"]}

package/aws-route53/lib/index.d.ts

@@ -1,3 +1,4 @@
 export * from './latency-a-record';
 export * from './weighted-a-record';
 export * from './weighted-latency-a-record';
+export * from "./domain-name";

package/aws-route53/lib/index.js

@@ -13,4 +13,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./latency-a-record"), exports);
 __exportStar(require("./weighted-a-record"), exports);
 __exportStar(require("./weighted-latency-a-record"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxxREFBbUM7QUFDbkMsc0RBQW9DO0FBQ3BDLDhEQUE0QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGF0ZW5jeS1hLXJlY29yZCc7XG5leHBvcnQgKiBmcm9tICcuL3dlaWdodGVkLWEtcmVjb3JkJztcbmV4cG9ydCAqIGZyb20gJy4vd2VpZ2h0ZWQtbGF0ZW5jeS1hLXJlY29yZCc7XG4iXX0=
+__exportStar(require("./domain-name"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxxREFBbUM7QUFDbkMsc0RBQW9DO0FBQ3BDLDhEQUE0QztBQUM1QyxnREFBOEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xhdGVuY3ktYS1yZWNvcmQnO1xuZXhwb3J0ICogZnJvbSAnLi93ZWlnaHRlZC1hLXJlY29yZCc7XG5leHBvcnQgKiBmcm9tICcuL3dlaWdodGVkLWxhdGVuY3ktYS1yZWNvcmQnO1xuZXhwb3J0ICogZnJvbSBcIi4vZG9tYWluLW5hbWVcIjtcbiJdfQ==

package/aws-website/lib/website.d.ts

@@ -1,22 +1,21 @@
 import { Construct } from "constructs";
 import { IBucket } from "aws-cdk-lib/aws-s3";
 import { Distribution, Function, HttpVersion, OriginAccessIdentity, PriceClass, SecurityPolicyProtocol } from "aws-cdk-lib/aws-cloudfront";
-import { ARecord, IHostedZone } from "aws-cdk-lib/aws-route53";
+import { ARecord } from "aws-cdk-lib/aws-route53";
 import { BucketDeployment } from "aws-cdk-lib/aws-s3-deployment";
 import { BundlingOptions, Duration } from "aws-cdk-lib";
+import { DomainNameProps } from "../../aws-route53";
 export declare enum SourceType {
     Custom = "Custom",
     Hugo = "Hugo",
     NpmDist = "NpmDist",
     Static = "Static"
 }
-export declare class DomainName {
-    readonly prefix: string;
-    readonly zone: string | IHostedZone;
+/**
+ * Properties for WebsiteDomainName.
+ */
+export interface WebsiteDomainNameProps extends DomainNameProps {
     readonly createRecord?: boolean;
-    constructor(prefix: string, zone: string | IHostedZone, createRecord?: boolean);
-    toString(): string;
-    toIdentifier(): string;
 }
 export interface WebsiteProps {
     /**
@@ -35,7 +34,7 @@ export interface WebsiteProps {
     /**
      * The domain names to be serviced. The first domain name in the list is treated as the apex domain.
      */
-    readonly domainNames?: DomainName[];
+    readonly domainNames?: WebsiteDomainNameProps[];
     /**
      * Redirect traffic to the first domain in the list of domainNames.
      *

package/aws-website/lib/website.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Website = exports.DomainName = exports.SourceType = void 0;
+exports.Website = exports.SourceType = void 0;
 const constructs_1 = require("constructs");
 const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
 const aws_cloudfront_origins_1 = require("aws-cdk-lib/aws-cloudfront-origins");
@@ -10,6 +10,7 @@ const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
 const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_s3_1 = require("../../aws-s3");
+const aws_route53_2 = require("../../aws-route53");
 var SourceType;
 (function (SourceType) {
     SourceType["Custom"] = "Custom";
@@ -17,24 +18,22 @@ var SourceType;
     SourceType["NpmDist"] = "NpmDist";
     SourceType["Static"] = "Static";
 })(SourceType = exports.SourceType || (exports.SourceType = {}));
-class DomainName {
-    constructor(prefix, zone, createRecord) {
-        this.prefix = prefix;
-        this.zone = zone;
-        this.createRecord = createRecord;
-    }
-    toString() {
-        return (this.prefix == "" ? "" : this.prefix + ".") + this.zone;
-    }
-    toIdentifier() {
-        return this.toString().replace(".", "-");
-    }
-}
-exports.DomainName = DomainName;
 class Website extends constructs_1.Construct {
     constructor(scope, id, props) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         super(scope, id);
+        const domainNames = aws_route53_2.DomainName.fromProps(props.domainNames);
+        let certificate = undefined;
+        if (props.certificateArn !== undefined) {
+            certificate = aws_certificatemanager_1.Certificate.fromCertificateArn(this, "Certificate", props.certificateArn);
+        }
+        else if (domainNames.length > 0) {
+            certificate = new aws_certificatemanager_1.Certificate(this, "Certificate", {
+                domainName: domainNames[0].toString(),
+                subjectAlternativeNames: aws_route53_2.DomainName.toStrings(domainNames).slice(1),
+                validation: aws_certificatemanager_1.CertificateValidation.fromDnsMultiZone(aws_route53_2.DomainName.toZoneMap(this, domainNames))
+            });
+        }
         this.bucket = (_a = props.bucket) !== null && _a !== void 0 ? _a : new aws_s3_1.ExtendedBucket(this, "Bucket", {
             removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
             autoDeleteObjects: true
@@ -45,7 +44,7 @@ class Website extends constructs_1.Construct {
         if (this.fallbackBucket) {
             this.fallbackBucket.grantRead(this.originAccessIdentity);
         }
-        this.apexDomain = ((_b = props === null || props === void 0 ? void 0 : props.domainNames) === null || _b === void 0 ? void 0 : _b[0].toString()) || "";
+        this.apexDomain = domainNames.length > 0 ? domainNames[0].toString() : "";
         this.viewerRequestFunction = new aws_cloudfront_1.Function(this, "ViewerRequestFunction", {
             code: aws_cloudfront_1.FunctionCode.fromInline(`
 function handler(event) {
@@ -67,7 +66,7 @@ function handler(event) {
   return event.request;
 }`
                 .replace(/APEX_DOMAIN/g, this.apexDomain)
-                .replace(/MATCH_APEX/g, this.apexDomain !== "" && ((_c = props.redirectToApexDomain) !== null && _c !== void 0 ? _c : true) ? "true" : "false"))
+                .replace(/MATCH_APEX/g, this.apexDomain !== "" && ((_b = props.redirectToApexDomain) !== null && _b !== void 0 ? _b : true) ? "true" : "false"))
         });
         const bucketOrigin = new aws_cloudfront_origins_1.S3Origin(this.bucket, {
             originAccessIdentity: this.originAccessIdentity
@@ -97,27 +96,21 @@ function handler(event) {
                     responsePagePath: "/404.html"
                 }
             ],
-            httpVersion: (_d = props.httpVersion) !== null && _d !== void 0 ? _d : aws_cloudfront_1.HttpVersion.HTTP1_1,
-            minimumProtocolVersion: (_e = props.minimumProtocolVersion) !== null && _e !== void 0 ? _e : aws_cloudfront_1.SecurityPolicyProtocol.TLS_V1_2_2021,
+            httpVersion: (_c = props.httpVersion) !== null && _c !== void 0 ? _c : aws_cloudfront_1.HttpVersion.HTTP1_1,
+            minimumProtocolVersion: (_d = props.minimumProtocolVersion) !== null && _d !== void 0 ? _d : aws_cloudfront_1.SecurityPolicyProtocol.TLS_V1_2_2021,
             defaultRootObject: "index.html",
-            certificate: (props === null || props === void 0 ? void 0 : props.certificateArn) == undefined ? undefined : aws_certificatemanager_1.Certificate.fromCertificateArn(this, "Certificate", props.certificateArn),
-            domainNames: (_f = props === null || props === void 0 ? void 0 : props.domainNames) === null || _f === void 0 ? void 0 : _f.map((domainName) => domainName.toString()),
+            certificate,
+            domainNames: aws_route53_2.DomainName.toStrings(domainNames),
             enableIpv6: true,
-            priceClass: (_g = props.priceClass) !== null && _g !== void 0 ? _g : aws_cloudfront_1.PriceClass.PRICE_CLASS_100
+            priceClass: (_e = props.priceClass) !== null && _e !== void 0 ? _e : aws_cloudfront_1.PriceClass.PRICE_CLASS_100
         });
         this.distributionUrl = `https://${(this.apexDomain != "" ? this.apexDomain : this.distribution.distributionDomainName)}`;
         this.aRecords = [];
-        if ((props === null || props === void 0 ? void 0 : props.domainNames) != undefined && props.domainNames.length > 0) {
-            for (let domainName of props.domainNames) {
-                if ((_h = domainName.createRecord) !== null && _h !== void 0 ? _h : true) {
-                    let zone = typeof domainName.zone !== "string" ? domainName.zone : aws_route53_1.HostedZone.fromLookup(this, "zone-" + domainName.toIdentifier(), {
-                        domainName: domainName.zone
-                    });
-                    this.aRecords.push(new aws_route53_1.ARecord(this, domainName.toIdentifier(), {
-                        zone: zone,
-                        recordName: domainName.toString(),
-                        target: aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.CloudFrontTarget(this.distribution))
-                    }));
+        for (let domainNameProps of (_f = props.domainNames) !== null && _f !== void 0 ? _f : []) {
+            if ((_g = domainNameProps.createRecord) !== null && _g !== void 0 ? _g : true) {
+                let domainName = aws_route53_2.DomainName.findDomainName(domainNameProps, domainNames);
+                if (domainName !== undefined) {
+                    this.aRecords.push(domainName.createARecord(this, aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.CloudFrontTarget(this.distribution))));
                 }
             }
         }
@@ -152,14 +145,14 @@ function handler(event) {
             sources: [source],
             destinationBucket: this.bucket,
             distribution: this.distribution,
-            cacheControl: [aws_s3_deployment_1.CacheControl.maxAge((_j = props.maxAge) !== null && _j !== void 0 ? _j : aws_cdk_lib_1.Duration.minutes(60))],
+            cacheControl: [aws_s3_deployment_1.CacheControl.maxAge((_h = props.maxAge) !== null && _h !== void 0 ? _h : aws_cdk_lib_1.Duration.minutes(60))],
             prune: false
         });
         if (this.fallbackBucket) {
             this.fallbackDeployment = new aws_s3_deployment_1.BucketDeployment(this, "FallbackAssets", {
                 sources: [source],
                 destinationBucket: this.fallbackBucket,
-                cacheControl: [aws_s3_deployment_1.CacheControl.maxAge((_k = props.maxAge) !== null && _k !== void 0 ? _k : aws_cdk_lib_1.Duration.minutes(60))],
+                cacheControl: [aws_s3_deployment_1.CacheControl.maxAge((_j = props.maxAge) !== null && _j !== void 0 ? _j : aws_cdk_lib_1.Duration.minutes(60))],
                 prune: false
             });
         }
@@ -190,4 +183,4 @@ Website.NPM_DIST_BUNDLING_OPTIONS = {
         ].join(" && ")
     ]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"website.js","sourceRoot":"","sources":["website.ts"],"names":[],"mappings":"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","sourcesContent":["import {Construct} from \"constructs\";\nimport {Bucket, IBucket} from \"aws-cdk-lib/aws-s3\";\nimport {\n  Distribution,\n  Function,\n  FunctionCode,\n  FunctionEventType,\n  HttpVersion,\n  OriginAccessIdentity,\n  PriceClass,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {OriginGroup, S3Origin} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport {Certificate} from \"aws-cdk-lib/aws-certificatemanager\";\nimport {ARecord, HostedZone, IHostedZone, RecordTarget} from \"aws-cdk-lib/aws-route53\";\nimport {CloudFrontTarget} from \"aws-cdk-lib/aws-route53-targets\";\nimport {BucketDeployment, CacheControl, Source} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {BundlingOptions, DockerImage, Duration, RemovalPolicy} from \"aws-cdk-lib\";\nimport {ExtendedBucket} from \"../../aws-s3\";\n\nexport enum SourceType {\n  Custom = \"Custom\",\n  Hugo = \"Hugo\",\n  NpmDist = \"NpmDist\",\n  Static = \"Static\"\n}\n\nexport class DomainName {\n  readonly prefix: string;\n  readonly zone: string | IHostedZone;\n  readonly createRecord?: boolean;\n\n  constructor(prefix: string, zone: string | IHostedZone, createRecord?: boolean) {\n    this.prefix = prefix;\n    this.zone = zone;\n    this.createRecord = createRecord\n  }\n\n  toString() {\n    return (this.prefix == \"\" ? \"\" : this.prefix + \".\") + this.zone;\n  }\n\n  toIdentifier() {\n    return this.toString().replace(\".\", \"-\");\n  }\n}\n\nexport interface WebsiteProps {\n\n  /**\n   * Bucket to use to store website content. If one is not provided, one will be generated.\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * Bucket to use if the primary bucket fails. If one is not provided a fallback is not setup.\n   */\n  readonly fallbackBucket?: IBucket;\n\n  /**\n   * The ARN to the ACM Certificate to use on the CloudFront distribution. If one is not\n   * provided and domainNames is populated, one will be generated.\n   */\n  readonly certificateArn?: string\n\n  /**\n   * The domain names to be serviced. The first domain name in the list is treated as the apex domain.\n   */\n  readonly domainNames?: DomainName[]\n\n  /**\n   * Redirect traffic to the first domain in the list of domainNames.\n   *\n   * @default true\n   */\n  readonly redirectToApexDomain?: boolean;\n\n  /**\n   * Price class for the CloudFront distribution.\n   *\n   * @default PriceClass.PRICE_CLASS_100\n   */\n  readonly priceClass?: PriceClass\n\n  /**\n   * Minimum protocol version to allow.\n   *\n   * @default SecurityPolicyProtocol.TLS_V1_2_2021,\n   */\n  readonly minimumProtocolVersion?: SecurityPolicyProtocol;\n\n  /**\n   * Minimum HTTP version to allow.\n   *\n   * @default HttpVersion.HTTP1_1\n   */\n  readonly httpVersion?: HttpVersion;\n\n  /**\n   * Cache-control max age.\n   *\n   * @default Duration.minutes(60)\n   */\n  readonly maxAge?: Duration;\n\n  /**\n   * The source type of the website.\n   *\n   * @default SourceType.Static\n   */\n  readonly sourceType?: SourceType;\n\n  /**\n   * The directory where the website sources are located.\n   */\n  readonly sourceDirectory: string;\n\n  /**\n   * Custom bundling options to use to bundle website sources. The sourceType\n   * must be set to SourceType.Custom.\n   */\n  readonly sourceBundlingOptions?: BundlingOptions\n}\n\nexport class Website extends Construct {\n\n  /**\n   * The default bundling options for SourceType.Hugo.\n   */\n  static readonly HUGO_BUNDLING_OPTIONS: BundlingOptions = {\n    image: DockerImage.fromRegistry(\"klakegg/hugo:latest-ext\"),\n    command: [\n      \"-d\", \"/asset-output\"\n    ]\n  }\n\n  /**\n   * The default bundling options for SourceType.NpmDist. It\"s expected that \"npm run dist\" command\n   * will place files in ${CDK_BUNDLING_OUTPUT_DIR}. Example: \"ng build --output-path=/asset-output\"\n   */\n  static readonly NPM_DIST_BUNDLING_OPTIONS: BundlingOptions = {\n    image: DockerImage.fromRegistry(\"node:16-alpine\"),\n    command: [\n      // TODO Figure out how to cache .npmcache\n      \"sh\", \"-c\", [\n        \"mkdir -p .npmcache\",\n        \"npm ci --cache .npmcache --prefer-offline\",\n        \"npm run dist\"\n      ].join(\" && \")\n    ]\n  }\n\n  readonly bucket: IBucket;\n  readonly fallbackBucket?: IBucket;\n  readonly originAccessIdentity: OriginAccessIdentity;\n  readonly apexDomain: string;\n  readonly viewerRequestFunction: Function;\n  readonly distribution: Distribution;\n  readonly distributionUrl: string;\n  readonly aRecords: ARecord[];\n  readonly deployment: BucketDeployment;\n  readonly fallbackDeployment?: BucketDeployment;\n\n  constructor(scope: Construct, id: string, props: WebsiteProps) {\n    super(scope, id);\n\n    this.bucket = props.bucket ?? new ExtendedBucket(this, \"Bucket\", {\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true\n    });\n    this.fallbackBucket = props.fallbackBucket;\n\n    this.originAccessIdentity = new OriginAccessIdentity(this, \"Access\");\n    this.bucket.grantRead(this.originAccessIdentity);\n    if (this.fallbackBucket) {\n      this.fallbackBucket.grantRead(this.originAccessIdentity);\n    }\n\n    this.apexDomain = props?.domainNames?.[0].toString() || \"\";\n\n    this.viewerRequestFunction = new Function(this, \"ViewerRequestFunction\", {\n      code: FunctionCode.fromInline(`\nfunction handler(event) {\n  var host = event.request.headers.host.value;\n  var uri = event.request.uri;\n  var matchApex = MATCH_APEX;\n  if (matchApex && host !== \"APEX_DOMAIN\") {\n    return {\n      statusCode: 301,\n      statusDescription: \"Permanently moved\",\n      headers: {\n        \"location\": { \"value\": \"https://APEX_DOMAIN\" + uri }\n      }\n    }\n  }\n  if (uri.endsWith(\"/\")) {\n    event.request.uri = uri + \"index.html\";\n  }\n  return event.request;\n}`\n        .replace(/APEX_DOMAIN/g, this.apexDomain)\n        .replace(/MATCH_APEX/g, this.apexDomain !== \"\" && (props.redirectToApexDomain??true) ? \"true\" : \"false\"))\n    });\n\n    const bucketOrigin = new S3Origin(this.bucket, {\n      originAccessIdentity: this.originAccessIdentity\n    });\n\n    const fallbackBucketOrigin = this.fallbackBucket === undefined ? undefined : new S3Origin(this.fallbackBucket, {\n      originAccessIdentity: this.originAccessIdentity\n    });\n\n    const defaultOrigin = fallbackBucketOrigin === undefined ? bucketOrigin : new OriginGroup({\n      primaryOrigin: bucketOrigin,\n      fallbackOrigin: fallbackBucketOrigin\n    });\n\n    this.distribution = new Distribution(this, \"Distribution\", {\n      defaultBehavior: {\n        origin: defaultOrigin,\n        viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n        functionAssociations: [\n          {\n            function: this.viewerRequestFunction,\n            eventType: FunctionEventType.VIEWER_REQUEST\n          }\n        ]\n      },\n      errorResponses: [\n        {\n          httpStatus: 404,\n          responseHttpStatus: 404,\n          responsePagePath: \"/404.html\"\n        }\n      ],\n      httpVersion: props.httpVersion??HttpVersion.HTTP1_1,\n      minimumProtocolVersion: props.minimumProtocolVersion??SecurityPolicyProtocol.TLS_V1_2_2021,\n      defaultRootObject: \"index.html\",\n      certificate: props?.certificateArn == undefined ? undefined : Certificate.fromCertificateArn(this, \"Certificate\", props.certificateArn),\n      domainNames: props?.domainNames?.map((domainName) => domainName.toString()),\n      enableIpv6: true,\n      priceClass: props.priceClass??PriceClass.PRICE_CLASS_100\n    });\n\n    this.distributionUrl = `https://${(this.apexDomain != \"\" ? this.apexDomain : this.distribution.distributionDomainName)}`\n\n    this.aRecords = [];\n\n    if (props?.domainNames != undefined && props.domainNames.length > 0) {\n      for (let domainName of props.domainNames) {\n        if (domainName.createRecord??true) {\n          let zone = typeof domainName.zone !== \"string\" ? domainName.zone : HostedZone.fromLookup(this, \"zone-\" + domainName.toIdentifier(), {\n            domainName: domainName.zone\n          });\n          this.aRecords.push(new ARecord(this, domainName.toIdentifier(), {\n            zone: zone,\n            recordName: domainName.toString(),\n            target: RecordTarget.fromAlias(new CloudFrontTarget(this.distribution))\n          }));\n        }\n      }\n    }\n\n    let bundlingOptions: BundlingOptions | undefined = undefined\n\n    if (props.sourceType === SourceType.Custom) {\n      if (!props.sourceBundlingOptions) {\n        throw new Error(\"sourceBundlingOptions is required if source type is Custom\");\n      }\n      bundlingOptions = props.sourceBundlingOptions\n    }\n\n    if (props.sourceType === SourceType.Static) {\n      if (props.sourceBundlingOptions) {\n        throw new Error(\"Cannot use sourceBundlingOptions with source type Static\");\n      }\n    }\n\n    if (props.sourceType === SourceType.Hugo) {\n      bundlingOptions = Website.HUGO_BUNDLING_OPTIONS\n      if (props.sourceBundlingOptions) {\n        throw new Error(\"Cannot use sourceBundlingOptions with source type Hugo\");\n      }\n    } else if (props.sourceType === SourceType.NpmDist) {\n      bundlingOptions = Website.NPM_DIST_BUNDLING_OPTIONS\n      if (props.sourceBundlingOptions) {\n        throw new Error(\"Cannot use sourceBundlingOptions with source type NpmDist\");\n      }\n    }\n\n    const source = Source.asset(props.sourceDirectory, {\n      bundling: bundlingOptions\n    });\n\n    this.deployment = new BucketDeployment(this, \"Assets\", {\n      sources: [source],\n      destinationBucket: this.bucket,\n      distribution: this.distribution,\n      cacheControl: [CacheControl.maxAge(props.maxAge??Duration.minutes(60))],\n      prune: false\n    });\n\n    if (this.fallbackBucket) {\n      this.fallbackDeployment = new BucketDeployment(this, \"FallbackAssets\", {\n        sources: [source],\n        destinationBucket: this.fallbackBucket,\n        cacheControl: [CacheControl.maxAge(props.maxAge??Duration.minutes(60))],\n        prune: false\n      })\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"website.js","sourceRoot":"","sources":["website.ts"],"names":[],"mappings":"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","sourcesContent":["import {Construct} from \"constructs\";\nimport {IBucket} from \"aws-cdk-lib/aws-s3\";\nimport {\n  Distribution,\n  Function,\n  FunctionCode,\n  FunctionEventType,\n  HttpVersion,\n  OriginAccessIdentity,\n  PriceClass,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {OriginGroup, S3Origin} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport {Certificate, CertificateValidation, ICertificate} from \"aws-cdk-lib/aws-certificatemanager\";\nimport {ARecord, RecordTarget} from \"aws-cdk-lib/aws-route53\";\nimport {CloudFrontTarget} from \"aws-cdk-lib/aws-route53-targets\";\nimport {BucketDeployment, CacheControl, Source} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {BundlingOptions, DockerImage, Duration, RemovalPolicy} from \"aws-cdk-lib\";\nimport {ExtendedBucket} from \"../../aws-s3\";\nimport {DomainName, DomainNameProps} from \"../../aws-route53\";\n\nexport enum SourceType {\n  Custom = \"Custom\",\n  Hugo = \"Hugo\",\n  NpmDist = \"NpmDist\",\n  Static = \"Static\"\n}\n\n/**\n * Properties for WebsiteDomainName.\n */\nexport interface WebsiteDomainNameProps extends DomainNameProps {\n\n  readonly createRecord?: boolean;\n\n}\n\nexport interface WebsiteProps {\n\n  /**\n   * Bucket to use to store website content. If one is not provided, one will be generated.\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * Bucket to use if the primary bucket fails. If one is not provided a fallback is not setup.\n   */\n  readonly fallbackBucket?: IBucket;\n\n  /**\n   * The ARN to the ACM Certificate to use on the CloudFront distribution. If one is not\n   * provided and domainNames is populated, one will be generated.\n   */\n  readonly certificateArn?: string;\n\n  /**\n   * The domain names to be serviced. The first domain name in the list is treated as the apex domain.\n   */\n  readonly domainNames?: WebsiteDomainNameProps[]\n\n  /**\n   * Redirect traffic to the first domain in the list of domainNames.\n   *\n   * @default true\n   */\n  readonly redirectToApexDomain?: boolean;\n\n  /**\n   * Price class for the CloudFront distribution.\n   *\n   * @default PriceClass.PRICE_CLASS_100\n   */\n  readonly priceClass?: PriceClass\n\n  /**\n   * Minimum protocol version to allow.\n   *\n   * @default SecurityPolicyProtocol.TLS_V1_2_2021,\n   */\n  readonly minimumProtocolVersion?: SecurityPolicyProtocol;\n\n  /**\n   * Minimum HTTP version to allow.\n   *\n   * @default HttpVersion.HTTP1_1\n   */\n  readonly httpVersion?: HttpVersion;\n\n  /**\n   * Cache-control max age.\n   *\n   * @default Duration.minutes(60)\n   */\n  readonly maxAge?: Duration;\n\n  /**\n   * The source type of the website.\n   *\n   * @default SourceType.Static\n   */\n  readonly sourceType?: SourceType;\n\n  /**\n   * The directory where the website sources are located.\n   */\n  readonly sourceDirectory: string;\n\n  /**\n   * Custom bundling options to use to bundle website sources. The sourceType\n   * must be set to SourceType.Custom.\n   */\n  readonly sourceBundlingOptions?: BundlingOptions\n}\n\nexport class Website extends Construct {\n\n  /**\n   * The default bundling options for SourceType.Hugo.\n   */\n  static readonly HUGO_BUNDLING_OPTIONS: BundlingOptions = {\n    image: DockerImage.fromRegistry(\"klakegg/hugo:latest-ext\"),\n    command: [\n      \"-d\", \"/asset-output\"\n    ]\n  }\n\n  /**\n   * The default bundling options for SourceType.NpmDist. It\"s expected that \"npm run dist\" command\n   * will place files in ${CDK_BUNDLING_OUTPUT_DIR}. Example: \"ng build --output-path=/asset-output\"\n   */\n  static readonly NPM_DIST_BUNDLING_OPTIONS: BundlingOptions = {\n    image: DockerImage.fromRegistry(\"node:16-alpine\"),\n    command: [\n      // TODO Figure out how to cache .npmcache\n      \"sh\", \"-c\", [\n        \"mkdir -p .npmcache\",\n        \"npm ci --cache .npmcache --prefer-offline\",\n        \"npm run dist\"\n      ].join(\" && \")\n    ]\n  }\n\n  readonly bucket: IBucket;\n  readonly fallbackBucket?: IBucket;\n  readonly originAccessIdentity: OriginAccessIdentity;\n  readonly apexDomain: string;\n  readonly viewerRequestFunction: Function;\n  readonly distribution: Distribution;\n  readonly distributionUrl: string;\n  readonly aRecords: ARecord[];\n  readonly deployment: BucketDeployment;\n  readonly fallbackDeployment?: BucketDeployment;\n\n  constructor(scope: Construct, id: string, props: WebsiteProps) {\n    super(scope, id);\n\n    const domainNames = DomainName.fromProps(props.domainNames);\n\n    let certificate: ICertificate | undefined = undefined;\n    if (props.certificateArn !== undefined) {\n      certificate = Certificate.fromCertificateArn(this, \"Certificate\", props.certificateArn)\n    } else if (domainNames.length > 0) {\n      certificate = new Certificate(this, \"Certificate\", {\n        domainName: domainNames[0].toString(),\n        subjectAlternativeNames: DomainName.toStrings(domainNames).slice(1),\n        validation: CertificateValidation.fromDnsMultiZone(DomainName.toZoneMap(this, domainNames))\n      });\n    }\n\n    this.bucket = props.bucket ?? new ExtendedBucket(this, \"Bucket\", {\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true\n    });\n    this.fallbackBucket = props.fallbackBucket;\n\n    this.originAccessIdentity = new OriginAccessIdentity(this, \"Access\");\n    this.bucket.grantRead(this.originAccessIdentity);\n    if (this.fallbackBucket) {\n      this.fallbackBucket.grantRead(this.originAccessIdentity);\n    }\n\n    this.apexDomain = domainNames.length > 0 ? domainNames[0].toString() : \"\";\n\n    this.viewerRequestFunction = new Function(this, \"ViewerRequestFunction\", {\n      code: FunctionCode.fromInline(`\nfunction handler(event) {\n  var host = event.request.headers.host.value;\n  var uri = event.request.uri;\n  var matchApex = MATCH_APEX;\n  if (matchApex && host !== \"APEX_DOMAIN\") {\n    return {\n      statusCode: 301,\n      statusDescription: \"Permanently moved\",\n      headers: {\n        \"location\": { \"value\": \"https://APEX_DOMAIN\" + uri }\n      }\n    }\n  }\n  if (uri.endsWith(\"/\")) {\n    event.request.uri = uri + \"index.html\";\n  }\n  return event.request;\n}`\n        .replace(/APEX_DOMAIN/g, this.apexDomain)\n        .replace(/MATCH_APEX/g, this.apexDomain !== \"\" && (props.redirectToApexDomain??true) ? \"true\" : \"false\"))\n    });\n\n    const bucketOrigin = new S3Origin(this.bucket, {\n      originAccessIdentity: this.originAccessIdentity\n    });\n\n    const fallbackBucketOrigin = this.fallbackBucket === undefined ? undefined : new S3Origin(this.fallbackBucket, {\n      originAccessIdentity: this.originAccessIdentity\n    });\n\n    const defaultOrigin = fallbackBucketOrigin === undefined ? bucketOrigin : new OriginGroup({\n      primaryOrigin: bucketOrigin,\n      fallbackOrigin: fallbackBucketOrigin\n    });\n\n    this.distribution = new Distribution(this, \"Distribution\", {\n      defaultBehavior: {\n        origin: defaultOrigin,\n        viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n        functionAssociations: [\n          {\n            function: this.viewerRequestFunction,\n            eventType: FunctionEventType.VIEWER_REQUEST\n          }\n        ]\n      },\n      errorResponses: [\n        {\n          httpStatus: 404,\n          responseHttpStatus: 404,\n          responsePagePath: \"/404.html\"\n        }\n      ],\n      httpVersion: props.httpVersion??HttpVersion.HTTP1_1,\n      minimumProtocolVersion: props.minimumProtocolVersion??SecurityPolicyProtocol.TLS_V1_2_2021,\n      defaultRootObject: \"index.html\",\n      certificate,\n      domainNames: DomainName.toStrings(domainNames),\n      enableIpv6: true,\n      priceClass: props.priceClass??PriceClass.PRICE_CLASS_100\n    });\n\n    this.distributionUrl = `https://${(this.apexDomain != \"\" ? this.apexDomain : this.distribution.distributionDomainName)}`\n\n    this.aRecords = [];\n\n    for (let domainNameProps of props.domainNames ?? []) {\n      if (domainNameProps.createRecord ?? true) {\n        let domainName = DomainName.findDomainName(domainNameProps, domainNames);\n        if (domainName !== undefined) {\n          this.aRecords.push(domainName.createARecord(this,\n            RecordTarget.fromAlias(new CloudFrontTarget(this.distribution))));\n        }\n      }\n    }\n\n    let bundlingOptions: BundlingOptions | undefined = undefined\n\n    if (props.sourceType === SourceType.Custom) {\n      if (!props.sourceBundlingOptions) {\n        throw new Error(\"sourceBundlingOptions is required if source type is Custom\");\n      }\n      bundlingOptions = props.sourceBundlingOptions\n    }\n\n    if (props.sourceType === SourceType.Static) {\n      if (props.sourceBundlingOptions) {\n        throw new Error(\"Cannot use sourceBundlingOptions with source type Static\");\n      }\n    }\n\n    if (props.sourceType === SourceType.Hugo) {\n      bundlingOptions = Website.HUGO_BUNDLING_OPTIONS\n      if (props.sourceBundlingOptions) {\n        throw new Error(\"Cannot use sourceBundlingOptions with source type Hugo\");\n      }\n    } else if (props.sourceType === SourceType.NpmDist) {\n      bundlingOptions = Website.NPM_DIST_BUNDLING_OPTIONS\n      if (props.sourceBundlingOptions) {\n        throw new Error(\"Cannot use sourceBundlingOptions with source type NpmDist\");\n      }\n    }\n\n    const source = Source.asset(props.sourceDirectory, {\n      bundling: bundlingOptions\n    });\n\n    this.deployment = new BucketDeployment(this, \"Assets\", {\n      sources: [source],\n      destinationBucket: this.bucket,\n      distribution: this.distribution,\n      cacheControl: [CacheControl.maxAge(props.maxAge??Duration.minutes(60))],\n      prune: false\n    });\n\n    if (this.fallbackBucket) {\n      this.fallbackDeployment = new BucketDeployment(this, \"FallbackAssets\", {\n        sources: [source],\n        destinationBucket: this.fallbackBucket,\n        cacheControl: [CacheControl.maxAge(props.maxAge??Duration.minutes(60))],\n        prune: false\n      })\n    }\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "truemark-cdk-lib",
-  "version": "0.0.35",
+  "version": "0.0.36-alpha.2+0e98502",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
@@ -49,5 +49,5 @@
     "@aws-cdk/aws-synthetics-alpha": "^2.18.0-alpha.0",
     "cdk-monitoring-constructs": "^1.10.0"
   },
-  "gitHead": "ea052915a434c6b6a4c5f63c0133b12cc762fcba"
+  "gitHead": "0e98502d0108c83436efd235e6e55737c70dc752"
 }

package/test/aws-website/website.test.js

@@ -12,15 +12,29 @@ test("Hugo Website Test", () => {
     const template = assertions_1.Template.fromStack(stack);
     template.hasResourceProperties("AWS::CloudFront::Distribution", {});
 });
-// TODO Need a way to skip tests
+// TODO We need to speed this up
 // test("Npm Dist Website Test", () => {
-//   const app = new cdk.App();
-//   const stack = new cdk.Stack(app, "TestStack");
+//   const stack = TestHelper.stack();
 //   new Website(stack, "TestWebsite", {
 //     sourceType: SourceType.NpmDist,
-//     sourceDirectory: path.join(__dirname, "angular-website")
+//     sourceDirectory: TestHelper.resolveTestFiles("angular-website")
 //   });
 //   const template = Template.fromStack(stack);
 //   template.hasResourceProperties("AWS::CloudFront::Distribution", {});
 // });
-//# sourceMappingURL=data:application/json;base64,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
+// TODO Need to fix
+// test("Website Certificate Test", () => {
+//   const stack = TestHelper.stack();
+//   new Website(stack, "TestWebsite", {
+//     sourceType: SourceType.Hugo,
+//     sourceDirectory: TestHelper.resolveTestFiles("hugo-website"),
+//     domainNames: [
+//       new DomainName("test", "example.com"),
+//       new DomainName("test2", "example.com")
+//     ]
+//   });
+//   const template = Template.fromStack(stack);
+//   console.log(template.toJSON());
+//   // TestHelper.logResources()
+// });
+//# sourceMappingURL=data:application/json;base64,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