svc-infra 0.1.589__py3-none-any.whl → 0.1.706__py3-none-any.whl

svc_infra/apf_payments/schemas.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
-from typing import Any, Literal, Optional
+from typing import Annotated, Any, Literal, Optional
 
-from pydantic import BaseModel, Field, conint, constr
+from pydantic import BaseModel, Field, StringConstraints
 
-Currency = constr(pattern=r"^[A-Z]{3}$")
-AmountMinor = conint(ge=0)  # minor units (cents)
+# Type aliases for payment fields using Annotated with proper type hints
+Currency = Annotated[str, StringConstraints(pattern=r"^[A-Z]{3}$")]
+AmountMinor = Annotated[int, Field(ge=0)]  # minor units (cents)
 
 
 class CustomerUpsertIn(BaseModel):
@@ -24,10 +25,12 @@ class CustomerOut(BaseModel):
 
 class IntentCreateIn(BaseModel):
     amount: AmountMinor = Field(..., description="Minor units (e.g., cents)")
-    currency: Currency = Field(..., example="USD")
+    currency: Currency = Field(..., json_schema_extra={"example": "USD"})
     description: Optional[str] = None
     capture_method: Literal["automatic", "manual"] = "automatic"
-    payment_method_types: list[str] = Field(default_factory=list)  # let provider default
+    payment_method_types: list[str] = Field(
+        default_factory=list
+    )  # let provider default
 
 
 class NextAction(BaseModel):
@@ -133,14 +136,18 @@ class SubscriptionCreateIn(BaseModel):
     price_provider_id: str
     quantity: int = 1
     trial_days: Optional[int] = None
-    proration_behavior: Literal["create_prorations", "none", "always_invoice"] = "create_prorations"
+    proration_behavior: Literal["create_prorations", "none", "always_invoice"] = (
+        "create_prorations"
+    )
 
 
 class SubscriptionUpdateIn(BaseModel):
     price_provider_id: Optional[str] = None
     quantity: Optional[int] = None
     cancel_at_period_end: Optional[bool] = None
-    proration_behavior: Literal["create_prorations", "none", "always_invoice"] = "create_prorations"
+    proration_behavior: Literal["create_prorations", "none", "always_invoice"] = (
+        "create_prorations"
+    )
 
 
 class SubscriptionOut(BaseModel):
@@ -187,7 +194,7 @@ class UsageRecordIn(BaseModel):
     # If provider doesn't use subscription_item, allow provider_price_id as fallback.
     subscription_item: Optional[str] = None
     provider_price_id: Optional[str] = None
-    quantity: conint(ge=0)
+    quantity: Annotated[int, Field(ge=0)]
     timestamp: Optional[int] = None  # Unix seconds; provider defaults to "now"
     action: Optional[Literal["increment", "set"]] = "increment"
 
@@ -198,7 +205,9 @@ class InvoiceLineItemIn(BaseModel):
     unit_amount: AmountMinor
     currency: Currency
     quantity: Optional[int] = 1
-    provider_price_id: Optional[str] = None  # if linked to a price, unit_amount may be ignored
+    provider_price_id: Optional[str] = (
+        None  # if linked to a price, unit_amount may be ignored
+    )
 
 
 class InvoicesListFilter(BaseModel):

svc_infra/apf_payments/service.py

@@ -19,6 +19,7 @@ from .models import (
     PaySetupIntent,
     PaySubscription,
 )
