@pwrdrvr/microapps-cdk 0.3.3-alpha.1 → 0.3.4

package/API.md

@@ -48,14 +48,6 @@ new MicroApps(scope: Construct, id: string, props?: MicroAppsProps)
 
 #### Properties <a name="Properties"></a>
 
-##### `apigwy`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.MicroApps.apigwy"></a>
-
-- *Type:* [`@pwrdrvr/microapps-cdk.IMicroAppsAPIGwy`](#@pwrdrvr/microapps-cdk.IMicroAppsAPIGwy)
-
-{@inheritdoc IMicroAppsAPIGwy}.
-
----
-
 ##### `cf`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.MicroApps.cf"></a>
 
 - *Type:* [`@pwrdrvr/microapps-cdk.IMicroAppsCF`](#@pwrdrvr/microapps-cdk.IMicroAppsCF)
@@ -80,6 +72,14 @@ new MicroApps(scope: Construct, id: string, props?: MicroAppsProps)
 
 ---
 
+##### `apigwy`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroApps.apigwy"></a>
+
+- *Type:* [`@pwrdrvr/microapps-cdk.IMicroAppsAPIGwy`](#@pwrdrvr/microapps-cdk.IMicroAppsAPIGwy)
+
+{@inheritdoc IMicroAppsAPIGwy}.
+
+---
+
 ##### `edgeToOrigin`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroApps.edgeToOrigin"></a>
 
 - *Type:* [`@pwrdrvr/microapps-cdk.IMicroAppsEdgeToOrigin`](#@pwrdrvr/microapps-cdk.IMicroAppsEdgeToOrigin)
@@ -498,15 +498,16 @@ import { AddRoutesOptions } from '@pwrdrvr/microapps-cdk'
 const addRoutesOptions: AddRoutesOptions = { ... }
 ```
 
-##### `apiGwyOrigin`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.apiGwyOrigin"></a>
+##### `appOrigin`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.appOrigin"></a>
 
 - *Type:* [`aws-cdk-lib.aws_cloudfront.IOrigin`](#aws-cdk-lib.aws_cloudfront.IOrigin)
+- *Default:* invalid URL (never used)
 
-API Gateway CloudFront Origin for API calls.
+Default origin (invalid URL or API Gateway).
 
 ---
 
-##### `apigwyOriginRequestPolicy`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.apigwyOriginRequestPolicy"></a>
+##### `appOriginRequestPolicy`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.appOriginRequestPolicy"></a>
 
 - *Type:* [`aws-cdk-lib.aws_cloudfront.IOriginRequestPolicy`](#aws-cdk-lib.aws_cloudfront.IOriginRequestPolicy)
 
@@ -533,7 +534,7 @@ CloudFront Distribution to add the Behaviors (Routes) to.
 ##### `createAPIPathRoute`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.createAPIPathRoute"></a>
 
 - *Type:* `boolean`
-- *Default:* true
+- *Default:* false
 
 Create an extra Behavior (Route) for /api/ that allows API routes to have a period in them.
 
@@ -547,7 +548,7 @@ even if they have a period in the path.
 ##### `createNextDataPathRoute`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.createNextDataPathRoute"></a>
 
 - *Type:* `boolean`
-- *Default:* true
+- *Default:* false
 
 Create an extra Behavior (Route) for /_next/data/ This route is used by Next.js to load data from the API Gateway on `getServerSideProps` calls.  The requests can end in `.json`, which would cause them to be routed to S3 if this route is not created.
 
@@ -772,14 +773,6 @@ S3 bucket origin for deployed applications.
 
 ---
 
-##### `httpApi`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.httpApi"></a>
-
-- *Type:* [`@aws-cdk/aws-apigatewayv2-alpha.HttpApi`](#@aws-cdk/aws-apigatewayv2-alpha.HttpApi)
-
-API Gateway v2 HTTP API for apps.
-
----
-
 ##### `assetNameRoot`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.assetNameRoot"></a>
 
 - *Type:* `string`
@@ -817,7 +810,7 @@ ACM Certificate that covers `domainNameEdge` name.
 ##### `createAPIPathRoute`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.createAPIPathRoute"></a>
 
 - *Type:* `boolean`
-- *Default:* true
+- *Default:* true if httpApi is provided
 
 Create an extra Behavior (Route) for /api/ that allows API routes to have a period in them.
 
@@ -831,7 +824,7 @@ even if they have a period in the path.
 ##### `createNextDataPathRoute`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.createNextDataPathRoute"></a>
 
 - *Type:* `boolean`
-- *Default:* true
+- *Default:* true if httpApi is provided
 
 Create an extra Behavior (Route) for /_next/data/ This route is used by Next.js to load data from the API Gateway on `getServerSideProps` calls.  The requests can end in `.json`, which would cause them to be routed to S3 if this route is not created.
 
@@ -869,6 +862,26 @@ Configuration of the edge to origin lambda functions.
 
 ---
 
+##### `httpApi`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.httpApi"></a>
+
+- *Type:* [`@aws-cdk/aws-apigatewayv2-alpha.HttpApi`](#@aws-cdk/aws-apigatewayv2-alpha.HttpApi)
+
+API Gateway v2 HTTP API for apps.
+
+---
+
+##### `originShieldRegion`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.originShieldRegion"></a>
+
+- *Type:* `string`
+- *Default:* none
+
+Optional Origin Shield Region.
+
+This should be the region where the DynamoDB is located so the
+EdgeToOrigin calls have the lowest latency (~1 ms).
+
+---
+
 ##### `r53Zone`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.r53Zone"></a>
 
 - *Type:* [`aws-cdk-lib.aws_route53.IHostedZone`](#aws-cdk-lib.aws_route53.IHostedZone)
@@ -983,6 +996,15 @@ Path prefix on the root of the API Gateway Stage.
 
 ---
 
+##### `setupApiGatewayPermissions`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsEdgeToOriginProps.setupApiGatewayPermissions"></a>
+
+- *Type:* `boolean`
+- *Default:* false
+
+Enable invoking API Gateway from the Edge Lambda.
+
+---
+
 ##### `signingMode`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsEdgeToOriginProps.signingMode"></a>
 
 - *Type:* `string`
@@ -1080,6 +1102,15 @@ Certificate in deployed region for the API Gateway.
 
 ---
 
+##### `createAPIGateway`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsProps.createAPIGateway"></a>
+
+- *Type:* `boolean`
+- *Default:* false
+
+Create API Gateway for non-edge invocation.
+
+---
+
 ##### `createAPIPathRoute`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsProps.createAPIPathRoute"></a>
 
 - *Type:* `boolean`
@@ -1094,6 +1125,20 @@ even if they have a period in the path.
 
 ---
 
+##### `createNextDataPathRoute`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsProps.createNextDataPathRoute"></a>
+
+- *Type:* `boolean`
+- *Default:* true
+
+Create an extra Behavior (Route) for /_next/data/ This route is used by Next.js to load data from the API Gateway on `getServerSideProps` calls.  The requests can end in `.json`, which would cause them to be routed to S3 if this route is not created.
+
+When false API routes with a period in the path will get routed to S3.
+
+When true API routes that contain /_next/data/ in the path will get routed to API Gateway
+even if they have a period in the path.
+
+---
+
 ##### `domainNameEdge`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsProps.domainNameEdge"></a>
 
 - *Type:* `string`
@@ -1125,7 +1170,19 @@ Additional edge lambda functions.
 - *Type:* `string`
 - *Default:* undefined
 
-Origin region that API Gateway will be deployed to, used for the config.yml on the Edge function to sign requests for the correct region.
+Origin region that API Gateway or Lambda function will be deployed to, used for the config.yml on the Edge function to sign requests for the correct region.
+
+---
+
+##### `originShieldRegion`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsProps.originShieldRegion"></a>
+
+- *Type:* `string`
+- *Default:* originRegion if specified, otherwise undefined
+
+Optional Origin Shield Region.
+
+This should be the region where the DynamoDB is located so the
+EdgeToOrigin calls have the lowest latency (~1 ms).
 
 ---
 
@@ -1337,6 +1394,18 @@ S3 logs bucket name.
 
 ---
 
+##### `originShieldRegion`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsS3Props.originShieldRegion"></a>
+
+- *Type:* `string`
+- *Default:* none
+
+Optional Origin Shield Region.
+
+This should be the region where the DynamoDB is located so the
+EdgeToOrigin calls have the lowest latency (~1 ms).
+
+---
+
 ##### `removalPolicy`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsS3Props.removalPolicy"></a>
 
 - *Type:* [`aws-cdk-lib.RemovalPolicy`](#aws-cdk-lib.RemovalPolicy)
@@ -1392,14 +1461,6 @@ S3 bucket for staged applications (prior to deploy).
 
 ---
 
-##### `httpApi`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsSvcsProps.httpApi"></a>
-
-- *Type:* [`@aws-cdk/aws-apigatewayv2-alpha.HttpApi`](#@aws-cdk/aws-apigatewayv2-alpha.HttpApi)
-
-API Gateway v2 HTTP for Router and app.
-
----
-
 ##### `assetNameRoot`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsSvcsProps.assetNameRoot"></a>
 
 - *Type:* `string`
@@ -1418,6 +1479,14 @@ Optional asset name suffix.
 
 ---
 
+##### `httpApi`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsSvcsProps.httpApi"></a>
+
+- *Type:* [`@aws-cdk/aws-apigatewayv2-alpha.HttpApi`](#@aws-cdk/aws-apigatewayv2-alpha.HttpApi)
+
+API Gateway v2 HTTP for Router and app.
+
+---
+
 ##### `removalPolicy`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsSvcsProps.removalPolicy"></a>
 
 - *Type:* [`aws-cdk-lib.RemovalPolicy`](#aws-cdk-lib.RemovalPolicy)
@@ -1582,14 +1651,6 @@ Represents a MicroApps.
 
 #### Properties <a name="Properties"></a>
 
-##### `apigwy`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.IMicroApps.apigwy"></a>
-
-- *Type:* [`@pwrdrvr/microapps-cdk.IMicroAppsAPIGwy`](#@pwrdrvr/microapps-cdk.IMicroAppsAPIGwy)
-
-{@inheritdoc IMicroAppsAPIGwy}.
-
----
-
 ##### `cf`<sup>Required</sup> <a name="@pwrdrvr/microapps-cdk.IMicroApps.cf"></a>
 
 - *Type:* [`@pwrdrvr/microapps-cdk.IMicroAppsCF`](#@pwrdrvr/microapps-cdk.IMicroAppsCF)
@@ -1614,6 +1675,14 @@ Represents a MicroApps.
 
 ---
 
+##### `apigwy`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.IMicroApps.apigwy"></a>
+
+- *Type:* [`@pwrdrvr/microapps-cdk.IMicroAppsAPIGwy`](#@pwrdrvr/microapps-cdk.IMicroAppsAPIGwy)
+
+{@inheritdoc IMicroAppsAPIGwy}.
+
+---
+
 ##### `edgeToOrigin`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.IMicroApps.edgeToOrigin"></a>
 
 - *Type:* [`@pwrdrvr/microapps-cdk.IMicroAppsEdgeToOrigin`](#@pwrdrvr/microapps-cdk.IMicroAppsEdgeToOrigin)

package/changelog.md

@@ -1,2 +1,2 @@
 
-### [0.3.3-alpha.1](https://github.com/pwrdrvr/microapps-core/compare/v0.3.2...v0.3.3-alpha.1) (2023-01-02)
+### [0.3.4](https://github.com/pwrdrvr/microapps-core/compare/v0.3.4-rc.2...v0.3.4) (2023-01-09)

package/lib/MicroApps.d.ts

@@ -162,6 +162,12 @@ export interface MicroAppsProps {
      * @example dev/
      */
     readonly rootPathPrefix?: string;
+    /**
+     * Create API Gateway for non-edge invocation
+     *
+     * @default false
+     */
+    readonly createAPIGateway?: boolean;
     /**
      * Create an extra Behavior (Route) for /api/ that allows
      * API routes to have a period in them.
@@ -174,6 +180,20 @@ export interface MicroAppsProps {
      * @default true
      */
     readonly createAPIPathRoute?: boolean;
+    /**
+     * Create an extra Behavior (Route) for /_next/data/
+     * This route is used by Next.js to load data from the API Gateway
+     * on `getServerSideProps` calls.  The requests can end in `.json`,
+     * which would cause them to be routed to S3 if this route is not created.
+     *
+     * When false API routes with a period in the path will get routed to S3.
+     *
+     * When true API routes that contain /_next/data/ in the path will get routed to API Gateway
+     * even if they have a period in the path.
+     *
+     * @default true
+     */
+    readonly createNextDataPathRoute?: boolean;
     /**
      * Adds an X-Forwarded-Host-Header when calling API Gateway
      *
@@ -208,13 +228,22 @@ export interface MicroAppsProps {
      */
     readonly signingMode?: 'sign' | 'presign' | 'none';
     /**
-     * Origin region that API Gateway will be deployed to, used
+     * Origin region that API Gateway or Lambda function will be deployed to, used
      * for the config.yml on the Edge function to sign requests for
      * the correct region
      *
      * @default undefined
      */
     readonly originRegion?: string;
+    /**
+     * Optional Origin Shield Region
+     *
+     * This should be the region where the DynamoDB is located so the
+     * EdgeToOrigin calls have the lowest latency (~1 ms).
+     *
+     * @default originRegion if specified, otherwise undefined
+     */
+    readonly originShieldRegion?: string;
     /**
      * Existing table for apps/versions/rules
      *
@@ -254,7 +283,7 @@ export interface IMicroApps {
     /** {@inheritdoc IMicroAppsSvcs} */
     readonly svcs: IMicroAppsSvcs;
     /** {@inheritdoc IMicroAppsAPIGwy} */
-    readonly apigwy: IMicroAppsAPIGwy;
+    readonly apigwy?: IMicroAppsAPIGwy;
 }
 /**
  * Create a new MicroApps "turnkey" construct for simple
@@ -283,8 +312,8 @@ export declare class MicroApps extends Construct implements IMicroApps {
     get edgeToOrigin(): IMicroAppsEdgeToOrigin | undefined;
     private _s3;
     get s3(): IMicroAppsS3;
-    private _apigwy;
-    get apigwy(): IMicroAppsAPIGwy;
+    private _apigwy?;
+    get apigwy(): IMicroAppsAPIGwy | undefined;
     private _svcs;
     get svcs(): IMicroAppsSvcs;
     constructor(scope: Construct, id: string, props?: MicroAppsProps);

package/lib/MicroApps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MicroApps.d.ts","sourceRoot":"","sources":["../src/MicroApps.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"MicroApps.d.ts","sourceRoot":"","sources":["../src/MicroApps.ts"],"names":[],"mappings":"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"}

package/lib/MicroApps.js

@@ -37,7 +37,7 @@ class MicroApps extends constructs_1.Construct {
         if (props === undefined) {
             throw new Error('props must be set');
         }
-        const { domainNameEdge, domainNameOrigin, assetNameRoot, assetNameSuffix, r53Zone, certEdge, appEnv = 'dev', certOrigin, removalPolicy, s3PolicyBypassAROAs, s3PolicyBypassPrincipalARNs, s3StrictBucketPolicy, rootPathPrefix, createAPIPathRoute = true, addXForwardedHostHeader = true, replaceHostHeader = true, signingMode = 'sign', originRegion, table, tableNameForEdgeToOrigin, } = props;
+        const { domainNameEdge, domainNameOrigin, assetNameRoot, assetNameSuffix, r53Zone, certEdge, appEnv = 'dev', certOrigin, removalPolicy, s3PolicyBypassAROAs, s3PolicyBypassPrincipalARNs, s3StrictBucketPolicy, rootPathPrefix, createAPIGateway = false, createAPIPathRoute = true, createNextDataPathRoute = true, addXForwardedHostHeader = true, replaceHostHeader = true, signingMode = 'sign', originRegion, table, tableNameForEdgeToOrigin, originShieldRegion = originRegion, } = props;
         this._s3 = new MicroAppsS3_1.MicroAppsS3(this, 's3', {
             removalPolicy,
             bucketLogsName: domainNameEdge ? `${ReverseDomain_1.reverseDomain(domainNameEdge)}-logs` : undefined,
@@ -47,20 +47,23 @@ class MicroApps extends constructs_1.Construct {
                 : undefined,
             assetNameRoot,
             assetNameSuffix,
+            originShieldRegion,
         });
-        this._apigwy = new MicroAppsAPIGwy_1.MicroAppsAPIGwy(this, 'api', {
-            removalPolicy,
-            assetNameRoot,
-            assetNameSuffix,
-            domainNameEdge,
-            domainNameOrigin,
-            r53Zone,
-            certOrigin,
-            rootPathPrefix,
-            requireIAMAuthorization: signingMode !== 'none',
-        });
+        if (createAPIGateway) {
+            this._apigwy = new MicroAppsAPIGwy_1.MicroAppsAPIGwy(this, 'api', {
+                removalPolicy,
+                assetNameRoot,
+                assetNameSuffix,
+                domainNameEdge,
+                domainNameOrigin,
+                r53Zone,
+                certOrigin,
+                rootPathPrefix,
+                requireIAMAuthorization: signingMode !== 'none',
+            });
+        }
         this._svcs = new MicroAppsSvcs_1.MicroAppsSvcs(this, 'svcs', {
-            httpApi: this.apigwy.httpApi,
+            ...(this._apigwy ? { httpApi: this._apigwy.httpApi } : {}),
             removalPolicy,
             bucketApps: this._s3.bucketApps,
             bucketAppsOAI: this._s3.bucketAppsOAI,
@@ -82,6 +85,7 @@ class MicroApps extends constructs_1.Construct {
                 assetNameSuffix,
                 removalPolicy,
                 addXForwardedHostHeader,
+                setupApiGatewayPermissions: createAPIGateway,
                 replaceHostHeader,
                 originRegion,
                 signingMode,
@@ -100,13 +104,15 @@ class MicroApps extends constructs_1.Construct {
             assetNameSuffix,
             domainNameEdge,
             domainNameOrigin,
-            httpApi: this._apigwy.httpApi,
+            ...(this._apigwy ? { httpApi: this._apigwy.httpApi } : {}),
             r53Zone,
             certEdge,
             bucketAppsOrigin: this._s3.bucketAppsOrigin,
             bucketLogs: this._s3.bucketLogs,
             rootPathPrefix,
             createAPIPathRoute,
+            createNextDataPathRoute,
+            originShieldRegion,
             ...(edgeLambdas.length ? { edgeLambdas } : {}),
         });
     }
@@ -128,5 +134,5 @@ class MicroApps extends constructs_1.Construct {
 }
 exports.MicroApps = MicroApps;
 _a = JSII_RTTI_SYMBOL_1;
-MicroApps[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroApps", version: "0.3.3-alpha.1" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MicroApps.js","sourceRoot":"","sources":["../src/MicroApps.ts"],"names":[],"mappings":"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","sourcesContent":["import { RemovalPolicy } from 'aws-cdk-lib';\nimport * as acm from 'aws-cdk-lib/aws-certificatemanager';\nimport * as cf from 'aws-cdk-lib/aws-cloudfront';\nimport * as dynamodb from 'aws-cdk-lib/aws-dynamodb';\nimport * as r53 from 'aws-cdk-lib/aws-route53';\nimport { Construct } from 'constructs';\nimport { IMicroAppsAPIGwy, MicroAppsAPIGwy } from './MicroAppsAPIGwy';\nimport { IMicroAppsCF, MicroAppsCF } from './MicroAppsCF';\nimport { IMicroAppsEdgeToOrigin, MicroAppsEdgeToOrigin } from './MicroAppsEdgeToOrigin';\nimport { IMicroAppsS3, MicroAppsS3 } from './MicroAppsS3';\nimport { IMicroAppsSvcs, MicroAppsSvcs } from './MicroAppsSvcs';\nimport { reverseDomain } from './utils/ReverseDomain';\n\n/**\n * A CDK Construct for creating a MicroApps runtime environment used\n * to host Next.js, React, or any other sort of web application with\n * multiple versions available for comparison, quick rollbacks, quick\n * releases, and a complete lack of user disturbance on deploys.\n *\n * @remarks\n *\n * {@link MicroApps} provides a turn-key construct that creates all\n * dependencies with limited exposure of underlying AWS Resource options.\n * This construct is the easiest to use when exploring MicroApps for the\n * first time.\n *\n * {@link MicroAppsAPIGwy}, {@link MicroAppsCF}, {@link MicroAppsS3},\n * and {@link MicroAppsSvcs}, and their helper static methods, can be used\n * to create AWS Resources more directly, to provide your own AWS Resources\n * (e.g. an existing CloudFront Distribution), and to have more flexibility\n * than the {@link MicroApps} construct offers.\n *\n * @packageDocumentation\n */\n\n/**\n * Properties to initialize an instance of `MicroApps`.\n */\nexport interface MicroAppsProps {\n  /**\n   * RemovalPolicy override for child resources\n   *\n   * Note: if set to DESTROY the S3 buckes will have `autoDeleteObjects` set to `true`\n   *\n   * @default - per resource default\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * Passed to NODE_ENV of Router and Deployer Lambda functions.\n   *\n   * @default dev\n   */\n  readonly appEnv: string;\n\n  /**\n   * Optional asset name root\n   *\n   * @example microapps\n   * @default - resource names auto assigned\n   */\n  readonly assetNameRoot?: string;\n\n  /**\n   * Optional asset name suffix\n   *\n   * @example -dev-pr-12\n   * @default none\n   */\n  readonly assetNameSuffix?: string;\n\n  /**\n   * Route53 zone in which to create optional `domainNameEdge` record\n   */\n  readonly r53Zone?: r53.IHostedZone;\n\n  /**\n   * Certificate in US-East-1 for the CloudFront distribution.\n   */\n  readonly certEdge?: acm.ICertificate;\n\n  /**\n   * Certificate in deployed region for the API Gateway.\n   */\n  readonly certOrigin?: acm.ICertificate;\n\n  /**\n   * Use a strict S3 Bucket Policy that prevents applications\n   * from reading/writing/modifying/deleting files in the S3 Bucket\n   * outside of the path that is specific to their app/version.\n   *\n   * This setting should be used when applications are less than\n   * fully trusted.\n   *\n   * @default false\n   */\n  readonly s3StrictBucketPolicy?: boolean;\n\n  /**\n   * Applies when using s3StrictBucketPolicy = true\n   *\n   * IAM Role or IAM User names to exclude from the DENY rules on the S3 Bucket Policy.\n   *\n   * Roles that are Assumed must instead have their AROA added to `s3PolicyBypassAROAs`.\n   *\n   * Typically any admin roles / users that need to view or manage the S3 Bucket\n   * would be added to this list.\n   *\n   * @example ['arn:aws:iam::1234567890123:role/AdminAccess', 'arn:aws:iam::1234567890123:user/MyAdminUser']\n   *\n   * @see s3PolicyBypassAROAs\n   */\n  readonly s3PolicyBypassPrincipalARNs?: string[];\n\n  /**\n   * Applies when using s3StrictBucketPolicy = true\n   *\n   * AROAs of the IAM Role to exclude from the DENY rules on the S3 Bucket Policy.\n   * This allows sessions that assume the IAM Role to be excluded from the\n   * DENY rules on the S3 Bucket Policy.\n   *\n   * Typically any admin roles / users that need to view or manage the S3 Bucket\n   * would be added to this list.\n   *\n   * Roles / users that are used directly, not assumed, can be added to `s3PolicyBypassRoleNames` instead.\n   *\n   * Note: This AROA must be specified to prevent this policy from locking\n   * out non-root sessions that have assumed the admin role.\n   *\n   * The notPrincipals will only match the role name exactly and will not match\n   * any session that has assumed the role since notPrincipals does not allow\n   * wildcard matches and does not do wildcard matches implicitly either.\n   *\n   * The AROA must be used because there are only 3 Principal variables available:\n   *  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable\n   *  aws:username, aws:userid, aws:PrincipalTag\n   *\n   * For an assumed role, aws:username is blank, aws:userid is:\n   *  [unique id AKA AROA for Role]:[session name]\n   *\n   * Table of unique ID prefixes such as AROA:\n   *  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-prefixes\n   *\n   * The name of the role is simply not available for an assumed role and, if it was,\n   * a complicated comparison would be requierd to prevent exclusion\n   * of applying the Deny Rule to roles from other accounts.\n   *\n   * To get the AROA with the AWS CLI:\n   *   aws iam get-role --role-name ROLE-NAME\n   *   aws iam get-user -–user-name USER-NAME\n   *\n   * @example [ 'AROA1234567890123' ]\n   *\n   * @see s3StrictBucketPolicy\n   */\n  readonly s3PolicyBypassAROAs?: string[];\n\n  /**\n   * Optional custom domain name for the CloudFront distribution.\n   *\n   * @example apps.pwrdrvr.com\n   * @default auto-assigned\n   */\n  readonly domainNameEdge?: string;\n\n  /**\n   * Optional custom domain name for the API Gateway HTTPv2 API.\n   *\n   * @example apps-origin.pwrdrvr.com\n   * @default auto-assigned\n   */\n  readonly domainNameOrigin?: string;\n\n  /**\n   * Path prefix on the root of the CloudFront distribution\n   *\n   * @example dev/\n   */\n  readonly rootPathPrefix?: string;\n\n  /**\n   * Create an extra Behavior (Route) for /api/ that allows\n   * API routes to have a period in them.\n   *\n   * When false API routes with a period in the path will get routed to S3.\n   *\n   * When true API routes that contain /api/ in the path will get routed to API Gateway\n   * even if they have a period in the path.\n   *\n   * @default true\n   */\n  readonly createAPIPathRoute?: boolean;\n\n  /**\n   * Adds an X-Forwarded-Host-Header when calling API Gateway\n   *\n   * Can only be trusted if `signingMode` is enabled, which restricts\n   * access to API Gateway to only IAM signed requests.\n   *\n   * Note: if true, creates OriginRequest Lambda @ Edge function for API Gateway Origin\n   * @default true\n   */\n  readonly addXForwardedHostHeader?: boolean;\n\n  /**\n   * Replaces Host header (which will be the Edge domain name) with the Origin domain name\n   * when enabled.  This is necessary when API Gateway has not been configured\n   * with a custom domain name that matches the exact domain name used by the CloudFront\n   * Distribution AND when the OriginRequestPolicy.HeadersBehavior is set\n   * to pass all headers to the origin.\n   *\n   * Note: if true, creates OriginRequest Lambda @ Edge function for API Gateway Origin\n   * @default true\n   */\n  readonly replaceHostHeader?: boolean;\n\n  /**\n   * Requires IAM auth on the API Gateway origin if not set to 'none'.\n   *\n   * 'sign' - Uses request headers for auth.\n   * 'presign' - Uses query string for auth.\n   *\n   * If enabled,\n   *\n   * Note: if 'sign' or 'presign', creates OriginRequest Lambda @ Edge function for API Gateway Origin\n   * @default 'sign'\n   */\n  readonly signingMode?: 'sign' | 'presign' | 'none';\n\n  /**\n   * Origin region that API Gateway will be deployed to, used\n   * for the config.yml on the Edge function to sign requests for\n   * the correct region\n   *\n   * @default undefined\n   */\n  readonly originRegion?: string;\n\n  /**\n   * Existing table for apps/versions/rules\n   *\n   * @warning - It is *strongly* suggested that production stacks create\n   * their own DynamoDB Table and pass it into this construct, for protection\n   * against data loss due to logical ID changes, the ability to configure\n   * Provisioned capacity with Auto Scaling, the ability to add additional indices, etc.\n   *\n   * Requirements:\n   * - Hash Key: `PK`\n   * - Sort Key: `SK`\n   *\n   * @default created by construct\n   */\n  readonly table?: dynamodb.ITable;\n\n  /**\n   * Pre-set table name for apps/versions/rules\n   *\n   * This is required when using v2 routing\n   */\n  readonly tableNameForEdgeToOrigin?: string;\n\n  /**\n   * Additional edge lambda functions\n   */\n  readonly edgeLambdas?: cf.EdgeLambda[];\n}\n\n/**\n * Represents a MicroApps\n */\nexport interface IMicroApps {\n  /** {@inheritdoc IMicroAppsCF} */\n  readonly cf: IMicroAppsCF;\n\n  /** {@inheritdoc IMicroAppsEdgeToOrigin} */\n  readonly edgeToOrigin?: IMicroAppsEdgeToOrigin;\n\n  /** {@inheritdoc IMicroAppsS3} */\n  readonly s3: IMicroAppsS3;\n\n  /** {@inheritdoc IMicroAppsSvcs} */\n  readonly svcs: IMicroAppsSvcs;\n\n  /** {@inheritdoc IMicroAppsAPIGwy} */\n  readonly apigwy: IMicroAppsAPIGwy;\n}\n\n/**\n * Create a new MicroApps \"turnkey\" construct for simple\n * deployments and for initial evaulation of the MicroApps framework.\n *\n * Use this construct to create a PoC working entire stack.\n *\n * Do not use this construct when adding MicroApps to an existing\n * CloudFront, API Gateway, S3 Bucket, etc. or where access\n * to all features of the AWS Resources are needed (e.g. to\n * add additional Behaviors to the CloudFront distribution, set authorizors\n * on API Gateway, etc.).\n *\n * @warning This construct is not intended for production use.\n * In a production stack the DynamoDB Table, API Gateway, S3 Buckets,\n * etc. should be created in a \"durable\" stack where the IDs will not\n * change and where changes to the MicroApps construct will not\n * cause failures to deploy or data to be deleted.\n *\n *  @see {@link https://github.com/pwrdrvr/microapps-core/blob/main/packages/cdk/lib/MicroApps.ts | example usage in a CDK Stack }\n */\nexport class MicroApps extends Construct implements IMicroApps {\n  private _cf: MicroAppsCF;\n  public get cf(): IMicroAppsCF {\n    return this._cf;\n  }\n\n  private _edgeToOrigin?: MicroAppsEdgeToOrigin;\n  public get edgeToOrigin(): IMicroAppsEdgeToOrigin | undefined {\n    return this._edgeToOrigin;\n  }\n\n  private _s3: MicroAppsS3;\n  public get s3(): IMicroAppsS3 {\n    return this._s3;\n  }\n\n  private _apigwy: MicroAppsAPIGwy;\n  public get apigwy(): IMicroAppsAPIGwy {\n    return this._apigwy;\n  }\n\n  private _svcs: MicroAppsSvcs;\n  public get svcs(): IMicroAppsSvcs {\n    return this._svcs;\n  }\n\n  constructor(scope: Construct, id: string, props?: MicroAppsProps) {\n    super(scope, id);\n\n    if (props === undefined) {\n      throw new Error('props must be set');\n    }\n\n    const {\n      domainNameEdge,\n      domainNameOrigin,\n      assetNameRoot,\n      assetNameSuffix,\n      r53Zone,\n      certEdge,\n      appEnv = 'dev',\n      certOrigin,\n      removalPolicy,\n      s3PolicyBypassAROAs,\n      s3PolicyBypassPrincipalARNs,\n      s3StrictBucketPolicy,\n      rootPathPrefix,\n      createAPIPathRoute = true,\n      addXForwardedHostHeader = true,\n      replaceHostHeader = true,\n      signingMode = 'sign',\n      originRegion,\n      table,\n      tableNameForEdgeToOrigin,\n    } = props;\n\n    this._s3 = new MicroAppsS3(this, 's3', {\n      removalPolicy,\n      bucketLogsName: domainNameEdge ? `${reverseDomain(domainNameEdge)}-logs` : undefined,\n      bucketAppsName: domainNameEdge ? `${reverseDomain(domainNameEdge)}` : undefined,\n      bucketAppsStagingName: domainNameEdge\n        ? `${reverseDomain(domainNameEdge)}-staging`\n        : undefined,\n      assetNameRoot,\n      assetNameSuffix,\n    });\n    this._apigwy = new MicroAppsAPIGwy(this, 'api', {\n      removalPolicy,\n      assetNameRoot,\n      assetNameSuffix,\n      domainNameEdge,\n      domainNameOrigin,\n      r53Zone,\n      certOrigin,\n      rootPathPrefix,\n      requireIAMAuthorization: signingMode !== 'none',\n    });\n    this._svcs = new MicroAppsSvcs(this, 'svcs', {\n      httpApi: this.apigwy.httpApi,\n      removalPolicy,\n      bucketApps: this._s3.bucketApps,\n      bucketAppsOAI: this._s3.bucketAppsOAI,\n      bucketAppsStaging: this._s3.bucketAppsStaging,\n      assetNameRoot,\n      assetNameSuffix,\n      appEnv,\n      s3PolicyBypassAROAs,\n      s3PolicyBypassPrincipalARNs,\n      s3StrictBucketPolicy,\n      rootPathPrefix,\n      requireIAMAuthorization: signingMode !== 'none',\n      table,\n    });\n    const edgeLambdas: cf.EdgeLambda[] = [];\n\n    if (signingMode !== 'none' || replaceHostHeader || addXForwardedHostHeader) {\n      this._edgeToOrigin = new MicroAppsEdgeToOrigin(this, 'edgeToOrigin', {\n        assetNameRoot,\n        assetNameSuffix,\n        removalPolicy,\n        addXForwardedHostHeader,\n        replaceHostHeader,\n        originRegion,\n        signingMode,\n        rootPathPrefix,\n        tableRulesArn: tableNameForEdgeToOrigin || this._svcs.table.tableName,\n      });\n\n      edgeLambdas.push(...this._edgeToOrigin.edgeToOriginLambdas);\n    }\n    // Add any extra lambdas\n    if (props.edgeLambdas?.length) {\n      edgeLambdas.push(...props.edgeLambdas);\n    }\n    this._cf = new MicroAppsCF(this, 'cft', {\n      removalPolicy,\n      assetNameRoot,\n      assetNameSuffix,\n      domainNameEdge,\n      domainNameOrigin,\n      httpApi: this._apigwy.httpApi,\n      r53Zone,\n      certEdge,\n      bucketAppsOrigin: this._s3.bucketAppsOrigin,\n      bucketLogs: this._s3.bucketLogs,\n      rootPathPrefix,\n      createAPIPathRoute,\n      ...(edgeLambdas.length ? { edgeLambdas } : {}),\n    });\n  }\n}\n"]}
+MicroApps[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroApps", version: "0.3.4" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MicroApps.js","sourceRoot":"","sources":["../src/MicroApps.ts"],"names":[],"mappings":"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","sourcesContent":["import { RemovalPolicy } from 'aws-cdk-lib';\nimport * as acm from 'aws-cdk-lib/aws-certificatemanager';\nimport * as cf from 'aws-cdk-lib/aws-cloudfront';\nimport * as dynamodb from 'aws-cdk-lib/aws-dynamodb';\nimport * as r53 from 'aws-cdk-lib/aws-route53';\nimport { Construct } from 'constructs';\nimport { IMicroAppsAPIGwy, MicroAppsAPIGwy } from './MicroAppsAPIGwy';\nimport { IMicroAppsCF, MicroAppsCF } from './MicroAppsCF';\nimport { IMicroAppsEdgeToOrigin, MicroAppsEdgeToOrigin } from './MicroAppsEdgeToOrigin';\nimport { IMicroAppsS3, MicroAppsS3 } from './MicroAppsS3';\nimport { IMicroAppsSvcs, MicroAppsSvcs } from './MicroAppsSvcs';\nimport { reverseDomain } from './utils/ReverseDomain';\n\n/**\n * A CDK Construct for creating a MicroApps runtime environment used\n * to host Next.js, React, or any other sort of web application with\n * multiple versions available for comparison, quick rollbacks, quick\n * releases, and a complete lack of user disturbance on deploys.\n *\n * @remarks\n *\n * {@link MicroApps} provides a turn-key construct that creates all\n * dependencies with limited exposure of underlying AWS Resource options.\n * This construct is the easiest to use when exploring MicroApps for the\n * first time.\n *\n * {@link MicroAppsAPIGwy}, {@link MicroAppsCF}, {@link MicroAppsS3},\n * and {@link MicroAppsSvcs}, and their helper static methods, can be used\n * to create AWS Resources more directly, to provide your own AWS Resources\n * (e.g. an existing CloudFront Distribution), and to have more flexibility\n * than the {@link MicroApps} construct offers.\n *\n * @packageDocumentation\n */\n\n/**\n * Properties to initialize an instance of `MicroApps`.\n */\nexport interface MicroAppsProps {\n  /**\n   * RemovalPolicy override for child resources\n   *\n   * Note: if set to DESTROY the S3 buckes will have `autoDeleteObjects` set to `true`\n   *\n   * @default - per resource default\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * Passed to NODE_ENV of Router and Deployer Lambda functions.\n   *\n   * @default dev\n   */\n  readonly appEnv: string;\n\n  /**\n   * Optional asset name root\n   *\n   * @example microapps\n   * @default - resource names auto assigned\n   */\n  readonly assetNameRoot?: string;\n\n  /**\n   * Optional asset name suffix\n   *\n   * @example -dev-pr-12\n   * @default none\n   */\n  readonly assetNameSuffix?: string;\n\n  /**\n   * Route53 zone in which to create optional `domainNameEdge` record\n   */\n  readonly r53Zone?: r53.IHostedZone;\n\n  /**\n   * Certificate in US-East-1 for the CloudFront distribution.\n   */\n  readonly certEdge?: acm.ICertificate;\n\n  /**\n   * Certificate in deployed region for the API Gateway.\n   */\n  readonly certOrigin?: acm.ICertificate;\n\n  /**\n   * Use a strict S3 Bucket Policy that prevents applications\n   * from reading/writing/modifying/deleting files in the S3 Bucket\n   * outside of the path that is specific to their app/version.\n   *\n   * This setting should be used when applications are less than\n   * fully trusted.\n   *\n   * @default false\n   */\n  readonly s3StrictBucketPolicy?: boolean;\n\n  /**\n   * Applies when using s3StrictBucketPolicy = true\n   *\n   * IAM Role or IAM User names to exclude from the DENY rules on the S3 Bucket Policy.\n   *\n   * Roles that are Assumed must instead have their AROA added to `s3PolicyBypassAROAs`.\n   *\n   * Typically any admin roles / users that need to view or manage the S3 Bucket\n   * would be added to this list.\n   *\n   * @example ['arn:aws:iam::1234567890123:role/AdminAccess', 'arn:aws:iam::1234567890123:user/MyAdminUser']\n   *\n   * @see s3PolicyBypassAROAs\n   */\n  readonly s3PolicyBypassPrincipalARNs?: string[];\n\n  /**\n   * Applies when using s3StrictBucketPolicy = true\n   *\n   * AROAs of the IAM Role to exclude from the DENY rules on the S3 Bucket Policy.\n   * This allows sessions that assume the IAM Role to be excluded from the\n   * DENY rules on the S3 Bucket Policy.\n   *\n   * Typically any admin roles / users that need to view or manage the S3 Bucket\n   * would be added to this list.\n   *\n   * Roles / users that are used directly, not assumed, can be added to `s3PolicyBypassRoleNames` instead.\n   *\n   * Note: This AROA must be specified to prevent this policy from locking\n   * out non-root sessions that have assumed the admin role.\n   *\n   * The notPrincipals will only match the role name exactly and will not match\n   * any session that has assumed the role since notPrincipals does not allow\n   * wildcard matches and does not do wildcard matches implicitly either.\n   *\n   * The AROA must be used because there are only 3 Principal variables available:\n   *  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable\n   *  aws:username, aws:userid, aws:PrincipalTag\n   *\n   * For an assumed role, aws:username is blank, aws:userid is:\n   *  [unique id AKA AROA for Role]:[session name]\n   *\n   * Table of unique ID prefixes such as AROA:\n   *  https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-prefixes\n   *\n   * The name of the role is simply not available for an assumed role and, if it was,\n   * a complicated comparison would be requierd to prevent exclusion\n   * of applying the Deny Rule to roles from other accounts.\n   *\n   * To get the AROA with the AWS CLI:\n   *   aws iam get-role --role-name ROLE-NAME\n   *   aws iam get-user -–user-name USER-NAME\n   *\n   * @example [ 'AROA1234567890123' ]\n   *\n   * @see s3StrictBucketPolicy\n   */\n  readonly s3PolicyBypassAROAs?: string[];\n\n  /**\n   * Optional custom domain name for the CloudFront distribution.\n   *\n   * @example apps.pwrdrvr.com\n   * @default auto-assigned\n   */\n  readonly domainNameEdge?: string;\n\n  /**\n   * Optional custom domain name for the API Gateway HTTPv2 API.\n   *\n   * @example apps-origin.pwrdrvr.com\n   * @default auto-assigned\n   */\n  readonly domainNameOrigin?: string;\n\n  /**\n   * Path prefix on the root of the CloudFront distribution\n   *\n   * @example dev/\n   */\n  readonly rootPathPrefix?: string;\n\n  /**\n   * Create API Gateway for non-edge invocation\n   *\n   * @default false\n   */\n  readonly createAPIGateway?: boolean;\n\n  /**\n   * Create an extra Behavior (Route) for /api/ that allows\n   * API routes to have a period in them.\n   *\n   * When false API routes with a period in the path will get routed to S3.\n   *\n   * When true API routes that contain /api/ in the path will get routed to API Gateway\n   * even if they have a period in the path.\n   *\n   * @default true\n   */\n  readonly createAPIPathRoute?: boolean;\n\n  /**\n   * Create an extra Behavior (Route) for /_next/data/\n   * This route is used by Next.js to load data from the API Gateway\n   * on `getServerSideProps` calls.  The requests can end in `.json`,\n   * which would cause them to be routed to S3 if this route is not created.\n   *\n   * When false API routes with a period in the path will get routed to S3.\n   *\n   * When true API routes that contain /_next/data/ in the path will get routed to API Gateway\n   * even if they have a period in the path.\n   *\n   * @default true\n   */\n  readonly createNextDataPathRoute?: boolean;\n\n  /**\n   * Adds an X-Forwarded-Host-Header when calling API Gateway\n   *\n   * Can only be trusted if `signingMode` is enabled, which restricts\n   * access to API Gateway to only IAM signed requests.\n   *\n   * Note: if true, creates OriginRequest Lambda @ Edge function for API Gateway Origin\n   * @default true\n   */\n  readonly addXForwardedHostHeader?: boolean;\n\n  /**\n   * Replaces Host header (which will be the Edge domain name) with the Origin domain name\n   * when enabled.  This is necessary when API Gateway has not been configured\n   * with a custom domain name that matches the exact domain name used by the CloudFront\n   * Distribution AND when the OriginRequestPolicy.HeadersBehavior is set\n   * to pass all headers to the origin.\n   *\n   * Note: if true, creates OriginRequest Lambda @ Edge function for API Gateway Origin\n   * @default true\n   */\n  readonly replaceHostHeader?: boolean;\n\n  /**\n   * Requires IAM auth on the API Gateway origin if not set to 'none'.\n   *\n   * 'sign' - Uses request headers for auth.\n   * 'presign' - Uses query string for auth.\n   *\n   * If enabled,\n   *\n   * Note: if 'sign' or 'presign', creates OriginRequest Lambda @ Edge function for API Gateway Origin\n   * @default 'sign'\n   */\n  readonly signingMode?: 'sign' | 'presign' | 'none';\n\n  /**\n   * Origin region that API Gateway or Lambda function will be deployed to, used\n   * for the config.yml on the Edge function to sign requests for\n   * the correct region\n   *\n   * @default undefined\n   */\n  readonly originRegion?: string;\n\n  /**\n   * Optional Origin Shield Region\n   *\n   * This should be the region where the DynamoDB is located so the\n   * EdgeToOrigin calls have the lowest latency (~1 ms).\n   *\n   * @default originRegion if specified, otherwise undefined\n   */\n  readonly originShieldRegion?: string;\n\n  /**\n   * Existing table for apps/versions/rules\n   *\n   * @warning - It is *strongly* suggested that production stacks create\n   * their own DynamoDB Table and pass it into this construct, for protection\n   * against data loss due to logical ID changes, the ability to configure\n   * Provisioned capacity with Auto Scaling, the ability to add additional indices, etc.\n   *\n   * Requirements:\n   * - Hash Key: `PK`\n   * - Sort Key: `SK`\n   *\n   * @default created by construct\n   */\n  readonly table?: dynamodb.ITable;\n\n  /**\n   * Pre-set table name for apps/versions/rules\n   *\n   * This is required when using v2 routing\n   */\n  readonly tableNameForEdgeToOrigin?: string;\n\n  /**\n   * Additional edge lambda functions\n   */\n  readonly edgeLambdas?: cf.EdgeLambda[];\n}\n\n/**\n * Represents a MicroApps\n */\nexport interface IMicroApps {\n  /** {@inheritdoc IMicroAppsCF} */\n  readonly cf: IMicroAppsCF;\n\n  /** {@inheritdoc IMicroAppsEdgeToOrigin} */\n  readonly edgeToOrigin?: IMicroAppsEdgeToOrigin;\n\n  /** {@inheritdoc IMicroAppsS3} */\n  readonly s3: IMicroAppsS3;\n\n  /** {@inheritdoc IMicroAppsSvcs} */\n  readonly svcs: IMicroAppsSvcs;\n\n  /** {@inheritdoc IMicroAppsAPIGwy} */\n  readonly apigwy?: IMicroAppsAPIGwy;\n}\n\n/**\n * Create a new MicroApps \"turnkey\" construct for simple\n * deployments and for initial evaulation of the MicroApps framework.\n *\n * Use this construct to create a PoC working entire stack.\n *\n * Do not use this construct when adding MicroApps to an existing\n * CloudFront, API Gateway, S3 Bucket, etc. or where access\n * to all features of the AWS Resources are needed (e.g. to\n * add additional Behaviors to the CloudFront distribution, set authorizors\n * on API Gateway, etc.).\n *\n * @warning This construct is not intended for production use.\n * In a production stack the DynamoDB Table, API Gateway, S3 Buckets,\n * etc. should be created in a \"durable\" stack where the IDs will not\n * change and where changes to the MicroApps construct will not\n * cause failures to deploy or data to be deleted.\n *\n *  @see {@link https://github.com/pwrdrvr/microapps-core/blob/main/packages/cdk/lib/MicroApps.ts | example usage in a CDK Stack }\n */\nexport class MicroApps extends Construct implements IMicroApps {\n  private _cf: MicroAppsCF;\n  public get cf(): IMicroAppsCF {\n    return this._cf;\n  }\n\n  private _edgeToOrigin?: MicroAppsEdgeToOrigin;\n  public get edgeToOrigin(): IMicroAppsEdgeToOrigin | undefined {\n    return this._edgeToOrigin;\n  }\n\n  private _s3: MicroAppsS3;\n  public get s3(): IMicroAppsS3 {\n    return this._s3;\n  }\n\n  private _apigwy?: MicroAppsAPIGwy;\n  public get apigwy(): IMicroAppsAPIGwy | undefined {\n    return this._apigwy;\n  }\n\n  private _svcs: MicroAppsSvcs;\n  public get svcs(): IMicroAppsSvcs {\n    return this._svcs;\n  }\n\n  constructor(scope: Construct, id: string, props?: MicroAppsProps) {\n    super(scope, id);\n\n    if (props === undefined) {\n      throw new Error('props must be set');\n    }\n\n    const {\n      domainNameEdge,\n      domainNameOrigin,\n      assetNameRoot,\n      assetNameSuffix,\n      r53Zone,\n      certEdge,\n      appEnv = 'dev',\n      certOrigin,\n      removalPolicy,\n      s3PolicyBypassAROAs,\n      s3PolicyBypassPrincipalARNs,\n      s3StrictBucketPolicy,\n      rootPathPrefix,\n      createAPIGateway = false,\n      createAPIPathRoute = true,\n      createNextDataPathRoute = true,\n      addXForwardedHostHeader = true,\n      replaceHostHeader = true,\n      signingMode = 'sign',\n      originRegion,\n      table,\n      tableNameForEdgeToOrigin,\n      originShieldRegion = originRegion,\n    } = props;\n\n    this._s3 = new MicroAppsS3(this, 's3', {\n      removalPolicy,\n      bucketLogsName: domainNameEdge ? `${reverseDomain(domainNameEdge)}-logs` : undefined,\n      bucketAppsName: domainNameEdge ? `${reverseDomain(domainNameEdge)}` : undefined,\n      bucketAppsStagingName: domainNameEdge\n        ? `${reverseDomain(domainNameEdge)}-staging`\n        : undefined,\n      assetNameRoot,\n      assetNameSuffix,\n      originShieldRegion,\n    });\n    if (createAPIGateway) {\n      this._apigwy = new MicroAppsAPIGwy(this, 'api', {\n        removalPolicy,\n        assetNameRoot,\n        assetNameSuffix,\n        domainNameEdge,\n        domainNameOrigin,\n        r53Zone,\n        certOrigin,\n        rootPathPrefix,\n        requireIAMAuthorization: signingMode !== 'none',\n      });\n    }\n    this._svcs = new MicroAppsSvcs(this, 'svcs', {\n      ...(this._apigwy ? { httpApi: this._apigwy.httpApi } : {}),\n      removalPolicy,\n      bucketApps: this._s3.bucketApps,\n      bucketAppsOAI: this._s3.bucketAppsOAI,\n      bucketAppsStaging: this._s3.bucketAppsStaging,\n      assetNameRoot,\n      assetNameSuffix,\n      appEnv,\n      s3PolicyBypassAROAs,\n      s3PolicyBypassPrincipalARNs,\n      s3StrictBucketPolicy,\n      rootPathPrefix,\n      requireIAMAuthorization: signingMode !== 'none',\n      table,\n    });\n    const edgeLambdas: cf.EdgeLambda[] = [];\n\n    if (signingMode !== 'none' || replaceHostHeader || addXForwardedHostHeader) {\n      this._edgeToOrigin = new MicroAppsEdgeToOrigin(this, 'edgeToOrigin', {\n        assetNameRoot,\n        assetNameSuffix,\n        removalPolicy,\n        addXForwardedHostHeader,\n        setupApiGatewayPermissions: createAPIGateway,\n        replaceHostHeader,\n        originRegion,\n        signingMode,\n        rootPathPrefix,\n        tableRulesArn: tableNameForEdgeToOrigin || this._svcs.table.tableName,\n      });\n\n      edgeLambdas.push(...this._edgeToOrigin.edgeToOriginLambdas);\n    }\n    // Add any extra lambdas\n    if (props.edgeLambdas?.length) {\n      edgeLambdas.push(...props.edgeLambdas);\n    }\n    this._cf = new MicroAppsCF(this, 'cft', {\n      removalPolicy,\n      assetNameRoot,\n      assetNameSuffix,\n      domainNameEdge,\n      domainNameOrigin,\n      ...(this._apigwy ? { httpApi: this._apigwy.httpApi } : {}),\n      r53Zone,\n      certEdge,\n      bucketAppsOrigin: this._s3.bucketAppsOrigin,\n      bucketLogs: this._s3.bucketLogs,\n      rootPathPrefix,\n      createAPIPathRoute,\n      createNextDataPathRoute,\n      originShieldRegion,\n      ...(edgeLambdas.length ? { edgeLambdas } : {}),\n    });\n  }\n}\n"]}

package/lib/MicroAppsAPIGwy.js

@@ -167,5 +167,5 @@ class MicroAppsAPIGwy extends constructs_1.Construct {
 }
 exports.MicroAppsAPIGwy = MicroAppsAPIGwy;
 _a = JSII_RTTI_SYMBOL_1;
-MicroAppsAPIGwy[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroAppsAPIGwy", version: "0.3.3-alpha.1" };
+MicroAppsAPIGwy[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroAppsAPIGwy", version: "0.3.4" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MicroAppsAPIGwy.js","sourceRoot":"","sources":["../src/MicroAppsAPIGwy.ts"],"names":[],"mappings":";;;;;AAAA,0DAA0D;AAC1D,0EAA0E;AAC1E,6CAAyD;AAGzD,2CAA2C;AAC3C,6CAA6C;AAC7C,+CAA+C;AAC/C,8DAA8D;AAC9D,2CAAuC;AA2FvC;;;GAGG;AACH,MAAa,eAAgB,SAAQ,sBAAS;IAW5C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA2B;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,KAAK,KAAK,SAAS,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;SAC9C;QAED,IACE,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,CAAC;YACnE,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,CAAC,EACnE;YACA,MAAM,IAAI,KAAK,CAAC,2EAA2E,CAAC,CAAC;SAC9F;QAED,IAAI,KAAK,CAAC,gBAAgB,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,EAAE;YAC1E,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;SAC3E;QAED,IACE,CAAC,KAAK,CAAC,cAAc,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,CAAC;YACtE,CAAC,KAAK,CAAC,cAAc,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,CAAC,EACtE;YACA,MAAM,IAAI,KAAK,CACb,8EAA8E,CAC/E,CAAC;SACH;QAED,MAAM,EACJ,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,aAAa,EACb,aAAa,EACb,eAAe,EACf,cAAc,EACd,uBAAuB,GAAG,IAAI,GAC/B,GAAG,KAAK,CAAC;QAEV,+DAA+D;QAC/D,mEAAmE;QACnE,MAAM,cAAc,GAAG,aAAa;YAClC,CAAC,CAAC,GAAG,aAAa,GAAG,eAAe,EAAE;YACtC,CAAC,CAAC,GAAG,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,YAAY,CAAC;QAE5C,EAAE;QACF,oDAAoD;QACpD,EAAE;QACF,IAAI,CAAC,QAAQ,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE;YAC9C,OAAO,EAAE,cAAc;YACvB,kBAAkB,EAAE,KAAK;YACzB,iBAAiB,EAAE,uBAAuB,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,SAAS;SAC5F,CAAC,CAAC;QACH,IAAI,aAAa,KAAK,SAAS,EAAE;YAC/B,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;SACjD;QACD,6DAA6D;QAC7D,kBAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;QAEvD,mBAAmB;QACnB,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE;YAChD,OAAO,EAAE,IAAI,CAAC,QAAQ;YACtB,UAAU,EAAE,IAAI;YAChB,mEAAmE;YACnE,SAAS,EAAE,cAAc;SAC1B,CAAC,CAAC;QACH,6DAA6D;QAC7D,kBAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;QAE/C,IAAI,cAAc,KAAK,SAAS,IAAI,UAAU,KAAK,SAAS,EAAE;YAC5D,wCAAwC;YACxC,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,wBAAwB,EAAE;gBACvE,UAAU,EAAE,cAAc;gBAC1B,WAAW,EAAE,UAAU;aACxB,CAAC,CAAC;YACH,IAAI,aAAa,KAAK,SAAS,EAAE;gBAC/B,UAAU,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;aAC9C;YAED,kDAAkD;YAClD,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE;gBACxD,GAAG,EAAE,IAAI,CAAC,QAAQ;gBAClB,UAAU,EAAE,UAAU;gBACtB,KAAK;aACN,CAAC,CAAC;YACH,yEAAyE;YACzE,4CAA4C;YAC5C,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;SAC3C;QAED,IAAI,gBAAgB,KAAK,SAAS,IAAI,UAAU,KAAK,SAAS,EAAE;YAC9D,IAAI,CAAC,aAAa,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE;gBAC5D,UAAU,EAAE,gBAAgB;gBAC5B,WAAW,EAAE,UAAU;aACxB,CAAC,CAAC;YACH,IAAI,aAAa,KAAK,SAAS,EAAE;gBAC/B,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;aACtD;SACF;QAED,oCAAoC;QACpC,MAAM,aAAa,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE;YACpD,YAAY,EAAE,cAAc;gBAC1B,CAAC,CAAC,eAAe,cAAc,EAAE;gBACjC,CAAC,CAAC,eAAe,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;YAC7C,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,SAAS;SACxC,CAAC,CAAC;QACH,IAAI,aAAa,KAAK,SAAS,EAAE;YAC/B,aAAa,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;SACjD;QACD,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,YAAkC,CAAC;QAC/D,QAAQ,CAAC,iBAAiB,GAAG;YAC3B,cAAc,EAAE,aAAa,CAAC,WAAW;YACzC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC;gBACrB,SAAS,EAAE,oBAAoB;gBAC/B,SAAS,EAAE,6BAA6B;gBACxC,QAAQ,EAAE,4BAA4B;gBACtC,WAAW,EAAE,sBAAsB;gBACnC,gBAAgB,EAAE,2BAA2B;gBAC7C,UAAU,EAAE,qBAAqB;gBACjC,IAAI,EAAE,eAAe;gBACrB,MAAM,EAAE,iBAAiB;gBACzB,QAAQ,EAAE,mBAAmB;gBAC7B,cAAc,EAAE,yBAAyB;gBACzC,UAAU,EAAE,qBAAqB;gBACjC,eAAe,EAAE,2BAA2B;aAC7C,CAAC;SACH,CAAC;QAEF,wBAAwB;QACxB,oDAAoD;QACpD,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE;YACpD,eAAe,EAAE;gBACf,GAAG,CAAC,aAAa,CAAC,wBAAwB,CACxC,mDAAmD,CACpD;aACF;YACD,SAAS,EAAE,IAAI,GAAG,CAAC,gBAAgB,CAAC,0BAA0B,CAAC;SAChE,CAAC,CAAC;QACH,aAAa,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QAExC,EAAE;QACF,yDAAyD;QACzD,gEAAgE;QAChE,6DAA6D;QAC7D,0BAA0B;QAC1B,EAAE;QACF,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE;YACpC,MAAM,eAAe,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,gBAAgB,EAAE;gBACpE,GAAG,EAAE,IAAI,CAAC,QAAQ;gBAClB,UAAU,EAAE,IAAI,CAAC,aAAa;gBAC9B,KAAK;aACN,CAAC,CAAC;YACH,yEAAyE;YACzE,4CAA4C;YAC5C,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACvD,IAAI,aAAa,KAAK,SAAS,EAAE;gBAC/B,eAAe,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;aACnD;SACF;QAED,EAAE;QACF,yCAAyC;QACzC,EAAE;QACF,IAAI,OAAO,KAAK,SAAS,IAAI,IAAI,CAAC,aAAa,EAAE;YAC/C,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,gBAAgB,EAAE;gBAC3D,IAAI,EAAE,OAAO;gBACb,UAAU,EAAE,gBAAgB;gBAC5B,MAAM,EAAE,GAAG,CAAC,YAAY,CAAC,SAAS,CAChC,IAAI,UAAU,CAAC,4BAA4B,CACzC,IAAI,CAAC,aAAa,CAAC,kBAAkB,EACrC,IAAI,CAAC,aAAa,CAAC,oBAAoB,CACxC,CACF;aACF,CAAC,CAAC;YACH,IAAI,aAAa,KAAK,SAAS,EAAE;gBAC/B,YAAY,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;aAChD;SACF;IACH,CAAC;IA5LD,IAAW,YAAY;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAGD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;;AATH,0CA+LC","sourcesContent":["import * as apigwy from '@aws-cdk/aws-apigatewayv2-alpha';\nimport * as apigwyAuth from '@aws-cdk/aws-apigatewayv2-authorizers-alpha';\nimport { RemovalPolicy, Stack, Tags } from 'aws-cdk-lib';\nimport * as apigwycfn from 'aws-cdk-lib/aws-apigatewayv2';\nimport * as acm from 'aws-cdk-lib/aws-certificatemanager';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as r53 from 'aws-cdk-lib/aws-route53';\nimport * as r53targets from 'aws-cdk-lib/aws-route53-targets';\nimport { Construct } from 'constructs';\n\n/**\n * Properties to initialize an instance of `MicroAppsAPIGwy`.\n */\nexport interface MicroAppsAPIGwyProps {\n  /**\n   * RemovalPolicy override for child resources\n   *\n   * Note: if set to DESTROY the S3 buckes will have `autoDeleteObjects` set to `true`\n   *\n   * @default - per resource default\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * CloudFront edge domain name\n   *\n   * @example apps.pwrdrvr.com\n   * @default auto-assigned\n   */\n  readonly domainNameEdge?: string;\n\n  /**\n   * API Gateway origin domain name\n   *\n   * @example apps-origin.pwrdrvr.com\n   * @default auto-assigned\n   */\n  readonly domainNameOrigin?: string;\n\n  /**\n   * Optional asset name root\n   *\n   * @example microapps\n   * @default - resource names auto assigned\n   */\n  readonly assetNameRoot?: string;\n\n  /**\n   * Optional asset name suffix\n   *\n   * @example -dev-pr-12\n   * @default none\n   */\n  readonly assetNameSuffix?: string;\n\n  /**\n   * Optional local region ACM certificate to use for API Gateway\n   * Note: required when using a custom domain\n   *\n   * @default none\n   */\n  readonly certOrigin?: acm.ICertificate;\n\n  /**\n   * Route53 zone in which to create optional `domainNameEdge` record\n   */\n  readonly r53Zone?: r53.IHostedZone;\n\n  /**\n   * Path prefix on the root of the API Gateway Stage\n   *\n   * @example dev/\n   * @default none\n   */\n  readonly rootPathPrefix?: string;\n\n  /**\n   * Require IAM auth on API Gateway\n   *\n   * @default true\n   */\n  readonly requireIAMAuthorization?: boolean;\n}\n\n/**\n * Represents a MicroApps API Gateway\n */\nexport interface IMicroAppsAPIGwy {\n  /**\n   * Domain Name applied to API Gateway origin\n   */\n  readonly dnAppsOrigin?: apigwy.IDomainName;\n\n  /**\n   * API Gateway\n   */\n  readonly httpApi: apigwy.HttpApi;\n}\n\n/**\n * Create a new MicroApps API Gateway HTTP API endpoint, optionally\n * requiring IAM authorization\n */\nexport class MicroAppsAPIGwy extends Construct implements IMicroAppsAPIGwy {\n  private _dnAppsOrigin: apigwy.DomainName | undefined;\n  public get dnAppsOrigin(): apigwy.IDomainName | undefined {\n    return this._dnAppsOrigin;\n  }\n\n  private _httpApi: apigwy.HttpApi;\n  public get httpApi(): apigwy.HttpApi {\n    return this._httpApi;\n  }\n\n  constructor(scope: Construct, id: string, props: MicroAppsAPIGwyProps) {\n    super(scope, id);\n\n    if (props === undefined) {\n      throw new Error('props cannot be undefined');\n    }\n\n    if (\n      (props.r53Zone === undefined && props.domainNameEdge !== undefined) ||\n      (props.r53Zone !== undefined && props.domainNameEdge === undefined)\n    ) {\n      throw new Error('If either of r53Zone or domainNameEdge are set then the other must be set');\n    }\n\n    if (props.domainNameOrigin !== undefined && props.certOrigin === undefined) {\n      throw new Error('If domainNameOrigin is set then certOrigin must be set');\n    }\n\n    if (\n      (props.domainNameEdge === undefined && props.certOrigin !== undefined) ||\n      (props.domainNameEdge !== undefined && props.certOrigin === undefined)\n    ) {\n      throw new Error(\n        'If either of domainNameEdge or certOrigin are set then the other must be set',\n      );\n    }\n\n    const {\n      r53Zone,\n      domainNameEdge,\n      domainNameOrigin,\n      certOrigin,\n      removalPolicy,\n      assetNameRoot,\n      assetNameSuffix,\n      rootPathPrefix,\n      requireIAMAuthorization = true,\n    } = props;\n\n    // API Gateway uses the `id` string as the gateway name without\n    // any randomization... we have to make sure the name is unique-ish\n    const apigatewayName = assetNameRoot\n      ? `${assetNameRoot}${assetNameSuffix}`\n      : `${Stack.of(this).stackName}-microapps`;\n\n    //\n    // APIGateway domain names for CloudFront and origin\n    //\n    this._httpApi = new apigwy.HttpApi(this, 'gwy', {\n      apiName: apigatewayName,\n      createDefaultStage: false,\n      defaultAuthorizer: requireIAMAuthorization ? new apigwyAuth.HttpIamAuthorizer() : undefined,\n    });\n    if (removalPolicy !== undefined) {\n      this._httpApi.applyRemovalPolicy(removalPolicy);\n    }\n    // This allows the Lambda @ Edge function to execute this api\n    Tags.of(this._httpApi).add('microapp-managed', 'true');\n\n    // Create the stage\n    const stage = new apigwy.HttpStage(this, 'stage', {\n      httpApi: this._httpApi,\n      autoDeploy: true,\n      // If rootPathPrefix is not defined this will be the $default stage\n      stageName: rootPathPrefix,\n    });\n    // This allows the Lambda @ Edge function to execute this api\n    Tags.of(stage).add('microapp-managed', 'true');\n\n    if (domainNameEdge !== undefined && certOrigin !== undefined) {\n      // Create Custom Domains for API Gateway\n      const dnAppsEdge = new apigwy.DomainName(this, 'microapps-apps-edge-dn', {\n        domainName: domainNameEdge,\n        certificate: certOrigin,\n      });\n      if (removalPolicy !== undefined) {\n        dnAppsEdge.applyRemovalPolicy(removalPolicy);\n      }\n\n      // Create the edge domain name mapping for the API\n      const apiMapping = new apigwy.ApiMapping(this, 'mapping', {\n        api: this._httpApi,\n        domainName: dnAppsEdge,\n        stage,\n      });\n      // 2022-01-16 - CDK is still generating CloudFormation with no dependency\n      // between the R53 RecordSet and the Mapping\n      apiMapping.node.addDependency(dnAppsEdge);\n    }\n\n    if (domainNameOrigin !== undefined && certOrigin !== undefined) {\n      this._dnAppsOrigin = new apigwy.DomainName(this, 'origin-dn', {\n        domainName: domainNameOrigin,\n        certificate: certOrigin,\n      });\n      if (removalPolicy !== undefined) {\n        this._dnAppsOrigin.applyRemovalPolicy(removalPolicy);\n      }\n    }\n\n    // Enable access logs on API Gateway\n    const apiAccessLogs = new logs.LogGroup(this, 'logs', {\n      logGroupName: apigatewayName\n        ? `/aws/apigwy/${apigatewayName}`\n        : `/aws/apigwy/${this.httpApi.httpApiName}`,\n      retention: logs.RetentionDays.TWO_WEEKS,\n    });\n    if (removalPolicy !== undefined) {\n      apiAccessLogs.applyRemovalPolicy(removalPolicy);\n    }\n    const cfnStage = stage.node.defaultChild as apigwycfn.CfnStage;\n    cfnStage.accessLogSettings = {\n      destinationArn: apiAccessLogs.logGroupArn,\n      format: JSON.stringify({\n        requestId: '$context.requestId',\n        userAgent: '$context.identity.userAgent',\n        sourceIp: '$context.identity.sourceIp',\n        requestTime: '$context.requestTime',\n        requestTimeEpoch: '$context.requestTimeEpoch',\n        httpMethod: '$context.httpMethod',\n        path: '$context.path',\n        status: '$context.status',\n        protocol: '$context.protocol',\n        responseLength: '$context.responseLength',\n        domainName: '$context.domainName',\n        authorizerError: '$context.authorizer.error',\n      }),\n    };\n\n    // Create a logging role\n    // Tips: https://github.com/aws/aws-cdk/issues/11100\n    const apiGwyLogRole = new iam.Role(this, 'logs-role', {\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'service-role/AmazonAPIGatewayPushToCloudWatchLogs',\n        ),\n      ],\n      assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com'),\n    });\n    apiAccessLogs.grantWrite(apiGwyLogRole);\n\n    //\n    // Let API Gateway accept requests using domainNameOrigin\n    // That is the origin URI that CloudFront uses for this gateway.\n    // The gateway will refuse the traffic if it doesn't have the\n    // domain name registered.\n    //\n    if (this._dnAppsOrigin !== undefined) {\n      const mappingAppsApis = new apigwy.ApiMapping(this, 'api-map-origin', {\n        api: this._httpApi,\n        domainName: this._dnAppsOrigin,\n        stage,\n      });\n      // 2022-01-16 - CDK is still generating CloudFormation with no dependency\n      // between the R53 RecordSet and the Mapping\n      mappingAppsApis.node.addDependency(this._dnAppsOrigin);\n      if (removalPolicy !== undefined) {\n        mappingAppsApis.applyRemovalPolicy(removalPolicy);\n      }\n    }\n\n    //\n    // Create the origin name for API Gateway\n    //\n    if (r53Zone !== undefined && this._dnAppsOrigin) {\n      const rrAppsOrigin = new r53.ARecord(this, 'origin-arecord', {\n        zone: r53Zone,\n        recordName: domainNameOrigin,\n        target: r53.RecordTarget.fromAlias(\n          new r53targets.ApiGatewayv2DomainProperties(\n            this._dnAppsOrigin.regionalDomainName,\n            this._dnAppsOrigin.regionalHostedZoneId,\n          ),\n        ),\n      });\n      if (removalPolicy !== undefined) {\n        rrAppsOrigin.applyRemovalPolicy(removalPolicy);\n      }\n    }\n  }\n}\n"]}