identity-plan-kit 0.2.7__tar.gz → 0.2.8__tar.gz

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: identity-plan-kit
-Version: 0.2.7
+Version: 0.2.8
 Summary: Modern FastAPI library for authentication, RBAC, subscription plans, and usage tracking
 Author-email: harut <harut.avetisyan2002@gmail.com>
 License: MIT

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "identity-plan-kit"
-version = "0.2.7"
+version = "0.2.8"
 description = "Modern FastAPI library for authentication, RBAC, subscription plans, and usage tracking"
 readme = "README.md"
 authors = [
@@ -140,7 +140,7 @@ testpaths = ["tests"]
 addopts = "-v --tb=short"
 
 [tool.bumpversion]
-current_version = "0.2.7"
+current_version = "0.2.8"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 tag = true

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/src/identity_plan_kit/auth/__init__.py

@@ -5,8 +5,14 @@ from identity_plan_kit.auth.domain.entities import RefreshToken, User, UserProvi
 from identity_plan_kit.auth.domain.exceptions import (
     AuthError,
     InvalidCredentialsError,
+    OAuthError,
     PasswordValidationError,
+    ProviderNotConfiguredError,
+    RefreshTokenExpiredError,
+    RefreshTokenInvalidError,
+    RefreshTokenMissingError,
     TokenExpiredError,
+    TokenInvalidError,
     UserInactiveError,
     UserNotFoundError,
 )
@@ -22,12 +28,18 @@ __all__ = [
     # Dependencies
     "CurrentUser",
     "InvalidCredentialsError",
+    "OAuthError",
     "OptionalUser",
     "PasswordValidationError",
+    "ProviderNotConfiguredError",
     "RefreshToken",
+    "RefreshTokenExpiredError",
+    "RefreshTokenInvalidError",
+    "RefreshTokenMissingError",
     # Repositories (for direct use with external sessions)
     "RefreshTokenRepository",
     "TokenExpiredError",
+    "TokenInvalidError",
     # Entities
     "User",
     "UserInactiveError",

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/src/identity_plan_kit/auth/domain/exceptions.py

@@ -35,6 +35,27 @@ class TokenInvalidError(AuthError):
     message = "Invalid token"
 
 
+class RefreshTokenMissingError(AuthError):
+    """Refresh token not provided."""
+
+    code = "REFRESH_TOKEN_MISSING"
+    message = "Refresh token not provided"
+
+
+class RefreshTokenInvalidError(AuthError):
+    """Refresh token is invalid."""
+
+    code = "REFRESH_TOKEN_INVALID"
+    message = "Invalid refresh token"
+
+
+class RefreshTokenExpiredError(AuthError):
+    """Refresh token has expired."""
+
+    code = "REFRESH_TOKEN_EXPIRED"
+    message = "Refresh token has expired"
+
+
 class UserNotFoundError(NotFoundError):
     """User not found."""
 

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/src/identity_plan_kit/plans/__init__.py

@@ -9,6 +9,10 @@ from identity_plan_kit.plans.domain.entities import Feature, Plan, PlanLimit, Us
 from identity_plan_kit.plans.domain.exceptions import (
     FeatureNotAvailableError,
     FeatureNotFoundError,
+    InvalidCustomLimitsError,
+    InvalidPlanDatesError,
+    PlanAssignmentError,
+    PlanAuthorizationError,
     PlanExpiredError,
     PlanNotFoundError,
     QuotaExceededError,
@@ -26,7 +30,11 @@ __all__ = [
     # Exceptions
     "FeatureNotAvailableError",
     "FeatureNotFoundError",
+    "InvalidCustomLimitsError",
+    "InvalidPlanDatesError",
     "Plan",
+    "PlanAssignmentError",
+    "PlanAuthorizationError",
     "PlanExpiredError",
     "PlanLimit",
     "PlanNotFoundError",

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/src/identity_plan_kit/rbac/domain/exceptions.py

@@ -21,10 +21,20 @@ class PermissionDeniedError(RBACError):
         permission: str | None = None,
         message: str | None = None,
     ) -> None:
-        self.permission = permission
+        self._permission = permission
         msg = message or (f"Permission denied: {permission}" if permission else "Permission denied")
         super().__init__(message=msg, details={"permission": permission} if permission else None)
 
+    @property
+    def permission(self) -> str | None:
+        """Get the permission code."""
+        return self._permission
+
+    @property
+    def permission_code(self) -> str | None:
+        """Alias for permission to support permission_code naming convention."""
+        return self._permission
+
 
 class RoleNotFoundError(NotFoundError):
     """Role not found."""

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/src/identity_plan_kit/shared/error_formatter.py

@@ -113,10 +113,11 @@ class DefaultErrorFormatter(ErrorFormatter):
     Produces responses in the format:
         ```json
         {
+            "success": false,
             "error": {
                 "code": "ERROR_CODE",
                 "message": "Human-readable message",
-                "details": { ... }
+                "context": { ... }
             }
         }
         ```
@@ -131,15 +132,16 @@ class DefaultErrorFormatter(ErrorFormatter):
         details: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """Format error in the default library format."""
-        content: dict[str, Any] = {
-            "error": {
-                "code": code,
-                "message": message,
-            }
+        error_content: dict[str, Any] = {
+            "code": code,
+            "message": message,
         }
         if details:
-            content["error"]["details"] = details
-        return content
+            error_content["context"] = details
+        return {
+            "success": False,
+            "error": error_content,
+        }
 
     def create_response(
         self,

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/src/identity_plan_kit/shared/exception_handlers.py

@@ -9,6 +9,10 @@ from fastapi.responses import JSONResponse
 
 from identity_plan_kit.auth.domain.exceptions import (
     AuthError,
+    OAuthError,
+    RefreshTokenExpiredError,
+    RefreshTokenInvalidError,
+    RefreshTokenMissingError,
     TokenExpiredError,
     TokenInvalidError,
     UserInactiveError,
@@ -16,6 +20,7 @@ from identity_plan_kit.auth.domain.exceptions import (
 )
 from identity_plan_kit.plans.domain.exceptions import (
     FeatureNotAvailableError,
+    PlanAuthorizationError,
     PlanExpiredError,
     PlanNotFoundError,
     QuotaExceededError,
@@ -183,6 +188,59 @@ async def token_invalid_handler(request: Request, exc: TokenInvalidError) -> JSO
     )
 
 
+async def refresh_token_missing_handler(
+    request: Request, exc: RefreshTokenMissingError
+) -> JSONResponse:
+    """Handle missing refresh token errors."""
+    return create_error_response(
+        request=request,
+        status_code=401,
+        code=exc.code,
+        message="Refresh token not provided. Please log in again.",
+    )
+
+
+async def refresh_token_invalid_handler(
+    request: Request, exc: RefreshTokenInvalidError
+) -> JSONResponse:
+    """Handle invalid refresh token errors."""
+    return create_error_response(
+        request=request,
+        status_code=401,
+        code=exc.code,
+        message="Invalid refresh token. Please log in again.",
+    )
+
+
+async def refresh_token_expired_handler(
+    request: Request, exc: RefreshTokenExpiredError
+) -> JSONResponse:
+    """Handle expired refresh token errors."""
+    return create_error_response(
+        request=request,
+        status_code=401,
+        code=exc.code,
+        message="Refresh token has expired. Please log in again.",
+    )
+
+
+async def oauth_error_handler(request: Request, exc: OAuthError) -> JSONResponse:
+    """Handle OAuth errors."""
+    logger.warning(
+        "oauth_error",
+        error_code=exc.code,
+        provider=exc.provider,
+        path=request.url.path,
+    )
+    return create_error_response(
+        request=request,
+        status_code=401,
+        code=exc.code,
+        message=exc.message,
+        details={"provider": exc.provider} if exc.provider else None,
+    )
+
+
 async def user_inactive_handler(request: Request, exc: UserInactiveError) -> JSONResponse:
     """Handle inactive user errors."""
     return create_error_response(
@@ -205,9 +263,10 @@ async def user_not_found_handler(request: Request, exc: UserNotFoundError) -> JS
 
 async def permission_denied_handler(request: Request, exc: PermissionDeniedError) -> JSONResponse:
     """Handle permission denied errors."""
+    permission = exc.permission_code
     logger.warning(
         "permission_denied",
-        permission=exc.permission_code,
+        permission=permission,
         path=request.url.path,
     )
     return create_error_response(
@@ -215,7 +274,7 @@ async def permission_denied_handler(request: Request, exc: PermissionDeniedError
         status_code=403,
         code=exc.code,
         message=exc.message,
-        details={"permission": exc.permission_code} if exc.permission_code else None,
+        details={"permission": permission} if permission else None,
     )
 
 
@@ -297,6 +356,33 @@ async def plan_not_found_handler(request: Request, exc: PlanNotFoundError) -> JS
     )
 
 
+async def plan_authorization_error_handler(
+    request: Request,
+    exc: PlanAuthorizationError,
+) -> JSONResponse:
+    """Handle plan authorization errors.
+
+    Raised when a plan operation is not authorized (e.g., unauthorized plan assignment).
+    """
+    logger.warning(
+        "plan_authorization_error",
+        operation=exc.operation,
+        target_user_id=exc.target_user_id,
+        caller_user_id=exc.caller_user_id,
+        path=request.url.path,
+    )
+    return create_error_response(
+        request=request,
+        status_code=403,
+        code=exc.code,
+        message=exc.message,
+        details={
+            "operation": exc.operation,
+            "target_user_id": exc.target_user_id,
+        },
+    )
+
+
 async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
     """
     Handle FastAPI HTTPException errors.
@@ -478,6 +564,10 @@ def register_exception_handlers(
     # Auth errors
     app.add_exception_handler(TokenExpiredError, token_expired_handler)
     app.add_exception_handler(TokenInvalidError, token_invalid_handler)
+    app.add_exception_handler(RefreshTokenMissingError, refresh_token_missing_handler)
+    app.add_exception_handler(RefreshTokenInvalidError, refresh_token_invalid_handler)
+    app.add_exception_handler(RefreshTokenExpiredError, refresh_token_expired_handler)
+    app.add_exception_handler(OAuthError, oauth_error_handler)
     app.add_exception_handler(UserInactiveError, user_inactive_handler)
     app.add_exception_handler(UserNotFoundError, user_not_found_handler)
     app.add_exception_handler(AuthError, auth_error_handler)
@@ -492,6 +582,7 @@ def register_exception_handlers(
     app.add_exception_handler(FeatureNotAvailableError, feature_not_available_handler)
     app.add_exception_handler(UserPlanNotFoundError, user_plan_not_found_handler)
     app.add_exception_handler(PlanNotFoundError, plan_not_found_handler)
+    app.add_exception_handler(PlanAuthorizationError, plan_authorization_error_handler)
 
     # Base error (catch-all for domain errors)
     app.add_exception_handler(BaseError, base_error_handler)

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/src/identity_plan_kit/shared/exceptions.py

@@ -23,14 +23,22 @@ class BaseError(Exception):
         self.details = details
         super().__init__(self.message)
 
+    @property
+    def context(self) -> dict[str, Any] | None:
+        """Alias for details to support context naming convention."""
+        return self.details
+
     def to_dict(self) -> dict[str, Any]:
         """Convert exception to error response dict."""
+        error_content: dict[str, Any] = {
+            "code": self.code,
+            "message": self.message,
+        }
+        if self.details:
+            error_content["context"] = self.details
         return {
-            "error": {
-                "code": self.code,
-                "message": self.message,
-                "details": self.details,
-            }
+            "success": False,
+            "error": error_content,
         }
 
 

{identity_plan_kit-0.2.7 → identity_plan_kit-0.2.8}/uv.lock

@@ -962,7 +962,7 @@ wheels = [
 
 [[package]]
 name = "identity-plan-kit"
-version = "0.2.6"
+version = "0.2.7"
 source = { editable = "." }
 dependencies = [
     { name = "alembic" },