quidproquo-deploy-awscdk 0.0.199 → 0.0.201

package/lib/esm/QPQApp.d.ts

@@ -0,0 +1,2 @@
+import * as cdk from 'aws-cdk-lib';
+export declare const createQPQApp: () => cdk.App;

package/lib/esm/QPQApp.js

@@ -0,0 +1,4 @@
+import * as cdk from 'aws-cdk-lib';
+export const createQPQApp = () => {
+    return new cdk.App();
+};

package/lib/esm/constants/BootstrapResource.d.ts

@@ -0,0 +1,3 @@
+export declare enum BootstrapResource {
+    WarmLambdas = "WarmLambdas"
+}

package/lib/esm/constants/BootstrapResource.js

@@ -0,0 +1,4 @@
+export var BootstrapResource;
+(function (BootstrapResource) {
+    BootstrapResource["WarmLambdas"] = "WarmLambdas";
+})(BootstrapResource || (BootstrapResource = {}));

package/lib/esm/constants/index.d.ts

@@ -0,0 +1,3 @@
+export * from './logging';
+export * from './warmLambdas';
+export * from './BootstrapResource';

package/lib/esm/constants/index.js

@@ -0,0 +1,3 @@
+export * from './logging';
+export * from './warmLambdas';
+export * from './BootstrapResource';

package/lib/esm/constants/logging.d.ts

@@ -0,0 +1 @@
+export declare const QPQ_LOG_BUCKET_NAME = "logs";

package/lib/esm/constants/logging.js

@@ -0,0 +1 @@
+export const QPQ_LOG_BUCKET_NAME = 'logs';

package/lib/esm/constants/warmLambdas.d.ts

@@ -0,0 +1,2 @@
+import { QpqWarmLambdaEvent } from '../types';
+export declare const WARM_LAMBDA_EVENT: QpqWarmLambdaEvent;

package/lib/esm/constants/warmLambdas.js

@@ -0,0 +1 @@
+export const WARM_LAMBDA_EVENT = { qpqWarm: true };

package/lib/esm/constructs/base/QpqConstructBlock.d.ts

@@ -0,0 +1,23 @@
+import { QPQConfig } from 'quidproquo-core';
+import { Construct } from 'constructs';
+import { QpqResource } from './QpqResource';
+import { IGrantable } from 'aws-cdk-lib/aws-iam';
+import { aws_iam } from 'aws-cdk-lib';
+export interface QpqConstructBlockProps {
+    awsAccountId: string;
+    qpqConfig: QPQConfig;
+}
+export declare class QpqConstructBlock extends Construct implements QpqResource {
+    awsAccountId: string;
+    qpqConfig: QPQConfig;
+    serviceRole?: aws_iam.IRole;
+    constructor(scope: Construct, id: string, props: QpqConstructBlockProps);
+    resourceName(name: string): string;
+    resourceNameWithModuleOveride(name: string, module?: string): string;
+    qpqResourceName(name: string, resourceType: string): string;
+    qpqBootstrapResourceName(name: string): string;
+    grantRead(grantee: IGrantable): void;
+    grantWrite(grantee: IGrantable): void;
+    grantAll(grantee: IGrantable): void;
+    getServiceRole(): aws_iam.IRole;
+}

package/lib/esm/constructs/base/QpqConstructBlock.js

@@ -0,0 +1,39 @@
+import { awsNamingUtils } from 'quidproquo-actionprocessor-awslambda';
+import { Construct } from 'constructs';
+import { aws_iam } from 'aws-cdk-lib';
+export class QpqConstructBlock extends Construct {
+    awsAccountId;
+    qpqConfig;
+    serviceRole;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.awsAccountId = props.awsAccountId;
+        this.qpqConfig = props.qpqConfig;
+    }
+    resourceName(name) {
+        return awsNamingUtils.getConfigRuntimeResourceNameFromConfig(name, this.qpqConfig);
+    }
+    resourceNameWithModuleOveride(name, module) {
+        return awsNamingUtils.getConfigRuntimeResourceNameFromConfigWithServiceOverride(name, this.qpqConfig, module);
+    }
+    qpqResourceName(name, resourceType) {
+        return awsNamingUtils.getQpqRuntimeResourceNameFromConfig(name, this.qpqConfig, resourceType);
+    }
+    qpqBootstrapResourceName(name) {
+        return awsNamingUtils.getConfigRuntimeBootstrapResourceNameFromConfig(name, this.qpqConfig);
+    }
+    grantRead(grantee) { }
+    grantWrite(grantee) { }
+    grantAll(grantee) {
+        this.grantRead(grantee);
+        this.grantWrite(grantee);
+    }
+    getServiceRole() {
+        if (!this.serviceRole) {
+            this.serviceRole = aws_iam.Role.fromRoleName(this, 'service-role', this.resourceName('service-role'), {
+                mutable: true,
+            });
+        }
+        return this.serviceRole;
+    }
+}

