lambda-api-decorators-cdk 0.2.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

lambda_api_decorators_cdk/ast_helper.py

@@ -256,6 +256,8 @@ def _validate_permission(invocation):
 
 
 def _parse_invocation(decorator):
+    if isinstance(decorator, ast.Name) and decorator.id == "public":
+        return DecoratorInvocation(name="public", args=(), kwargs=())
     if not isinstance(decorator, ast.Call) or not isinstance(decorator.func, ast.Name):
         return None
     name = decorator.func.id
@@ -275,6 +277,12 @@ def _parse_invocation(decorator):
         _validate_grant(invocation, "bucket_name")
     elif name == "permission":
         invocation = _validate_permission(invocation)
+    elif name == "authorizer":
+        if len(invocation.args) != 1 or invocation.kwargs:
+            raise ValueError("authorizer requires exactly one positional key")
+        _require_non_empty_string(invocation.args[0], name, "key")
+    elif name == "public":
+        raise ValueError("public must be used as a bare decorator")
     return invocation
 
 
@@ -301,6 +309,19 @@ def get_file_nodes(parsed_tree, id, directory):
                     is_lambda_http = True
                     paths.append((path, invocation.name))
 
+            auth_invocations = [
+                invocation for invocation in decorator_invocations
+                if invocation.name in ("authorizer", "public")
+            ]
+            if len(auth_invocations) > 1:
+                raise ValueError(
+                    "Conflicting or repeated authentication decorators are not allowed"
+                )
+            if len(paths) > 1 and auth_invocations:
+                raise ValueError(
+                    "Authentication on a handler with multiple routes is ambiguous"
+                )
+
             #ast.FunctionDef ends. If the Function had an HTTP Decorator it means it's a lambda function
             if is_lambda_http: 
                 for key,value in paths:

lambda_api_decorators_cdk/lambda_api_config.py

@@ -27,6 +27,8 @@ class LambdaApiConfig:
         environment: Optional[Mapping[str, str]] = None,
         dynamodb_tables: Optional[Mapping[str, dynamodb.ITable]] = None,
         s3_buckets: Optional[Mapping[str, s3.IBucket]] = None,
+        authorizers: Optional[Mapping[str, object]] = None,
+        default_authorizer: Optional[str] = None,
     ) -> None:
         self._default_runtime = runtime
         self._default_timeout = timeout
@@ -49,10 +51,15 @@ class LambdaApiConfig:
 
         self._dynamodb_tables = {}
         self._s3_buckets = {}
+        self._authorizers = {}
         for key, table in (dynamodb_tables or {}).items():
             self.add_dynamodb_table(key, table)
         for key, bucket in (s3_buckets or {}).items():
             self.add_s3_bucket(key, bucket)
+        for key, authorizer in (authorizers or {}).items():
+            self.add_authorizer(key, authorizer)
+        self._default_authorizer = None
+        self.set_default_authorizer(default_authorizer)
 
     def set_default_runtime(self, runtime: Optional[lambda_.Runtime]) -> None:
         self._default_runtime = runtime
@@ -117,6 +124,35 @@ class LambdaApiConfig:
     def add_s3_bucket(self, key: str, bucket: s3.IBucket) -> None:
         self._add_resource(key, bucket, self._s3_buckets, "S3 bucket")
 
+    def add_authorizer(self, key: str, authorizer: object) -> None:
+        if not isinstance(key, str):
+            raise TypeError("Authorizer registry keys must be strings")
+        if not key.strip():
+            raise ValueError("Authorizer registry keys must not be empty or whitespace")
+        interfaces = getattr(authorizer, "__jsii_ifaces__", ()) if authorizer is not None else ()
+        supported = {
+            "aws_cdk.aws_apigateway.IAuthorizer",
+            "aws_cdk.aws_apigatewayv2.IHttpRouteAuthorizer",
+        }
+        if not any(f"{interface.__module__}.{interface.__name__}" in supported
+                   for interface in interfaces):
+            raise TypeError("Authorizer must be a CDK authorizer object")
+        if key in self._authorizers:
+            raise ValueError(f"Authorizer key {key!r} is already registered")
+        self._authorizers[key] = authorizer
+
+    def set_default_authorizer(self, key: Optional[str]) -> None:
+        if key is None:
+            self._default_authorizer = None
+            return
+        if not isinstance(key, str):
+            raise TypeError("Default authorizer key must be a string or None")
+        if not key.strip():
+            raise ValueError("Default authorizer key must not be empty or whitespace")
+        if key not in self._authorizers:
+            raise KeyError(f"Authorizer key {key!r} is not registered")
+        self._default_authorizer = key
+
     @staticmethod
     def _add_resource(key: str, resource, registry: dict, resource_type: str) -> None:
         if not isinstance(key, str):
