wellapi 0.2.1__tar.gz → 0.3.3__tar.gz

wellapi-0.3.3/.github/workflows/build.pipeline.yml

@@ -0,0 +1,31 @@
+name: Python package
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.6.14"
+
+      - name: Set up Python
+        run: uv python install
+
+      - name: Install the project
+        run: uv sync --all-extras --dev
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish package
+        run: uv publish --trusted-publishing always

{wellapi-0.2.1 → wellapi-0.3.3}/.gitignore

@@ -7,3 +7,6 @@ wheels/
 
 # Virtual environments
 .venv
+
+# IDE and editor files
+.idea/

wellapi-0.3.3/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: wellapi
+Version: 0.3.3
+Summary: A simple web framework for aws lambda
+Author-email: romayuhym <romayuhym@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: email-validator>=2.0.0
+Requires-Dist: pydantic==2.11.3
+Requires-Dist: typing-extensions>=4.8.0
+Provides-Extra: deploy
+Requires-Dist: aws-cdk-lib>=2.189.1; extra == 'deploy'
+Requires-Dist: constructs>=10.0.0; extra == 'deploy'
+Provides-Extra: local
+Requires-Dist: click>=8.1.8; extra == 'local'
+Requires-Dist: watchdog>=4.0.2; extra == 'local'
+Description-Content-Type: text/markdown
+
+# WellAPI
+
+WellAPI is a simple web framework for work with AWS Lambda
+and API Gateway. It is designed to be easy to use and flexible, allowing you to create RESTful APIs quickly and efficiently.
+
+## Features
+- Simple and intuitive API for defining routes and handling requests
+- Support for middleware functions
+- Automatic request validation and error handling
+- Support for CORS
+- Support for query parameters, path parameters, and request bodies
+- Support for error handling
+- Support for AWS Lambda and API Gateway
+
+## Installation
+
+You can install WellAPI using pip:
+
+```bash
+pip instsll wellapi
+```
+
+## Example
+
+```python
+from wellapi import WellApi
+
+app = WellApi()
+
+@app.get("/hello")
+def hello():
+    return {"message": "Hello, World!"}
+```
+
+## Local development
+
+You can run your WellAPI application locally using the `wellapi` command:
+
+```bash
+wellapi run main:app
+```
+
+
+## Deploy
+
+```python
+from wellapi.build.cdk import WellApiCDK
+
+
+class MyStack(Stack):
+    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
+        super().__init__(scope, id_, **kwargs)
+
+        app = WellApiCDK(
+            self,
+            "WellApiCDK",
+            app_srt="main:app",
+            handlers_dir="handlers",
+        )
+```
+
+### CORS
+You can enable CORS for your API by setting the `cors` parameter to `True` when creating the `WellApiCDK` instance:
+
+```python
+from wellapi.build.cdk import WellApiCDK
+
+
+class MyStack(Stack):
+    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
+        super().__init__(scope, id_, **kwargs)
+
+        app = WellApiCDK(
+            self,
+            "WellApiCDK",
+            app_srt="main:app",
+            handlers_dir="handlers",
+            cors=True,
+        )
+```
+
+### Cache
+
+You can enable caching for your API by setting the `cache_enable` parameter to `True` when creating the `WellApiCDK` instance:
+
+```python
+from wellapi.build.cdk import WellApiCDK
+
+
+class MyStack(Stack):
+    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
+        super().__init__(scope, id_, **kwargs)
+
+        app = WellApiCDK(
+            self,
+            "WellApiCDK",
+            app_srt="main:app",
+            handlers_dir="handlers",
+            cache_enable=True,
+        )
+```
+**!!! WARNING !!!**
+
+Caching support only GET endpoints
+
+### Logging
+
+You can enable logging for your API by setting the `log_enable` parameter to `True` when creating the `WellApiCDK` instance:
+
+```python
+from wellapi.build.cdk import WellApiCDK
+
+
+class MyStack(Stack):
+    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
+        super().__init__(scope, id_, **kwargs)
+
+        app = WellApiCDK(
+            self,
+            "WellApiCDK",
+            app_srt="main:app",
+            handlers_dir="handlers",
+            log_enable=True,
+        )
+```