+from .provider.base import ProviderAdapter
 from .provider.registry import get_provider_registry
 from .schemas import (
     BalanceSnapshotOut,
@@ -65,15 +66,30 @@ def _default_provider_name() -> str:
 
 
 class PaymentsService:
+    """Payments service facade wrapping provider adapters and persisting key rows.
 
-    def __init__(self, session: AsyncSession, provider_name: Optional[str] = None):
+    NOTE: tenant_id is now required for all persistence operations. This is a breaking
+    change; callers must supply a valid tenant scope. (Future: could allow multi-tenant
+    mapping via adapter registry.)
+    """
+
+    def __init__(
+        self,
+        session: AsyncSession,
+        *,
+        tenant_id: str,
+        provider_name: Optional[str] = None,
+    ):
+        if not tenant_id:
+            raise ValueError("tenant_id is required for PaymentsService")
         self.session = session
+        self.tenant_id = tenant_id
         self._provider_name = (provider_name or _default_provider_name()).lower()
-        self._adapter = None  # resolved on first use
+        self._adapter: ProviderAdapter | None = None  # resolved on first use
 
     # --- internal helpers -----------------------------------------------------
 
-    def _get_adapter(self):
+    def _get_adapter(self) -> ProviderAdapter:
         if self._adapter is not None:
             return self._adapter
         reg = get_provider_registry()
@@ -118,6 +134,7 @@ class PaymentsService:
             # If your PayCustomer model has additional columns (email/name), include them here.
             self.session.add(
                 PayCustomer(
+                    tenant_id=self.tenant_id,
                     provider=out.provider,
                     provider_customer_id=out.provider_customer_id,
                     user_id=data.user_id,
@@ -127,11 +144,14 @@ class PaymentsService:
 
     # --- Intents --------------------------------------------------------------
 
-    async def create_intent(self, user_id: Optional[str], data: IntentCreateIn) -> IntentOut:
+    async def create_intent(
+        self, user_id: Optional[str], data: IntentCreateIn
+    ) -> IntentOut:
         adapter = self._get_adapter()
         out = await adapter.create_intent(data, user_id=user_id)
         self.session.add(
             PayIntent(
+                tenant_id=self.tenant_id,
                 provider=out.provider,
                 provider_intent_id=out.provider_intent_id,
                 user_id=user_id,
@@ -167,15 +187,44 @@ class PaymentsService:
     async def refund(self, provider_intent_id: str, data: RefundIn) -> IntentOut:
         adapter = self._get_adapter()
         out = await adapter.refund(provider_intent_id, data)
+        # Create ledger entry if amount present and not already recorded
+        pi = await self.session.scalar(
+            select(PayIntent).where(PayIntent.provider_intent_id == provider_intent_id)
+        )
+        if pi:
+            amount = int(data.amount) if data.amount is not None else out.amount
+            # Guard against duplicates (same provider_ref + kind)
+            existing = await self.session.scalar(
+                select(LedgerEntry).where(
+                    LedgerEntry.provider_ref == provider_intent_id,
+                    LedgerEntry.kind == "refund",
+                )
+            )
+            if amount > 0 and not existing:
+                self.session.add(
+                    LedgerEntry(
+                        tenant_id=self.tenant_id,
+                        provider=pi.provider,
+                        provider_ref=provider_intent_id,
+                        user_id=pi.user_id,
+                        amount=+amount,
+                        currency=out.currency,
+                        kind="refund",
+                        status="posted",
+                    )
+                )
         return out
 
     # --- Webhooks -------------------------------------------------------------
 
-    async def handle_webhook(self, provider: str, signature: str | None, payload: bytes) -> dict:
+    async def handle_webhook(
+        self, provider: str, signature: str | None, payload: bytes
+    ) -> dict:
         adapter = self._get_adapter()
         parsed = await adapter.verify_and_parse_webhook(signature, payload)
         self.session.add(
             PayEvent(
+                tenant_id=self.tenant_id,
                 provider=provider,
                 provider_event_id=parsed["id"],
                 type=parsed.get("type", ""),
@@ -199,6 +248,7 @@ class PaymentsService:
             intent.status = "succeeded"
             self.session.add(
                 LedgerEntry(
+                    tenant_id=self.tenant_id,
                     provider=intent.provider,
                     provider_ref=provider_intent_id,
                     user_id=intent.user_id,
@@ -217,17 +267,27 @@ class PaymentsService:
             select(PayIntent).where(PayIntent.provider_intent_id == pi_id)
         )
         if intent:
-            self.session.add(
-                LedgerEntry(
-                    provider=intent.provider,
-                    provider_ref=charge_obj.get("id"),
-                    user_id=intent.user_id,
-                    amount=+amount,
-                    currency=currency,
-                    kind="capture",
-                    status="posted",
+            # Avoid duplicate capture entries
+            existing = await self.session.scalar(
+                select(LedgerEntry).where(
+                    LedgerEntry.provider_ref == charge_obj.get("id"),
+                    LedgerEntry.kind == "capture",
                 )
             )
+            if not existing:
+                self.session.add(
+                    LedgerEntry(
+                        tenant_id=self.tenant_id,
+                        provider=intent.provider,
+                        provider_ref=charge_obj.get("id"),
+                        user_id=intent.user_id,
+                        amount=+amount,
+                        currency=currency,
+                        kind="capture",
+                        status="posted",
+                    )
+                )
+            intent.captured = True
 
     async def _post_refund(self, charge_obj: dict):
         amount = int(charge_obj.get("amount_refunded") or 0)
@@ -237,22 +297,33 @@ class PaymentsService:
             select(PayIntent).where(PayIntent.provider_intent_id == pi_id)
         )
         if intent and amount > 0:
-            self.session.add(
-                LedgerEntry(
-                    provider=intent.provider,
-                    provider_ref=charge_obj.get("id"),
-                    user_id=intent.user_id,
-                    amount=+amount,
-                    currency=currency,
-                    kind="refund",
-                    status="posted",
+            existing = await self.session.scalar(
+                select(LedgerEntry).where(
+                    LedgerEntry.provider_ref == charge_obj.get("id"),
+                    LedgerEntry.kind == "refund",
                 )
             )
+            if not existing:
+                self.session.add(
+                    LedgerEntry(
+                        tenant_id=self.tenant_id,
+                        provider=intent.provider,
+                        provider_ref=charge_obj.get("id"),
+                        user_id=intent.user_id,
+                        amount=+amount,
+                        currency=currency,
+                        kind="refund",
+                        status="posted",
+                    )
+                )
 
-    async def attach_payment_method(self, data: PaymentMethodAttachIn) -> PaymentMethodOut:
+    async def attach_payment_method(
+        self, data: PaymentMethodAttachIn
+    ) -> PaymentMethodOut:
         out = await self._get_adapter().attach_payment_method(data)
         # Upsert locally for quick listing
         pm = PayPaymentMethod(
+            tenant_id=self.tenant_id,
             provider=out.provider,
             provider_customer_id=out.provider_customer_id,
             provider_method_id=out.provider_method_id,
@@ -265,7 +336,9 @@ class PaymentsService:
         self.session.add(pm)
         return out
 
-    async def list_payment_methods(self, provider_customer_id: str) -> list[PaymentMethodOut]:
+    async def list_payment_methods(
+        self, provider_customer_id: str
+    ) -> list[PaymentMethodOut]:
         return await self._get_adapter().list_payment_methods(provider_customer_id)
 
     async def detach_payment_method(self, provider_method_id: str) -> PaymentMethodOut:
@@ -283,6 +356,7 @@ class PaymentsService:
         out = await self._get_adapter().create_product(data)
         self.session.add(
             PayProduct(
+                tenant_id=self.tenant_id,
                 provider=out.provider,
                 provider_product_id=out.provider_product_id,
                 name=out.name,
@@ -295,6 +369,7 @@ class PaymentsService:
         out = await self._get_adapter().create_price(data)
         self.session.add(
             PayPrice(
+                tenant_id=self.tenant_id,
                 provider=out.provider,
                 provider_price_id=out.provider_price_id,
                 provider_product_id=out.provider_product_id,
@@ -312,6 +387,7 @@ class PaymentsService:
         out = await self._get_adapter().create_subscription(data)
         self.session.add(
             PaySubscription(
+                tenant_id=self.tenant_id,
                 provider=out.provider,
                 provider_subscription_id=out.provider_subscription_id,
                 provider_price_id=out.provider_price_id,
@@ -325,14 +401,18 @@ class PaymentsService:
     async def update_subscription(
         self, provider_subscription_id: str, data: SubscriptionUpdateIn
     ) -> SubscriptionOut:
-        out = await self._get_adapter().update_subscription(provider_subscription_id, data)
+        out = await self._get_adapter().update_subscription(
+            provider_subscription_id, data
+        )
         # Optionally reflect status/quantity locally (query + update if exists)
         return out
 
     async def cancel_subscription(
         self, provider_subscription_id: str, at_period_end: bool = True
     ) -> SubscriptionOut:
-        out = await self._get_adapter().cancel_subscription(provider_subscription_id, at_period_end)
+        out = await self._get_adapter().cancel_subscription(
+            provider_subscription_id, at_period_end
+        )
         return out
 
     # --- Invoices ---
@@ -340,6 +420,7 @@ class PaymentsService:
         out = await self._get_adapter().create_invoice(data)
         self.session.add(
             PayInvoice(
+                tenant_id=self.tenant_id,
                 provider=out.provider,
                 provider_invoice_id=out.provider_invoice_id,
                 provider_customer_id=out.provider_customer_id,
@@ -376,15 +457,15 @@ class PaymentsService:
         q = select(
             func.date_trunc("day", LedgerEntry.ts).label("day"),
             LedgerEntry.currency,
-            func.sum(func.case((LedgerEntry.kind == "payment", LedgerEntry.amount), else_=0)).label(
-                "gross"
-            ),
-            func.sum(func.case((LedgerEntry.kind == "refund", LedgerEntry.amount), else_=0)).label(
-                "refunds"
-            ),
-            func.sum(func.case((LedgerEntry.kind == "fee", LedgerEntry.amount), else_=0)).label(
-                "fees"
-            ),
+            func.sum(
+                func.case((LedgerEntry.kind == "payment", LedgerEntry.amount), else_=0)
+            ).label("gross"),
+            func.sum(
+                func.case((LedgerEntry.kind == "refund", LedgerEntry.amount), else_=0)
+            ).label("refunds"),
+            func.sum(
+                func.case((LedgerEntry.kind == "fee", LedgerEntry.amount), else_=0)
+            ).label("fees"),
             func.count().label("count"),
         )
         if date_from:
@@ -397,9 +478,9 @@ class PaymentsService:
                 q = q.where(LedgerEntry.ts <= datetime.fromisoformat(date_to))
             except Exception:
                 pass
-        q = q.group_by(func.date_trunc("day", LedgerEntry.ts), LedgerEntry.currency).order_by(
-            func.date_trunc("day", LedgerEntry.ts).desc()
-        )
+        q = q.group_by(
+            func.date_trunc("day", LedgerEntry.ts), LedgerEntry.currency
+        ).order_by(func.date_trunc("day", LedgerEntry.ts).desc())
 
         rows = (await self.session.execute(q)).all()
         out: list[StatementRow] = []
@@ -421,9 +502,12 @@ class PaymentsService:
             )
         return out
 
-    async def capture_intent(self, provider_intent_id: str, data: CaptureIn) -> IntentOut:
+    async def capture_intent(
+        self, provider_intent_id: str, data: CaptureIn
+    ) -> IntentOut:
         out = await self._get_adapter().capture_intent(
-            provider_intent_id, amount=int(data.amount) if data.amount is not None else None
+            provider_intent_id,
+            amount=int(data.amount) if data.amount is not None else None,
         )
         pi = await self.session.scalar(
             select(PayIntent).where(PayIntent.provider_intent_id == provider_intent_id)
@@ -432,9 +516,32 @@ class PaymentsService:
             pi.status = out.status
             if out.status in ("succeeded", "requires_capture"):  # Stripe specifics vary
                 pi.captured = True if out.status == "succeeded" else pi.captured
+                # Add capture ledger entry if succeeded and not already posted
+                if out.status == "succeeded":
+                    existing = await self.session.scalar(
+                        select(LedgerEntry).where(
+                            LedgerEntry.provider_ref == provider_intent_id,
+                            LedgerEntry.kind == "capture",
+                        )
+                    )
+                    if not existing:
+                        self.session.add(
+                            LedgerEntry(
+                                tenant_id=self.tenant_id,
+                                provider=pi.provider,
+                                provider_ref=provider_intent_id,
+                                user_id=pi.user_id,
+                                amount=+out.amount,
+                                currency=out.currency,
+                                kind="capture",
+                                status="posted",
+                            )
+                        )
         return out
 
-    async def list_intents(self, f: IntentListFilter) -> tuple[list[IntentOut], str | None]:
+    async def list_intents(
+        self, f: IntentListFilter
+    ) -> tuple[list[IntentOut], str | None]:
         return await self._get_adapter().list_intents(
             customer_provider_id=f.customer_provider_id,
             status=f.status,
@@ -446,9 +553,13 @@ class PaymentsService:
     async def add_invoice_line_item(
         self, provider_invoice_id: str, data: InvoiceLineItemIn
     ) -> InvoiceOut:
-        return await self._get_adapter().add_invoice_line_item(provider_invoice_id, data)
+        return await self._get_adapter().add_invoice_line_item(
+            provider_invoice_id, data
+        )
 
-    async def list_invoices(self, f: InvoicesListFilter) -> tuple[list[InvoiceOut], str | None]:
+    async def list_invoices(
+        self, f: InvoicesListFilter
+    ) -> tuple[list[InvoiceOut], str | None]:
         return await self._get_adapter().list_invoices(
             customer_provider_id=f.customer_provider_id,
             status=f.status,
@@ -475,6 +586,7 @@ class PaymentsService:
         out = await self._get_adapter().create_setup_intent(data)
         self.session.add(
             PaySetupIntent(
+                tenant_id=self.tenant_id,
                 provider=out.provider,
                 provider_setup_intent_id=out.provider_setup_intent_id,
                 user_id=None,
@@ -484,7 +596,9 @@ class PaymentsService:
         )
         return out
 
-    async def confirm_setup_intent(self, provider_setup_intent_id: str) -> SetupIntentOut:
+    async def confirm_setup_intent(
+        self, provider_setup_intent_id: str
+    ) -> SetupIntentOut:
         out = await self._get_adapter().confirm_setup_intent(provider_setup_intent_id)
         row = await self.session.scalar(
             select(PaySetupIntent).where(
@@ -510,6 +624,7 @@ class PaymentsService:
         else:
             self.session.add(
                 PaySetupIntent(
+                    tenant_id=self.tenant_id,
                     provider=out.provider,
                     provider_setup_intent_id=out.provider_setup_intent_id,
                     user_id=None,
@@ -534,13 +649,17 @@ class PaymentsService:
     async def list_disputes(
         self, *, status: Optional[str], limit: int, cursor: Optional[str]
     ) -> tuple[list[DisputeOut], Optional[str]]:
-        return await self._get_adapter().list_disputes(status=status, limit=limit, cursor=cursor)
+        return await self._get_adapter().list_disputes(
+            status=status, limit=limit, cursor=cursor
+        )
 
     async def get_dispute(self, provider_dispute_id: str) -> DisputeOut:
         out = await self._get_adapter().get_dispute(provider_dispute_id)
         # Upsert locally
         row = await self.session.scalar(
-            select(PayDispute).where(PayDispute.provider_dispute_id == provider_dispute_id)
+            select(PayDispute).where(
+                PayDispute.provider_dispute_id == provider_dispute_id
+            )
         )
         if row:
             row.status = out.status
@@ -549,6 +668,7 @@ class PaymentsService:
         else:
             self.session.add(
                 PayDispute(
+                    tenant_id=self.tenant_id,
                     provider=out.provider,
                     provider_dispute_id=out.provider_dispute_id,
                     provider_charge_id=None,  # set if adapter returns it
@@ -560,11 +680,17 @@ class PaymentsService:
             )
         return out
 
-    async def submit_dispute_evidence(self, provider_dispute_id: str, evidence: dict) -> DisputeOut:
-        out = await self._get_adapter().submit_dispute_evidence(provider_dispute_id, evidence)
+    async def submit_dispute_evidence(
+        self, provider_dispute_id: str, evidence: dict
+    ) -> DisputeOut:
+        out = await self._get_adapter().submit_dispute_evidence(
+            provider_dispute_id, evidence
+        )
         # reflect status
         row = await self.session.scalar(
-            select(PayDispute).where(PayDispute.provider_dispute_id == provider_dispute_id)
+            select(PayDispute).where(
+                PayDispute.provider_dispute_id == provider_dispute_id
+            )
         )
         if row:
             row.status = out.status
@@ -594,6 +720,7 @@ class PaymentsService:
         else:
             self.session.add(
                 PayPayout(
+                    tenant_id=self.tenant_id,
                     provider=out.provider,
                     provider_payout_id=out.provider_payout_id,
                     amount=out.amount,
@@ -633,11 +760,16 @@ class PaymentsService:
         return len(rows)
 
     # ---- Customers ----
-    async def list_customers(self, f: CustomersListFilter) -> tuple[list[CustomerOut], str | None]:
+    async def list_customers(
+        self, f: CustomersListFilter
+    ) -> tuple[list[CustomerOut], str | None]:
         adapter = self._get_adapter()
         try:
             return await adapter.list_customers(
-                provider=f.provider, user_id=f.user_id, limit=f.limit or 50, cursor=f.cursor
+                provider=f.provider,
+                user_id=f.user_id,
+                limit=f.limit or 50,
+                cursor=f.cursor,
             )
         except NotImplementedError:
             # Fallback to local DB listing
@@ -673,15 +805,17 @@ class PaymentsService:
             raise RuntimeError("Customer not found")
         # upsert locally
         row = await self.session.scalar(
-            select(PayCustomer).where(PayCustomer.provider_customer_id == provider_customer_id)
+            select(PayCustomer).where(
+                PayCustomer.provider_customer_id == provider_customer_id
+            )
         )
         if not row:
             self.session.add(
                 PayCustomer(
+                    tenant_id=self.tenant_id,
                     provider=out.provider,
                     provider_customer_id=out.provider_customer_id,
                     user_id=None,
-                    tenant_id="",
                 )
             )
         return out
@@ -693,13 +827,19 @@ class PaymentsService:
     async def list_products(
         self, *, active: bool | None, limit: int, cursor: str | None
     ) -> tuple[list[ProductOut], str | None]:
-        return await self._get_adapter().list_products(active=active, limit=limit, cursor=cursor)
+        return await self._get_adapter().list_products(
+            active=active, limit=limit, cursor=cursor
+        )
 
-    async def update_product(self, provider_product_id: str, data: ProductUpdateIn) -> ProductOut:
+    async def update_product(
+        self, provider_product_id: str, data: ProductUpdateIn
+    ) -> ProductOut:
         out = await self._get_adapter().update_product(provider_product_id, data)
         # reflect DB
         row = await self.session.scalar(
-            select(PayProduct).where(PayProduct.provider_product_id == provider_product_id)
+            select(PayProduct).where(
+                PayProduct.provider_product_id == provider_product_id
+            )
         )
         if row:
             if data.name is not None:
@@ -720,10 +860,15 @@ class PaymentsService:
         cursor: str | None,
     ) -> tuple[list[PriceOut], str | None]:
         return await self._get_adapter().list_prices(
-            provider_product_id=provider_product_id, active=active, limit=limit, cursor=cursor
+            provider_product_id=provider_product_id,
+            active=active,
+            limit=limit,
+            cursor=cursor,
         )
 
-    async def update_price(self, provider_price_id: str, data: PriceUpdateIn) -> PriceOut:
+    async def update_price(
+        self, provider_price_id: str, data: PriceUpdateIn
+    ) -> PriceOut:
         out = await self._get_adapter().update_price(provider_price_id, data)
         row = await self.session.scalar(
             select(PayPrice).where(PayPrice.provider_price_id == provider_price_id)
@@ -745,7 +890,10 @@ class PaymentsService:
         cursor: str | None,
     ) -> tuple[list[SubscriptionOut], str | None]:
         return await self._get_adapter().list_subscriptions(
-            customer_provider_id=customer_provider_id, status=status, limit=limit, cursor=cursor
+            customer_provider_id=customer_provider_id,
+            status=status,
+            limit=limit,
+            cursor=cursor,
         )
 
     # ---- Payment Methods (get/update) ----
@@ -775,7 +923,9 @@ class PaymentsService:
         self, *, provider_payment_intent_id: str | None, limit: int, cursor: str | None
     ) -> tuple[list[RefundOut], str | None]:
         return await self._get_adapter().list_refunds(
-            provider_payment_intent_id=provider_payment_intent_id, limit=limit, cursor=cursor
+            provider_payment_intent_id=provider_payment_intent_id,
+            limit=limit,
+            cursor=cursor,
         )
 
     async def get_refund(self, provider_refund_id: str) -> RefundOut:
@@ -797,10 +947,3 @@ class PaymentsService:
 
     async def get_usage_record(self, usage_record_id: str) -> UsageRecordOut:
         return await self._get_adapter().get_usage_record(usage_record_id)
-
-    async def delete_invoice_line_item(
-        self, provider_invoice_id: str, provider_line_item_id: str
-    ) -> InvoiceOut:
-        return await self._get_adapter().delete_invoice_line_item(
-            provider_invoice_id, provider_line_item_id
-        )

svc_infra/apf_payments/settings.py

@@ -7,7 +7,18 @@ from pydantic import BaseModel, SecretStr
 
 STRIPE_KEY = os.getenv("STRIPE_SECRET") or os.getenv("STRIPE_API_KEY")
 STRIPE_WH = os.getenv("STRIPE_WH_SECRET")
-PROVIDER = (os.getenv("APF_PAYMENTS_PROVIDER") or os.getenv("PAYMENTS_PROVIDER", "stripe")).lower()
+PROVIDER = (
+    os.getenv("APF_PAYMENTS_PROVIDER")
+    or os.getenv("PAYMENTS_PROVIDER", "stripe")
+    or "stripe"
+).lower()
+
+AIYDAN_KEY = os.getenv("AIYDAN_API_KEY")
+AIYDAN_CLIENT_KEY = os.getenv("AIYDAN_CLIENT_KEY")
+AIYDAN_MERCHANT = os.getenv("AIYDAN_MERCHANT_ACCOUNT")
+AIYDAN_HMAC = os.getenv("AIYDAN_HMAC_KEY")
+AIYDAN_BASE_URL = os.getenv("AIYDAN_BASE_URL")
+AIYDAN_WH = os.getenv("AIYDAN_WH_SECRET")
 
 
 class StripeConfig(BaseModel):
@@ -15,11 +26,13 @@ class StripeConfig(BaseModel):
     webhook_secret: Optional[SecretStr] = None
 
 
-class AdyenConfig(BaseModel):
+class AiydanConfig(BaseModel):
     api_key: SecretStr
     client_key: Optional[SecretStr] = None
     merchant_account: Optional[str] = None
     hmac_key: Optional[SecretStr] = None
+    base_url: Optional[str] = None
+    webhook_secret: Optional[SecretStr] = None
 
 
 class PaymentsSettings(BaseModel):
@@ -34,7 +47,18 @@ class PaymentsSettings(BaseModel):
         if STRIPE_KEY
         else None
     )
-    adyen: Optional[AdyenConfig] = None
+    aiydan: Optional[AiydanConfig] = (
+        AiydanConfig(
+            api_key=SecretStr(AIYDAN_KEY),
+            client_key=SecretStr(AIYDAN_CLIENT_KEY) if AIYDAN_CLIENT_KEY else None,
+            merchant_account=AIYDAN_MERCHANT,
+            hmac_key=SecretStr(AIYDAN_HMAC) if AIYDAN_HMAC else None,
+            base_url=AIYDAN_BASE_URL,
+            webhook_secret=SecretStr(AIYDAN_WH) if AIYDAN_WH else None,
+        )
+        if AIYDAN_KEY
+        else None
+    )
 
 
 _SETTINGS: Optional[PaymentsSettings] = None