aws-cdk-constructs 2.28.0__tar.gz → 2.30.0__tar.gz

{aws_cdk_constructs-2.28.0 → aws_cdk_constructs-2.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws_cdk_constructs
-Version: 2.28.0
+Version: 2.30.0
 Summary: AWS CDK constructs
 Home-page: https://bitbucket.org/cioapps/aws-cdk-constructs
 Author: author

{aws_cdk_constructs-2.28.0 → aws_cdk_constructs-2.30.0}/aws_cdk_constructs/__init__.py

@@ -14,4 +14,4 @@ from .load_balancer import Alb, Nlb
 from .security_group import SecurityGroup
 from .windows_server import WindowsServer
 
-__version__ = '2.28.0'
+__version__ = '2.30.0'

{aws_cdk_constructs-2.28.0 → aws_cdk_constructs-2.30.0}/aws_cdk_constructs/api/api.py

@@ -74,6 +74,7 @@ class Api(Construct):
         quota: Union[_apigateway.QuotaSettings, None] = None,
         throttle: Union[_apigateway.ThrottleSettings, None] = None,
         stage_options: Union[_apigateway.StageOptions, None] = None,
+        domain_name_options: Union[_apigateway.DomainNameOptions, None] = None,
         **kwargs,
     ) -> None:
         super().__init__(scope, id, **kwargs)
@@ -100,6 +101,7 @@ class Api(Construct):
             api_definition=_apigateway.ApiDefinition.from_asset(
                 api_definition_path
             ),
