auth-framework 0.4.2

A comprehensive, production-ready authentication and authorization framework for Rust applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

"""User management service for AuthFramework.

Copyright (c) 2025 AuthFramework. All rights reserved.
"""

from __future__ import annotations

from typing import Any

from ._base import BaseClient, RequestConfig


class UserService:
    """Service for user management operations."""

    def __init__(self, client: BaseClient) -> None:
        """Initialize user service.

        Args:
            client: The base HTTP client

        """
        self._client = client

    async def get_profile(self) -> dict[str, Any]:
        """Get current user's profile.

        Returns:
            User profile data.

        """
        return await self._client.make_request("GET", "/user/profile")

    async def update_profile(self, profile_data: dict[str, Any]) -> dict[str, Any]:
        """Update current user's profile.

        Args:
            profile_data: Updated profile information

        Returns:
            Updated profile data.

        """
        config = RequestConfig(json_data=profile_data)
        return await self._client.make_request("PUT", "/user/profile", config=config)

    async def get_users(
        self,
        limit: int = 50,
        offset: int = 0,
        search: str | None = None,
    ) -> dict[str, Any]:
        """Get list of users.

        Args:
            limit: Maximum number of users to return
            offset: Number of users to skip
            search: Search query

        Returns:
            List of users and pagination info.

        """
        params: dict[str, Any] = {"limit": limit, "offset": offset}
        if search:
            params["search"] = search

        config = RequestConfig(params=params)
        return await self._client.make_request("GET", "/users", config=config)

    async def get_user(self, user_id: str) -> dict[str, Any]:
        """Get specific user by ID.

        Args:
            user_id: User ID

        Returns:
            User data.

        """
        return await self._client.make_request("GET", f"/users/{user_id}")

    async def create_user(self, user_data: dict[str, Any]) -> dict[str, Any]:
        """Create a new user (admin only).

        Args:
            user_data: User creation data

        Returns:
            Created user data.

        """
        config = RequestConfig(json_data=user_data)
        return await self._client.make_request("POST", "/users", config=config)

    async def update_user(
        self,
        user_id: str,
        user_data: dict[str, Any],
    ) -> dict[str, Any]:
        """Update user information (admin only).

        Args:
            user_id: User ID
            user_data: Updated user data

        Returns:
            Updated user data.

        """
        config = RequestConfig(json_data=user_data)
        return await self._client.make_request(
            "PUT",
            f"/users/{user_id}",
            config=config,
        )

    async def delete_user(self, user_id: str) -> dict[str, Any]:
        """Delete a user (admin only).

        Args:
            user_id: User ID

        Returns:
            Deletion confirmation.

        """
        return await self._client.make_request("DELETE", f"/users/{user_id}")

    async def deactivate_user(self, user_id: str) -> dict[str, Any]:
        """Deactivate a user account.

        Args:
            user_id: User ID

        Returns:
            Deactivation confirmation.

        """
        return await self._client.make_request("POST", f"/users/{user_id}/deactivate")

    async def activate_user(self, user_id: str) -> dict[str, Any]:
        """Activate a user account.

        Args:
            user_id: User ID

        Returns:
            Activation confirmation.

        """
        return await self._client.make_request("POST", f"/users/{user_id}/activate")