lambda-forge-cli-aws 1.0.0__py3-none-any.whl

templates/python-queue/{{cookiecutter.project_slug}}/infrastructure/lib/stack.js

@@ -0,0 +1,79 @@
+const cdk = require('aws-cdk-lib');
+const lambda = require('aws-cdk-lib/aws-lambda');
+const sqs = require('aws-cdk-lib/aws-sqs');
+const dynamodb = require('aws-cdk-lib/aws-dynamodb');
+const logs = require('aws-cdk-lib/aws-logs');
+const { SqsEventSource } = require('aws-cdk-lib/aws-lambda-event-sources');
+
+class {{ cookiecutter.project_name|replace('-', '')|capitalize }}Stack extends cdk.Stack {
+  constructor(scope, id, props) {
+    super(scope, id, props);
+    const envName = props.envName || 'dev';
+
+    // Dead Letter Queue
+    const dlq = new sqs.Queue(this, 'DeadLetterQueue', {
+      queueName: `{{ cookiecutter.project_name }}-dlq-${envName}`,
+      retentionPeriod: cdk.Duration.days(14),
+    });
+
+    // Main SQS Queue
+    const queue = new sqs.Queue(this, 'ProcessingQueue', {
+      queueName: `{{ cookiecutter.project_name }}-queue-${envName}`,
+      visibilityTimeout: cdk.Duration.seconds({{ cookiecutter.timeout_seconds }} * 6),
+      deadLetterQueue: {
+        queue: dlq,
+        maxReceiveCount: 3,
+      },
+    });
+
+    // DynamoDB Table
+    const table = new dynamodb.Table(this, 'ProcessingTable', {
+      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
+      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+      pointInTimeRecovery: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    // Lambda Function
+    const fn = new lambda.Function(this, 'ProcessorFunction', {
+      runtime: lambda.Runtime.PYTHON_3_12,
+      architecture: lambda.Architecture.ARM_64,
+      handler: 'handler.handler',
+      code: lambda.Code.fromAsset('../src'),
+      memorySize: {{ cookiecutter.memory_mb }},
+      timeout: cdk.Duration.seconds({{ cookiecutter.timeout_seconds }}),
+      tracing: lambda.Tracing.ACTIVE,
+      logRetention: logs.RetentionDays.ONE_MONTH,
+      environment: {
+        TABLE_NAME: table.tableName,
+        STAGE: envName,
+        POWERTOOLS_SERVICE_NAME: '{{ cookiecutter.project_slug }}',
+      },
+    });
+
+    // Grant permissions
+    table.grantReadWriteData(fn);
+    queue.grantConsumeMessages(fn);
+
+    // SQS Event Source with partial batch response
+    fn.addEventSource(new SqsEventSource(queue, {
+      batchSize: 10,
+      maxBatchingWindow: cdk.Duration.seconds(5),
+      reportBatchItemFailures: true,
+    }));
+
+    // Tags
+    cdk.Tags.of(this).add('Project', '{{ cookiecutter.project_name }}');
+    cdk.Tags.of(this).add('ManagedBy', 'LambdaForge');
+    cdk.Tags.of(this).add('Environment', envName);
+
+    // Outputs
+    new cdk.CfnOutput(this, 'FunctionName', { value: fn.functionName });
+    new cdk.CfnOutput(this, 'QueueUrl', { value: queue.queueUrl });
+    new cdk.CfnOutput(this, 'QueueArn', { value: queue.queueArn });
+    new cdk.CfnOutput(this, 'TableName', { value: table.tableName });
+    new cdk.CfnOutput(this, 'DlqUrl', { value: dlq.queueUrl });
+  }
+}
+
+module.exports = { {{ cookiecutter.project_name|replace('-', '')|capitalize }}Stack };

templates/python-queue/{{cookiecutter.project_slug}}/infrastructure/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "{{ cookiecutter.project_slug }}-infrastructure",
+  "version": "0.1.0",
+  "description": "AWS CDK infrastructure for {{ cookiecutter.project_name }}",
+  "private": true,
+  "scripts": {
+    "cdk": "cdk",
+    "synth": "cdk synth",
+    "deploy": "cdk deploy --require-approval never",
+    "destroy": "cdk destroy --force",
+    "diff": "cdk diff"
+  },
+  "dependencies": {
+    "aws-cdk-lib": "^2.170.0",
+    "constructs": "^10.4.0"
+  }
+}

templates/python-queue/{{cookiecutter.project_slug}}/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "{{ cookiecutter.project_slug }}"
+version = "0.1.0"
+description = "{{ cookiecutter.description }}"
+authors = [
+    {name = "{{ cookiecutter.author_name }}", email = "{{ cookiecutter.author_email }}"}
+]
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+keywords = ["aws", "lambda", "serverless", "sqs", "queue"]
+
+dependencies = [
+    "aws-lambda-powertools[tracer,logger]>=3.0.0",
+    "boto3>=1.34.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.1.0",
+    "moto[dynamodb,sqs]>=5.0.0",
+    "ruff>=0.1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "-v --strict-markers --cov=src --cov-report=term-missing"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "N", "S", "RUF"]
+ignore = ["S101"]
+
+[tool.coverage.run]
+source = ["src"]
+omit = ["tests/*"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "if __name__ == .__main__.:",
+    "raise NotImplementedError",
+]

templates/python-queue/{{cookiecutter.project_slug}}/requirements.txt

@@ -0,0 +1,2 @@
+aws-lambda-powertools[tracer,logger]>=3.0.0
+boto3>=1.34.0

templates/python-queue/{{cookiecutter.project_slug}}/src/handler.py

@@ -0,0 +1,64 @@
+"""{{ cookiecutter.project_name }} — SQS batch processor handler.
+
+Processes messages from SQS with partial batch failure support.
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+import boto3
+from aws_lambda_powertools import Logger, Tracer
+from aws_lambda_powertools.utilities.batch import (
+    BatchProcessor,
+    EventType,
+    process_partial_response,
+)
+from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+logger = Logger(service="{{ cookiecutter.project_slug }}")
+tracer = Tracer(service="{{ cookiecutter.project_slug }}")
+
+TABLE_NAME = os.environ.get("TABLE_NAME", "")
+STAGE = os.environ.get("STAGE", "dev")
+
+processor = BatchProcessor(event_type=EventType.SQS)
+dynamodb = boto3.resource("dynamodb")
+
+
+@tracer.capture_method
+def process_record(record: SQSRecord) -> dict[str, Any]:
+    """Process a single SQS record.
+
+    Replace this with your business logic.
+    """
+    body = json.loads(record.body)
+    message_id = record.message_id
+
+    logger.info("processing_record", extra={"message_id": message_id, "body": body})
+
+    result = {
+        "message_id": message_id,
+        "status": "processed",
+    }
+
+    if TABLE_NAME:
+        table = dynamodb.Table(TABLE_NAME)
+        table.put_item(Item={"id": message_id, **result})
+
+    logger.info("record_processed", extra=result)
+    return result
+
+
+@logger.inject_lambda_context
+@tracer.capture_lambda_handler
+def handler(event: dict, context: LambdaContext) -> dict[str, Any]:
+    """Lambda handler — processes SQS batch with partial failure support."""
+    return process_partial_response(
+        event=event,
+        record_handler=process_record,
+        processor=processor,
+        context=context,
+    )

templates/python-queue/{{cookiecutter.project_slug}}/tests/conftest.py

@@ -0,0 +1,22 @@
+"""Test configuration and fixtures."""
+from __future__ import annotations
+
+import os
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def aws_credentials(monkeypatch):
+    """Mock AWS credentials for moto."""
+    monkeypatch.setenv("AWS_ACCESS_KEY_ID", "testing")
+    monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "testing")
+    monkeypatch.setenv("AWS_SECURITY_TOKEN", "testing")
+    monkeypatch.setenv("AWS_SESSION_TOKEN", "testing")
+    monkeypatch.setenv("AWS_DEFAULT_REGION", "us-east-1")
+
+
+@pytest.fixture
+def table_name():
+    """Provide a test table name."""
+    return os.environ.get("TABLE_NAME", "test-table")

templates/python-queue/{{cookiecutter.project_slug}}/tests/test_handler.py

@@ -0,0 +1,60 @@
+"""Tests for {{ cookiecutter.project_name }} SQS processor handler."""
+from __future__ import annotations
+
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from src.handler import handler
+
+
+@pytest.fixture
+def sqs_event():
+    """Sample SQS batch event."""
+    return {
+        "Records": [
+            {
+                "messageId": "msg-001",
+                "receiptHandle": "test-receipt-handle",
+                "body": json.dumps({"action": "process", "data": "test-payload"}),
+                "attributes": {
+                    "ApproximateReceiveCount": "1",
+                    "SentTimestamp": "1704067200000",
+                    "SenderId": "123456789012",
+                    "ApproximateFirstReceiveTimestamp": "1704067200001",
+                },
+                "messageAttributes": {},
+                "md5OfBody": "test-md5",
+                "eventSource": "aws:sqs",
+                "eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:test-queue",
+                "awsRegion": "us-east-1",
+            }
+        ]
+    }
+
+
+def test_handler_processes_batch(sqs_event):
+    """Test handler processes SQS batch without error."""
+    context = MagicMock()
+    context.function_name = "test-function"
+    context.aws_request_id = "test-request-id"
+
+    with patch("src.handler.dynamodb"):
+        response = handler(sqs_event, context)
+
+    assert "batchItemFailures" in response
+
+
+def test_handler_handles_empty_batch():
+    """Test handler handles empty records list."""
+    event = {"Records": []}
+    context = MagicMock()
+    context.function_name = "test-function"
+    context.aws_request_id = "test-request-id"
+
+    with patch("src.handler.dynamodb"):
+        response = handler(event, context)
+
+    assert "batchItemFailures" in response
+    assert response["batchItemFailures"] == []

templates/python-s3/cookiecutter.json

@@ -0,0 +1,13 @@
+{
+  "project_name": "my-s3-processor",
+  "project_slug": "{{ cookiecutter.project_name|replace('-', '_') }}",
+  "module_name": "{{ cookiecutter.project_slug }}",
+  "description": "S3 event processor Lambda",
+  "author_name": "LambdaForge User",
+  "author_email": "user@example.com",
+  "runtime": "python3.12",
+  "aws_region": "us-east-1",
+  "memory_mb": 1024,
+  "timeout_seconds": 120,
+  "source_bucket_prefix": "uploads/"
+}

templates/python-s3/{{cookiecutter.project_slug}}/.gitignore

@@ -0,0 +1,65 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Testing
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+coverage.xml
+*.cover
+
+# Type checking
+.mypy_cache/
+.ruff_cache/
+
+# IDEs
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# CDK
+cdk.out/
+cdk.context.json
+
+# Lambda
+*.zip
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Secrets
+*.pem
+*.key
+secrets.yml

templates/python-s3/{{cookiecutter.project_slug}}/Dockerfile

@@ -0,0 +1,11 @@
+FROM public.ecr.aws/lambda/python:3.12-arm64
+
+# Install dependencies first for better layer caching
+COPY requirements.txt ${LAMBDA_TASK_ROOT}/
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy function code
+COPY src/ ${LAMBDA_TASK_ROOT}/
+
+# Set the handler
+CMD [ "handler.handler" ]

templates/python-s3/{{cookiecutter.project_slug}}/infrastructure/app.js

@@ -0,0 +1,25 @@
+const cdk = require('aws-cdk-lib');
+const { {{ cookiecutter.project_name|replace('-', '')|capitalize }}Stack } = require('./lib/stack');
+
+const app = new cdk.App();
+
+// Environment from CDK context (default: dev)
+const envName = app.node.tryGetContext('env') || 'dev';
+
+new {{ cookiecutter.project_name|replace('-', '')|capitalize }}Stack(app, `{{ cookiecutter.project_name }}-${envName}`, {
+  stackName: `{{ cookiecutter.project_name }}-${envName}`,
+  env: {
+    account: process.env.CDK_DEFAULT_ACCOUNT,
+    region: process.env.CDK_DEFAULT_REGION || '{{ cookiecutter.aws_region }}',
+  },
+  description: `{{ cookiecutter.description }} (${envName})`,
+  tags: {
+    Project: '{{ cookiecutter.project_name }}',
+    Environment: envName,
+    ManagedBy: 'LambdaForge',
+    CostCenter: '{{ cookiecutter.project_name }}',
+  },
+  envName: envName,
+});
+
+app.synth();

templates/python-s3/{{cookiecutter.project_slug}}/infrastructure/cdk.json

@@ -0,0 +1,3 @@
+{
+  "app": "node app.js"
+}

templates/python-s3/{{cookiecutter.project_slug}}/infrastructure/lib/stack.js

@@ -0,0 +1,89 @@
+const cdk = require('aws-cdk-lib');
+const lambda = require('aws-cdk-lib/aws-lambda');
+const s3 = require('aws-cdk-lib/aws-s3');
+const s3n = require('aws-cdk-lib/aws-s3-notifications');
+const dynamodb = require('aws-cdk-lib/aws-dynamodb');
+const sqs = require('aws-cdk-lib/aws-sqs');
+const logs = require('aws-cdk-lib/aws-logs');
+
+class {{ cookiecutter.project_name|replace('-', '')|capitalize }}Stack extends cdk.Stack {
+  constructor(scope, id, props) {
+    super(scope, id, props);
+    const envName = props.envName || 'dev';
+
+    // S3 Source Bucket
+    const bucket = new s3.Bucket(this, 'SourceBucket', {
+      bucketName: `{{ cookiecutter.project_name }}-source-${envName}-${this.account}`,
+      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
+      enforceSSL: true,
+      versioned: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+      lifecycleRules: [
+        {
+          expiration: cdk.Duration.days(90),
+          noncurrentVersionExpiration: cdk.Duration.days(30),
+        },
+      ],
+    });
+
+    // Dead Letter Queue
+    const dlq = new sqs.Queue(this, 'DeadLetterQueue', {
+      queueName: `{{ cookiecutter.project_name }}-dlq-${envName}`,
+      retentionPeriod: cdk.Duration.days(14),
+    });
+
+    // DynamoDB Table for tracking processed objects
+    const table = new dynamodb.Table(this, 'ProcessingTable', {
+      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
+      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+      pointInTimeRecovery: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    // Lambda Function
+    const fn = new lambda.Function(this, 'S3ProcessorFunction', {
+      runtime: lambda.Runtime.PYTHON_3_12,
+      architecture: lambda.Architecture.ARM_64,
+      handler: 'handler.handler',
+      code: lambda.Code.fromAsset('../src'),
+      memorySize: {{ cookiecutter.memory_mb }},
+      timeout: cdk.Duration.seconds({{ cookiecutter.timeout_seconds }}),
+      tracing: lambda.Tracing.ACTIVE,
+      deadLetterQueue: dlq,
+      retryAttempts: 2,
+      logRetention: logs.RetentionDays.ONE_MONTH,
+      environment: {
+        TABLE_NAME: table.tableName,
+        SOURCE_BUCKET: bucket.bucketName,
+        STAGE: envName,
+        POWERTOOLS_SERVICE_NAME: '{{ cookiecutter.project_slug }}',
+      },
+    });
+
+    // Grant permissions
+    table.grantReadWriteData(fn);
+    bucket.grantRead(fn);
+
+    // S3 Event Notification — trigger on PutObject with prefix
+    bucket.addEventNotification(
+      s3.EventType.OBJECT_CREATED_PUT,
+      new s3n.LambdaDestination(fn),
+      { prefix: '{{ cookiecutter.source_bucket_prefix }}' }
+    );
+
+    // Tags
+    cdk.Tags.of(this).add('Project', '{{ cookiecutter.project_name }}');
+    cdk.Tags.of(this).add('ManagedBy', 'LambdaForge');
+    cdk.Tags.of(this).add('Environment', envName);
+
+    // Outputs
+    new cdk.CfnOutput(this, 'FunctionName', { value: fn.functionName });
+    new cdk.CfnOutput(this, 'BucketName', { value: bucket.bucketName });
+    new cdk.CfnOutput(this, 'BucketArn', { value: bucket.bucketArn });
+    new cdk.CfnOutput(this, 'TableName', { value: table.tableName });
+    new cdk.CfnOutput(this, 'DlqUrl', { value: dlq.queueUrl });
+  }
+}
+
+module.exports = { {{ cookiecutter.project_name|replace('-', '')|capitalize }}Stack };

templates/python-s3/{{cookiecutter.project_slug}}/infrastructure/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "{{ cookiecutter.project_slug }}-infrastructure",
+  "version": "0.1.0",
+  "description": "AWS CDK infrastructure for {{ cookiecutter.project_name }}",
+  "private": true,
+  "scripts": {
+    "cdk": "cdk",
+    "synth": "cdk synth",
+    "deploy": "cdk deploy --require-approval never",
+    "destroy": "cdk destroy --force",
+    "diff": "cdk diff"
+  },
+  "dependencies": {
+    "aws-cdk-lib": "^2.170.0",
+    "constructs": "^10.4.0"
+  }
+}

templates/python-s3/{{cookiecutter.project_slug}}/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "{{ cookiecutter.project_slug }}"
+version = "0.1.0"
+description = "{{ cookiecutter.description }}"
+authors = [
+    {name = "{{ cookiecutter.author_name }}", email = "{{ cookiecutter.author_email }}"}
+]
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+keywords = ["aws", "lambda", "serverless", "s3", "file-processing"]
+
+dependencies = [
+    "aws-lambda-powertools[tracer,logger]>=3.0.0",
+    "boto3>=1.34.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.1.0",
+    "moto[dynamodb,s3]>=5.0.0",
+    "ruff>=0.1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "-v --strict-markers --cov=src --cov-report=term-missing"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "N", "S", "RUF"]
+ignore = ["S101"]
+
+[tool.coverage.run]
+source = ["src"]
+omit = ["tests/*"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "if __name__ == .__main__.:",
+    "raise NotImplementedError",
+]

templates/python-s3/{{cookiecutter.project_slug}}/requirements.txt

@@ -0,0 +1,2 @@
+aws-lambda-powertools[tracer,logger]>=3.0.0
+boto3>=1.34.0

templates/python-s3/{{cookiecutter.project_slug}}/src/handler.py

@@ -0,0 +1,86 @@
+"""{{ cookiecutter.project_name }} — S3 event processor handler.
+
+Processes S3 PutObject events for objects matching prefix: {{ cookiecutter.source_bucket_prefix }}
+"""
+from __future__ import annotations
+
+import os
+import urllib.parse
+from typing import Any
+
+import boto3
+from aws_lambda_powertools import Logger, Tracer
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+logger = Logger(service="{{ cookiecutter.project_slug }}")
+tracer = Tracer(service="{{ cookiecutter.project_slug }}")
+
+TABLE_NAME = os.environ.get("TABLE_NAME", "")
+STAGE = os.environ.get("STAGE", "dev")
+
+s3_client = boto3.client("s3")
+dynamodb = boto3.resource("dynamodb")
+
+
+@tracer.capture_method
+def process_s3_object(bucket: str, key: str) -> dict[str, Any]:
+    """Process a single S3 object.
+
+    Downloads the object and performs processing.
+    Replace this with your business logic.
+    """
+    logger.info("processing_object", extra={"bucket": bucket, "key": key})
+
+    # Download the object
+    response = s3_client.get_object(Bucket=bucket, Key=key)
+    content_length = response["ContentLength"]
+    content_type = response.get("ContentType", "unknown")
+
+    result = {
+        "bucket": bucket,
+        "key": key,
+        "content_length": content_length,
+        "content_type": content_type,
+        "status": "processed",
+    }
+
+    if TABLE_NAME:
+        table = dynamodb.Table(TABLE_NAME)
+        table.put_item(Item={"id": f"{bucket}/{key}", **result})
+
+    logger.info("object_processed", extra=result)
+    return result
+
+
+@logger.inject_lambda_context
+@tracer.capture_lambda_handler
+def handler(event: dict, context: LambdaContext) -> dict[str, Any]:
+    """Lambda handler — processes S3 PutObject events."""
+    results = []
+    errors = []
+
+    for record in event.get("Records", []):
+        try:
+            bucket = record["s3"]["bucket"]["name"]
+            key = urllib.parse.unquote_plus(record["s3"]["object"]["key"])
+
+            result = process_s3_object(bucket, key)
+            results.append(result)
+        except Exception:
+            logger.exception("record_processing_failed", extra={"record": record})
+            errors.append(record)
+
+    response = {
+        "statusCode": 200,
+        "body": {
+            "processed": len(results),
+            "failed": len(errors),
+            "results": results,
+        },
+    }
+
+    if errors:
+        response["statusCode"] = 207  # Multi-Status
+        logger.warning("partial_failure", extra={"failed_count": len(errors)})
+
+    return response