+            domain_name=domain_name_options if domain_name_options else None,
             deploy_options=(
                 stage_options
                 if stage_options

aws_cdk_constructs-2.30.0/aws_cdk_constructs/bucket/auth_flow.py

@@ -0,0 +1,137 @@
+import builtins
+from os import path
+import os
+import typing
+import aws_cdk
+import constructs
+from aws_cdk_constructs.bucket.edge_role import EdgeRole
+from aws_cdk_constructs.bucket.edge_function import EdgeFunction
+from aws_cdk_constructs.bucket.configuration import EdgeLambdaConfiguration
+
+from aws_cdk_constructs.bucket.log_level import LogLevel
+
+from aws_cdk import aws_lambda, aws_cloudfront
+
+dirname = os.path.dirname(__file__)
+
+
+class RedirectPaths(typing.TypedDict):
+    sign_in: str
+    auth_refresh: str
+    sign_out: str
+
+
+class AuthFlow(constructs.Construct):
+    def __init__(
+        self,
+        scope: constructs.Construct,
+        id: builtins.str,
+        *,
+        app_name: str,
+        cognito_auth_domain: builtins.str,
+        cookie_settings: typing.Mapping[builtins.str, builtins.str],
+        log_level: LogLevel,
+        nonce_signing_secret: builtins.str,
+        oauth_scopes: typing.Sequence[aws_cdk.aws_cognito.OAuthScope],
+        redirect_paths: RedirectPaths,
+        user_pool: aws_cdk.aws_cognito.IUserPool,
+        user_pool_client: aws_cdk.aws_cognito.IUserPoolClient,
+        client_secret: typing.Optional[builtins.str] = None,
+    ) -> None:
+        """
+        :param scope: -
+        :param id: -
+        :param cognito_auth_domain: -
+        :param cookie_settings: -
+        :param log_level: -
+        :param nonce_signing_secret: -
+        :param oauth_scopes: -
+        :param redirect_paths: -
+        :param user_pool: -
+        :param user_pool_client: -
+        :param client_secret: -
+        """
+        super().__init__(scope, id)
+
+        self.edge_role = EdgeRole(self, 'EdgeRole', app_name=app_name)
+
+        self.configuration = EdgeLambdaConfiguration(
+            **{
+                'logLevel': log_level.value,
+                'redirectPathSignIn': redirect_paths.get('sign_in'),
+                'redirectPathAuthRefresh': redirect_paths.get('auth_refresh'),
+                'redirectPathSignOut': redirect_paths.get('sign_out'),
+                'userPoolId': user_pool.user_pool_id,
+                'clientId': user_pool_client.user_pool_client_id,
+                'oauthScopes': list(
+                    map(lambda scope: scope.scope_name, oauth_scopes)
+                ),
+                'cognitoAuthDomain': cognito_auth_domain,
+                'cookieSettings': cookie_settings,
+                'nonceSigningSecret': nonce_signing_secret,
+                'clientSecret': client_secret,
+            }
+        )
+
+        self.check_auth = EdgeFunction(
+            self,
+            'CheckAuth',
+            name='check-auth',
+            code=aws_lambda.Code.from_asset(
+                path=os.path.join(dirname, '../../lambda/check-auth/')
+            ),
+            edge_role=self.edge_role,
+            configuration=self.configuration,
+            event_type=aws_cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
+        )
+
+        self.parse_auth = EdgeFunction(
+            self,
+            'ParseAuth',
+            name='parse-auth',
+            code=aws_lambda.Code.from_asset(
+                path=os.path.join(dirname, '../../lambda/parse-auth/')
+            ),
+            edge_role=self.edge_role,
+            configuration=self.configuration,
+            event_type=aws_cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
+        )
+
+        self.refresh_auth = EdgeFunction(
+            self,
+            'RefreshAuth',
+            name='refresh-auth',
+            code=aws_lambda.Code.from_asset(
+                path=os.path.join(dirname, '../../lambda/refresh-auth/')
+            ),
+            edge_role=self.edge_role,
+            configuration=self.configuration,
+            event_type=aws_cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
+        )
+
+        self.sign_out = EdgeFunction(
+            self,
+            'SignOut',
+            name='sign-out',
+            code=aws_lambda.Code.from_asset(
+                path=os.path.join(dirname, '../../lambda/sign-out/')
+            ),
+            edge_role=self.edge_role,
+            configuration=self.configuration,
+            event_type=aws_cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
+        )
+
+    def add_edge_function(
+        self, name, path, event_type: aws_cloudfront.LambdaEdgeEventType
+    ):
+        return EdgeFunction(
+            self,
+            name,
+            name=name,
+            code=aws_lambda.Code.from_asset(
+                path=os.path.join(dirname, f'../../lambda/{path}')
+            ),
+            edge_role=self.edge_role,
+            configuration=self.configuration,
+            event_type=event_type,
+        )

aws_cdk_constructs-2.30.0/aws_cdk_constructs/bucket/base_edge_constructs.py

@@ -0,0 +1,63 @@
+import builtins
+import aws_cdk
+import constructs
+
+
+class BaseEdgeConstruct(constructs.Construct):
+    def __init__(self, scope: constructs.Construct, id: builtins.str) -> None:
+        """
+        :param scope: -
+        :param id: -
+        """
+
+        super().__init__(scope, id)
+
+        self._stack = aws_cdk.Stack.of(self)
+
+        self._edge_stack = (
+            self.get_or_create_cross_region_support_stack()
+            if self.stack.region != 'us-east-1'
+            else self.stack
+        )
+
+    @property
+    def stack(self):
+        return self._stack
+
+    @property
+    def edge_stack(self):
+        return self._edge_stack
+
+    def get_or_create_cross_region_support_stack(self) -> aws_cdk.Stack:
+
+        stack = self.stack.nested_stack_parent or self.stack
+        account = stack.account
+        stack_name = stack.stack_name
+        stack_id = 'lambda-cloudfront-support-stack'
+        app = self.require_app()
+
+        support_stack: aws_cdk.Stack = app.node.try_find_child(stack_id)
+
+        if support_stack is None:
+            support_stack = aws_cdk.Stack(
+                app,
+                stack_id,
+                stack_name=f'{stack_name}-support-lambda-cloudfront',
+                env={'account': account, 'region': 'us-east-1'},
+            )
+
+        # the stack containing the edge lambdas must be deployed before
+        self.stack.add_dependency(support_stack)
+
+        return support_stack
+
+    def require_app(self) -> aws_cdk.App:
+
+        app = self.node.root
+
+        if app is None or aws_cdk.App.is_app(app) is False:
+            raise Exception(
+                'Stacks which uses edge constructs must be part of a CDK app'
+            )
+
+        return app