wellapi-0.3.3/README.md

@@ -0,0 +1,125 @@
+# WellAPI
+
+WellAPI is a simple web framework for work with AWS Lambda
+and API Gateway. It is designed to be easy to use and flexible, allowing you to create RESTful APIs quickly and efficiently.
+
+## Features
+- Simple and intuitive API for defining routes and handling requests
+- Support for middleware functions
+- Automatic request validation and error handling
+- Support for CORS
+- Support for query parameters, path parameters, and request bodies
+- Support for error handling
+- Support for AWS Lambda and API Gateway
+
+## Installation
+
+You can install WellAPI using pip:
+
+```bash
+pip instsll wellapi
+```
+
+## Example
+
+```python
+from wellapi import WellApi
+
+app = WellApi()
+
+@app.get("/hello")
+def hello():
+    return {"message": "Hello, World!"}
+```
+
+## Local development
+
+You can run your WellAPI application locally using the `wellapi` command:
+
+```bash
+wellapi run main:app
+```
+
+
+## Deploy
+
+```python
+from wellapi.build.cdk import WellApiCDK
+
+
+class MyStack(Stack):
+    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
+        super().__init__(scope, id_, **kwargs)
+
+        app = WellApiCDK(
+            self,
+            "WellApiCDK",
+            app_srt="main:app",
+            handlers_dir="handlers",
+        )
+```
+
+### CORS
+You can enable CORS for your API by setting the `cors` parameter to `True` when creating the `WellApiCDK` instance:
+
+```python
+from wellapi.build.cdk import WellApiCDK
+
+
+class MyStack(Stack):
+    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
+        super().__init__(scope, id_, **kwargs)
+
+        app = WellApiCDK(
+            self,
+            "WellApiCDK",
+            app_srt="main:app",
+            handlers_dir="handlers",
+            cors=True,
+        )
+```
+
+### Cache
+
+You can enable caching for your API by setting the `cache_enable` parameter to `True` when creating the `WellApiCDK` instance:
+
+```python
+from wellapi.build.cdk import WellApiCDK
+
+
+class MyStack(Stack):
+    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
+        super().__init__(scope, id_, **kwargs)
+
+        app = WellApiCDK(
+            self,
+            "WellApiCDK",
+            app_srt="main:app",
+            handlers_dir="handlers",
+            cache_enable=True,
+        )
+```
+**!!! WARNING !!!**
+
+Caching support only GET endpoints
+
+### Logging
+
+You can enable logging for your API by setting the `log_enable` parameter to `True` when creating the `WellApiCDK` instance:
+
+```python
+from wellapi.build.cdk import WellApiCDK
+
+
+class MyStack(Stack):
+    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
+        super().__init__(scope, id_, **kwargs)
+
+        app = WellApiCDK(
+            self,
+            "WellApiCDK",
+            app_srt="main:app",
+            handlers_dir="handlers",
+            log_enable=True,
+        )
+```

{wellapi-0.2.1 → wellapi-0.3.3}/pyproject.toml

@@ -1,24 +1,27 @@
 [project]
 name = "wellapi"
-version = "0.2.1"
-description = "Add your description here"
+version = "0.3.3"
+description = "A simple web framework for aws lambda"
 readme = "README.md"
 authors = [
-    { name = "ramses", email = "romayuhym@gmail.com" }
+    { name = "romayuhym", email = "romayuhym@gmail.com" }
 ]
 requires-python = ">=3.12"
 dependencies = [
     "pydantic==2.11.3",
     "typing-extensions>=4.8.0",
     "email-validator>=2.0.0",
-    "aws-cdk-lib>=2.189.1",
 ]
 
 [project.scripts]
 wellapi = "wellapi.cli.main:cli"
 
 [project.optional-dependencies]
