@pwrdrvr/microapps-cdk 0.3.2 → 0.3.4-rc1

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)
 
@@ -530,18 +531,10 @@ CloudFront Distribution to add the Behaviors (Routes) to.
 
 ---
 
-##### `apigwyEdgeFunctions`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.apigwyEdgeFunctions"></a>
-
-- *Type:* [`aws-cdk-lib.aws_cloudfront.EdgeLambda`](#aws-cdk-lib.aws_cloudfront.EdgeLambda)[]
-
-Edge lambdas to associate with the API Gateway routes.
-
----
-
 ##### `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.
 
@@ -555,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.
 
@@ -566,6 +559,14 @@ even if they have a period in the path.
 
 ---
 
+##### `edgeLambdas`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.edgeLambdas"></a>
+
+- *Type:* [`aws-cdk-lib.aws_cloudfront.EdgeLambda`](#aws-cdk-lib.aws_cloudfront.EdgeLambda)[]
+
+Edge lambdas to associate with the API Gateway routes.
+
+---
+
 ##### `rootPathPrefix`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.AddRoutesOptions.rootPathPrefix"></a>
 
 - *Type:* `string`
@@ -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.
 
@@ -860,14 +853,35 @@ API Gateway custom origin domain name.
 
 ---
 
-##### `edgeToOriginLambdas`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.edgeToOriginLambdas"></a>
+##### `edgeLambdas`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsCFProps.edgeLambdas"></a>
 
 - *Type:* [`aws-cdk-lib.aws_cloudfront.EdgeLambda`](#aws-cdk-lib.aws_cloudfront.EdgeLambda)[]
+- *Default:* no edge to API Gateway origin functions added
 
 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)
@@ -982,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`
@@ -1079,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`
@@ -1093,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`
@@ -1111,12 +1157,32 @@ Optional custom domain name for the API Gateway HTTPv2 API.
 
 ---
 
+##### `edgeLambdas`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsProps.edgeLambdas"></a>
+
+- *Type:* [`aws-cdk-lib.aws_cloudfront.EdgeLambda`](#aws-cdk-lib.aws_cloudfront.EdgeLambda)[]
+
+Additional edge lambda functions.
+
+---
+
 ##### `originRegion`<sup>Optional</sup> <a name="@pwrdrvr/microapps-cdk.MicroAppsProps.originRegion"></a>
 
 - *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).
 
 ---
 
@@ -1328,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)
@@ -1383,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`
@@ -1409,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)
@@ -1573,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)
@@ -1605,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/README.md

@@ -6,6 +6,8 @@ The MicroApps project enables rapidly deploying many web apps to AWS on a single
 
 MicroApps allows many versions of an application to be deployed either as ephemeral deploys (e.g. for pull request builds) or as semi-permanent deploys. The `microapps-router` Lambda function handled routing requests to apps to the current version targeted for a particular application start request using rules as complex as one is interested in implementing (e.g. A/B testing integration, canary releases, per-user rules for logged in users, per-group, per-deparment, and default rules).
 
+2023-01-01 NOTE: The next paragraph is dated as the `iframe` is no longer required for frameworks that write absolute URLs for their static resources and API requests.
+
 Users start applications via a URL such as `[/{prefix}]/{appname}/`, which hits the `microapps-router` that looks up the version of the application to be run, then renders a transparent `iframe` with a link to that version. The URL seen by the user in the browser (and available for bookmarking) has no version in it, so subsequent launches (e.g. the next day or just in another tab) will lookup the version again. All relative URL API requests (e.g. `some/api/path`) will go to the corresponding API version that matches the version of the loaded static files, eliminating issues of incompatibility between static files and API deployments.
 
 For development / testing purposes only, each version of an applicaton can be accessed directly via a URL of the pattern `[/{prefix}]/{appname}/{semver}/`. These "versioned" URLs are not intended to be advertised to end users as they would cause a user to be stuck on a particular version of the app if the URL was bookmarked. Note that the system does not limit access to particular versions of an application, as of 2022-01-26, but that can be added as a feature.