package/lib/esm/constructs/base/QpqResource.d.ts

@@ -0,0 +1,21 @@
+import { aws_iam } from 'aws-cdk-lib';
+export interface QpqResource {
+    /**
+     * Grants read permissions on this resource.
+     *
+     * @param grantee the role to be granted read-only access to the resource.
+     */
+    grantRead(grantee: aws_iam.IGrantable): void;
+    /**
+     * Grants write permissions on the resource.
+     *
+     * @param grantee the role to be granted write access to the resource.
+     */
+    grantWrite(grantee: aws_iam.IGrantable): void;
+    /**
+     * Grants read/write permissions on the resource.
+     *
+     * @param grantee the role to be granted read/write access to the resource.
+     */
+    grantAll(grantee: aws_iam.IGrantable): void;
+}

package/lib/esm/constructs/base/QpqResource.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/constructs/base/index.d.ts

@@ -0,0 +1,2 @@
+export * from './QpqConstructBlock';
+export * from './QpqResource';

package/lib/esm/constructs/base/index.js

@@ -0,0 +1,2 @@
+export * from './QpqConstructBlock';
+export * from './QpqResource';

package/lib/esm/constructs/basic/BSQpqLambdaWarmerEventConstruct.d.ts

@@ -0,0 +1,7 @@
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base/QpqConstructBlock';
+import { Construct } from 'constructs';
+export interface BSQpqLambdaWarmerEventConstructConstructProps extends QpqConstructBlockProps {
+}
+export declare class BSQpqLambdaWarmerEventConstructConstruct extends QpqConstructBlock {
+    constructor(scope: Construct, id: string, props: BSQpqLambdaWarmerEventConstructConstructProps);
+}

package/lib/esm/constructs/basic/BSQpqLambdaWarmerEventConstruct.js

@@ -0,0 +1,22 @@
+import { aws_events, aws_sns, aws_events_targets } from 'aws-cdk-lib';
+import { QpqConstructBlock } from '../base/QpqConstructBlock';
+import { BootstrapResource } from '../../constants';
+export class BSQpqLambdaWarmerEventConstructConstruct extends QpqConstructBlock {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const rule = new aws_events.Rule(this, 'WarmLambdaRule', {
+            ruleName: this.qpqBootstrapResourceName(BootstrapResource.WarmLambdas),
+            // Create an EventBridge rule to trigger the Lambda every X minutes
+            schedule: aws_events.Schedule.expression('rate(5 minutes)'),
+        });
+        const topic = new aws_sns.Topic(this, 'MyTopic', {
+            topicName: this.qpqBootstrapResourceName(BootstrapResource.WarmLambdas),
+            displayName: 'Warm Lambdas',
+        });
+        rule.addTarget(new aws_events_targets.SnsTopic(topic, {
+            message: aws_events.RuleTargetInput.fromObject({
+                type: 'QpqLambdaWarmerEvent',
+            }),
+        }));
+    }
+}

package/lib/esm/constructs/basic/DnsValidatedCertificate.d.ts

@@ -0,0 +1,18 @@
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base/QpqConstructBlock';
+import { Construct } from 'constructs';
+import { aws_route53, aws_certificatemanager } from 'aws-cdk-lib';
+interface DomainConfig {
+    rootDomain: string;
+    subDomainNames?: string[];
+    onRootDomain: boolean;
+}
+export interface DnsValidatedCertificateProps extends QpqConstructBlockProps {
+    domain: DomainConfig;
+}
+export declare class DnsValidatedCertificate extends QpqConstructBlock {
+    readonly domainNames: string[];
+    readonly certificate: aws_certificatemanager.Certificate;
+    readonly hostedZone: aws_route53.IHostedZone;
+    constructor(scope: Construct, id: string, props: DnsValidatedCertificateProps);
+}
+export {};

