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

templates/python-s3/{{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-s3/{{cookiecutter.project_slug}}/tests/test_handler.py

@@ -0,0 +1,71 @@
+"""Tests for {{ cookiecutter.project_name }} S3 event processor handler."""
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from src.handler import handler
+
+
+@pytest.fixture
+def s3_put_event():
+    """Sample S3 PutObject event."""
+    return {
+        "Records": [
+            {
+                "eventVersion": "2.1",
+                "eventSource": "aws:s3",
+                "awsRegion": "us-east-1",
+                "eventTime": "2024-01-01T00:00:00.000Z",
+                "eventName": "ObjectCreated:Put",
+                "s3": {
+                    "s3SchemaVersion": "1.0",
+                    "configurationId": "test-config",
+                    "bucket": {
+                        "name": "test-bucket",
+                        "arn": "arn:aws:s3:::test-bucket",
+                    },
+                    "object": {
+                        "key": "uploads/test-file.csv",
+                        "size": 1024,
+                        "eTag": "test-etag",
+                    },
+                },
+            }
+        ]
+    }
+
+
+def test_handler_processes_s3_event(s3_put_event):
+    """Test handler processes S3 PutObject event without error."""
+    context = MagicMock()
+    context.function_name = "test-function"
+    context.aws_request_id = "test-request-id"
+
+    mock_response = {
+        "ContentLength": 1024,
+        "ContentType": "text/csv",
+        "Body": MagicMock(),
+    }
+
+    with patch("src.handler.s3_client.get_object", return_value=mock_response), \
+         patch("src.handler.dynamodb"):
+        response = handler(s3_put_event, context)
+
+    assert response["statusCode"] == 200
+    assert response["body"]["processed"] == 1
+    assert response["body"]["failed"] == 0
+
+
+def test_handler_handles_empty_records():
+    """Test handler handles event with no records."""
+    event = {"Records": []}
+    context = MagicMock()
+    context.function_name = "test-function"
+    context.aws_request_id = "test-request-id"
+
+    response = handler(event, context)
+
+    assert response["statusCode"] == 200
+    assert response["body"]["processed"] == 0

templates/python-stream/cookiecutter.json

@@ -0,0 +1,12 @@
+{
+  "project_name": "my-stream-processor",
+  "project_slug": "{{ cookiecutter.project_name|replace('-', '_') }}",
+  "module_name": "{{ cookiecutter.project_slug }}",
+  "description": "Kinesis/DynamoDB Streams processor Lambda",
+  "author_name": "LambdaForge User",
+  "author_email": "user@example.com",
+  "runtime": "python3.12",
+  "aws_region": "us-east-1",
+  "memory_mb": 1024,
+  "timeout_seconds": 60
+}

templates/python-stream/{{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-stream/{{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-stream/{{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-stream/{{cookiecutter.project_slug}}/infrastructure/cdk.json

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

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

@@ -0,0 +1,81 @@
+const cdk = require('aws-cdk-lib');
+const lambda = require('aws-cdk-lib/aws-lambda');
+const kinesis = require('aws-cdk-lib/aws-kinesis');
+const dynamodb = require('aws-cdk-lib/aws-dynamodb');
+const sqs = require('aws-cdk-lib/aws-sqs');
+const logs = require('aws-cdk-lib/aws-logs');
+const { KinesisEventSource } = 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';
+
+    // Kinesis Data Stream
+    const stream = new kinesis.Stream(this, 'DataStream', {
+      streamName: `{{ cookiecutter.project_name }}-stream-${envName}`,
+      shardCount: 1,
+      retentionPeriod: cdk.Duration.hours(24),
+    });
+
+    // Dead Letter Queue for failed records
+    const dlq = new sqs.Queue(this, 'DeadLetterQueue', {
+      queueName: `{{ cookiecutter.project_name }}-dlq-${envName}`,
+      retentionPeriod: cdk.Duration.days(14),
+    });
+
+    // DynamoDB Table for processed results
+    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, 'StreamProcessorFunction', {
+      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);
+    stream.grantRead(fn);
+    dlq.grantSendMessages(fn);
+
+    // Kinesis Event Source with batch processing
+    fn.addEventSource(new KinesisEventSource(stream, {
+      batchSize: 100,
+      maxBatchingWindow: cdk.Duration.seconds(5),
+      startingPosition: lambda.StartingPosition.TRIM_HORIZON,
+      bisectBatchOnError: true,
+      retryAttempts: 3,
+      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, 'StreamName', { value: stream.streamName });
+    new cdk.CfnOutput(this, 'StreamArn', { value: stream.streamArn });
+    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-stream/{{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-stream/{{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", "kinesis", "stream"]
+
+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,kinesis]>=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-stream/{{cookiecutter.project_slug}}/requirements.txt

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

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

@@ -0,0 +1,69 @@
+"""{{ cookiecutter.project_name }} — Kinesis/DynamoDB Streams processor handler.
+
+Processes records from a Kinesis data stream with batch checkpointing.
+"""
+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.kinesis_stream_event import (
+    KinesisStreamRecord,
+)
+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.KinesisDataStreams)
+dynamodb = boto3.resource("dynamodb")
+
+
+@tracer.capture_method
+def process_record(record: KinesisStreamRecord) -> dict[str, Any]:
+    """Process a single stream record.
+
+    Replace this with your business logic.
+    """
+    payload = json.loads(record.kinesis.data_as_text())
+    sequence_number = record.kinesis.sequence_number
+
+    logger.info(
+        "processing_record",
+        extra={"sequence_number": sequence_number, "payload": payload},
+    )
+
+    result = {
+        "sequence_number": sequence_number,
+        "status": "processed",
+    }
+
+    if TABLE_NAME:
+        table = dynamodb.Table(TABLE_NAME)
+        table.put_item(Item={"id": sequence_number, **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 Kinesis stream batch with checkpointing."""
+    return process_partial_response(
+        event=event,
+        record_handler=process_record,
+        processor=processor,
+        context=context,
+    )

templates/python-stream/{{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-stream/{{cookiecutter.project_slug}}/tests/test_handler.py

@@ -0,0 +1,64 @@
+"""Tests for {{ cookiecutter.project_name }} Kinesis stream processor handler."""
+from __future__ import annotations
+
+import base64
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from src.handler import handler
+
+
+@pytest.fixture
+def kinesis_event():
+    """Sample Kinesis stream event."""
+    data = json.dumps({"action": "update", "entity_id": "test-123"})
+    encoded_data = base64.b64encode(data.encode()).decode()
+
+    return {
+        "Records": [
+            {
+                "kinesis": {
+                    "kinesisSchemaVersion": "1.0",
+                    "partitionKey": "partition-1",
+                    "sequenceNumber": "49590338271490256608559692538361571095921575989136588898",
+                    "data": encoded_data,
+                    "approximateArrivalTimestamp": 1704067200.0,
+                },
+                "eventSource": "aws:kinesis",
+                "eventVersion": "1.0",
+                "eventID": "shardId-000000000000:49590338271490256608559692538361571095921575989136588898",
+                "eventName": "aws:kinesis:record",
+                "invokeIdentityArn": "arn:aws:iam::123456789012:role/test-role",
+                "awsRegion": "us-east-1",
+                "eventSourceARN": "arn:aws:kinesis:us-east-1:123456789012:stream/test-stream",
+            }
+        ]
+    }
+
+
+def test_handler_processes_stream_batch(kinesis_event):
+    """Test handler processes Kinesis batch without error."""
+    context = MagicMock()
+    context.function_name = "test-function"
+    context.aws_request_id = "test-request-id"
+
+    with patch("src.handler.dynamodb"):
+        response = handler(kinesis_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"] == []