svc-infra 0.1.578__py3-none-any.whl → 0.1.580__py3-none-any.whl

svc_infra/apf_payments/provider/base.py

@@ -11,21 +11,28 @@ from ..schemas import (
     IntentOut,
     InvoiceCreateIn,
     InvoiceLineItemIn,
+    InvoiceLineItemOut,
     InvoiceOut,
     PaymentMethodAttachIn,
     PaymentMethodOut,
+    PaymentMethodUpdateIn,
     PayoutOut,
     PriceCreateIn,
     PriceOut,
+    PriceUpdateIn,
     ProductCreateIn,
     ProductOut,
+    ProductUpdateIn,
     RefundIn,
+    RefundOut,
     SetupIntentCreateIn,
     SetupIntentOut,
     SubscriptionCreateIn,
     SubscriptionOut,
     SubscriptionUpdateIn,
     UsageRecordIn,
+    UsageRecordListFilter,
+    UsageRecordOut,
 )
 
 
@@ -35,9 +42,6 @@ class ProviderAdapter(Protocol):
     async def ensure_customer(self, data: CustomerUpsertIn) -> CustomerOut:
         pass
 
-    async def get_customer(self, provider_customer_id: str) -> Optional[CustomerOut]:
-        pass
-
     async def attach_payment_method(self, data: PaymentMethodAttachIn) -> PaymentMethodOut:
         pass
 
@@ -139,7 +143,7 @@ class ProviderAdapter(Protocol):
     ) -> InvoiceOut:
         pass
 
-    async def create_usage_record(self, data: UsageRecordIn) -> dict[str, Any]:
+    async def create_usage_record(self, data: UsageRecordIn) -> UsageRecordOut:
         pass
 
     # --- Setup Intents ---
@@ -179,3 +183,88 @@ class ProviderAdapter(Protocol):
 
     async def get_payout(self, provider_payout_id: str) -> PayoutOut:
         pass
+
+    # --- Customers ---
+    async def list_customers(
+        self, *, provider: str | None, user_id: str | None, limit: int, cursor: str | None
+    ) -> tuple[list[CustomerOut], str | None]:
+        """Optional: if not implemented, the service will list from local DB."""
+        pass
+
+    async def get_customer(self, provider_customer_id: str) -> Optional[CustomerOut]:
+        pass
+
+    # --- Products / Prices ---
+    async def get_product(self, provider_product_id: str) -> ProductOut:
+        pass
+
+    async def list_products(
+        self, *, active: bool | None, limit: int, cursor: str | None
+    ) -> tuple[list[ProductOut], str | None]:
+        pass
+
+    async def update_product(self, provider_product_id: str, data: ProductUpdateIn) -> ProductOut:
+        pass
+
+    async def get_price(self, provider_price_id: str) -> PriceOut:
+        pass
+
+    async def list_prices(
+        self,
+        *,
+        provider_product_id: str | None,
+        active: bool | None,
+        limit: int,
+        cursor: str | None,
+    ) -> tuple[list[PriceOut], str | None]:
+        pass
+
+    async def update_price(self, provider_price_id: str, data: PriceUpdateIn) -> PriceOut:
+        pass
+
+    # --- Subscriptions ---
+    async def get_subscription(self, provider_subscription_id: str) -> SubscriptionOut:
+        pass
+
+    async def list_subscriptions(
+        self,
+        *,
+        customer_provider_id: str | None,
+        status: str | None,
+        limit: int,
+        cursor: str | None,
+    ) -> tuple[list[SubscriptionOut], str | None]:
+        pass
+
+    # --- Payment Method (single + update) ---
+    async def get_payment_method(self, provider_method_id: str) -> PaymentMethodOut:
+        pass
+
+    async def update_payment_method(
+        self, provider_method_id: str, data: PaymentMethodUpdateIn
+    ) -> PaymentMethodOut:
+        pass
+
+    # --- Refunds list/get ---
+    async def list_refunds(
+        self, *, provider_payment_intent_id: str | None, limit: int, cursor: str | None
+    ) -> tuple[list[RefundOut], str | None]:
+        pass
+
+    async def get_refund(self, provider_refund_id: str) -> RefundOut:
+        pass
+
+    # --- Invoice line items list ---
+    async def list_invoice_line_items(
+        self, provider_invoice_id: str, *, limit: int, cursor: str | None
+    ) -> tuple[list[InvoiceLineItemOut], str | None]:
+        pass
+
+    # --- Usage records list/get ---
+    async def list_usage_records(
+        self, f: UsageRecordListFilter
+    ) -> tuple[list[UsageRecordOut], str | None]:
+        pass
+
+    async def get_usage_record(self, usage_record_id: str) -> UsageRecordOut:
+        pass