package/lib/esm/constructs/basic/DnsValidatedCertificate.js

@@ -0,0 +1,35 @@
+import { QpqConstructBlock } from '../base/QpqConstructBlock';
+import { aws_route53, aws_certificatemanager } from 'aws-cdk-lib';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import * as qpqDeployAwsCdkUtils from '../../utils';
+export class DnsValidatedCertificate extends QpqConstructBlock {
+    domainNames;
+    certificate;
+    hostedZone;
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        // Determine the apex domain
+        const apexDomain = qpqWebServerUtils.resolveApexDomainNameFromDomainConfig(props.qpqConfig, props.domain.rootDomain, props.domain.onRootDomain);
+        // Lookup the hosted zone
+        this.hostedZone = aws_route53.HostedZone.fromLookup(this, 'MyHostedZone', {
+            domainName: apexDomain,
+        });
+        // Generate domain names for all subdomains
+        this.domainNames =
+            props.domain.subDomainNames?.map((subDomain) => `${subDomain}.${apexDomain}`) || [];
+        // Include the apex domain if onRootDomain is true
+        if (props.domain.onRootDomain &&
+            (!props.domain.subDomainNames || props.domain.subDomainNames.length === 0)) {
+            this.domainNames.unshift(apexDomain);
+        }
+        // Create the certificate
+        this.certificate = new aws_certificatemanager.Certificate(this, 'SiteCertificate', {
+            // Use the apex domain or the first subdomain as the main domain name
+            domainName: this.domainNames[0],
+            // Include all other domain names as subject alternative names (SANs), if any
+            subjectAlternativeNames: this.domainNames.slice(1),
+            validation: aws_certificatemanager.CertificateValidation.fromDns(this.hostedZone),
+        });
+        qpqDeployAwsCdkUtils.applyEnvironmentTags(this.certificate, props.qpqConfig);
+    }
+}

package/lib/esm/constructs/basic/Function.d.ts

@@ -0,0 +1,23 @@
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base/QpqConstructBlock';
+import { Construct } from 'constructs';
+import { aws_lambda, aws_iam } from 'aws-cdk-lib';
+export interface FunctionProps extends QpqConstructBlockProps {
+    functionName?: string;
+    buildPath: string;
+    srcFilename?: string;
+    functionType: string;
+    executorName: string;
+    timeoutInSeconds?: number;
+    memoryInBytes?: number;
+    environment?: {
+        [key: string]: string;
+    };
+    apiLayerVersions?: aws_lambda.ILayerVersion[];
+    reservedConcurrentExecutions?: number;
+    role?: aws_iam.IRole;
+    reacreateOnFunctionNameChange?: boolean;
+}
+export declare class Function extends QpqConstructBlock {
+    readonly lambdaFunction: aws_lambda.Function;
+    constructor(scope: Construct, id: string, props: FunctionProps);
+}

package/lib/esm/constructs/basic/Function.js

