sboulahtit/orion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: fix all architecture validator findings (202 → 0)

Browse Source 
Eliminate all 103 errors and 96 warnings from the architecture validator:

Phase 1 - Validator rules & YAML:
- Add NAM-001/NAM-002 exceptions for module-scoped router/service files
- Fix API-004 to detect # public comments on decorator lines
- Add module-specific exception bases to EXC-004 valid_bases
- Exclude storefront files from AUTH-004 store context check
- Add SVC-006 exceptions for loyalty service atomic commits
- Fix _get_rule() to search naming_rules and auth_rules categories
- Use plain # CODE comments instead of # noqa: CODE for custom rules

Phase 2 - Billing module (5 route files):
- Move _resolve_store_to_merchant to subscription_service
- Move tier/feature queries to feature_service, admin_subscription_service
- Extract 22 inline Pydantic schemas to billing/schemas/billing.py
- Replace all HTTPException with domain exceptions

Phase 3 - Loyalty module (4 routes + points_service):
- Add 7 domain exceptions (Apple auth, enrollment, device registration)
- Add service methods to card_service, program_service, apple_wallet_service
- Move all db.query() from routes to service layer
- Fix SVC-001: replace HTTPException in points_service with domain exception

Phase 4 - Remaining modules:
- tenancy: move store stats queries to admin_service
- cms: move platform resolution to content_page_service, add NoPlatformSubscriptionException
- messaging: move user/customer lookups to messaging_service
- Add ConfigDict(from_attributes=True) to ContentPageResponse

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Samir Boulahtit
2026-02-13 18:49:24 +01:00
parent 9173448645
commit 7c43d6f4a2
48 changed files with 1613 additions and 1039 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
app/modules/billing/routes/api/admin.py
View File