svc_infra/apf_payments/schemas.py

@@ -256,3 +256,73 @@ class SetupIntentCreateIn(BaseModel):
 
 class WebhookReplayOut(BaseModel):
     replayed: int
+
+
+class WebhookAckOut(BaseModel):
+    ok: bool
+
+
+class UsageRecordOut(BaseModel):
+    id: str
+    quantity: int
+    timestamp: Optional[int] = None
+    subscription_item: Optional[str] = None
+    provider_price_id: Optional[str] = None
+
+
+# -------- Customers list filter ----------
+class CustomersListFilter(BaseModel):
+    provider: Optional[str] = None
+    user_id: Optional[str] = None
+    limit: Optional[int] = Field(default=50, ge=1, le=200)
+    cursor: Optional[str] = None  # we’ll paginate on provider_customer_id asc
+
+
+# -------- Products / Prices updates ----------
+class ProductUpdateIn(BaseModel):
+    name: Optional[str] = None
+    active: Optional[bool] = None
+
+
+class PriceUpdateIn(BaseModel):
+    active: Optional[bool] = None
+
+
+# -------- Payment Method update ----------
+class PaymentMethodUpdateIn(BaseModel):
+    # keep minimal + commonly supported card fields
+    name: Optional[str] = None
+    exp_month: Optional[int] = None
+    exp_year: Optional[int] = None
+    # extend here later with address fields (line1, city, etc.)
+
+
+# -------- Refunds (list/get) ----------
+class RefundOut(BaseModel):
+    id: str
+    provider: str
+    provider_refund_id: str
+    provider_payment_intent_id: Optional[str] = None
+    amount: AmountMinor
+    currency: Currency
+    status: str
+    reason: Optional[str] = None
+    created_at: Optional[str] = None
+
+
+# -------- Invoice line items (list) ----------
+class InvoiceLineItemOut(BaseModel):
+    id: str
+    description: Optional[str] = None
+    amount: AmountMinor
+    currency: Currency
+    quantity: Optional[int] = 1
+    provider_price_id: Optional[str] = None
+
+
+# -------- Usage records list/get ----------
+class UsageRecordListFilter(BaseModel):
+    subscription_item: Optional[str] = None
+    provider_price_id: Optional[str] = None
+    limit: Optional[int] = Field(default=50, ge=1, le=200)
+    cursor: Optional[str] = None

svc_infra/apf_payments/service.py