@@ -0,0 +1,40 @@
+import path from 'path';
+import { QpqConstructBlock } from '../base/QpqConstructBlock';
+import { aws_lambda, aws_logs, aws_sns, aws_sns_subscriptions, } from 'aws-cdk-lib';
+import * as cdk from 'aws-cdk-lib';
+import { getAwsServiceAccountInfoConfig } from 'quidproquo-config-aws';
+import { BootstrapResource } from '../../constants';
+import { qpqCoreUtils } from 'quidproquo-core';
+export class Function extends QpqConstructBlock {
+    lambdaFunction;
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const handlerFile = props.srcFilename || 'index';
+        const serviceInfo = getAwsServiceAccountInfoConfig(props.qpqConfig);
+        const functionId = props.reacreateOnFunctionNameChange && props.functionName ? props.functionName : 'function';
+        this.lambdaFunction = new aws_lambda.Function(this, functionId, {
+            functionName: props.functionName,
+            timeout: cdk.Duration.seconds(props.timeoutInSeconds || 25),
+            runtime: aws_lambda.Runtime.NODEJS_18_X,
+            memorySize: props.memoryInBytes || serviceInfo.lambdaMaxMemoryInMiB || 1024,
+            layers: props.apiLayerVersions,
+            code: aws_lambda.Code.fromAsset(path.join(props.buildPath, props.functionType)),
+            handler: `${handlerFile}.${props.executorName}`,
+            environment: {
+                AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',
+                ...(props.environment || {}),
+            },
+            reservedConcurrentExecutions: props.reservedConcurrentExecutions,
+            // TODO: Make this optional
+            tracing: aws_lambda.Tracing.DISABLED,
+            logRetention: aws_logs.RetentionDays.ONE_WEEK,
+            role: props.role,
+        });
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(props.qpqConfig);
+        const accountId = props.awsAccountId;
+        const topicName = this.qpqBootstrapResourceName(BootstrapResource.WarmLambdas);
+        const topicArn = `arn:aws:sns:${region}:${accountId}:${topicName}`;
+        const topic = aws_sns.Topic.fromTopicArn(this, 'ImportedTopic', topicArn);
+        topic.addSubscription(new aws_sns_subscriptions.LambdaSubscription(this.lambdaFunction));
+    }
+}

package/lib/esm/constructs/basic/InfQpqWebserverServiceDomainsConstruct.d.ts

@@ -0,0 +1,7 @@
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base/QpqConstructBlock';
+import { Construct } from 'constructs';
+export interface InfQpqWebserverServiceDomainsConstructProps extends QpqConstructBlockProps {
+}
+export declare class InfQpqWebserverServiceDomainsConstruct extends QpqConstructBlock {
+    constructor(scope: Construct, id: string, props: InfQpqWebserverServiceDomainsConstructProps);
+}

package/lib/esm/constructs/basic/InfQpqWebserverServiceDomainsConstruct.js

@@ -0,0 +1,30 @@
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import { QpqConstructBlock } from '../base/QpqConstructBlock';
+import { ServiceDomainConstruct } from './ServiceDomain';
+export class InfQpqWebserverServiceDomainsConstruct extends QpqConstructBlock {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const webEntryRootDomains = qpqWebServerUtils
+            .getWebEntryConfigs(props.qpqConfig)
+            .filter((we) => !we.domain.onRootDomain)
+            .map((we) => we.domain.rootDomain);
+        const domainProxyRootDomains = qpqWebServerUtils
+            .getDomainProxyConfigs(props.qpqConfig)
+            .filter((we) => !we.domain.onRootDomain)
+            .map((we) => we.domain.rootDomain);
+        const websocketRootDomains = qpqWebServerUtils
+            .getOwnedWebsocketSettings(props.qpqConfig)
+            .filter((we) => !we.onRootDomain)
+            .map((we) => we.rootDomain);
+        const uniqueRootDomains = [
+            ...new Set([...webEntryRootDomains, ...domainProxyRootDomains, ...websocketRootDomains]),
+        ];
+        for (const rootDomain of uniqueRootDomains) {
+            new ServiceDomainConstruct(this, `domain-${rootDomain}`, {
+                awsAccountId: props.awsAccountId,
+                qpqConfig: props.qpqConfig,
+                rootDomain,
+            });
+        }
+    }
+}

package/lib/esm/constructs/basic/LambdaLayers.d.ts

@@ -0,0 +1,9 @@
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base/QpqConstructBlock';
+import { Construct } from 'constructs';
+import { aws_lambda } from 'aws-cdk-lib';
+export interface LambdaLayersProps extends QpqConstructBlockProps {
+}
+export declare class LambdaLayers extends QpqConstructBlock {
+    readonly layers: aws_lambda.ILayerVersion[];
+    constructor(scope: Construct, id: string, props: LambdaLayersProps);
+}

package/lib/esm/constructs/basic/LambdaLayers.js

