geek-cafe-saas-sdk 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

geek_cafe_saas_sdk/domains/subscriptions/handlers/discounts/create/app.py

@@ -0,0 +1,83 @@
+"""
+Lambda handler for creating discounts.
+
+Admin endpoint - requires authentication.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Create a new discount/promo code.
+    
+    Expected body:
+    {
+        "discountCode": "SUMMER25",
+        "discountName": "Summer Sale",
+        "discountType": "percentage",
+        "percentOff": 25.0,
+        "duration": "repeating",
+        "durationInMonths": 3,
+        "maxRedemptions": 100
+    }
+    
+    Returns 201 with created discount
+    """
+    return handler_wrapper.execute(event, context, create_discount, injected_service)
+
+
+def create_discount(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for creating a discount.
+    """
+    payload = event["parsed_body"]
+    
+    # Extract required fields
+    discount_code = payload.get("discount_code")
+    if not discount_code:
+        raise ValueError("discount_code is required")
+    
+    discount_name = payload.get("discount_name")
+    if not discount_name:
+        raise ValueError("discount_name is required")
+    
+    discount_type = payload.get("discount_type", "percentage")
+    
+    # Build kwargs for optional fields
+    kwargs = {}
+    optional_fields = [
+        "description", "amount_off_cents", "percent_off", "trial_extension_days",
+        "currency", "duration", "duration_in_months",
+        "valid_from_utc_ts", "valid_until_utc_ts",
+        "max_redemptions", "max_redemptions_per_customer",
+        "status", "minimum_amount_cents",
+        "applies_to_plan_codes", "applies_to_addon_codes", "applies_to_intervals",
+        "first_time_transaction", "campaign_name", "source", "notes"
+    ]
+    
+    for field in optional_fields:
+        if field in payload:
+            kwargs[field] = payload[field]
+    
+    result = service.create_discount(
+        discount_code=discount_code,
+        discount_name=discount_name,
+        discount_type=discount_type,
+        **kwargs
+    )
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/handlers/discounts/get/app.py

@@ -0,0 +1,47 @@
+"""
+Lambda handler for getting a discount.
+
+Admin endpoint - requires authentication.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_body=False,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Get a discount by ID.
+    
+    Path parameters:
+    - discountId: Discount ID
+    
+    Returns 200 with discount details
+    """
+    return handler_wrapper.execute(event, context, get_discount, injected_service)
+
+
+def get_discount(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for getting a discount.
+    """
+    path_params = event.get("pathParameters") or {}
+    discount_id = path_params.get("discount_id")
+    
+    if not discount_id:
+        raise ValueError("discount_id is required in path")
+    
+    result = service.get_discount(discount_id=discount_id)
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/handlers/discounts/validate/app.py

@@ -0,0 +1,62 @@
+"""
+Lambda handler for validating discount codes.
+
+Public endpoint - no authentication required.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_auth=False,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Validate a discount code.
+    
+    Expected body:
+    {
+        "discountCode": "SUMMER25",
+        "planCode": "pro",  // optional
+        "amountCents": 2999,  // optional
+        "isFirstPurchase": false  // optional
+    }
+    
+    Returns 200 with discount details if valid
+    """
+    return handler_wrapper.execute(event, context, validate_discount, injected_service)
+
+
+def validate_discount(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for validating a discount.
+    """
+    payload = event["parsed_body"]
+    
+    discount_code = payload.get("discount_code")
+    if not discount_code:
+        raise ValueError("discount_code is required")
+    
+    plan_code = payload.get("plan_code")
+    amount_cents = payload.get("amount_cents")
+    is_first_purchase = payload.get("is_first_purchase", False)
+    
+    result = service.validate_discount(
+        discount_code=discount_code,
+        plan_code=plan_code,
+        amount_cents=amount_cents,
+        is_first_purchase=is_first_purchase
+    )
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/handlers/plans/create/app.py

@@ -0,0 +1,82 @@
+"""
+Lambda handler for creating subscription plans.
+
+Admin endpoint - requires authentication.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Create a new subscription plan.
+    
+    Expected body:
+    {
+        "planCode": "pro",
+        "planName": "Pro Plan",
+        "priceMonthlyC ents": 2999,
+        "description": "For growing teams",
+        "features": {"api_access": true, "sso": false},
+        "limits": {"max_projects": 100, "max_storage_gb": 500}
+    }
+    
+    Returns 201 with created plan
+    """
+    return handler_wrapper.execute(event, context, create_plan, injected_service)
+
+
+def create_plan(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for creating a plan.
+    """
+    payload = event["parsed_body"]
+    
+    # Extract required fields
+    plan_code = payload.get("plan_code")
+    if not plan_code:
+        raise ValueError("plan_code is required")
+    
+    plan_name = payload.get("plan_name")
+    if not plan_name:
+        raise ValueError("plan_name is required")
+    
+    price_monthly_cents = payload.get("price_monthly_cents", 0)
+    
+    # Build kwargs for optional fields
+    kwargs = {}
+    optional_fields = [
+        "description", "tagline", "status", "is_public", "is_featured", "sort_order",
+        "price_annual_cents", "price_monthly_currency", "price_annual_currency",
+        "annual_discount_percentage", "trial_days", "trial_requires_payment_method",
+        "min_seats", "max_seats", "price_per_additional_seat_cents",
+        "features", "limits", "included_addon_ids", "compatible_addon_ids",
+        "feature_list", "cta_text", "recommended",
+        "allow_downgrades", "allow_upgrades"
+    ]
+    
+    for field in optional_fields:
+        if field in payload:
+            kwargs[field] = payload[field]
+    
+    result = service.create_plan(
+        plan_code=plan_code,
+        plan_name=plan_name,
+        price_monthly_cents=price_monthly_cents,
+        **kwargs
+    )
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/handlers/plans/get/app.py

@@ -0,0 +1,48 @@
+"""
+Lambda handler for getting a subscription plan.
+
+Public endpoint - no authentication required.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_auth=False,
+    require_body=False,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Get a subscription plan by ID.
+    
+    Path parameters:
+    - planId: Plan ID
+    
+    Returns 200 with plan details
+    """
+    return handler_wrapper.execute(event, context, get_plan, injected_service)
+
+
+def get_plan(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for getting a plan.
+    """
+    path_params = event.get("pathParameters") or {}
+    plan_id = path_params.get("plan_id")
+    
+    if not plan_id:
+        raise ValueError("plan_id is required in path")
+    
+    result = service.get_plan(plan_id=plan_id)
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/handlers/plans/list/app.py

@@ -0,0 +1,66 @@
+"""
+Lambda handler for listing subscription plans.
+
+Public endpoint - no authentication required for public plans.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+# Public endpoint - no auth required
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_auth=False,
+    require_body=False,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    List public subscription plans.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional SubscriptionManagerService for testing
+    
+    Query parameters:
+    - status: Filter by status (default: "active")
+    - isPublic: Filter by public visibility (default: true)
+    - limit: Max results (default: 50)
+    
+    Returns 200 with list of plans
+    """
+    return handler_wrapper.execute(event, context, list_plans, injected_service)
+
+
+def list_plans(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for listing plans.
+    """
+    params = event.get("queryStringParameters") or {}
+    
+    status = params.get("status", "active")
+    is_public = params.get("is_public")
+    limit = int(params.get("limit", "50"))
+    
+    # Convert string to bool if provided
+    if is_public is not None:
+        is_public = is_public.lower() in ["true", "1", "yes"]
+    else:
+        is_public = True  # Default to public plans only
+    
+    result = service.list_plans(
+        status=status,
+        is_public=is_public,
+        limit=limit
+    )
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/handlers/plans/update/app.py

@@ -0,0 +1,54 @@
+"""
+Lambda handler for updating subscription plans.
+
+Admin endpoint - requires authentication.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Update a subscription plan.
+    
+    Path parameters:
+    - planId: Plan ID
+    
+    Body contains fields to update
+    
+    Returns 200 with updated plan
+    """
+    return handler_wrapper.execute(event, context, update_plan, injected_service)
+
+
+def update_plan(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for updating a plan.
+    """
+    path_params = event.get("pathParameters") or {}
+    plan_id = path_params.get("plan_id")
+    
+    if not plan_id:
+        raise ValueError("plan_id is required in path")
+    
+    payload = event["parsed_body"]
+    
+    result = service.update_plan(
+        plan_id=plan_id,
+        updates=payload
+    )
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/handlers/usage/aggregate/app.py

@@ -0,0 +1,72 @@
+"""
+Lambda handler for aggregating usage.
+
+Requires authentication (secure mode).
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_body=False,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Get aggregated usage for a billing period.
+    
+    Query parameters:
+    - subscriptionId: Subscription ID (required)
+    - addonCode: Addon code (required)
+    - periodStart: Period start timestamp (required)
+    - periodEnd: Period end timestamp (required)
+    
+    Returns 200 with aggregated usage total
+    """
+    return handler_wrapper.execute(event, context, aggregate_usage, injected_service)
+
+
+def aggregate_usage(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for aggregating usage.
+    """
+    params = event.get("queryStringParameters") or {}
+    
+    tenant_id = user_context.get("tenant_id")
+    
+    subscription_id = params.get("subscription_id")
+    if not subscription_id:
+        raise ValueError("subscription_id is required")
+    
+    addon_code = params.get("addon_code")
+    if not addon_code:
+        raise ValueError("addon_code is required")
+    
+    period_start = params.get("period_start")
+    if not period_start:
+        raise ValueError("period_start is required")
+    period_start = float(period_start)
+    
+    period_end = params.get("period_end")
+    if not period_end:
+        raise ValueError("period_end is required")
+    period_end = float(period_end)
+    
+    result = service.aggregate_usage(
+        tenant_id=tenant_id,
+        subscription_id=subscription_id,
+        addon_code=addon_code,
+        period_start=period_start,
+        period_end=period_end
+    )
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/handlers/usage/record/app.py

@@ -0,0 +1,89 @@
+"""
+Lambda handler for recording usage events.
+
+Requires authentication (secure mode).
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.subscriptions.services import SubscriptionManagerService
+
+
+handler_wrapper = create_handler(
+    service_class=SubscriptionManagerService,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Record a usage event for metered billing.
+    
+    Expected body:
+    {
+        "subscriptionId": "sub-123",
+        "addonCode": "extra_storage",
+        "meterEventName": "storage_gb",
+        "quantity": 50.5,
+        "action": "increment",  // optional: increment, decrement, set
+        "idempotencyKey": "unique-key",  // optional
+        "metadata": {}  // optional
+    }
+    
+    Returns 201 with usage record
+    """
+    return handler_wrapper.execute(event, context, record_usage, injected_service)
+
+
+def record_usage(
+    event: Dict[str, Any],
+    service: SubscriptionManagerService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for recording usage.
+    """
+    payload = event["parsed_body"]
+    
+    tenant_id = user_context.get("tenant_id")
+    
+    # Extract required fields
+    subscription_id = payload.get("subscription_id")
+    if not subscription_id:
+        raise ValueError("subscription_id is required")
+    
+    addon_code = payload.get("addon_code")
+    if not addon_code:
+        raise ValueError("addon_code is required")
+    
+    meter_event_name = payload.get("meter_event_name")
+    if not meter_event_name:
+        raise ValueError("meter_event_name is required")
+    
+    quantity = payload.get("quantity")
+    if quantity is None:
+        raise ValueError("quantity is required")
+    
+    # Build kwargs for optional fields
+    kwargs = {}
+    optional_fields = [
+        "action", "unit_name", "idempotency_key",
+        "billing_period_start_utc_ts", "billing_period_end_utc_ts",
+        "metadata", "source", "description"
+    ]
+    
+    for field in optional_fields:
+        if field in payload:
+            kwargs[field] = payload[field]
+    
+    result = service.record_usage(
+        tenant_id=tenant_id,
+        subscription_id=subscription_id,
+        addon_code=addon_code,
+        meter_event_name=meter_event_name,
+        quantity=quantity,
+        **kwargs
+    )
+    
+    return result

geek_cafe_saas_sdk/domains/subscriptions/models/__init__.py

@@ -0,0 +1,13 @@
+"""
+Subscriptions Domain Models.
+
+Geek Cafe, LLC
+MIT License. See Project Root for the license information.
+"""
+
+from .plan import Plan
+from .addon import Addon
+from .usage_record import UsageRecord
+from .discount import Discount
+
+__all__ = ["Plan", "Addon", "UsageRecord", "Discount"]