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 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)