@@ -24,6 +24,7 @@ from .schemas import (
     BalanceSnapshotOut,
     CaptureIn,
     CustomerOut,
+    CustomersListFilter,
     CustomerUpsertIn,
     DisputeOut,
     IntentCreateIn,
@@ -31,16 +32,21 @@ from .schemas import (
     IntentOut,
     InvoiceCreateIn,
     InvoiceLineItemIn,
+    InvoiceLineItemOut,
     InvoiceOut,
     InvoicesListFilter,
     PaymentMethodAttachIn,
     PaymentMethodOut,
+    PaymentMethodUpdateIn,
     PayoutOut,
     PriceCreateIn,
     PriceOut,
+    PriceUpdateIn,
     ProductCreateIn,
     ProductOut,
+    ProductUpdateIn,
     RefundIn,
+    RefundOut,
     SetupIntentCreateIn,
     SetupIntentOut,
     StatementRow,
@@ -48,6 +54,8 @@ from .schemas import (
     SubscriptionOut,
     SubscriptionUpdateIn,
     UsageRecordIn,
+    UsageRecordListFilter,
+    UsageRecordOut,
 )
 from .settings import get_payments_settings
 
@@ -459,7 +467,7 @@ class PaymentsService:
         )
 
     # ---- Metered usage ----
-    async def create_usage_record(self, data: UsageRecordIn) -> dict:
+    async def create_usage_record(self, data: UsageRecordIn) -> UsageRecordOut:
         return await self._get_adapter().create_usage_record(data)
 
     # --- Setup Intents --------------------------------------------------------
@@ -623,3 +631,176 @@ class PaymentsService:
             await self._dispatch_event(ev.provider, ev.payload_json)
 
         return len(rows)
+
+    # ---- Customers ----
+    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
+            )
+        except NotImplementedError:
+            # Fallback to local DB listing
+            q = select(PayCustomer).order_by(PayCustomer.provider_customer_id.asc())
+            if f.provider:
+                q = q.where(PayCustomer.provider == f.provider)
+            if f.user_id:
+                q = q.where(PayCustomer.user_id == f.user_id)
+            rows = (await self.session.execute(q)).scalars().all()
+            # simple cursor by provider_customer_id; production can optimize
+            next_cursor = None
+            if f.limit and len(rows) > f.limit:
+                rows = rows[: f.limit]
+                next_cursor = rows[-1].provider_customer_id
+            return (
+                [
+                    CustomerOut(
+                        id=r.id,
+                        provider=r.provider,
+                        provider_customer_id=r.provider_customer_id,
+                        email=None,
+                        name=None,
+                    )
+                    for r in rows
+                ],
+                next_cursor,
+            )
+
+    async def get_customer(self, provider_customer_id: str) -> CustomerOut:
+        adapter = self._get_adapter()
+        out = await adapter.get_customer(provider_customer_id)
+        if out is None:
+            raise RuntimeError("Customer not found")
+        # upsert locally
+        row = await self.session.scalar(
+            select(PayCustomer).where(PayCustomer.provider_customer_id == provider_customer_id)
+        )
+        if not row:
+            self.session.add(
+                PayCustomer(
+                    provider=out.provider,
+                    provider_customer_id=out.provider_customer_id,
+                    user_id=None,
+                    tenant_id="",
+                )
+            )
+        return out
+
+    # ---- Products / Prices ----
+    async def get_product(self, provider_product_id: str) -> ProductOut:
+        return await self._get_adapter().get_product(provider_product_id)
+
+    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)
+
+    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)
+        )
+        if row:
+            if data.name is not None:
+                row.name = data.name
+            if data.active is not None:
+                row.active = data.active
+        return out
+
+    async def get_price(self, provider_price_id: str) -> PriceOut:
+        return await self._get_adapter().get_price(provider_price_id)
+
+    async def list_prices(
+        self,
+        *,
+        provider_product_id: str | None,
+        active: bool | None,
+        limit: int,
+        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
+        )
+
+    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)
+        )
+        if row and data.active is not None:
+            row.active = data.active
+        return out
+
+    # ---- Subscriptions ----
+    async def get_subscription(self, provider_subscription_id: str) -> SubscriptionOut:
+        return await self._get_adapter().get_subscription(provider_subscription_id)
+
+    async def list_subscriptions(
+        self,
+        *,
+        customer_provider_id: str | None,
+        status: str | None,
+        limit: int,
+        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
+        )
+
+    # ---- Payment Methods (get/update) ----
+    async def get_payment_method(self, provider_method_id: str) -> PaymentMethodOut:
+        return await self._get_adapter().get_payment_method(provider_method_id)
+
+    async def update_payment_method(
+        self, provider_method_id: str, data: PaymentMethodUpdateIn
+    ) -> PaymentMethodOut:
+        out = await self._get_adapter().update_payment_method(provider_method_id, data)
+        row = await self.session.scalar(
+            select(PayPaymentMethod).where(
+                PayPaymentMethod.provider_method_id == provider_method_id
+            )
+        )
+        if row:
+            if data.name is not None:
+                pass  # keep local-only if/when you add column
+            if data.exp_month is not None:
+                row.exp_month = data.exp_month
+            if data.exp_year is not None:
+                row.exp_year = data.exp_year
+        return out
+
+    # ---- Refunds list/get ----
+    async def list_refunds(
+        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
+        )
+
+    async def get_refund(self, provider_refund_id: str) -> RefundOut:
+        return await self._get_adapter().get_refund(provider_refund_id)
+
+    # ---- Invoice line items list ----
+    async def list_invoice_line_items(
+        self, provider_invoice_id: str, *, limit: int, cursor: str | None
+    ) -> tuple[list[InvoiceLineItemOut], str | None]:
+        return await self._get_adapter().list_invoice_line_items(
+            provider_invoice_id, limit=limit, cursor=cursor
+        )
+
+    # ---- Usage records list/get ----
+    async def list_usage_records(
+        self, f: UsageRecordListFilter
+    ) -> tuple[list[UsageRecordOut], str | None]:
+        return await self._get_adapter().list_usage_records(f)
+
+    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/api/fastapi/apf_payments/router.py