@@ -148,4 +184,6 @@ class LambdaApiConfig:
             custom_vpcs=dict(self._custom_vpcs),
             dynamodb_tables=dict(self._dynamodb_tables),
             s3_buckets=dict(self._s3_buckets),
+            authorizers=dict(self._authorizers),
+            default_authorizer=self._default_authorizer,
         )

lambda_api_decorators_cdk/resource_builder.py

@@ -8,13 +8,16 @@ from aws_cdk import (
     aws_apigatewayv2_integrations as integrations,
     aws_lambda as lambda_,
     aws_s3 as s3,
-    aws_lambda_python_alpha as _lambda_python)
+    aws_lambda_python_alpha as _lambda_python,
+    Annotations)
 import hashlib
+import inspect
 import os
 from pathlib import Path
 from lambda_api_decorators_cdk import ast_helper
 from lambda_api_decorators_cdk.source_layout import SourceLayout
 from typing import Optional, List, Dict
+from constructs import Construct
 
 class ResourceBuilder():
     '''
@@ -42,10 +45,12 @@ class ResourceBuilder():
                 custom_vpcs = None, ####TODO
                 dynamodb_tables: Optional[Dict[str, dynamodb.ITable]] = None,
                 s3_buckets: Optional[Dict[str, s3.IBucket]] = None,
+                authorizers: Optional[Dict[str, object]] = None,
+                default_authorizer: Optional[str] = None,
                 ) -> 'ResourceBuilder':
     
         '''
-        Creates base instance of a Resource Builder. By default, there are no predetermined custom, common nor default settings with the exception of the following custom runtimes: python3.8, python3.9, python.10, python.11, python.12.
+        Creates base instance of a Resource Builder. By default, there are no predetermined custom, common nor default settings with the exception of the following custom runtimes: python3.8, python3.9, python3.10, python3.11, python3.12, python3.13, python3.14.
         You can optionally specify arguments (Keep in mind some of them are constructs of the aws_cdk toolkit) such as:
         @param default_runtime
         @param default_timeout
@@ -83,6 +88,8 @@ class ResourceBuilder():
         self.custom_vpcs = custom_vpcs if custom_vpcs is not None else {}
         self.dynamodb_tables = dynamodb_tables if dynamodb_tables is not None else {}
         self.s3_buckets = s3_buckets if s3_buckets is not None else {}
+        self.authorizers = authorizers if authorizers is not None else {}
+        self.default_authorizer = default_authorizer
         self._physical_dynamodb_tables = {}
         self._physical_s3_buckets = {}
 
@@ -91,6 +98,8 @@ class ResourceBuilder():
         self.custom_runtimes.update({'python3.10':lambda_.Runtime.PYTHON_3_10})
         self.custom_runtimes.update({'python3.11':lambda_.Runtime.PYTHON_3_11})
         self.custom_runtimes.update({'python3.12':lambda_.Runtime.PYTHON_3_12})
+        self.custom_runtimes.update({'python3.13':lambda_.Runtime.PYTHON_3_13})
+        self.custom_runtimes.update({'python3.14':lambda_.Runtime.PYTHON_3_14})
 
 
     #Setters
@@ -236,6 +245,7 @@ class ResourceBuilder():
         if print_tree:
             ast_helper.dump_tree(graph)
         self._prepare_layers(construct, graph, layer_sources)
+        self._emit_authorization_diagnostics(construct, graph)
         self.build_from_graph(
             construct, graph, api_resource, lambda_root, source_layout)
 
@@ -257,6 +267,7 @@ class ResourceBuilder():
         if print_tree:
             ast_helper.dump_tree(graph)
         self._prepare_layers(construct, graph, layer_sources)
+        self._emit_authorization_diagnostics(construct, graph)
         self.build_http_from_graph(
             construct, graph, http_api, lambda_root, source_layout)
 
@@ -493,6 +504,114 @@ class ResourceBuilder():
                 decorators[invocation.name] = value
         return decorators
 
