runapi 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- runapi/__init__.py +174 -0
- runapi/auth.py +359 -0
- runapi/cli.py +576 -0
- runapi/config.py +141 -0
- runapi/core.py +219 -0
- runapi/errors.py +338 -0
- runapi/middleware.py +383 -0
- runapi-0.1.0.dist-info/METADATA +797 -0
- runapi-0.1.0.dist-info/RECORD +12 -0
- runapi-0.1.0.dist-info/WHEEL +4 -0
- runapi-0.1.0.dist-info/entry_points.txt +2 -0
- runapi-0.1.0.dist-info/licenses/LICENSE +21 -0
runapi/__init__.py
ADDED
|
@@ -0,0 +1,174 @@
|
|
|
1
|
+
"""
|
|
2
|
+
RunApi - A Next.js-inspired file-based routing framework built on FastAPI
|
|
3
|
+
"""
|
|
4
|
+
|
|
5
|
+
__version__ = "0.1.0"
|
|
6
|
+
__author__ = "Amanpreet Singh"
|
|
7
|
+
__email__ = "amanpreetsinghjhiwant7@gmail.com"
|
|
8
|
+
|
|
9
|
+
# Core framework
|
|
10
|
+
from .core import create_app, create_runapi_app, RunApiApp
|
|
11
|
+
|
|
12
|
+
# Configuration
|
|
13
|
+
from .config import RunApiConfig, get_config, load_config
|
|
14
|
+
|
|
15
|
+
# Error handling
|
|
16
|
+
from .errors import (
|
|
17
|
+
RunApiException,
|
|
18
|
+
ValidationError,
|
|
19
|
+
AuthenticationError,
|
|
20
|
+
AuthorizationError,
|
|
21
|
+
NotFoundError,
|
|
22
|
+
ConflictError,
|
|
23
|
+
RateLimitError,
|
|
24
|
+
ServerError,
|
|
25
|
+
DatabaseError,
|
|
26
|
+
ExternalServiceError,
|
|
27
|
+
ErrorResponse,
|
|
28
|
+
ErrorHandler,
|
|
29
|
+
setup_error_handlers,
|
|
30
|
+
raise_validation_error,
|
|
31
|
+
raise_auth_error,
|
|
32
|
+
raise_permission_error,
|
|
33
|
+
raise_not_found,
|
|
34
|
+
raise_conflict,
|
|
35
|
+
raise_server_error,
|
|
36
|
+
create_error_response,
|
|
37
|
+
bad_request,
|
|
38
|
+
unauthorized,
|
|
39
|
+
forbidden,
|
|
40
|
+
not_found,
|
|
41
|
+
conflict,
|
|
42
|
+
unprocessable_entity,
|
|
43
|
+
rate_limited,
|
|
44
|
+
internal_error,
|
|
45
|
+
)
|
|
46
|
+
|
|
47
|
+
# Authentication
|
|
48
|
+
from .auth import (
|
|
49
|
+
PasswordManager,
|
|
50
|
+
JWTManager,
|
|
51
|
+
APIKeyManager,
|
|
52
|
+
AuthDependencies,
|
|
53
|
+
TokenResponse,
|
|
54
|
+
hash_password,
|
|
55
|
+
verify_password,
|
|
56
|
+
create_access_token,
|
|
57
|
+
create_refresh_token,
|
|
58
|
+
verify_token,
|
|
59
|
+
get_current_user,
|
|
60
|
+
get_current_active_user,
|
|
61
|
+
require_roles,
|
|
62
|
+
require_permissions,
|
|
63
|
+
generate_api_key,
|
|
64
|
+
generate_password,
|
|
65
|
+
create_token_response,
|
|
66
|
+
api_key_manager,
|
|
67
|
+
)
|
|
68
|
+
|
|
69
|
+
# Middleware
|
|
70
|
+
from .middleware import (
|
|
71
|
+
RunApiMiddleware,
|
|
72
|
+
RequestLoggingMiddleware,
|
|
73
|
+
RateLimitMiddleware,
|
|
74
|
+
AuthMiddleware,
|
|
75
|
+
SecurityHeadersMiddleware,
|
|
76
|
+
CompressionMiddleware,
|
|
77
|
+
CORSMiddleware,
|
|
78
|
+
create_rate_limit_middleware,
|
|
79
|
+
create_auth_middleware,
|
|
80
|
+
create_logging_middleware,
|
|
81
|
+
create_security_middleware,
|
|
82
|
+
)
|
|
83
|
+
|
|
84
|
+
# Convenience imports
|
|
85
|
+
from fastapi import FastAPI, APIRouter, Depends, HTTPException, Request, Response
|
|
86
|
+
from fastapi.responses import JSONResponse, HTMLResponse, FileResponse
|
|
87
|
+
from fastapi.middleware.cors import CORSMiddleware as FastAPICORSMiddleware
|
|
88
|
+
|
|
89
|
+
__all__ = [
|
|
90
|
+
# Core
|
|
91
|
+
"create_app",
|
|
92
|
+
"create_runapi_app",
|
|
93
|
+
"RunApiApp",
|
|
94
|
+
|
|
95
|
+
# Configuration
|
|
96
|
+
"RunApiConfig",
|
|
97
|
+
"get_config",
|
|
98
|
+
"load_config",
|
|
99
|
+
|
|
100
|
+
# Error handling
|
|
101
|
+
"RunApiException",
|
|
102
|
+
"ValidationError",
|
|
103
|
+
"AuthenticationError",
|
|
104
|
+
"AuthorizationError",
|
|
105
|
+
"NotFoundError",
|
|
106
|
+
"ConflictError",
|
|
107
|
+
"RateLimitError",
|
|
108
|
+
"ServerError",
|
|
109
|
+
"DatabaseError",
|
|
110
|
+
"ExternalServiceError",
|
|
111
|
+
"ErrorResponse",
|
|
112
|
+
"ErrorHandler",
|
|
113
|
+
"setup_error_handlers",
|
|
114
|
+
"raise_validation_error",
|
|
115
|
+
"raise_auth_error",
|
|
116
|
+
"raise_permission_error",
|
|
117
|
+
"raise_not_found",
|
|
118
|
+
"raise_conflict",
|
|
119
|
+
"raise_server_error",
|
|
120
|
+
"create_error_response",
|
|
121
|
+
"bad_request",
|
|
122
|
+
"unauthorized",
|
|
123
|
+
"forbidden",
|
|
124
|
+
"not_found",
|
|
125
|
+
"conflict",
|
|
126
|
+
"unprocessable_entity",
|
|
127
|
+
"rate_limited",
|
|
128
|
+
"internal_error",
|
|
129
|
+
|
|
130
|
+
# Authentication
|
|
131
|
+
"PasswordManager",
|
|
132
|
+
"JWTManager",
|
|
133
|
+
"APIKeyManager",
|
|
134
|
+
"AuthDependencies",
|
|
135
|
+
"TokenResponse",
|
|
136
|
+
"hash_password",
|
|
137
|
+
"verify_password",
|
|
138
|
+
"create_access_token",
|
|
139
|
+
"create_refresh_token",
|
|
140
|
+
"verify_token",
|
|
141
|
+
"get_current_user",
|
|
142
|
+
"get_current_active_user",
|
|
143
|
+
"require_roles",
|
|
144
|
+
"require_permissions",
|
|
145
|
+
"generate_api_key",
|
|
146
|
+
"generate_password",
|
|
147
|
+
"create_token_response",
|
|
148
|
+
"api_key_manager",
|
|
149
|
+
|
|
150
|
+
# Middleware
|
|
151
|
+
"RunApiMiddleware",
|
|
152
|
+
"RequestLoggingMiddleware",
|
|
153
|
+
"RateLimitMiddleware",
|
|
154
|
+
"AuthMiddleware",
|
|
155
|
+
"SecurityHeadersMiddleware",
|
|
156
|
+
"CompressionMiddleware",
|
|
157
|
+
"CORSMiddleware",
|
|
158
|
+
"create_rate_limit_middleware",
|
|
159
|
+
"create_auth_middleware",
|
|
160
|
+
"create_logging_middleware",
|
|
161
|
+
"create_security_middleware",
|
|
162
|
+
|
|
163
|
+
# FastAPI re-exports
|
|
164
|
+
"FastAPI",
|
|
165
|
+
"APIRouter",
|
|
166
|
+
"Depends",
|
|
167
|
+
"HTTPException",
|
|
168
|
+
"Request",
|
|
169
|
+
"Response",
|
|
170
|
+
"JSONResponse",
|
|
171
|
+
"HTMLResponse",
|
|
172
|
+
"FileResponse",
|
|
173
|
+
"FastAPICORSMiddleware",
|
|
174
|
+
]
|
runapi/auth.py
ADDED
|
@@ -0,0 +1,359 @@
|
|
|
1
|
+
import os
|
|
2
|
+
import time
|
|
3
|
+
import hashlib
|
|
4
|
+
import secrets
|
|
5
|
+
from typing import Optional, Dict, Any, Union
|
|
6
|
+
from datetime import datetime, timedelta
|
|
7
|
+
import json
|
|
8
|
+
import base64
|
|
9
|
+
import hmac
|
|
10
|
+
|
|
11
|
+
try:
|
|
12
|
+
from passlib.context import CryptContext
|
|
13
|
+
except ImportError:
|
|
14
|
+
CryptContext = None
|
|
15
|
+
|
|
16
|
+
from fastapi import HTTPException, Depends, Request
|
|
17
|
+
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
|
|
18
|
+
|
|
19
|
+
from .config import get_config
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
class PasswordManager:
|
|
23
|
+
"""Password hashing and verification utilities."""
|
|
24
|
+
|
|
25
|
+
def __init__(self, schemes: list = None):
|
|
26
|
+
if CryptContext is None:
|
|
27
|
+
raise ImportError("passlib is required for password hashing. Install with: pip install passlib[bcrypt]")
|
|
28
|
+
self.schemes = schemes or ["bcrypt"]
|
|
29
|
+
self.pwd_context = CryptContext(schemes=self.schemes, deprecated="auto")
|
|
30
|
+
|
|
31
|
+
def hash_password(self, password: str) -> str:
|
|
32
|
+
"""Hash a password."""
|
|
33
|
+
return self.pwd_context.hash(password)
|
|
34
|
+
|
|
35
|
+
def verify_password(self, plain_password: str, hashed_password: str) -> bool:
|
|
36
|
+
"""Verify a password against its hash."""
|
|
37
|
+
return self.pwd_context.verify(plain_password, hashed_password)
|
|
38
|
+
|
|
39
|
+
def generate_random_password(self, length: int = 12) -> str:
|
|
40
|
+
"""Generate a random password."""
|
|
41
|
+
return secrets.token_urlsafe(length)
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
class JWTManager:
|
|
45
|
+
"""JWT token management utilities."""
|
|
46
|
+
|
|
47
|
+
def __init__(self, secret_key: str = None, algorithm: str = "HS256"):
|
|
48
|
+
self.config = get_config()
|
|
49
|
+
self.secret_key = secret_key or self.config.secret_key
|
|
50
|
+
self.algorithm = algorithm or self.config.jwt_algorithm
|
|
51
|
+
self.access_token_expire = self.config.jwt_expiry
|
|
52
|
+
self.refresh_token_expire = self.config.jwt_refresh_expiry
|
|
53
|
+
|
|
54
|
+
if self.secret_key == "dev-secret-key-change-in-production":
|
|
55
|
+
raise ValueError("Change the SECRET_KEY in production!")
|
|
56
|
+
|
|
57
|
+
def _base64url_encode(self, data: bytes) -> str:
|
|
58
|
+
"""Base64 URL-safe encode."""
|
|
59
|
+
return base64.urlsafe_b64encode(data).decode().rstrip('=')
|
|
60
|
+
|
|
61
|
+
def _base64url_decode(self, data: str) -> bytes:
|
|
62
|
+
"""Base64 URL-safe decode."""
|
|
63
|
+
# Add padding if needed
|
|
64
|
+
padding = 4 - len(data) % 4
|
|
65
|
+
if padding != 4:
|
|
66
|
+
data += '=' * padding
|
|
67
|
+
return base64.urlsafe_b64decode(data)
|
|
68
|
+
|
|
69
|
+
def _create_signature(self, header: str, payload: str) -> str:
|
|
70
|
+
"""Create JWT signature."""
|
|
71
|
+
message = f"{header}.{payload}"
|
|
72
|
+
signature = hmac.new(
|
|
73
|
+
self.secret_key.encode(),
|
|
74
|
+
message.encode(),
|
|
75
|
+
hashlib.sha256
|
|
76
|
+
).digest()
|
|
77
|
+
return self._base64url_encode(signature)
|
|
78
|
+
|
|
79
|
+
def create_token(
|
|
80
|
+
self,
|
|
81
|
+
data: Dict[str, Any],
|
|
82
|
+
expires_delta: Optional[timedelta] = None,
|
|
83
|
+
token_type: str = "access"
|
|
84
|
+
) -> str:
|
|
85
|
+
"""Create a JWT token."""
|
|
86
|
+
# Create header
|
|
87
|
+
header = {
|
|
88
|
+
"alg": self.algorithm,
|
|
89
|
+
"typ": "JWT"
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
# Create payload
|
|
93
|
+
to_encode = data.copy()
|
|
94
|
+
|
|
95
|
+
# Set expiration
|
|
96
|
+
if expires_delta:
|
|
97
|
+
expire = datetime.utcnow() + expires_delta
|
|
98
|
+
else:
|
|
99
|
+
expire_minutes = self.access_token_expire if token_type == "access" else self.refresh_token_expire
|
|
100
|
+
expire = datetime.utcnow() + timedelta(seconds=expire_minutes)
|
|
101
|
+
|
|
102
|
+
to_encode.update({
|
|
103
|
+
"exp": int(expire.timestamp()),
|
|
104
|
+
"iat": int(datetime.utcnow().timestamp()),
|
|
105
|
+
"type": token_type
|
|
106
|
+
})
|
|
107
|
+
|
|
108
|
+
# Encode header and payload
|
|
109
|
+
header_encoded = self._base64url_encode(json.dumps(header).encode())
|
|
110
|
+
payload_encoded = self._base64url_encode(json.dumps(to_encode).encode())
|
|
111
|
+
|
|
112
|
+
# Create signature
|
|
113
|
+
signature = self._create_signature(header_encoded, payload_encoded)
|
|
114
|
+
|
|
115
|
+
# Return complete token
|
|
116
|
+
return f"{header_encoded}.{payload_encoded}.{signature}"
|
|
117
|
+
|
|
118
|
+
def verify_token(self, token: str) -> Optional[Dict[str, Any]]:
|
|
119
|
+
"""Verify and decode a JWT token."""
|
|
120
|
+
try:
|
|
121
|
+
parts = token.split('.')
|
|
122
|
+
if len(parts) != 3:
|
|
123
|
+
return None
|
|
124
|
+
|
|
125
|
+
header_encoded, payload_encoded, signature = parts
|
|
126
|
+
|
|
127
|
+
# Verify signature
|
|
128
|
+
expected_signature = self._create_signature(header_encoded, payload_encoded)
|
|
129
|
+
if not hmac.compare_digest(signature, expected_signature):
|
|
130
|
+
return None
|
|
131
|
+
|
|
132
|
+
# Decode payload
|
|
133
|
+
payload_data = json.loads(self._base64url_decode(payload_encoded))
|
|
134
|
+
|
|
135
|
+
# Check expiration
|
|
136
|
+
if 'exp' in payload_data and payload_data['exp'] < time.time():
|
|
137
|
+
return None
|
|
138
|
+
|
|
139
|
+
return payload_data
|
|
140
|
+
|
|
141
|
+
except Exception:
|
|
142
|
+
return None
|
|
143
|
+
|
|
144
|
+
def create_access_token(self, data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
|
|
145
|
+
"""Create an access token."""
|
|
146
|
+
return self.create_token(data, expires_delta, "access")
|
|
147
|
+
|
|
148
|
+
def create_refresh_token(self, data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
|
|
149
|
+
"""Create a refresh token."""
|
|
150
|
+
return self.create_token(data, expires_delta, "refresh")
|
|
151
|
+
|
|
152
|
+
def refresh_access_token(self, refresh_token: str) -> Optional[str]:
|
|
153
|
+
"""Create new access token from refresh token."""
|
|
154
|
+
payload = self.verify_token(refresh_token)
|
|
155
|
+
if not payload or payload.get("type") != "refresh":
|
|
156
|
+
return None
|
|
157
|
+
|
|
158
|
+
# Remove token-specific fields
|
|
159
|
+
user_data = {k: v for k, v in payload.items() if k not in ['exp', 'iat', 'type']}
|
|
160
|
+
return self.create_access_token(user_data)
|
|
161
|
+
|
|
162
|
+
|
|
163
|
+
class APIKeyManager:
|
|
164
|
+
"""API Key management utilities."""
|
|
165
|
+
|
|
166
|
+
def __init__(self):
|
|
167
|
+
self.config = get_config()
|
|
168
|
+
|
|
169
|
+
def generate_api_key(self, length: int = 32) -> str:
|
|
170
|
+
"""Generate a new API key."""
|
|
171
|
+
return secrets.token_urlsafe(length)
|
|
172
|
+
|
|
173
|
+
def hash_api_key(self, api_key: str) -> str:
|
|
174
|
+
"""Hash an API key for storage."""
|
|
175
|
+
return hashlib.sha256(api_key.encode()).hexdigest()
|
|
176
|
+
|
|
177
|
+
def verify_api_key(self, api_key: str, hashed_key: str) -> bool:
|
|
178
|
+
"""Verify an API key against its hash."""
|
|
179
|
+
return hmac.compare_digest(self.hash_api_key(api_key), hashed_key)
|
|
180
|
+
|
|
181
|
+
|
|
182
|
+
class AuthDependencies:
|
|
183
|
+
"""FastAPI dependency classes for authentication."""
|
|
184
|
+
|
|
185
|
+
def __init__(self, jwt_manager: JWTManager = None):
|
|
186
|
+
self.jwt_manager = jwt_manager or JWTManager()
|
|
187
|
+
self.bearer_scheme = HTTPBearer()
|
|
188
|
+
|
|
189
|
+
async def get_current_user(
|
|
190
|
+
self,
|
|
191
|
+
credentials: HTTPAuthorizationCredentials = Depends(HTTPBearer())
|
|
192
|
+
) -> Dict[str, Any]:
|
|
193
|
+
"""Dependency to get current authenticated user."""
|
|
194
|
+
token = credentials.credentials
|
|
195
|
+
payload = self.jwt_manager.verify_token(token)
|
|
196
|
+
|
|
197
|
+
if not payload:
|
|
198
|
+
raise HTTPException(
|
|
199
|
+
status_code=401,
|
|
200
|
+
detail="Invalid or expired token",
|
|
201
|
+
headers={"WWW-Authenticate": "Bearer"},
|
|
202
|
+
)
|
|
203
|
+
|
|
204
|
+
return payload
|
|
205
|
+
|
|
206
|
+
async def get_current_active_user(
|
|
207
|
+
self,
|
|
208
|
+
current_user: Dict[str, Any] = Depends(lambda: AuthDependencies().get_current_user)
|
|
209
|
+
) -> Dict[str, Any]:
|
|
210
|
+
"""Dependency to get current active user."""
|
|
211
|
+
if current_user.get("disabled"):
|
|
212
|
+
raise HTTPException(status_code=400, detail="Inactive user")
|
|
213
|
+
return current_user
|
|
214
|
+
|
|
215
|
+
async def require_roles(self, required_roles: list):
|
|
216
|
+
"""Create a dependency that requires specific roles."""
|
|
217
|
+
async def role_checker(
|
|
218
|
+
current_user: Dict[str, Any] = Depends(self.get_current_user)
|
|
219
|
+
):
|
|
220
|
+
user_roles = current_user.get("roles", [])
|
|
221
|
+
if not any(role in user_roles for role in required_roles):
|
|
222
|
+
raise HTTPException(
|
|
223
|
+
status_code=403,
|
|
224
|
+
detail="Insufficient permissions"
|
|
225
|
+
)
|
|
226
|
+
return current_user
|
|
227
|
+
return role_checker
|
|
228
|
+
|
|
229
|
+
async def require_permissions(self, required_permissions: list):
|
|
230
|
+
"""Create a dependency that requires specific permissions."""
|
|
231
|
+
async def permission_checker(
|
|
232
|
+
current_user: Dict[str, Any] = Depends(self.get_current_user)
|
|
233
|
+
):
|
|
234
|
+
user_permissions = current_user.get("permissions", [])
|
|
235
|
+
if not all(perm in user_permissions for perm in required_permissions):
|
|
236
|
+
raise HTTPException(
|
|
237
|
+
status_code=403,
|
|
238
|
+
detail="Insufficient permissions"
|
|
239
|
+
)
|
|
240
|
+
return current_user
|
|
241
|
+
return permission_checker
|
|
242
|
+
|
|
243
|
+
|
|
244
|
+
# Global instances (lazy initialization to handle import errors gracefully)
|
|
245
|
+
password_manager = None
|
|
246
|
+
jwt_manager = None
|
|
247
|
+
api_key_manager = APIKeyManager()
|
|
248
|
+
auth_deps = None
|
|
249
|
+
|
|
250
|
+
def _get_password_manager():
|
|
251
|
+
global password_manager
|
|
252
|
+
if password_manager is None:
|
|
253
|
+
try:
|
|
254
|
+
password_manager = PasswordManager()
|
|
255
|
+
except ImportError:
|
|
256
|
+
pass
|
|
257
|
+
return password_manager
|
|
258
|
+
|
|
259
|
+
def _get_jwt_manager():
|
|
260
|
+
global jwt_manager
|
|
261
|
+
if jwt_manager is None:
|
|
262
|
+
jwt_manager = JWTManager()
|
|
263
|
+
return jwt_manager
|
|
264
|
+
|
|
265
|
+
def _get_auth_deps():
|
|
266
|
+
global auth_deps
|
|
267
|
+
if auth_deps is None:
|
|
268
|
+
auth_deps = AuthDependencies()
|
|
269
|
+
return auth_deps
|
|
270
|
+
|
|
271
|
+
|
|
272
|
+
def hash_password(password: str) -> str:
|
|
273
|
+
"""Hash a password using the global password manager."""
|
|
274
|
+
manager = _get_password_manager()
|
|
275
|
+
if manager is None:
|
|
276
|
+
raise ImportError("passlib is required for password hashing. Install with: pip install passlib[bcrypt]")
|
|
277
|
+
return manager.hash_password(password)
|
|
278
|
+
|
|
279
|
+
|
|
280
|
+
def verify_password(plain_password: str, hashed_password: str) -> bool:
|
|
281
|
+
"""Verify a password using the global password manager."""
|
|
282
|
+
manager = _get_password_manager()
|
|
283
|
+
if manager is None:
|
|
284
|
+
raise ImportError("passlib is required for password hashing. Install with: pip install passlib[bcrypt]")
|
|
285
|
+
return manager.verify_password(plain_password, hashed_password)
|
|
286
|
+
|
|
287
|
+
|
|
288
|
+
def create_access_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
|
|
289
|
+
"""Create an access token using the global JWT manager."""
|
|
290
|
+
return _get_jwt_manager().create_access_token(data, expires_delta)
|
|
291
|
+
|
|
292
|
+
|
|
293
|
+
def create_refresh_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
|
|
294
|
+
"""Create a refresh token using the global JWT manager."""
|
|
295
|
+
return _get_jwt_manager().create_refresh_token(data, expires_delta)
|
|
296
|
+
|
|
297
|
+
|
|
298
|
+
def verify_token(token: str) -> Optional[Dict[str, Any]]:
|
|
299
|
+
"""Verify a token using the global JWT manager."""
|
|
300
|
+
return _get_jwt_manager().verify_token(token)
|
|
301
|
+
|
|
302
|
+
|
|
303
|
+
def get_current_user():
|
|
304
|
+
"""Get the current user dependency."""
|
|
305
|
+
return _get_auth_deps().get_current_user
|
|
306
|
+
|
|
307
|
+
|
|
308
|
+
def get_current_active_user():
|
|
309
|
+
"""Get the current active user dependency."""
|
|
310
|
+
return _get_auth_deps().get_current_active_user
|
|
311
|
+
|
|
312
|
+
|
|
313
|
+
def require_roles(roles: list):
|
|
314
|
+
"""Create a dependency that requires specific roles."""
|
|
315
|
+
return _get_auth_deps().require_roles(roles)
|
|
316
|
+
|
|
317
|
+
|
|
318
|
+
def require_permissions(permissions: list):
|
|
319
|
+
"""Create a dependency that requires specific permissions."""
|
|
320
|
+
return _get_auth_deps().require_permissions(permissions)
|
|
321
|
+
|
|
322
|
+
|
|
323
|
+
# Utility functions
|
|
324
|
+
def generate_api_key(length: int = 32) -> str:
|
|
325
|
+
"""Generate a new API key."""
|
|
326
|
+
return api_key_manager.generate_api_key(length)
|
|
327
|
+
|
|
328
|
+
|
|
329
|
+
def generate_password(length: int = 12) -> str:
|
|
330
|
+
"""Generate a random password."""
|
|
331
|
+
manager = _get_password_manager()
|
|
332
|
+
if manager is None:
|
|
333
|
+
raise ImportError("passlib is required for password generation. Install with: pip install passlib[bcrypt]")
|
|
334
|
+
return manager.generate_random_password(length)
|
|
335
|
+
|
|
336
|
+
|
|
337
|
+
class TokenResponse:
|
|
338
|
+
"""Standard token response format."""
|
|
339
|
+
|
|
340
|
+
def __init__(self, access_token: str, refresh_token: str = None, token_type: str = "bearer"):
|
|
341
|
+
self.access_token = access_token
|
|
342
|
+
self.refresh_token = refresh_token
|
|
343
|
+
self.token_type = token_type
|
|
344
|
+
|
|
345
|
+
def dict(self):
|
|
346
|
+
result = {
|
|
347
|
+
"access_token": self.access_token,
|
|
348
|
+
"token_type": self.token_type
|
|
349
|
+
}
|
|
350
|
+
if self.refresh_token:
|
|
351
|
+
result["refresh_token"] = self.refresh_token
|
|
352
|
+
return result
|
|
353
|
+
|
|
354
|
+
|
|
355
|
+
def create_token_response(user_data: Dict[str, Any]) -> TokenResponse:
|
|
356
|
+
"""Create a standard token response with access and refresh tokens."""
|
|
357
|
+
access_token = create_access_token(user_data)
|
|
358
|
+
refresh_token = create_refresh_token(user_data)
|
|
359
|
+
return TokenResponse(access_token=access_token, refresh_token=refresh_token)
|