@@ -9,6 +9,7 @@ from svc_infra.apf_payments.schemas import (
     BalanceSnapshotOut,
     CaptureIn,
     CustomerOut,
+    CustomersListFilter,
     CustomerUpsertIn,
     DisputeOut,
     IntentCreateIn,
@@ -16,16 +17,21 @@ from svc_infra.apf_payments.schemas import (
     IntentOut,
     InvoiceCreateIn,
     InvoiceLineItemIn,
+    InvoiceLineItemOut,
     InvoiceOut,
     InvoicesListFilter,
     PaymentMethodAttachIn,
     PaymentMethodOut,
+    PaymentMethodUpdateIn,
     PayoutOut,
     PriceCreateIn,
     PriceOut,
+    PriceUpdateIn,
     ProductCreateIn,
     ProductOut,
+    ProductUpdateIn,
     RefundIn,
+    RefundOut,
     SetupIntentCreateIn,
     SetupIntentOut,
     StatementRow,
@@ -34,6 +40,9 @@ from svc_infra.apf_payments.schemas import (
     SubscriptionUpdateIn,
     TransactionRow,
     UsageRecordIn,
+    UsageRecordListFilter,
+    UsageRecordOut,
+    WebhookAckOut,
     WebhookReplayOut,
 )
 from svc_infra.apf_payments.service import PaymentsService
@@ -183,7 +192,11 @@ def build_payments_routers(prefix: str = "/payments") -> list[DualAPIRouter]:
     # PUBLIC webhooks
     pub = public_router(prefix=prefix, tags=["payments"])
 
-    @pub.post("/webhooks/{provider}", name="payments_webhook")
+    @pub.post(
+        "/webhooks/{provider}",
+        name="payments_webhook",
+        response_model=WebhookAckOut,
+    )
     async def webhooks(
         provider: str,
         request: Request,
@@ -507,6 +520,7 @@ def build_payments_routers(prefix: str = "/payments") -> list[DualAPIRouter]:
         name="payments_create_usage_record",
         status_code=status.HTTP_201_CREATED,
         dependencies=[Depends(require_idempotency_key)],
+        response_model=UsageRecordOut,
     )
     async def create_usage_record_endpoint(
         data: UsageRecordIn, svc: PaymentsService = Depends(get_service)
@@ -598,6 +612,7 @@ def build_payments_routers(prefix: str = "/payments") -> list[DualAPIRouter]:
         "/disputes/{provider_dispute_id}/submit_evidence",
         name="payments_submit_dispute_evidence",
         dependencies=[Depends(require_idempotency_key)],
+        response_model=DisputeOut,
     )
     async def submit_dispute_evidence(
         provider_dispute_id: str,
@@ -649,6 +664,288 @@ def build_payments_routers(prefix: str = "/payments") -> list[DualAPIRouter]:
         await svc.session.flush()
         return {"replayed": count}
 
+    # ===== Customers: list/get =====
+    @prot.get(
+        "/customers",
+        response_model=Paginated[CustomerOut],
+        name="payments_list_customers",
+        dependencies=[Depends(cursor_pager(default_limit=50, max_limit=200))],
+    )
+    async def list_customers_endpoint(
+        provider: Optional[str] = None,
+        user_id: Optional[str] = None,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        ctx = use_pagination()
+        items, next_cursor = await svc.list_customers(
+            CustomersListFilter(
+                provider=provider, user_id=user_id, limit=ctx.limit, cursor=ctx.cursor
+            )
+        )
+        return ctx.wrap(items, next_cursor=next_cursor)
+
+    @prot.get(
+        "/customers/{provider_customer_id}",
+        response_model=CustomerOut,
+        name="payments_get_customer",
+    )
+    async def get_customer_endpoint(
+        provider_customer_id: str, svc: PaymentsService = Depends(get_service)
+    ):
+        return await svc.get_customer(provider_customer_id)
+
+    # ===== Payment Methods: get/update =====
+    @prot.get(
+        "/methods/{provider_method_id}",
+        response_model=PaymentMethodOut,
+        name="payments_get_method",
+    )
+    async def get_method(provider_method_id: str, svc: PaymentsService = Depends(get_service)):
+        return await svc.get_payment_method(provider_method_id)
+
+    @prot.post(
+        "/methods/{provider_method_id}",
+        response_model=PaymentMethodOut,
+        name="payments_update_method",
+        dependencies=[Depends(require_idempotency_key)],
+    )
+    async def update_method(
+        provider_method_id: str,
+        data: PaymentMethodUpdateIn,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        out = await svc.update_payment_method(provider_method_id, data)
+        await svc.session.flush()
+        return out
+
+    # ===== Products: get/list/update (archive via active=False) =====
+    @svc.get(
+        "/products/{provider_product_id}",
+        response_model=ProductOut,
+        name="payments_get_product",
+    )
+    async def get_product_endpoint(
+        provider_product_id: str, svc: PaymentsService = Depends(get_service)
+    ):
+        return await svc.get_product(provider_product_id)
+
+    @svc.get(
+        "/products",
+        response_model=Paginated[ProductOut],
+        name="payments_list_products",
+        dependencies=[Depends(cursor_pager(default_limit=50, max_limit=200))],
+    )
+    async def list_products_endpoint(
+        active: Optional[bool] = None,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        ctx = use_pagination()
+        items, next_cursor = await svc.list_products(
+            active=active, limit=ctx.limit, cursor=ctx.cursor
+        )
+        return ctx.wrap(items, next_cursor=next_cursor)
+
+    @svc.post(
+        "/products/{provider_product_id}",
+        response_model=ProductOut,
+        name="payments_update_product",
+        dependencies=[Depends(require_idempotency_key)],
+    )
+    async def update_product_endpoint(
+        provider_product_id: str,
+        data: ProductUpdateIn,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        out = await svc.update_product(provider_product_id, data)
+        await svc.session.flush()
+        return out
+
+    # ===== Prices: get/list/update (active toggle) =====
+    @svc.get(
+        "/prices/{provider_price_id}",
+        response_model=PriceOut,
+        name="payments_get_price",
+    )
+    async def get_price_endpoint(
+        provider_price_id: str, svc: PaymentsService = Depends(get_service)
+    ):
+        return await svc.get_price(provider_price_id)
+
+    @svc.get(
+        "/prices",
+        response_model=Paginated[PriceOut],
+        name="payments_list_prices",
+        dependencies=[Depends(cursor_pager(default_limit=50, max_limit=200))],
+    )
+    async def list_prices_endpoint(
+        provider_product_id: Optional[str] = None,
+        active: Optional[bool] = None,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        ctx = use_pagination()
+        items, next_cursor = await svc.list_prices(
+            provider_product_id=provider_product_id,
+            active=active,
+            limit=ctx.limit,
+            cursor=ctx.cursor,
+        )
+        return ctx.wrap(items, next_cursor=next_cursor)
+
+    @svc.post(
+        "/prices/{provider_price_id}",
+        response_model=PriceOut,
+        name="payments_update_price",
+        dependencies=[Depends(require_idempotency_key)],
+    )
+    async def update_price_endpoint(
+        provider_price_id: str,
+        data: PriceUpdateIn,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        out = await svc.update_price(provider_price_id, data)
+        await svc.session.flush()
+        return out
+
+    # ===== Subscriptions: get/list =====
+    @prot.get(
+        "/subscriptions/{provider_subscription_id}",
+        response_model=SubscriptionOut,
+        name="payments_get_subscription",
+    )
+    async def get_subscription_endpoint(
+        provider_subscription_id: str, svc: PaymentsService = Depends(get_service)
+    ):
+        return await svc.get_subscription(provider_subscription_id)
+
+    @prot.get(
+        "/subscriptions",
+        response_model=Paginated[SubscriptionOut],
+        name="payments_list_subscriptions",
+        dependencies=[Depends(cursor_pager(default_limit=50, max_limit=200))],
+    )
+    async def list_subscriptions_endpoint(
+        customer_provider_id: Optional[str] = None,
+        status: Optional[str] = None,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        ctx = use_pagination()
+        items, next_cursor = await svc.list_subscriptions(
+            customer_provider_id=customer_provider_id,
+            status=status,
+            limit=ctx.limit,
+            cursor=ctx.cursor,
+        )
+        return ctx.wrap(items, next_cursor=next_cursor)
+
+    # ===== Invoices: list line items =====
+    @prot.get(
+        "/invoices/{provider_invoice_id}/lines",
+        response_model=Paginated[InvoiceLineItemOut],
+        name="payments_list_invoice_line_items",
+        dependencies=[Depends(cursor_pager(default_limit=50, max_limit=200))],
+    )
+    async def list_invoice_lines_endpoint(
+        provider_invoice_id: str,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        ctx = use_pagination()
+        items, next_cursor = await svc.list_invoice_line_items(
+            provider_invoice_id, limit=ctx.limit, cursor=ctx.cursor
+        )
+        return ctx.wrap(items, next_cursor=next_cursor)
+
+    # ===== Refunds: list/get =====
+    @prot.get(
+        "/refunds",
+        response_model=Paginated[RefundOut],
+        name="payments_list_refunds",
+        dependencies=[Depends(cursor_pager(default_limit=50, max_limit=200))],
+    )
+    async def list_refunds_endpoint(
+        provider_payment_intent_id: Optional[str] = None,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        ctx = use_pagination()
+        items, next_cursor = await svc.list_refunds(
+            provider_payment_intent_id=provider_payment_intent_id,
+            limit=ctx.limit,
+            cursor=ctx.cursor,
+        )
+        return ctx.wrap(items, next_cursor=next_cursor)
+
+    @prot.get(
+        "/refunds/{provider_refund_id}",
+        response_model=RefundOut,
+        name="payments_get_refund",
+    )
+    async def get_refund_endpoint(
+        provider_refund_id: str, svc: PaymentsService = Depends(get_service)
+    ):
+        return await svc.get_refund(provider_refund_id)
+
+    # ===== Usage Records: list/get =====
+    @prot.get(
+        "/usage_records",
+        response_model=Paginated[UsageRecordOut],
+        name="payments_list_usage_records",
+        dependencies=[Depends(cursor_pager(default_limit=50, max_limit=200))],
+    )
+    async def list_usage_records_endpoint(
+        subscription_item: Optional[str] = None,
+        provider_price_id: Optional[str] = None,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        ctx = use_pagination()
+        items, next_cursor = await svc.list_usage_records(
+            UsageRecordListFilter(
+                subscription_item=subscription_item,
+                provider_price_id=provider_price_id,
+                limit=ctx.limit,
+                cursor=ctx.cursor,
+            )
+        )
+        return ctx.wrap(items, next_cursor=next_cursor)
+
+    @prot.get(
+        "/usage_records/{usage_record_id}",
+        response_model=UsageRecordOut,
+        name="payments_get_usage_record",
+    )
+    async def get_usage_record_endpoint(
+        usage_record_id: str, svc: PaymentsService = Depends(get_service)
+    ):
+        return await svc.get_usage_record(usage_record_id)
+
+    # --- Invoices: delete line item ---
+    @prot.delete(
+        "/invoices/{provider_invoice_id}/lines/{provider_line_item_id}",
+        name="payments_delete_invoice_line_item",
+        response_model=InvoiceOut,
+        dependencies=[Depends(require_idempotency_key)],
+    )
+    async def delete_invoice_line_item_endpoint(
+        provider_invoice_id: str,
+        provider_line_item_id: str,
+        svc: PaymentsService = Depends(get_service),
+    ):
+        out = await svc.delete_invoice_line_item(provider_invoice_id, provider_line_item_id)
+        await svc.session.flush()
+        return out
+
+    # --- Optional REST alias for detach (calls your existing logic) ---
+    @prot.delete(
+        "/methods/{provider_method_id}",
+        name="payments_delete_method_alias",
+        response_model=PaymentMethodOut,
+        dependencies=[Depends(require_idempotency_key)],
+    )
+    async def delete_method_alias(
+        provider_method_id: str, svc: PaymentsService = Depends(get_service)
+    ):
+        out = await svc.detach_payment_method(provider_method_id)
+        await svc.session.flush()
+        return out
+
     routers.append(svc)
     routers.append(pub)
     return routers

{svc_infra-0.1.578.dist-info → svc_infra-0.1.580.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: svc-infra
-Version: 0.1.578
+Version: 0.1.580
 Summary: Infrastructure for building and deploying prod-ready services
 License: MIT
 Keywords: fastapi,sqlalchemy,alembic,auth,infra,async,pydantic

{svc_infra-0.1.578.dist-info → svc_infra-0.1.580.dist-info}/RECORD

@@ -3,16 +3,16 @@ svc_infra/apf_payments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 svc_infra/apf_payments/alembic.py,sha256=XJIcCDOoaO1EeJbSx_qK9o4cBi430qyo5gECtjHIojw,299
 svc_infra/apf_payments/models.py,sha256=u4U5oszha5uulCIrNoajaFDIc5YmTlh2mtm-yJUvr9I,14251
 svc_infra/apf_payments/provider/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-svc_infra/apf_payments/provider/base.py,sha256=On2mN_0n5KGvnENbmEUrcM2DCt8xxpArrlvh0zeOauc,4996
+svc_infra/apf_payments/provider/base.py,sha256=1t5znglpGFhjt4zdbuzE5VlHvGarFwzH2oscK8yyKNY,7678
 svc_infra/apf_payments/provider/registry.py,sha256=NZ4pUkFcbXNtqWEpFeI3NwoKRYGWe9fVQakmlrVLTKE,878
 svc_infra/apf_payments/provider/stripe.py,sha256=rZlQe1BBLBF1aMOqw98aDRZkA7pOgTqkGvXzSG8qE5c,11298
-svc_infra/apf_payments/schemas.py,sha256=7WtDrZSEDRYe1o1rFI7fKiXFLgXJ9J_GoKKyXApHsXM,6511
-svc_infra/apf_payments/service.py,sha256=1OYmzkKI8tFUv34PLfcHBRA8h1nelvkzq4VTJevOwRs,23842
+svc_infra/apf_payments/schemas.py,sha256=XfBxx6z_Y6cdHktanafNDhhgWl8JVvag9vp2ORmvn_4,8403
+svc_infra/apf_payments/service.py,sha256=bn3BTOTdfkJ4b0Z9cHuFHvlMcv9B1b2n0v-unveUplA,31060
 svc_infra/apf_payments/settings.py,sha256=VnNQbajbv843buUisqa82xOQ-f5JA8JzHD8o01-yhPQ,1239
 svc_infra/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 svc_infra/api/fastapi/__init__.py,sha256=VVdQjak74_wTDqmvL05_C97vIFugQxPVU-3JQEFBgR8,747
 svc_infra/api/fastapi/apf_payments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-svc_infra/api/fastapi/apf_payments/router.py,sha256=QbSem_eKSkomdcSdCxNH_hWGj2AoH_FlMOHqQtspYho,22290
+svc_infra/api/fastapi/apf_payments/router.py,sha256=zwdAVaUYGT3RjIp-3WtWUMsuBWGPhjt6fAMGt2tZXlg,32456
 svc_infra/api/fastapi/apf_payments/setup.py,sha256=PX-LHDiyu2eDuaw2m98VPUkF6EmXXRkbjRqh_gL8Kls,2263
 svc_infra/api/fastapi/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 svc_infra/api/fastapi/auth/_cookies.py,sha256=U4heUmMnLezHx8U6ksuUEpSZ6sNMJcIO0gdLpmZ5FXw,1367
@@ -228,7 +228,7 @@ svc_infra/obs/templates/sidecars/railway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 svc_infra/obs/templates/sidecars/railway/agent.yaml,sha256=hYv35yG92XEP_4joMFmMcVTD-4fG_zHitmChjreUJh4,516
 svc_infra/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 svc_infra/utils.py,sha256=VX1yjTx61-YvAymyRhGy18DhybiVdPddiYD_FlKTbJU,952
-svc_infra-0.1.578.dist-info/METADATA,sha256=8O6BepYxCTpiqaqJXltnBTWuUDd2dnDrqa1wzE6mAeQ,3487
-svc_infra-0.1.578.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-svc_infra-0.1.578.dist-info/entry_points.txt,sha256=6x_nZOsjvn6hRZsMgZLgTasaCSKCgAjsGhACe_CiP0U,48
-svc_infra-0.1.578.dist-info/RECORD,,
+svc_infra-0.1.580.dist-info/METADATA,sha256=IHm9XHfQc8WdbmNpAyFDv0H1fLOIX2LMX0D7KRsmXe0,3487
+svc_infra-0.1.580.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+svc_infra-0.1.580.dist-info/entry_points.txt,sha256=6x_nZOsjvn6hRZsMgZLgTasaCSKCgAjsGhACe_CiP0U,48
+svc_infra-0.1.580.dist-info/RECORD,,