+    @staticmethod
+    def _auth_override(method: ast_helper.Method):
+        """Return inherit, public, or an explicit logical authorizer key."""
+        for invocation in method.get_decorator_invocations():
+            if invocation.name == "public":
+                return ("public", None)
+            if invocation.name == "authorizer":
+                return ("authorizer", invocation.args[0])
+        return ("inherit", None)
+
+    def _effective_authorizer_key(self, method: ast_helper.Method):
+        state, key = self._auth_override(method)
+        if state == "public":
+            return None
+        return key if state == "authorizer" else self.default_authorizer
+
+    @staticmethod
+    def _implements_interface(authorizer, interface) -> bool:
+        return interface in getattr(authorizer, "__jsii_ifaces__", ())
+
+    def _resolve_authorizer(self, method: ast_helper.Method, family: str):
+        key = self._effective_authorizer_key(method)
+        if key is None:
+            return None
+        try:
+            authorizer = self.authorizers[key]
+        except KeyError:
+            raise KeyError(f"Authorizer key {key!r} is not registered") from None
+        interface = (
+            apigateway.IAuthorizer
+            if family == "REST"
+            else apigateway2.IHttpRouteAuthorizer
+        )
+        if not self._implements_interface(authorizer, interface):
+            raise TypeError(
+                f"Authorizer key {key!r} is not compatible with {family} APIs"
+            )
+        return authorizer
+
+    def _rest_method_options(self, method: ast_helper.Method):
+        authorizer = self._resolve_authorizer(method, "REST")
+        if authorizer is None:
+            return {
+                "authorizer": None,
+                "authorization_type": apigateway.AuthorizationType.NONE,
+            }
+        return {
+            "authorizer": authorizer,
+            "authorization_type": authorizer.authorization_type,
+        }
+
+    def _add_rest_method(self, resource, method, integration):
+        options = self._rest_method_options(method)
+        parameters = inspect.signature(resource.add_method).parameters.values()
+        accepts_options = any(
+            parameter.kind is inspect.Parameter.VAR_KEYWORD
+            or parameter.name == "authorization_type"
+            for parameter in parameters
+        )
+        if accepts_options:
+            return resource.add_method(method.get_method(), integration, **options)
+        # Preserve compatibility with narrow direct-builder test doubles and
+        # existing callers that expose only the historical two-argument shape.
+        return resource.add_method(method.get_method(), integration)
+
+    def _http_route_authorizer(self, method: ast_helper.Method):
+        authorizer = self._resolve_authorizer(method, "HTTP")
+        return authorizer if authorizer is not None else apigateway2.HttpNoneAuthorizer()
+
+    def _emit_authorization_diagnostics(self, construct, graph):
+        if not isinstance(construct, Construct):
+            return
+        if self.default_authorizer is None:
+            Annotations.of(construct).add_warning_v2(
+                "LAD_AUTH_PUBLIC_DEFAULT",
+                "LAD_AUTH_PUBLIC_DEFAULT: Routes without explicit authorization are public because no "
+                "default authorizer is configured.",
+            )
+
+        deviations = []
+
+        def visit(resource):
+            for method in resource.get_methods():
+                state, key = self._auth_override(method)
+                if self.default_authorizer is None:
+                    if state == "authorizer":
+                        deviations.append((resource.get_path(), method.get_method(), key))
+                elif state == "public":
+                    deviations.append((resource.get_path(), method.get_method(), "PUBLIC"))
+                elif state == "authorizer" and key != self.default_authorizer:
+                    deviations.append((resource.get_path(), method.get_method(), key))
+            for child in resource.get_connections():
+                visit(child)
+
+        visit(graph)
+        if not deviations:
+            return
+        deviations.sort(key=lambda item: (item[0], item[1]))
+        if self.default_authorizer is None:
+            heading = "Default authorizer: PUBLIC\n\nProtected routes:"
+        else:
+            heading = f"Default authorizer: {self.default_authorizer}\n\nOverrides:"
+        details = "\n".join(
+            f"    {method} {path}    {value}"
+            for path, method, value in deviations
+        )
+        Annotations.of(construct).add_info(f"{heading}\n{details}")
+
     @staticmethod
     def _physical_resource_id(resource_type: str, physical_name: str) -> str:
         """Create a stable, collision-safe construct ID for an imported resource."""