package/changelog.md

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

package/lib/MicroApps.d.ts

@@ -1,5 +1,6 @@
 import { RemovalPolicy } from 'aws-cdk-lib';
 import * as acm from 'aws-cdk-lib/aws-certificatemanager';
+import * as cf from 'aws-cdk-lib/aws-cloudfront';
 import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
 import * as r53 from 'aws-cdk-lib/aws-route53';
 import { Construct } from 'constructs';
@@ -161,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.
@@ -173,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
      *
@@ -207,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
      *
@@ -235,6 +265,10 @@ export interface MicroAppsProps {
      * This is required when using v2 routing
      */
     readonly tableNameForEdgeToOrigin?: string;
+    /**
+     * Additional edge lambda functions
+     */
+    readonly edgeLambdas?: cf.EdgeLambda[];
 }
 /**
  * Represents a MicroApps
@@ -249,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
@@ -278,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

@@ -32,11 +32,12 @@ const ReverseDomain_1 = require("./utils/ReverseDomain");
  */
 class MicroApps extends constructs_1.Construct {
     constructor(scope, id, props) {
+        var _b;
         super(scope, id);
         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,
@@ -46,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,
@@ -74,18 +78,25 @@ class MicroApps extends constructs_1.Construct {
             requireIAMAuthorization: signingMode !== 'none',
             table,
         });
+        const edgeLambdas = [];
         if (signingMode !== 'none' || replaceHostHeader || addXForwardedHostHeader) {
             this._edgeToOrigin = new MicroAppsEdgeToOrigin_1.MicroAppsEdgeToOrigin(this, 'edgeToOrigin', {
                 assetNameRoot,
                 assetNameSuffix,
                 removalPolicy,
                 addXForwardedHostHeader,
+                setupApiGatewayPermissions: createAPIGateway,
                 replaceHostHeader,
                 originRegion,
                 signingMode,
                 rootPathPrefix,
                 tableRulesArn: tableNameForEdgeToOrigin || this._svcs.table.tableName,
             });
+            edgeLambdas.push(...this._edgeToOrigin.edgeToOriginLambdas);
+        }
+        // Add any extra lambdas
+        if ((_b = props.edgeLambdas) === null || _b === void 0 ? void 0 : _b.length) {
+            edgeLambdas.push(...props.edgeLambdas);
         }
         this._cf = new MicroAppsCF_1.MicroAppsCF(this, 'cft', {
             removalPolicy,
@@ -93,14 +104,16 @@ 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,
-            edgeToOriginLambdas: this._edgeToOrigin ? this._edgeToOrigin.edgeToOriginLambdas : undefined,
+            createNextDataPathRoute,
+            originShieldRegion,
+            ...(edgeLambdas.length ? { edgeLambdas } : {}),
         });
     }
     get cf() {
@@ -121,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.2" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MicroApps.js","sourceRoot":"","sources":["../src/MicroApps.ts"],"names":[],"mappings":";;;;;AAIA,2CAAuC;AACvC,uDAAsE;AACtE,+CAA0D;AAC1D,mEAAwF;AACxF,+CAA0D;AAC1D,mDAAgE;AAChE,yDAAsD;AA+QtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,SAAU,SAAQ,sBAAS;IA0BtC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAsB;QAC9D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,KAAK,KAAK,SAAS,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;SACtC;QAED,MAAM,EACJ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,OAAO,EACP,QAAQ,EACR,MAAM,GAAG,KAAK,EACd,UAAU,EACV,aAAa,EACb,mBAAmB,EACnB,2BAA2B,EAC3B,oBAAoB,EACpB,cAAc,EACd,kBAAkB,GAAG,IAAI,EACzB,uBAAuB,GAAG,IAAI,EAC9B,iBAAiB,GAAG,IAAI,EACxB,WAAW,GAAG,MAAM,EACpB,YAAY,EACZ,KAAK,EACL,wBAAwB,GACzB,GAAG,KAAK,CAAC;QAEV,IAAI,CAAC,GAAG,GAAG,IAAI,yBAAW,CAAC,IAAI,EAAE,IAAI,EAAE;YACrC,aAAa;YACb,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,6BAAa,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;YACpF,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,6BAAa,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;YAC/E,qBAAqB,EAAE,cAAc;gBACnC,CAAC,CAAC,GAAG,6BAAa,CAAC,cAAc,CAAC,UAAU;gBAC5C,CAAC,CAAC,SAAS;YACb,aAAa;YACb,eAAe;SAChB,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,GAAG,IAAI,iCAAe,CAAC,IAAI,EAAE,KAAK,EAAE;YAC9C,aAAa;YACb,aAAa;YACb,eAAe;YACf,cAAc;YACd,gBAAgB;YAChB,OAAO;YACP,UAAU;YACV,cAAc;YACd,uBAAuB,EAAE,WAAW,KAAK,MAAM;SAChD,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,IAAI,6BAAa,CAAC,IAAI,EAAE,MAAM,EAAE;YAC3C,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO;YAC5B,aAAa;YACb,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU;YAC/B,aAAa,EAAE,IAAI,CAAC,GAAG,CAAC,aAAa;YACrC,iBAAiB,EAAE,IAAI,CAAC,GAAG,CAAC,iBAAiB;YAC7C,aAAa;YACb,eAAe;YACf,MAAM;YACN,mBAAmB;YACnB,2BAA2B;YAC3B,oBAAoB;YACpB,cAAc;YACd,uBAAuB,EAAE,WAAW,KAAK,MAAM;YAC/C,KAAK;SACN,CAAC,CAAC;QACH,IAAI,WAAW,KAAK,MAAM,IAAI,iBAAiB,IAAI,uBAAuB,EAAE;YAC1E,IAAI,CAAC,aAAa,GAAG,IAAI,6CAAqB,CAAC,IAAI,EAAE,cAAc,EAAE;gBACnE,aAAa;gBACb,eAAe;gBACf,aAAa;gBACb,uBAAuB;gBACvB,iBAAiB;gBACjB,YAAY;gBACZ,WAAW;gBACX,cAAc;gBACd,aAAa,EAAE,wBAAwB,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS;aACtE,CAAC,CAAC;SACJ;QACD,IAAI,CAAC,GAAG,GAAG,IAAI,yBAAW,CAAC,IAAI,EAAE,KAAK,EAAE;YACtC,aAAa;YACb,aAAa;YACb,eAAe;YACf,cAAc;YACd,gBAAgB;YAChB,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO;YAC7B,OAAO;YACP,QAAQ;YACR,gBAAgB,EAAE,IAAI,CAAC,GAAG,CAAC,gBAAgB;YAC3C,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU;YAC/B,cAAc;YACd,kBAAkB;YAClB,mBAAmB,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC,CAAC,SAAS;SAC7F,CAAC,CAAC;IACL,CAAC;IAvHD,IAAW,EAAE;QACX,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAGD,IAAW,YAAY;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAGD,IAAW,EAAE;QACX,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAGD,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAGD,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;;AAxBH,8BA0HC","sourcesContent":["import { RemovalPolicy } from 'aws-cdk-lib';\nimport * as acm from 'aws-cdk-lib/aws-certificatemanager';\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/**\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    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    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      edgeToOriginLambdas: this._edgeToOrigin ? this._edgeToOrigin.edgeToOriginLambdas : undefined,\n    });\n  }\n}\n"]}
+MicroApps[_a] = { fqn: "@pwrdrvr/microapps-cdk.MicroApps", version: "0.3.4-rc1" };
+//# 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"]}