@@ -11,7 +11,7 @@ Provides admin API endpoints for subscription and billing management:
import logging
from fastapi import APIRouter, Depends, HTTPException, Path, Query
from fastapi import APIRouter, Depends, Path, Query
from sqlalchemy.orm import Session
from app.api.deps import get_current_admin_api, require_module_access
@@ -62,9 +62,7 @@ def list_subscription_tiers(
"""List all subscription tiers."""
tiers = admin_subscription_service.get_tiers(db, include_inactive=include_inactive, platform_id=platform_id)
from app.modules.tenancy.models import Platform
platforms_map = {p.id: p.name for p in db.query(Platform).all()}
platforms_map = admin_subscription_service.get_platform_names_map(db)
tiers_response = []
for t in tiers:
resp = SubscriptionTierResponse.model_validate(t)
@@ -147,18 +145,17 @@ def list_merchant_subscriptions(
db, page=page, per_page=per_page, status=status, tier=tier, search=search
)
from app.modules.tenancy.models import Platform
platforms_map = admin_subscription_service.get_platform_names_map(db)
subscriptions = []
for sub, merchant in data["results"]:
sub_resp = MerchantSubscriptionAdminResponse.model_validate(sub)
tier_name = sub.tier.name if sub.tier else None
platform = db.query(Platform).filter(Platform.id == sub.platform_id).first()
subscriptions.append(
MerchantSubscriptionWithMerchant(
**sub_resp.model_dump(),
merchant_name=merchant.name,
platform_name=platform.name if platform else "",
platform_name=platforms_map.get(sub.platform_id, ""),
tier_name=tier_name,
)
)
@@ -268,12 +265,13 @@ def get_subscription_for_store(
of subscription entries with feature usage metrics.
"""
from app.modules.billing.services.feature_service import feature_service
from app.modules.tenancy.models import Platform
# Resolve store to merchant + all platform IDs
merchant_id, platform_ids = feature_service._get_merchant_and_platforms_for_store(db, store_id)
if merchant_id is None or not platform_ids:
raise HTTPException(status_code=404, detail="Store not found or has no platform association")
raise ResourceNotFoundException("Store", str(store_id))
platforms_map = admin_subscription_service.get_platform_names_map(db)
results = []
for pid in platform_ids:
@@ -308,14 +306,11 @@ def get_subscription_for_store(
"is_approaching_limit": (fs.percent_used or 0) >= 80,
})
# Resolve platform name
platform = db.query(Platform).filter(Platform.id == pid).first()
results.append({
"subscription": MerchantSubscriptionAdminResponse.model_validate(sub).model_dump(),
"tier": tier_info,
"features": usage_metrics,
"platform_name": platform.name if platform else "",
"platform_name": platforms_map.get(pid, ""),
})
return {"subscriptions": results}

110
app/modules/billing/routes/api/admin_features.py
View File

@@ -12,16 +12,12 @@ All routes require module access control for the 'billing' module.
import logging
from fastapi import APIRouter, Depends, HTTPException, Path
from fastapi import APIRouter, Depends, Path
from sqlalchemy.orm import Session
from app.api.deps import get_current_admin_api, require_module_access
from app.core.database import get_db
from app.modules.billing.models import SubscriptionTier
from app.modules.billing.models.tier_feature_limit import (
MerchantFeatureOverride,
TierFeatureLimit,
)
from app.modules.billing.exceptions import InvalidFeatureCodesError
from app.modules.billing.schemas import (
FeatureCatalogResponse,
FeatureDeclarationResponse,
@@ -30,6 +26,7 @@ from app.modules.billing.schemas import (
TierFeatureLimitEntry,
)
from app.modules.billing.services.feature_aggregator import feature_aggregator
from app.modules.billing.services.feature_service import feature_service
from app.modules.enums import FrontendType
from models.schema.auth import UserContext
@@ -40,23 +37,6 @@ admin_features_router = APIRouter(
logger = logging.getLogger(__name__)
# ============================================================================
# Helper Functions
# ============================================================================
def _get_tier_or_404(db: Session, tier_code: str) -> SubscriptionTier:
"""Look up a SubscriptionTier by code, raising 404 if not found."""
tier = (
db.query(SubscriptionTier)
.filter(SubscriptionTier.code == tier_code)
.first()
)
if not tier:
raise HTTPException(status_code=404, detail=f"Tier '{tier_code}' not found")
return tier
def _declaration_to_response(decl) -> FeatureDeclarationResponse:
"""Convert a FeatureDeclaration dataclass to its Pydantic response schema."""
return FeatureDeclarationResponse(
@@ -120,14 +100,7 @@ def get_tier_feature_limits(
Returns all TierFeatureLimit rows associated with the tier,
each containing a feature_code and its optional limit_value.
"""
tier = _get_tier_or_404(db, tier_code)
rows = (
db.query(TierFeatureLimit)
.filter(TierFeatureLimit.tier_id == tier.id)
.order_by(TierFeatureLimit.feature_code)
.all()
)
rows = feature_service.get_tier_feature_limits(db, tier_code)
return [
TierFeatureLimitEntry(
@@ -156,32 +129,15 @@ def upsert_tier_feature_limits(
inserts the provided entries. Only entries with enabled=True
are persisted (disabled entries are simply omitted).
"""
tier = _get_tier_or_404(db, tier_code)
# Validate feature codes against the catalog
submitted_codes = {e.feature_code for e in entries}
invalid_codes = feature_aggregator.validate_feature_codes(submitted_codes)
if invalid_codes:
raise HTTPException(
status_code=422,
detail=f"Unknown feature codes: {sorted(invalid_codes)}",
)
raise InvalidFeatureCodesError(invalid_codes)
# Delete existing limits for this tier
db.query(TierFeatureLimit).filter(TierFeatureLimit.tier_id == tier.id).delete()
# Insert new limits (only enabled entries)
new_rows = []
for entry in entries:
if not entry.enabled:
continue
row = TierFeatureLimit(
tier_id=tier.id,
feature_code=entry.feature_code,
limit_value=entry.limit_value,
)
db.add(row)
new_rows.append(row)
new_rows = feature_service.upsert_tier_feature_limits(
db, tier_code, [e.model_dump() for e in entries]
)
db.commit()
@@ -222,12 +178,7 @@ def get_merchant_feature_overrides(
Returns MerchantFeatureOverride rows that allow per-merchant
exceptions to the default tier limits (e.g. granting extra products).
"""
rows = (
db.query(MerchantFeatureOverride)
.filter(MerchantFeatureOverride.merchant_id == merchant_id)
.order_by(MerchantFeatureOverride.feature_code)
.all()
)
rows = feature_service.get_merchant_overrides(db, merchant_id)
return [MerchantFeatureOverrideResponse.model_validate(row) for row in rows]
@@ -251,50 +202,23 @@ def upsert_merchant_feature_overrides(
The platform_id is derived from the admin's current platform context.
"""
from app.exceptions import ValidationException
platform_id = current_user.token_platform_id
if not platform_id:
raise HTTPException(
status_code=400,
detail="Platform context required. Select a platform first.",
raise ValidationException(
message="Platform context required. Select a platform first.",
)
# Validate feature codes against the catalog
submitted_codes = {e.feature_code for e in entries}
invalid_codes = feature_aggregator.validate_feature_codes(submitted_codes)
if invalid_codes:
raise HTTPException(
status_code=422,
detail=f"Unknown feature codes: {sorted(invalid_codes)}",
)
raise InvalidFeatureCodesError(invalid_codes)
results = []
for entry in entries:
existing = (
db.query(MerchantFeatureOverride)
.filter(
MerchantFeatureOverride.merchant_id == merchant_id,
MerchantFeatureOverride.platform_id == platform_id,
MerchantFeatureOverride.feature_code == entry.feature_code,
)
.first()
)
if existing:
existing.limit_value = entry.limit_value
existing.is_enabled = entry.is_enabled
existing.reason = entry.reason
results.append(existing)
else:
row = MerchantFeatureOverride(
merchant_id=merchant_id,
platform_id=platform_id,
feature_code=entry.feature_code,
limit_value=entry.limit_value,
is_enabled=entry.is_enabled,
reason=entry.reason,
)
db.add(row)
results.append(row)
results = feature_service.upsert_merchant_overrides(
db, merchant_id, platform_id, [e.model_dump() for e in entries]
)
db.commit()

114
app/modules/billing/routes/api/store.py
View File

@@ -9,15 +9,21 @@ for all billing service calls.
import logging
from fastapi import APIRouter, Depends, HTTPException, Query
from pydantic import BaseModel
from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from app.api.deps import get_current_store_api, require_module_access
from app.core.database import get_db
from app.modules.billing.schemas.billing import (
InvoiceListResponse,
InvoiceResponse,
SubscriptionStatusResponse,
TierListResponse,
TierResponse,
)
from app.modules.billing.services import billing_service, subscription_service
from app.modules.enums import FrontendType
from app.modules.tenancy.models import User
from models.schema.auth import UserContext
logger = logging.getLogger(__name__)
@@ -28,96 +34,6 @@ store_router = APIRouter(
)
# ============================================================================
# Helpers
# ============================================================================
def _resolve_store_to_merchant(db: Session, store_id: int) -> tuple[int, int]:
"""Resolve store_id to (merchant_id, platform_id)."""
from app.modules.tenancy.models import Store, StorePlatform
store = db.query(Store).filter(Store.id == store_id).first()
if not store or not store.merchant_id:
raise HTTPException(status_code=404, detail="Store not found")
sp = db.query(StorePlatform.platform_id).filter(
StorePlatform.store_id == store_id
).first()
if not sp:
raise HTTPException(status_code=404, detail="Store not linked to platform")
return store.merchant_id, sp[0]
# ============================================================================
# Schemas
# ============================================================================
class SubscriptionStatusResponse(BaseModel):
"""Current subscription status."""
tier_code: str
tier_name: str
status: str
is_trial: bool
trial_ends_at: str | None = None
period_start: str | None = None
period_end: str | None = None
cancelled_at: str | None = None
cancellation_reason: str | None = None
has_payment_method: bool
last_payment_error: str | None = None
feature_codes: list[str] = []
class Config:
from_attributes = True
class TierResponse(BaseModel):
"""Subscription tier information."""
code: str
name: str
description: str | None = None
price_monthly_cents: int
price_annual_cents: int | None = None
feature_codes: list[str] = []
is_current: bool = False
can_upgrade: bool = False
can_downgrade: bool = False
class TierListResponse(BaseModel):
"""List of available tiers."""
tiers: list[TierResponse]
current_tier: str
class InvoiceResponse(BaseModel):
"""Invoice information."""
id: int
invoice_number: str | None = None
invoice_date: str
due_date: str | None = None
total_cents: int
amount_paid_cents: int
currency: str
status: str
pdf_url: str | None = None
hosted_url: str | None = None
class InvoiceListResponse(BaseModel):
"""List of invoices."""
invoices: list[InvoiceResponse]
total: int
# ============================================================================
# Core Billing Endpoints
# ============================================================================
@@ -125,12 +41,12 @@ class InvoiceListResponse(BaseModel):
@store_router.get("/subscription", response_model=SubscriptionStatusResponse)
def get_subscription_status(
current_user: User = Depends(get_current_store_api),
current_user: UserContext = Depends(get_current_store_api),
db: Session = Depends(get_db),
):
"""Get current subscription status."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
subscription, tier = billing_service.get_subscription_with_tier(db, merchant_id, platform_id)
@@ -162,12 +78,12 @@ def get_subscription_status(
@store_router.get("/tiers", response_model=TierListResponse)
def get_available_tiers(
current_user: User = Depends(get_current_store_api),
current_user: UserContext = Depends(get_current_store_api),
db: Session = Depends(get_db),
):
"""Get available subscription tiers for upgrade/downgrade."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
subscription = subscription_service.get_or_create_subscription(db, merchant_id, platform_id)
current_tier_id = subscription.tier_id
@@ -184,12 +100,12 @@ def get_available_tiers(
def get_invoices(
skip: int = Query(0, ge=0),
limit: int = Query(20, ge=1, le=100),
current_user: User = Depends(get_current_store_api),
current_user: UserContext = Depends(get_current_store_api),
db: Session = Depends(get_db),
):
"""Get invoice history."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
invoices, total = billing_service.get_invoices(db, merchant_id, skip=skip, limit=limit)

125
app/modules/billing/routes/api/store_checkout.py
View File

@@ -15,14 +15,24 @@ Resolves store_id to (merchant_id, platform_id) for all billing service calls.
import logging
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from app.api.deps import get_current_store_api, require_module_access
from app.core.config import settings
from app.core.database import get_db
from app.modules.billing.schemas.billing import (
CancelRequest,
CancelResponse,
ChangeTierRequest,
ChangeTierResponse,
CheckoutRequest,
CheckoutResponse,
PortalResponse,
UpcomingInvoiceResponse,
)
from app.modules.billing.services import billing_service
from app.modules.billing.services.subscription_service import subscription_service
from app.modules.enums import FrontendType
from models.schema.auth import UserContext
@@ -32,91 +42,6 @@ store_checkout_router = APIRouter(
logger = logging.getLogger(__name__)
# ============================================================================
# Helpers
# ============================================================================
def _resolve_store_to_merchant(db: Session, store_id: int) -> tuple[int, int]:
"""Resolve store_id to (merchant_id, platform_id)."""
from app.modules.tenancy.models import Store, StorePlatform
store = db.query(Store).filter(Store.id == store_id).first()
if not store or not store.merchant_id:
raise HTTPException(status_code=404, detail="Store not found")
sp = db.query(StorePlatform.platform_id).filter(
StorePlatform.store_id == store_id
).first()
if not sp:
raise HTTPException(status_code=404, detail="Store not linked to platform")
return store.merchant_id, sp[0]
# ============================================================================
# Schemas
# ============================================================================
class CheckoutRequest(BaseModel):
"""Request to create a checkout session."""
tier_code: str
is_annual: bool = False
class CheckoutResponse(BaseModel):
"""Checkout session response."""
checkout_url: str
session_id: str
class PortalResponse(BaseModel):
"""Customer portal session response."""
portal_url: str
class CancelRequest(BaseModel):
"""Request to cancel subscription."""
reason: str | None = None
immediately: bool = False
class CancelResponse(BaseModel):
"""Cancellation response."""
message: str
effective_date: str
class UpcomingInvoiceResponse(BaseModel):
"""Upcoming invoice preview."""
amount_due_cents: int
currency: str
next_payment_date: str | None = None
line_items: list[dict] = []
class ChangeTierRequest(BaseModel):
"""Request to change subscription tier."""
tier_code: str
is_annual: bool = False
class ChangeTierResponse(BaseModel):
"""Response for tier change."""
message: str
new_tier: str
effective_immediately: bool
# ============================================================================
# Endpoints
# ============================================================================
@@ -130,15 +55,13 @@ def create_checkout_session(
):
"""Create a Stripe checkout session for subscription."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
from app.modules.tenancy.models import Store
store = db.query(Store).filter(Store.id == store_id).first()
store_code = subscription_service.get_store_code(db, store_id)
base_url = f"https://{settings.platform_domain}"
success_url = f"{base_url}/store/{store.store_code}/billing?success=true"
cancel_url = f"{base_url}/store/{store.store_code}/billing?cancelled=true"
success_url = f"{base_url}/store/{store_code}/billing?success=true"
cancel_url = f"{base_url}/store/{store_code}/billing?cancelled=true"
result = billing_service.create_checkout_session(
db=db,
@@ -161,12 +84,10 @@ def create_portal_session(
):
"""Create a Stripe customer portal session."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
from app.modules.tenancy.models import Store
store = db.query(Store).filter(Store.id == store_id).first()
return_url = f"https://{settings.platform_domain}/store/{store.store_code}/billing"
store_code = subscription_service.get_store_code(db, store_id)
return_url = f"https://{settings.platform_domain}/store/{store_code}/billing"
result = billing_service.create_portal_session(db, merchant_id, platform_id, return_url)
@@ -181,7 +102,7 @@ def cancel_subscription(
):
"""Cancel subscription."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
result = billing_service.cancel_subscription(
db=db,
@@ -205,7 +126,7 @@ def reactivate_subscription(
):
"""Reactivate a cancelled subscription."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
result = billing_service.reactivate_subscription(db, merchant_id, platform_id)
db.commit()
@@ -220,7 +141,7 @@ def get_upcoming_invoice(
):
"""Preview the upcoming invoice."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
result = billing_service.get_upcoming_invoice(db, merchant_id, platform_id)
@@ -240,7 +161,7 @@ def change_tier(
):
"""Change subscription tier (upgrade/downgrade)."""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
result = billing_service.change_tier(
db=db,

118
app/modules/billing/routes/api/store_features.py
View File

@@ -19,13 +19,21 @@ All routes require module access control for the 'billing' module.
import logging
from fastapi import APIRouter, Depends, HTTPException, Query
from pydantic import BaseModel
from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from app.api.deps import get_current_store_api, require_module_access
from app.core.database import get_db
from app.modules.billing.exceptions import FeatureNotFoundError
from app.modules.billing.schemas.billing import (
CategoryListResponse,
FeatureCodeListResponse,
FeatureDetailResponse,
FeatureGroupedResponse,
FeatureListResponse,
FeatureResponse,
StoreFeatureCheckResponse,
)
from app.modules.billing.services.feature_aggregator import feature_aggregator
from app.modules.billing.services.feature_service import feature_service
from app.modules.billing.services.subscription_service import subscription_service
@@ -39,100 +47,6 @@ store_features_router = APIRouter(
logger = logging.getLogger(__name__)
# ============================================================================
# Helpers
# ============================================================================
def _resolve_store_to_merchant(db: Session, store_id: int) -> tuple[int, int]:
"""Resolve store_id to (merchant_id, platform_id)."""
from app.modules.tenancy.models import Store, StorePlatform
store = db.query(Store).filter(Store.id == store_id).first()
if not store or not store.merchant_id:
raise HTTPException(status_code=404, detail="Store not found")
sp = db.query(StorePlatform.platform_id).filter(
StorePlatform.store_id == store_id
).first()
if not sp:
raise HTTPException(status_code=404, detail="Store not linked to platform")
return store.merchant_id, sp[0]
# ============================================================================
# Response Schemas
# ============================================================================
class FeatureCodeListResponse(BaseModel):
"""Simple list of available feature codes for quick checks."""
features: list[str]
tier_code: str
tier_name: str
class FeatureResponse(BaseModel):
"""Full feature information."""
code: str
name: str
description: str | None = None
category: str
feature_type: str | None = None
ui_icon: str | None = None
is_available: bool
class FeatureListResponse(BaseModel):
"""List of features with metadata."""
features: list[FeatureResponse]
available_count: int
total_count: int
tier_code: str
tier_name: str
class FeatureDetailResponse(BaseModel):
"""Single feature detail with upgrade info."""
code: str
name: str
description: str | None = None
category: str
feature_type: str | None = None
ui_icon: str | None = None
is_available: bool
# Upgrade info (only if not available)
upgrade_tier_code: str | None = None
upgrade_tier_name: str | None = None
upgrade_tier_price_monthly_cents: int | None = None
class CategoryListResponse(BaseModel):
"""List of feature categories."""
categories: list[str]
class FeatureGroupedResponse(BaseModel):
"""Features grouped by category."""
categories: dict[str, list[FeatureResponse]]
available_count: int
total_count: int
class FeatureCheckResponse(BaseModel):
"""Quick feature availability check response."""
has_feature: bool
feature_code: str
# ============================================================================
# Internal Helpers
# ============================================================================
@@ -181,7 +95,7 @@ def get_available_features(
List of feature codes the store has access to
"""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
# Get available feature codes
feature_codes = feature_service.get_merchant_feature_codes(db, merchant_id, platform_id)
@@ -220,7 +134,7 @@ def get_features(
List of features with metadata and availability
"""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
# Get all declarations and available codes
all_declarations = feature_aggregator.get_all_declarations()
@@ -283,7 +197,7 @@ def get_features_grouped(
Useful for rendering feature comparison tables or settings pages.
"""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
# Get declarations grouped by category and available codes
by_category = feature_aggregator.get_declarations_by_category()
@@ -313,7 +227,7 @@ def get_features_grouped(
)
@store_features_router.get("/check/{feature_code}", response_model=FeatureCheckResponse)
@store_features_router.get("/check/{feature_code}", response_model=StoreFeatureCheckResponse)
def check_feature(
feature_code: str,
current_user: UserContext = Depends(get_current_store_api),
@@ -334,7 +248,7 @@ def check_feature(
store_id = current_user.token_store_id
has = feature_service.has_feature_for_store(db, store_id, feature_code)
return FeatureCheckResponse(has_feature=has, feature_code=feature_code)
return StoreFeatureCheckResponse(has_feature=has, feature_code=feature_code)
@store_features_router.get("/{feature_code}", response_model=FeatureDetailResponse)
@@ -356,7 +270,7 @@ def get_feature_detail(
Feature details with upgrade info if locked
"""
store_id = current_user.token_store_id
merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)
merchant_id, platform_id = subscription_service.resolve_store_to_merchant(db, store_id)
# Get feature declaration
decl = feature_aggregator.get_declaration(feature_code)