-standard = [
+deploy = [
+    "aws-cdk-lib>=2.189.1",
+    "constructs>=10.0.0",
+]
+local = [
     "click>=8.1.8",
     "watchdog>=4.0.2",
 ]

wellapi-0.3.3/src/wellapi/__init__.py

@@ -0,0 +1,10 @@
+from wellapi.applications import WellApi as WellApi
+from wellapi.params import Path as Path
+from wellapi.params import Query as Query
+from wellapi.params import Header as Header
+from wellapi.params import Body as Body
+from wellapi.params import Cache as Cache
+from wellapi.models import RequestAPIGateway as RequestAPIGateway
+from wellapi.models import ResponseAPIGateway as ResponseAPIGateway
+from wellapi.security import OAuth2PasswordBearer as OAuth2PasswordBearer
+from wellapi.security import APIKeyHeader as APIKeyHeader

{wellapi-0.2.1 → wellapi-0.3.3}/src/wellapi/applications.py

@@ -55,6 +55,7 @@ class Lambda:
         response_model: Any = Default(None),
         status_code: int | None = None,
         description: str | None = None,
+        cache_parameters: params.Cache | None = None,
         response_description: str = "Successful Response",
         responses: dict[int | str, dict[str, Any]] | None = None,
         response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
@@ -79,6 +80,7 @@ class Lambda:
         self.timeout = timeout
         self.method = method
         self.endpoint = endpoint
+        self.cache_parameters = cache_parameters
         self.path_regex, self.path_format, self.param_convertors = compile_path(path)
         self.dependencies = list(dependencies or [])
         self.operation_id = operation_id
@@ -271,6 +273,7 @@ class WellApi:
         *,
         response_model: Any = Default(None),
         status_code: int | None = None,
+        cache_parameters: params.Cache | None = None,
         response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
             ResponseAPIGateway
         ),
@@ -291,6 +294,7 @@ class WellApi:
                 response_model=response_model,
                 status_code=status_code,
                 method="GET",
+                cache_parameters=cache_parameters,
                 response_class=response_class,
                 response_model_include=response_model_include,
                 response_model_exclude=response_model_exclude,
@@ -311,6 +315,7 @@ class WellApi:
         *,
         response_model: Any = Default(None),
         status_code: int | None = None,
+        cache_parameters: params.Cache | None = None,
         response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
             ResponseAPIGateway
         ),
@@ -331,6 +336,133 @@ class WellApi:
                 response_model=response_model,
                 status_code=status_code,
                 method="POST",