@@ -0,0 +1,20 @@
+import { awsNamingUtils } from 'quidproquo-actionprocessor-awslambda';
+import { QpqConstructBlock } from '../base/QpqConstructBlock';
+import { aws_lambda } from 'aws-cdk-lib';
+import { getLambdaLayersWithFullPaths } from 'quidproquo-config-aws';
+export class LambdaLayers extends QpqConstructBlock {
+    layers;
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const apiLayers = getLambdaLayersWithFullPaths(props.qpqConfig);
+        this.layers = apiLayers.map((layer) => {
+            return layer.buildPath
+                ? new aws_lambda.LayerVersion(this, `${layer.name}-layer`, {
+                    layerVersionName: awsNamingUtils.getQpqRuntimeResourceNameFromConfig(layer.name, props.qpqConfig),
+                    code: new aws_lambda.AssetCode(layer.buildPath),
+                    compatibleRuntimes: [aws_lambda.Runtime.NODEJS_18_X],
+                })
+                : aws_lambda.LayerVersion.fromLayerVersionArn(this, `${layer.name}-layer-ref`, layer.layerArn);
+        });
+    }
+}

package/lib/esm/constructs/basic/LogStorage.d.ts

@@ -0,0 +1,22 @@
+import { QPQConfig } from 'quidproquo-core';
+import { Construct } from 'constructs';
+import { aws_s3, aws_iam, aws_dynamodb } from 'aws-cdk-lib';
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base/QpqConstructBlock';
+import { QpqResource } from '../base';
+export interface LogStorageProps extends QpqConstructBlockProps {
+}
+export declare abstract class LogStorageConstructBase extends QpqConstructBlock implements QpqResource {
+    abstract bucket: aws_s3.IBucket;
+    abstract storyResultsTable: aws_dynamodb.ITable;
+    abstract fromStoryResultsTable: aws_dynamodb.ITable;
+    grantRead(grantee: aws_iam.IGrantable): void;
+    grantWrite(grantee: aws_iam.IGrantable): void;
+    grantAll(grantee: aws_iam.IGrantable): void;
+}
+export declare class LogStorage extends QpqConstructBlock {
+    readonly bucket: aws_s3.IBucket;
+    readonly storyResultsTable: aws_dynamodb.ITable;
+    readonly fromStoryResultsTable: aws_dynamodb.ITable;
+    static fromOtherStack(scope: Construct, id: string, qpqConfig: QPQConfig, awsAccountId: string, serviceBucketName: string): QpqResource;
+    constructor(scope: Construct, id: string, props: LogStorageProps);
+}

package/lib/esm/constructs/basic/LogStorage.js