@@ -734,7 +853,8 @@ class ResourceBuilder():
             for method in graph.get_methods():
                 lbda = self._build_discovered_lambda(
                     construct, method, lambda_root, source_layout)
-                new_resource.add_method(method.get_method(), apigateway.LambdaIntegration(lbda))
+                self._add_rest_method(
+                    new_resource, method, apigateway.LambdaIntegration(lbda))
         else:
             #We can get a skip from /something to /something/one/two/method, so resources with no methods "one" and "two" should be created
             new_api_resources = path[len(api_resource.path):].lstrip('/').split('/')
@@ -746,7 +866,8 @@ class ResourceBuilder():
             for method in graph.get_methods():
                 lbda = self._build_discovered_lambda(
                     construct, method, lambda_root, source_layout)
-                new_resource.add_method(method.get_method(), apigateway.LambdaIntegration(lbda))
+                self._add_rest_method(
+                    new_resource, method, apigateway.LambdaIntegration(lbda))
 
         for node in graph.get_connections():
             self.build_from_graph(
@@ -776,7 +897,8 @@ class ResourceBuilder():
                 http_api.add_routes(
                     path='/',
                     methods=[method_mapping[method.get_method()]],
-                    integration= api_lbda_integration
+                    integration=api_lbda_integration,
+                    authorizer=self._http_route_authorizer(method),
                 )
         else:
             for method in graph.get_methods():
@@ -786,7 +908,8 @@ class ResourceBuilder():
                 http_api.add_routes(
                     path=path,
                     methods=[method_mapping[method.get_method()]],
-                    integration= api_lbda_integration
+                    integration=api_lbda_integration,
+                    authorizer=self._http_route_authorizer(method),
                 )
 
         for node in graph.get_connections():

lambda_api_decorators_cdk-0.4.1.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: lambda-api-decorators-cdk
+Version: 0.4.1
+Summary: AWS CDK integration for Lambda API Decorators. Generate AWS Lambda and API Gateway infrastructure from decorated Python handlers.
+Author: Mateo Marcos, Emanuel Arguinarena, Lucas Picchi
+License: MIT License
+        
+        Copyright (c) 2024 Lambda API Decorators CDK
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/lambda-api-decorators/lambda-api-decorators-cdk
+Project-URL: Repository, https://github.com/lambda-api-decorators/lambda-api-decorators-cdk
+Project-URL: Bug Reports, https://github.com/lambda-api-decorators/lambda-api-decorators-cdk
+Keywords: cdk,lambda,aws,api gateway,ast
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: AWS CDK :: 2
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aws-cdk.aws-lambda-python-alpha
+Dynamic: license-file
+
+# Lambda API Decorators CDK
+
+AWS CDK integration for [Lambda API Decorators](https://github.com/infrastructure-as-decorator/lambda-api-decorators). Define API routes with Python decorators and let CDK create the Lambda functions, integrations, routes, and related configuration.
+
+The complete cross-package guides and architecture documentation are available at [lambda-api-decorators.github.io](https://infrastructure-as-decorator.github.io/).
+
+## Installation
+
+```bash
+pip install lambda-api-decorators-cdk
+```
+
+The package requires Python 3.10 or newer and AWS CDK v2. The `lambda-api-decorators` package provides the decorators used by the Lambda source files.
+
+## Quick start
+
+`LambdaApi` is the recommended high-level construct. It creates a REST API by default and discovers decorated handlers below `lambda_path`.
+
+```python
+from aws_cdk import Stack
+from constructs import Construct
+
+from lambda_api_decorators_cdk import LambdaApi
+
+
+class ExampleStack(Stack):
+    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
+        super().__init__(scope, construct_id, **kwargs)
+
+        LambdaApi(self, "ExampleApi", lambda_path="lambdas")
+```
+
+A handler must include an HTTP method decorator from `lambda-api-decorators`:
+
+```python
+from lambda_api_decorators import GET
+
+
+@GET("/hello")
+def hello(event, context):
+    return {"statusCode": 200, "body": "Hello, world!"}
+```
+
+`lambda_path` is resolved from the directory where CDK is run. Files without a supported route decorator are ignored.
+
+## API types and imported APIs
+
+REST is the default. Select an HTTP API with `ApiType.HTTP`, or provide an existing supported API and let the construct infer its type.
+
+```python
+from aws_cdk import aws_apigateway as apigateway
+from lambda_api_decorators_cdk import ApiType, LambdaApi
+
+
+LambdaApi(self, "HttpApi", lambda_path="lambdas", api_type=ApiType.HTTP)
+
+existing_rest_api = apigateway.RestApi(self, "ExistingRestApi")
+LambdaApi(self, "ExistingApiRoutes", lambda_path="lambdas", api=existing_rest_api)
+```
+
+Created and imported REST APIs are supported. Concrete `aws_apigatewayv2.HttpApi` instances are supported for HTTP APIs.
+
+## Reusable configuration
+
+Use `LambdaApiConfig` for defaults and named resources shared by one or more `LambdaApi` constructs. Configuration must be complete before constructing the API.
+
+```python
+from aws_cdk import Duration, aws_lambda as lambda_
+from lambda_api_decorators_cdk import LambdaApi, LambdaApiConfig
+
+
+config = LambdaApiConfig(
+    runtime=lambda_.Runtime.PYTHON_3_12,
+    timeout=Duration.seconds(30),
+    memory_size=512,
+    environment={"ENVIRONMENT": "production"},
+)
+config.add_custom_environment("PAYMENTS_URL", "https://payments.example.com")
+
+LambdaApi(self, "ConfiguredApi", lambda_path="lambdas", config=config)
+```
+
+`LambdaApiConfig` supports default and custom runtimes, roles, VPCs, subnets, layers, security groups, and environment variables. It also supports registries for DynamoDB tables, S3 buckets, and REST or HTTP authorizers. A reused configuration creates an isolated builder snapshot for each API.
+
+## Source layout and layers
+
+By default, each handler is packaged relative to the source root. For a service-oriented layout, use `SourceLayout.SERVICE`:
+
+```python
+from lambda_api_decorators_cdk import LambdaApi, SourceLayout
+
+
+LambdaApi(
+    self,
+    "ServiceApi",
+    lambda_path="services",
+    source_layout=SourceLayout.SERVICE,
+    layers_path="layers",
+)
+```
+
+When `layers_path` is provided, each visible child directory is treated as a discoverable layer source. Explicit layer configuration remains available through `LambdaApiConfig`.
+
+## Authorization and permissions
+
+Register authorizers with a logical key and select the default authorizer for routes. A handler can override the default with `@authorizer("key")` or make itself public with `@public`.
+
+```python
+from aws_cdk import aws_apigateway as apigateway
+from lambda_api_decorators_cdk import LambdaApiConfig
+
+
+authorizer = apigateway.TokenAuthorizer(self, "UsersAuthorizer", handler=authorizer_fn)
+config = LambdaApiConfig(authorizers={"users": authorizer}, default_authorizer="users")
+```
+
+The resource registries also allow decorated handlers to request least-privilege grants for registered DynamoDB tables and S3 buckets. See the [complete documentation](https://lambda-api-decorators.github.io/) for decorator syntax and supported access levels.
+
+## Low-level builder
+
+`ResourceBuilder` remains a supported lower-level API for callers that need direct control over the API root or build lifecycle:
+
+```python
+from aws_cdk import Duration
+from lambda_api_decorators_cdk import ResourceBuilder
+
+
+builder = ResourceBuilder()
+builder.set_default_timeout(Duration.seconds(30))
+builder.add_common_environment("ENVIRONMENT", "production")
+builder.build(self, rest_api.root, "lambdas")
+```
+
+Prefer `LambdaApi` for new code. It owns API creation or reuse and delegates option resolution to isolated `ResourceBuilder` snapshots.
+
+## Releases
+
+The Git tag is the single source of truth for this package's version. For example, `v0.3.0` produces Python package version `0.3.0`. This repository is versioned independently from `lambda-api-decorators`.
+
+To release from `main`, push a semantic version tag:
+
+```bash
+git checkout main
+git pull
+git tag v0.3.0
+git push origin v0.3.0
+```
+
+Pushing the tag triggers the release workflow, which tests, builds, verifies the version, and publishes to PyPI using trusted publishing. The PyPI project must have a trusted publisher configured for this repository, the `release.yml` workflow, and the `pypi` GitHub environment.

lambda_api_decorators_cdk-0.4.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+lambda_api_decorators_cdk/__init__.py,sha256=LkPu_ySBeRlGKVYbeLV86H78kYFrEQHBuzmskZo3nf8,197
+lambda_api_decorators_cdk/api_type.py,sha256=UjhwP6KBwILl7NpL17e4mL-Bi5JdcfDs3oq2bxoESL0,146
+lambda_api_decorators_cdk/ast_helper.py,sha256=5aXh7dFjTKaBdEfO9Vd9l8HEOnO7WkgnXCQaUA-bmCU,15996
+lambda_api_decorators_cdk/lambda_api.py,sha256=wqiwe10-XOuPG8kxn2YGcpk4IHag1WG6mMHFENLgRhc,3148
+lambda_api_decorators_cdk/lambda_api_config.py,sha256=NWJPjAvFXhxjiFN0wCrWGyT3-UJ_jJJp12KDyQOzya4,7989
+lambda_api_decorators_cdk/resource_builder.py,sha256=z3m_Qzq-c_r69CVWgn1FdLcN_XxOj8q_o3SsTLC_p4Q,41791
+lambda_api_decorators_cdk/source_layout.py,sha256=rvw2D0UTOyhHmiCg_NTuxFf2wvsFCBugnwNKd3NLWLo,167
+lambda_api_decorators_cdk-0.4.1.dist-info/licenses/LICENSE,sha256=kABKIBEzZQqtNkBsAA9tA_Ume6OKdVUnChslMCL2Baw,1081
+lambda_api_decorators_cdk-0.4.1.dist-info/METADATA,sha256=D7jZG1z7ywoK4eAh-QyYCbLpUBOvqXp_Nn_WEZfn_so,8181
+lambda_api_decorators_cdk-0.4.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+lambda_api_decorators_cdk-0.4.1.dist-info/top_level.txt,sha256=1goCGc19BssxULn6ejZNLDYP0sQHEyqCMhivbGjxDCE,26
+lambda_api_decorators_cdk-0.4.1.dist-info/RECORD,,

lambda_api_decorators_cdk-0.2.3.dist-info/METADATA

@@ -1,144 +0,0 @@
-Metadata-Version: 2.4
-Name: lambda-api-decorators-cdk
-Version: 0.2.3
-Summary: AWS CDK integration for Lambda API Decorators. Generate AWS Lambda and API Gateway infrastructure from decorated Python handlers.
-Author: Mateo Marcos, Emanuel Arguinarena, Lucas Picchi
-License: MIT License
-        
-        Copyright (c) 2024 Lambda API Decorators CDK
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-Project-URL: Homepage, https://github.com/lambda-api-decorators/lambda-api-decorators-cdk
-Project-URL: Repository, https://github.com/lambda-api-decorators/lambda-api-decorators-cdk
-Project-URL: Bug Reports, https://github.com/lambda-api-decorators/lambda-api-decorators-cdk
-Keywords: cdk,lambda,aws,api gateway,ast
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Framework :: AWS CDK :: 2
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Build Tools
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aws-cdk.aws-lambda-python-alpha
-Dynamic: license-file
-
-# Lambda API Decorators CDK
-
-## A library for AWS API Gateway/Lambda Proxy Integration
-
-Lambda API Decorators CDK allows simplified resource creation for AWS Lambda functions and Rest API resources by using decorators and setting a builder with default, common or custom values for IAM Roles, Runtimes, Timeouts, Layers, Environment values, etc. This project relies abstract syntactic trees (ast) to analyze the code of your lambda functions and generate infraestructure accordingly.
-
-### Installation
-
-`lambda_api_decorators_cdk` is available from PyPI as `lambda-api-decorators-cdk`:
-
-    pip install lambda-api-decorators-cdk
-
-Installation of [lambda-api-decorators](https://pypi.org/project/lambda-api-decorators/) is also required as a dependency for your lambda functions, since it provides the definition of decorators used within this module.
-
-
-### Example
-
-```python
-    import lambda_api_decorators_cdk
-    or
-    from lambda_api_decorators_cdk import ResourceBuilder
-```
-
-### Builder instance
-
-You may define a builder using lambda_api_decorators_cdk's constructor `ResourceBuilder`. This method returns an instance of the class that will be used to configure and create your Lambda Functions. By default, no parameters are required to instantiate the object, but custom options may be passed in advanced use cases.
-
-```python
-    from lambda_api_decorators_cdk import ResourceBuilder
-
-    builder = ResourceBuilder()
-```
-
-### Builder Configuration
-
-If opted to, you can set default values for IAM Roles, Memory Size, Timeout, Runtime and VPC.
-
-On the same note, support for common configuration that all the Lambda Functions will receive, such as Security Groups, Environment variables and Layers, is provided.
-
-Lastly you can setup custom environments, layers, security groups, vpcs a Lambda Function will receive ONLY if they have the decorators defined.
-
-```python
-    from lambda_api_decorators_cdk import ResourceBuilder
-    from aws_cdk import Duration
-
-    builder = ResourceBuilder()
-    builder.set_default_timeout(Duration.seconds(30))
-    builder.add_common_environment("DATABASE_URI", "something-db-related")
-    builder.add_custom_environment("URL-PREFIX", "lambda-api-decorators-cdk-") #Lambda Function should have decorator @environment("URL-PREFIX")
-```
-
-### Building
-
-Assuming you have already instantiated a Builder, configured it and ready to deploy your stack, then simply define the directory of your Lambda Functions and build!
-
-Note: For a Lambda Function to be recognised and built, it has to have a decorator specifying the HTTP method it responds to. Decorators are defined in the [lambda-api-decorators](https://pypi.org/project/lambda-api-decorators/) package.
-
-```python
-[...] # Imports
-
-class LambdaApiDecoratorsExampleStack(Stack):
-
-    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
-        super().__init__(scope, construct_id, **kwargs)
-
-        [...]  # Instantiating builder, defining options and layers...
-
-        lambda_path = 'lambdas'
-
-        restapi = apigateway.RestApi(
-            self, 'lambda-api-decorators-RestApi',
-            rest_api_name= 'lambda-api-decorators-restApi')
-        root_resource = restapi.root
-
-        builder.build(self, root_resource, lambda_path, print_tree=True)
-
-```
-
-## Maintainer releases
-
-The Git tag is the single source of truth for this package's version. For
-example, `v0.3.0` produces Python package version `0.3.0`. This repository is
-versioned independently from `lambda-api-decorators`.
-
-To release from `main`, choose and push a semantic version tag:
-
-```bash
-git checkout main
-git pull
-
-git tag v0.3.0
-git push origin v0.3.0
-```
-
-Pushing the tag triggers the release workflow, which tests, builds, verifies
-the version, and publishes with PyPI trusted publishing. The PyPI project must
-have a trusted publisher configured for this repository, the `release.yml`
-workflow, and the `pypi` GitHub environment.

lambda_api_decorators_cdk-0.2.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-lambda_api_decorators_cdk/__init__.py,sha256=LkPu_ySBeRlGKVYbeLV86H78kYFrEQHBuzmskZo3nf8,197
-lambda_api_decorators_cdk/api_type.py,sha256=UjhwP6KBwILl7NpL17e4mL-Bi5JdcfDs3oq2bxoESL0,146
-lambda_api_decorators_cdk/ast_helper.py,sha256=zx1albQktG5D3Rlf5eXEJXiwoZsPF7qwEgTb_sATGEg,14978
-lambda_api_decorators_cdk/lambda_api.py,sha256=wqiwe10-XOuPG8kxn2YGcpk4IHag1WG6mMHFENLgRhc,3148
-lambda_api_decorators_cdk/lambda_api_config.py,sha256=Ngi0g-tN-M9ifv8xrX3UQqjA2RxtVmf6ejqhkYc2nNo,6103
-lambda_api_decorators_cdk/resource_builder.py,sha256=IRYlILYasYywF1_kua-zNHYxG2jGJn4qF5QeAoJqFEQ,36350
-lambda_api_decorators_cdk/source_layout.py,sha256=rvw2D0UTOyhHmiCg_NTuxFf2wvsFCBugnwNKd3NLWLo,167
-lambda_api_decorators_cdk-0.2.3.dist-info/licenses/LICENSE,sha256=kABKIBEzZQqtNkBsAA9tA_Ume6OKdVUnChslMCL2Baw,1081
-lambda_api_decorators_cdk-0.2.3.dist-info/METADATA,sha256=9vYl2q28NItUYeN16dmg4bzqKZgM1tF38KJ3Mf6DBq8,6434
-lambda_api_decorators_cdk-0.2.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-lambda_api_decorators_cdk-0.2.3.dist-info/top_level.txt,sha256=1goCGc19BssxULn6ejZNLDYP0sQHEyqCMhivbGjxDCE,26
-lambda_api_decorators_cdk-0.2.3.dist-info/RECORD,,