+                cache_parameters=cache_parameters,
+                response_class=response_class,
+                response_model_include=response_model_include,
+                response_model_exclude=response_model_exclude,
+                response_model_by_alias=response_model_by_alias,
+                response_model_exclude_unset=response_model_exclude_unset,
+                response_model_exclude_defaults=response_model_exclude_defaults,
+                response_model_exclude_none=response_model_exclude_none,
+                dependencies=dependencies,
+                tags=tags,
+            )
+            return lambda_
+
+        return decorator
+
+    def put(
+        self,
+        path: str,
+        *,
+        response_model: Any = Default(None),
+        status_code: int | None = None,
+        cache_parameters: params.Cache | None = None,
+        response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
+            ResponseAPIGateway
+        ),
+        response_model_include: IncEx | None = None,
+        response_model_exclude: IncEx | None = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        dependencies: Sequence[params.Depends] | None = None,
+        tags: list[str | Enum] | None = None,
+    ):
+        def decorator(func):
+            lambda_ = self.add_endpoint(
+                path,
+                func,
+                type_="endpoint",
+                response_model=response_model,
+                status_code=status_code,
+                method="PUT",
+                cache_parameters=cache_parameters,
+                response_class=response_class,
+                response_model_include=response_model_include,
+                response_model_exclude=response_model_exclude,
+                response_model_by_alias=response_model_by_alias,
+                response_model_exclude_unset=response_model_exclude_unset,
+                response_model_exclude_defaults=response_model_exclude_defaults,
+                response_model_exclude_none=response_model_exclude_none,
+                dependencies=dependencies,
+                tags=tags,
+            )
+            return lambda_
+
+        return decorator
+
+    def patch(
+        self,
+        path: str,
+        *,
+        response_model: Any = Default(None),
+        status_code: int | None = None,
+        cache_parameters: params.Cache | None = None,
+        response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
+            ResponseAPIGateway
+        ),
+        response_model_include: IncEx | None = None,
+        response_model_exclude: IncEx | None = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        dependencies: Sequence[params.Depends] | None = None,
+        tags: list[str | Enum] | None = None,
+    ):
+        def decorator(func):
+            lambda_ = self.add_endpoint(
+                path,
+                func,
+                type_="endpoint",
+                response_model=response_model,
+                status_code=status_code,
+                method="PATCH",
+                cache_parameters=cache_parameters,
+                response_class=response_class,
+                response_model_include=response_model_include,
+                response_model_exclude=response_model_exclude,
+                response_model_by_alias=response_model_by_alias,
+                response_model_exclude_unset=response_model_exclude_unset,
+                response_model_exclude_defaults=response_model_exclude_defaults,
+                response_model_exclude_none=response_model_exclude_none,
+                dependencies=dependencies,
+                tags=tags,
+            )
+            return lambda_
+
+        return decorator
+
+    def delete(
+        self,
+        path: str,
+        *,
+        response_model: Any = Default(None),
+        status_code: int | None = None,
+        cache_parameters: params.Cache | None = None,
+        response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
+            ResponseAPIGateway
+        ),
+        response_model_include: IncEx | None = None,
+        response_model_exclude: IncEx | None = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        dependencies: Sequence[params.Depends] | None = None,
+        tags: list[str | Enum] | None = None,
+    ):
+        def decorator(func):
+            lambda_ = self.add_endpoint(
+                path,
+                func,
+                type_="endpoint",
+                response_model=response_model,
+                status_code=status_code,
+                method="DELETE",
+                cache_parameters=cache_parameters,
                 response_class=response_class,
                 response_model_include=response_model_include,
                 response_model_exclude=response_model_exclude,

{wellapi-0.2.1 → wellapi-0.3.3}/src/wellapi/build/cdk.py

@@ -11,10 +11,10 @@ from aws_cdk import (
     aws_iam as iam,
     aws_lambda as _lambda,
     aws_lambda_event_sources as lambda_event_source,
+    aws_logs as logs,
     aws_sqs as sqs,
     aws_s3_assets as s3_assets,
 )
-from aws_cdk.aws_lambda import CfnFunction
 from constructs import Construct
 
 from wellapi.applications import Lambda, WellApi
@@ -39,24 +39,18 @@ class WellApiCDK(Construct):
         *,
         app_srt: str,
         handlers_dir: str,
+        cors: bool = False,
+        cache_enable: bool = False,
+        log_enable: bool = False,
     ) -> None:
         super().__init__(scope, id_)
 
         self.app_srt = app_srt
         self.handlers_dir = os.path.abspath(handlers_dir)
 
-        wellapi_app: WellApi = self._package_app()
+        wellapi_app: WellApi = self._package_app(cors=cors)
 
-        # defining a Cfn Asset from the openAPI file
-        open_api_asset = s3_assets.Asset(self, "OpenApiAsset", path=OPENAPI_FILE)
-        transform_map = {"Location": open_api_asset.s3_object_url}
-        data = Fn.transform("AWS::Include", transform_map)
-
-        self.api = apigw.SpecRestApi(
-            self,
-            f"{wellapi_app.title}Api",
-            api_definition=apigw.ApiDefinition.from_inline(data),
-        )
+        self._create_api(wellapi_app, cache_enable=cache_enable, log_enable=log_enable)
 
         for q in wellapi_app.queues:
             queue = sqs.Queue(self, f"{q.queue_name}Queue", queue_name=q.queue_name)
@@ -91,12 +85,13 @@ class WellApiCDK(Construct):
                     f"{lmbd.arn}Permission",
                     principal=iam.ServicePrincipal("apigateway.amazonaws.com"),
                     action="lambda:InvokeFunction",
-                    source_arn=self.api.arn_for_execute_api(lmbd.method.upper()),
+                    source_arn=self.api.arn_for_execute_api(
+                        lmbd.method.upper(), lmbd.path
+                    ),
                 )
 
-                cfn_lambda: CfnFunction = lambda_function.node.default_child  # type: ignore
+                cfn_lambda: _lambda.CfnFunction = lambda_function.node.default_child  # type: ignore
                 cfn_lambda.override_logical_id(f"{lmbd.arn}Function")