@@ -0,0 +1,86 @@
+import path from 'path';
+import { aws_s3, aws_dynamodb, aws_s3_notifications } from 'aws-cdk-lib';
+import * as cdk from 'aws-cdk-lib';
+import { QpqConstructBlock } from '../base/QpqConstructBlock';
+import { QPQ_LOG_BUCKET_NAME } from '../../constants';
+import { Function } from './Function';
+export class LogStorageConstructBase extends QpqConstructBlock {
+    grantRead(grantee) {
+        this.storyResultsTable.grantReadData(grantee);
+        this.fromStoryResultsTable.grantReadData(grantee);
+        this.bucket.grantRead(grantee);
+    }
+    grantWrite(grantee) {
+        this.storyResultsTable.grantWriteData(grantee);
+        this.fromStoryResultsTable.grantWriteData(grantee);
+        this.bucket.grantWrite(grantee);
+    }
+    grantAll(grantee) {
+        this.grantRead(grantee);
+        this.grantWrite(grantee);
+    }
+}
+export class LogStorage extends QpqConstructBlock {
+    bucket;
+    storyResultsTable;
+    fromStoryResultsTable;
+    static fromOtherStack(scope, id, qpqConfig, awsAccountId, serviceBucketName) {
+        class Import extends LogStorageConstructBase {
+            bucket = aws_s3.Bucket.fromBucketName(scope, `${id}-log-storage`, this.qpqResourceName(serviceBucketName, 'log'));
+            storyResultsTable = aws_dynamodb.Table.fromTableName(scope, `${id}-log-table`, this.qpqResourceName(serviceBucketName, 'log'));
+            fromStoryResultsTable = aws_dynamodb.Table.fromTableName(scope, `${id}-flog-table`, this.qpqResourceName(serviceBucketName, 'flog'));
+        }
+        return new Import(scope, id, { qpqConfig, awsAccountId });
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.bucket = new aws_s3.Bucket(this, 'bucket', {
+            bucketName: this.qpqResourceName(QPQ_LOG_BUCKET_NAME, 'log'),
+            // Disable public access to this bucket
+            publicReadAccess: false,
+            blockPublicAccess: aws_s3.BlockPublicAccess.BLOCK_ALL,
+            // Allow bucket to auto delete upon cdk:Destroy
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+            autoDeleteObjects: true,
+        });
+        // Time based query over all logs for a given runtimeType
+        const storyResultsTable = new aws_dynamodb.Table(this, 'table', {
+            tableName: this.qpqResourceName(QPQ_LOG_BUCKET_NAME, 'log'),
+            partitionKey: { name: 'runtimeType', type: aws_dynamodb.AttributeType.STRING },
+            sortKey: { name: 'startedAtWithCorrelation', type: aws_dynamodb.AttributeType.STRING },
+            billingMode: aws_dynamodb.BillingMode.PAY_PER_REQUEST,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        // Query by correlation
+        storyResultsTable.addGlobalSecondaryIndex({
+            indexName: 'CorrelationIndex',
+            partitionKey: { name: 'correlation', type: aws_dynamodb.AttributeType.STRING },
+        });
+        // Second table for the from logs ~ Second table because a GSI will dupe the data more then needed
+        // Also, we cant have a GSI on keys that can be undefined, this table will only contain
+        // logs with a fromCorrelation
+        const fromStoryResultsTable = new aws_dynamodb.Table(this, 'from-table', {
+            tableName: this.qpqResourceName(QPQ_LOG_BUCKET_NAME, 'flog'),
+            partitionKey: { name: 'fromCorrelation', type: aws_dynamodb.AttributeType.STRING },
+            sortKey: { name: 'startedAtWithCorrelation', type: aws_dynamodb.AttributeType.STRING },
+            billingMode: aws_dynamodb.BillingMode.PAY_PER_REQUEST,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        this.storyResultsTable = storyResultsTable;
+        this.fromStoryResultsTable = fromStoryResultsTable;
+        // Create a lambda that is trigged when files are written to the bucket
+        const func = new Function(this, 'function', {
+            buildPath: path.join(__dirname, '../..'),
+            functionName: this.qpqResourceName(QPQ_LOG_BUCKET_NAME, 'log'),
+            functionType: 'lambdas',
+            executorName: 'executeS3FileWriteEvent',
+            srcFilename: 'lambdaS3FileWriteEvent_log',
+            qpqConfig: props.qpqConfig,
+            awsAccountId: props.awsAccountId,
+        });
+        // Grant the Lambda function read access to the S3 bucket / dynamo table
+        // this.bucket.grantRead(func.lambdaFunction);
+        // storyResultsTable.grantWriteData(func.lambdaFunction);
+        this.bucket.addEventNotification(aws_s3.EventType.OBJECT_CREATED, new aws_s3_notifications.LambdaDestination(func.lambdaFunction));
+    }
+}

package/lib/esm/constructs/basic/ServiceDomain.d.ts

@@ -0,0 +1,8 @@
+import { Construct } from 'constructs';
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base';
+export interface ServiceDomainConstructProps extends QpqConstructBlockProps {
+    rootDomain: string;
+}
+export declare class ServiceDomainConstruct extends QpqConstructBlock {
+    constructor(scope: Construct, id: string, props: ServiceDomainConstructProps);
+}

package/lib/esm/constructs/basic/ServiceDomain.js

@@ -0,0 +1,39 @@
+import { aws_route53 } from 'aws-cdk-lib';
+import { qpqCoreUtils } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import { QpqConstructBlock } from '../base';
+export class ServiceDomainConstruct extends QpqConstructBlock {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        // example.com
+        // dev.example.com
+        const feature = qpqCoreUtils.getApplicationModuleFeature(props.qpqConfig);
+        const environment = qpqCoreUtils.getApplicationModuleEnvironment(props.qpqConfig);
+        const service = qpqCoreUtils.getApplicationModuleName(props.qpqConfig);
+        const domainRoot = qpqWebServerUtils.getDomainRoot(props.rootDomain, environment, feature);
+        // The hosted zone already setup
+        // development.example.com
+        // joecoady.development.example.com
+        // staging.example.com
+        // example.com
+        let apexHostedZone = aws_route53.HostedZone.fromLookup(this, 'hosted-zone', {
+            domainName: domainRoot,
+        });
+        // Root domain name for our service
+        // search.example.com
+        // search.development.example.com
+        // search.joecoady.development.example.com
+        const serviceDomainName = qpqWebServerUtils.constructServiceDomainName(props.rootDomain, environment, service, feature);
+        console.log(`ServiceDomain: ${serviceDomainName} on apex - $${domainRoot}`);
+        // Create the root hosted zone for our service
+        const serviceHostedZone = new aws_route53.HostedZone(this, 'service-hosted-zone', {
+            zoneName: serviceDomainName,
+        });
+        // Add the new NS Records to the root hosted zone so subdomains can be resolved
+        new aws_route53.NsRecord(this, 'service-ns-records', {
+            zone: apexHostedZone,
+            recordName: serviceDomainName,
+            values: serviceHostedZone.hostedZoneNameServers || [],
+        });
+    }
+}

package/lib/esm/constructs/basic/SubdomainName.d.ts

@@ -0,0 +1,14 @@
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base/QpqConstructBlock';
+import { Construct } from 'constructs';
+import { aws_route53, aws_certificatemanager, aws_apigateway } from 'aws-cdk-lib';
+export interface SubdomainNameProps extends QpqConstructBlockProps {
+    subdomain: string;
+    apexDomain: string;
+}
+export declare class SubdomainName extends QpqConstructBlock {
+    readonly domainName: aws_apigateway.DomainName;
+    readonly certificate: aws_certificatemanager.Certificate;
+    readonly targetARecord: aws_route53.RecordTarget;
+    readonly deployDomain: string;
+    constructor(scope: Construct, id: string, props: SubdomainNameProps);
+}

package/lib/esm/constructs/basic/SubdomainName.js

@@ -0,0 +1,37 @@
+import { QpqConstructBlock } from '../base/QpqConstructBlock';
+import { aws_route53, aws_certificatemanager, aws_apigateway, aws_route53_targets, } from 'aws-cdk-lib';
+export class SubdomainName extends QpqConstructBlock {
+    domainName;
+    certificate;
+    targetARecord;
+    deployDomain;
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.deployDomain = `${props.subdomain}.${props.apexDomain}`;
+        const apexHostedZone = aws_route53.HostedZone.fromLookup(this, 'hosted-zone', {
+            domainName: props.apexDomain,
+        });
+        this.certificate = new aws_certificatemanager.Certificate(this, 'certificate', {
+            domainName: this.deployDomain,
+            certificateName: `${this.deployDomain}-cert`,
+            validation: aws_certificatemanager.CertificateValidation.fromDns(apexHostedZone),
+        });
+        this.domainName = new aws_apigateway.DomainName(this, 'domain-name', {
+            domainName: this.deployDomain,
+            certificate: this.certificate,
+            securityPolicy: aws_apigateway.SecurityPolicy.TLS_1_2,
+            endpointType: aws_apigateway.EndpointType.REGIONAL,
+        });
+        this.targetARecord = aws_route53.RecordTarget.fromAlias(new aws_route53_targets.ApiGatewayDomain(this.domainName));
+        new aws_route53.ARecord(this, 'a-record', {
+            zone: apexHostedZone,
+            recordName: this.deployDomain,
+            target: this.targetARecord,
+        });
+        // // Export the names so we can import them later
+        // new cdk.CfnOutput(this, 'HostedZoneID', {
+        //   value: apexHostedZone.hostedZoneId,
+        //   exportName: `${apexHostedZone}-hosted-zone-id`,
+        // });
+    }
+}

package/lib/esm/constructs/basic/WebserverRoll.d.ts

@@ -0,0 +1,9 @@
+import { Construct } from 'constructs';
+import { aws_iam } from 'aws-cdk-lib';
+import { QpqConstructBlock, QpqConstructBlockProps } from '../base/QpqConstructBlock';
+export interface WebserverRollProps extends QpqConstructBlockProps {
+}
+export declare class WebserverRoll extends QpqConstructBlock {
+    role: aws_iam.IRole;
+    constructor(scope: Construct, id: string, props: WebserverRollProps);
+}