-                # self.api.node.add_dependency(lambda_function)
 
             if lmbd.type_ == "queue":
                 queue = sqs.Queue(
@@ -120,7 +115,102 @@ class WellApiCDK(Construct):
 
                 rule.add_target(targets.LambdaFunction(lambda_function))  # type: ignore
 
-    def _package_app(self) -> WellApi:
+    def _create_api(
+        self, wellapi_app: WellApi, cache_enable: bool = False, log_enable: bool = False
+    ) -> None:
+        # defining a Cfn Asset from the openAPI file
+        open_api_asset = s3_assets.Asset(self, "OpenApiAsset", path=OPENAPI_FILE)
+        transform_map = {"Location": open_api_asset.s3_object_url}
+        data = Fn.transform("AWS::Include", transform_map)
+
+        cache_deploy_options = {}
+        if cache_enable:
+            cache_deploy_options = {
+                "cache_cluster_enabled": cache_enable,
+                # "cache_cluster_size": "0.5",
+                # "cache_ttl": Duration.minutes(15),
+                "method_options": {
+                    # "{resource_path}/{http_method}": apigw.MethodDeploymentOptions
+                    "/*/*": apigw.MethodDeploymentOptions(
+                        caching_enabled=True,
+                        cache_ttl=Duration.minutes(15),
+                    )
+                },
+            }
+
+        log_deploy_options = {}
+        if log_enable:
+            access_log_group = logs.LogGroup(
+                self,
+                "AccessLogGroup",
+                log_group_name="AccessLogGroup-apiGateway",
+                retention=logs.RetentionDays.ONE_MONTH,
+            )
+            log_deploy_options = {
+                "logging_level": apigw.MethodLoggingLevel.ERROR,
+                # data_trace_enabled=True,
+                "metrics_enabled": True,
+                "access_log_destination": apigw.LogGroupLogDestination(
+                    access_log_group  # type: ignore
+                ),
+                "access_log_format": apigw.AccessLogFormat.custom(
+                    json.dumps(
+                        {
+                            "request_id": apigw.AccessLogField.context_request_id(),
+                            "source_ip": apigw.AccessLogField.context_identity_source_ip(),
+                            "method": apigw.AccessLogField.context_http_method(),
+                            "path": apigw.AccessLogField.context_resource_path(),
+                            "request_path": apigw.AccessLogField.context_path(),
+                            "status": apigw.AccessLogField.context_status(),
+                            "user_agent": apigw.AccessLogField.context_identity_user_agent(),
+                            "integration_id": apigw.AccessLogField.context_aws_endpoint_request_id(),
+                        }
+                    )
+                ),
+            }
+
+        if cache_deploy_options or log_deploy_options:
+            deploy_options = apigw.StageOptions(
+                **cache_deploy_options, **log_deploy_options
+            )
+        else:
+            deploy_options = None
+
+        self.api = apigw.SpecRestApi(
+            self,
+            f"{wellapi_app.title}Api",
+            api_definition=apigw.ApiDefinition.from_inline(data),
+            deploy_options=deploy_options,
+        )
+
+        self.api_key = apigw.ApiKey(
+            self,
+            "MyApiKey",
+            api_key_name="my-service-key",
+        )
+
+        self.usage_plan = apigw.UsagePlan(
+            self,
+            "MyUsagePlan",
+            api_stages=[
+                apigw.UsagePlanPerApiStage(
+                    api=self.api,
+                    stage=self.api.deployment_stage,
+                )
+            ],
+            name="MyUsagePlan",
+            quota=apigw.QuotaSettings(
+                limit=10_000,
+                period=apigw.Period.DAY,
+            ),
+            throttle=apigw.ThrottleSettings(
+                burst_limit=2,
+                rate_limit=10,
+            ),
+        )
+        self.usage_plan.add_api_key(self.api_key)
+
+    def _package_app(self, cors: bool = False) -> WellApi:
         wellapi_app = import_app(self.app_srt)
         load_handlers(self.handlers_dir)
 
@@ -132,6 +222,7 @@ class WellApiCDK(Construct):
             lambdas=wellapi_app.lambdas,
             tags=wellapi_app.openapi_tags,
             servers=wellapi_app.servers,
+            cors=cors,
         )
         with open(OPENAPI_FILE, "w") as f:
             json.dump(resp, f)