fastv 1.0.0__py3-none-any.whl

fastv/__init__.py

@@ -0,0 +1,396 @@
+"""
+Application - Framework core entry point.
+"""
+
+import importlib
+import os
+import sys
+from contextlib import asynccontextmanager
+from typing import AsyncIterator, Callable, Coroutine, List
+
+from fastapi import FastAPI
+
+from fastv.config import Config
+from fastv.container.container import Container
+from fastv.support.helpers import set_application
+
+
+class Application(Container):
+    _instance = None
+
+    def __new__(cls, base_dir=None):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, base_dir=None):
+        if getattr(self, "_initialized", False):
+            return
+        super().__init__()
+        self.base_dir = base_dir or os.getcwd()
+        self._shutdown_callbacks: List[Callable[[], Coroutine]] = []
+        self._startup_callbacks: List[Callable[[], Coroutine]] = []
+        self.app = FastAPI(title="FastAPI Application")
+        self.config = Config(self.base_dir)
+        self.router = None
+        self._bootstrapped = False
+        self._initialized = True
+        set_application(self)
+
+    def _on_startup(self, callback: Callable[[], Coroutine]):
+        """注册 startup 回调（替代 @app.on_event("startup")）"""
+        self._startup_callbacks.append(callback)
+
+    def _on_shutdown(self, callback: Callable[[], Coroutine]):
+        """注册 shutdown 回调（替代 @app.on_event("shutdown")）"""
+        self._shutdown_callbacks.append(callback)
+
+    @asynccontextmanager
+    async def _lifespan(self, app: FastAPI) -> AsyncIterator[None]:
+        """FastAPI lifespan 上下文管理器"""
+        # 启动
+        for cb in self._startup_callbacks:
+            try:
+                await cb()
+            except Exception as e:
+                print(f"[Lifespan] startup callback failed: {e}")
+        yield
+        # 关闭
+        for cb in self._shutdown_callbacks:
+            try:
+                await cb()
+            except Exception as e:
+                print(f"[Lifespan] shutdown callback failed: {e}")
+
+    def bootstrap(self):
+        if self._bootstrapped:
+            return self.app
+        self._load_config()
+        self._register_services()
+        self._register_exception_handler()
+        self._init_redis()
+        self._init_cache()
+        self._init_logger()
+        self._init_database()
+        self._init_auth()
+        self._init_asynctasq()
+        self._discover_routes()
+        self._discover_middleware()
+        self._discover_events()
+        self._discover_commands()
+        # 注册 lifespan（替代 on_event）
+        self.app.router.lifespan_context = self._lifespan
+        self._bootstrapped = True
+        return self.app
+
+    def _load_config(self):
+        config_dir = os.path.join(self.base_dir, "config")
+        if os.path.isdir(config_dir):
+            self.config.load_from_dir(config_dir)
+        self.instance("config", self.config)
+
+    def _register_services(self):
+        from fastv.events.dispatcher import Dispatcher
+        from fastv.http.middleware.pipeline import Pipeline
+        from fastv.routing.router import Router
+        self.singleton("router", lambda: Router())
+        self.singleton("pipeline", lambda: Pipeline())
+        self.singleton("events", lambda: Dispatcher())
+        self.instance("app", self.app)
+
+    def _register_exception_handler(self):
+        from fastv.exceptions.handler import register_exception_handler
+        exc_config = self.config.get("exception", {})
+        register_exception_handler(self.app, exc_config)
+
+    def _discover_routes(self):
+        route_dir = os.path.join(self.base_dir, "app")
+        if not os.path.isdir(route_dir):
+            return
+        self._add_app_to_path()
+        route_count = 0
+        for root, dirs, files in os.walk(route_dir):
+            if os.path.basename(root) == "route":
+                for f in files:
+                    if f.endswith(".py") and not f.startswith("_"):
+                        rel_path = os.path.relpath(os.path.join(root, f), self.base_dir)
+                        module_name = rel_path.replace(os.sep, ".").replace(".py", "")
+                        try:
+                            module = importlib.import_module(module_name)
+                            if hasattr(module, "register"):
+                                module.register(self.app)
+                                route_count += 1
+                            from fastv.routing.router import Router as PkgRouter
+                            for name in dir(module):
+                                obj = getattr(module, name)
+                                if isinstance(obj, PkgRouter):
+                                    obj.register(self.app)
+                                    route_count += 1
+                        except ImportError as e:
+                            print("[Route] Failed:", module_name, e)
+        if route_count > 0:
+            print("[Route] Discovered", route_count, "route file(s)")
+
+    def _discover_middleware(self):
+        mw_config = self.config.get("middleware")
+        if mw_config:
+            self._load_middleware_from_config(mw_config)
+        else:
+            self._auto_discover_middleware()
+
+    def _load_middleware_from_config(self, mw_config: dict):
+        mw_count = 0
+        self._add_app_to_path()
+
+        # 全局中间件
+        for mw_path in mw_config.get("global_middleware", []):
+            cls = self._import_class(mw_path)
+            if cls:
+                self.app.middleware("http")(self._mw_adapter(cls))
+                mw_count += 1
+
+        # 模块中间件
+        for module_name, mw_list in mw_config.get("modules", {}).items():
+            for mw_path in mw_list:
+                cls = self._import_class(mw_path)
+                if cls:
+                    self.app.middleware("http")(self._mw_adapter(cls))
+                    mw_count += 1
+
+        if mw_count > 0:
+            print(f"[Middleware] Registered {mw_count} middleware(s) from config")
+
+    def _auto_discover_middleware(self):
+        app_dir = os.path.join(self.base_dir, "app")
+        if not os.path.isdir(app_dir):
+            return
+        self._add_app_to_path()
+        mw_count = 0
+        for root, dirs, files in os.walk(app_dir):
+            if os.path.basename(root) == "middleware":
+                for f in files:
+                    if f.endswith(".py") and not f.startswith("_"):
+                        rel_path = os.path.relpath(os.path.join(root, f), self.base_dir)
+                        module_name = rel_path.replace(os.sep, ".").replace(".py", "")
+                        try:
+                            module = importlib.import_module(module_name)
+                            for name in dir(module):
+                                cls = getattr(module, name)
+                                if isinstance(cls, type) and hasattr(cls, "__call__"):
+                                    self.app.middleware("http")(self._mw_adapter(cls))
+                                    mw_count += 1
+                        except ImportError as e:
+                            print("[Middleware] Failed:", module_name, e)
+        if mw_count > 0:
+            print(f"[Middleware] Auto-discovered {mw_count} middleware(s)")
+
+    @staticmethod
+    def _import_class(dotted_path: str):
+        module_name, class_name = dotted_path.rsplit(".", 1)
+        try:
+            module = importlib.import_module(module_name)
+            return getattr(module, class_name, None)
+        except ImportError as e:
+            print(f"[Middleware] Failed to import {dotted_path}: {e}")
+            return None
+
+    def _discover_events(self):
+        event_dir = os.path.join(self.base_dir, "app", "event")
+        if not os.path.isdir(event_dir):
+            return
+        self._add_app_to_path()
+        listener_count = 0
+        for f in os.listdir(event_dir):
+            if f.endswith(".py") and not f.startswith("_"):
+                modname = "app.event." + f[:-3]
+                try:
+                    module = importlib.import_module(modname)
+                    dispatcher = self.make("events")
+                    if hasattr(module, "register"):
+                        module.register(dispatcher)
+                        listener_count += 1
+                    for name in dir(module):
+                        cls = getattr(module, name)
+                        if isinstance(cls, type) and hasattr(cls, "subscribe"):
+                            cls().subscribe(dispatcher)
+                            listener_count += 1
+                except ImportError as e:
+                    print("[Event] Failed:", modname, e)
+        if listener_count > 0:
+            print("[Event] Registered", listener_count, "event listener(s)")
+
+    def _init_database(self):
+        default = self.config.get("database.default", "sqlite")
+        connections = self.config.get("database.connections", {})
+        if not connections:
+            return
+        conn_config = connections.get(default, {})
+        if not conn_config:
+            return
+        from fastv.database.connection import ConnectionManager, get_db
+        db = get_db()
+        url = ConnectionManager.build_url(conn_config)
+        echo = self.config.get("database.debug", False)
+
+        # 连接池配置（可在 config/database.php 中覆盖）
+        pool_kwargs = {
+            "pool_size": conn_config.get("pool_size", 10),
+            "max_overflow": conn_config.get("max_overflow", 20),
+            "pool_recycle": conn_config.get("pool_recycle", 3600),
+            "pool_pre_ping": conn_config.get("pool_pre_ping", True),
+            "connect_timeout": conn_config.get("connect_timeout", 10),
+        }
+        try:
+            db.configure(url, echo=echo, **pool_kwargs)
+            self.instance("db", db)
+            print(f"[Database] Connected ({default}) pool_size={pool_kwargs['pool_size']}")
+
+            self._on_shutdown(_make_close_db(db))
+        except Exception as e:
+            print(f"[Database] Skip ({e})")
+            return
+
+    def _init_auth(self):
+        """初始化认证服务"""
+        auth_config = self.config.get("auth", {})
+        if not auth_config:
+            return
+
+        from fastv.auth import AuthManager, set_auth
+        auth = AuthManager(auth_config)
+        self.instance("auth", auth)
+        set_auth(auth)
+        print("[Auth] JWT authentication initialized")
+
+    def _discover_commands(self):
+        """Deprecated: CLI command discovery is now handled by ArtisanApplication via fastv.py."""
+        pass
+
+    def _add_app_to_path(self):
+        app_path = os.path.join(self.base_dir, "app")
+        if app_path not in sys.path:
+            sys.path.insert(0, app_path)
+        if self.base_dir not in sys.path:
+            sys.path.insert(0, self.base_dir)
+
+
+    def _init_redis(self):
+        """初始化 Redis 连接"""
+        redis_config = self.config.get("redis.redis", {})
+        if not redis_config:
+            return
+        from fastv.redis import get_redis
+        rm = get_redis()
+        rm.configure(redis_config)
+        conn = rm.connection("default")
+
+        self.instance("redis", rm)
+
+        if conn.is_connected:
+            import asyncio
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                print("[Redis] Connected")
+            else:
+                try:
+                    pong = loop.run_until_complete(conn.ping())
+                    if pong:
+                        print("[Redis] Connected")
+                    else:
+                        print("[Redis] Connected but server unreachable")
+                except Exception as e:
+                    print(f"[Redis] Connected but ping failed ({e})")
+
+            self._on_shutdown(_make_close_redis(rm))
+        else:
+            print("[Redis] Package not installed (pip install redis), using fallback")
+
+    def _init_cache(self):
+        """初始化缓存"""
+        default = self.config.get("cache.default", "file")
+        stores = self.config.get("cache.stores", {})
+        if not stores:
+            stores = {"array": {"driver": "array"}}
+            default = "array"
+        redis_mgr = None
+        if self.has("redis"):
+            redis_mgr = self.make("redis")
+        from fastv.cache import get_cache
+        cm = get_cache()
+        cm.configure(default, stores, redis_mgr)
+        self.instance("cache", cm)
+        print(f"[Cache] Driver: {default}")
+
+    def _init_logger(self):
+        """初始化日志"""
+        default = self.config.get("logging.default", "daily")
+        channels = self.config.get("logging.channels", {})
+        level = self.config.get("logging.level", "debug")
+        if not channels:
+            channels = {"daily": {"driver": "daily", "path": "storage/logs/app.log", "level": "debug", "days": 14}}
+        from fastv.log import get_logger
+        lm = get_logger()
+        lm.configure(default, channels, level)
+        self.instance("log", lm)
+        lm.info(f"[Logger] Channel: {default}, Level: {level}")
+        print(f"[Logger] Channel: {default}")
+
+    def _init_asynctasq(self):
+        """初始化 AsyncTasQ 任务队列"""
+        queue_cfg = self.config.get("queue.asynctasq", {})
+        if not queue_cfg:
+            return
+        redis_cfg = self.config.get("redis.redis.default", {})
+        db_name = self.config.get("database.default", "sqlite")
+        db_cfg = self.config.get(f"database.connections.{db_name}", {})
+        try:
+            from fastv.queue import register_lifecycle
+            register_lifecycle(self, queue_cfg, redis_cfg, db_cfg)
+        except ImportError:
+            print("[TaskQueue] asynctasq not installed, skipping")
+        except Exception as e:
+            print(f"[TaskQueue] Init failed ({e}), task dispatch will be unavailable")
+
+    async def __call__(self, scope, receive, send):
+        await self.app(scope, receive, send)
+
+    @staticmethod
+    def _mw_adapter(mw_class):
+        async def middleware_func(request, call_next):
+            instance = mw_class()
+            if hasattr(instance, "__call__"):
+                return await instance(request, call_next)
+            if hasattr(instance, "handle"):
+                return await instance.handle(request, call_next)
+            return await call_next(request)
+        return middleware_func
+
+
+def _make_close_db(db):
+    """创建关闭数据库连接的回调"""
+    async def _close():
+        await db.close()
+        print("[Database] Disconnected")
+    return _close
+
+
+def _make_close_redis(rm):
+    """创建关闭 Redis 连接的回调"""
+    async def _close():
+        await rm.close_all()
+        print("[Redis] Disconnected")
+    return _close
+
+
+def get_app():
+    return Application._instance
+
+
+def cli():
+    """CLI entry point — Artisan-style command interface."""
+    from fastv.console.application import ArtisanApplication
+    app = ArtisanApplication()
+    app.discover()
+    app.create_cli()()
+

fastv/auth/__init__.py

@@ -0,0 +1,24 @@
+"""
+Auth 认证模块
+
+提供 JWT 认证功能：
+    - JwtManager: JWT token 生成和验证
+    - PasswordHasher: 密码哈希和验证
+    - JwtGuard: JWT 认证守卫
+    - AuthManager: 认证管理器
+    - get_auth(): 获取全局 Auth 实例
+"""
+
+from .auth_manager import AuthManager, get_auth, set_auth
+from .guard import JwtGuard
+from .jwt_manager import JwtManager
+from .password_hasher import PasswordHasher
+
+__all__ = [
+    "get_auth",
+    "set_auth",
+    "JwtManager",
+    "PasswordHasher",
+    "JwtGuard",
+    "AuthManager",
+]

fastv/auth/auth_manager.py

@@ -0,0 +1,122 @@
+"""
+Auth Manager - 认证管理器
+
+管理多个认证守卫（类似 Laravel AuthManager）：
+    - guard(): 获取指定守卫
+    - check(): 检查是否已认证
+    - user(): 获取当前用户
+    - id(): 获取当前用户 ID
+"""
+
+import importlib
+from typing import Optional
+
+from fastv.auth.guard import JwtGuard
+from fastv.auth.jwt_manager import JwtManager
+
+
+class AuthManager:
+    """认证管理器"""
+
+    def __init__(self, config: dict):
+        self.config = config
+        self._guards = {}
+        self._current_guard_name = config.get("guards", {}).get("default", "jwt")
+
+    def guard(self, name: Optional[str] = None) -> JwtGuard:
+        """
+        获取指定守卫
+
+        Args:
+            name: 守卫名称，默认使用配置中的 default
+
+        Returns:
+            JwtGuard 实例
+        """
+        guard_name = name or self._current_guard_name
+
+        if guard_name not in self._guards:
+            self._guards[guard_name] = self._create_guard(guard_name)
+
+        return self._guards[guard_name]
+
+    def _create_guard(self, name: str) -> JwtGuard:
+        """创建守卫实例"""
+        guards_config = self.config.get("guards", {}).get("guards", {})
+        guard_config = guards_config.get(name, {})
+
+        driver = guard_config.get("driver", "jwt")
+        provider_name = guard_config.get("provider", "users")
+
+        if driver != "jwt":
+            raise ValueError(f"Unsupported guard driver: {driver}")
+
+        # 获取用户提供者配置
+        providers_config = self.config.get("guards", {}).get("providers", {})
+        provider_config = providers_config.get(provider_name, {})
+
+        provider_driver = provider_config.get("driver", "eloquent")
+        model_path = provider_config.get("model", "app.model.user.User")
+
+        if provider_driver != "eloquent":
+            raise ValueError(f"Unsupported provider driver: {provider_driver}")
+
+        # 动态加载用户模型
+        user_model = self._load_model(model_path)
+
+        # 创建 JWT 管理器
+        jwt_manager = JwtManager(self.config)
+
+        return JwtGuard(user_model, jwt_manager)
+
+    @staticmethod
+    def _load_model(model_path: str):
+        """动态加载模型类"""
+        module_path, class_name = model_path.rsplit(".", 1)
+        module = importlib.import_module(module_path)
+        return getattr(module, class_name)
+
+    def check(self) -> bool:
+        """检查是否已认证"""
+        return self.guard().check()
+
+    def user(self) -> Optional[object]:
+        """获取当前用户"""
+        return self.guard().user()
+
+    def id(self) -> Optional[int]:
+        """获取当前用户 ID"""
+        return self.guard().id()
+
+    def logout(self):
+        """登出"""
+        self.guard().logout()
+
+
+# 全局 Auth 实例（类似 Laravel Auth facade）
+_auth_instance: Optional[AuthManager] = None
+
+
+def get_auth() -> AuthManager:
+    """获取全局 Auth 实例"""
+    global _auth_instance
+    if _auth_instance is None:
+        # 从 Application 容器获取
+        try:
+            from fastv import get_app
+            app = get_app()
+            if app and app.has("auth"):
+                _auth_instance = app.make("auth")
+        except Exception:
+            pass
+
+    if _auth_instance is None:
+        raise RuntimeError("Auth not initialized. Call Application._init_auth() first.")
+
+    return _auth_instance
+
+
+def set_auth(auth: AuthManager):
+    """设置全局 Auth 实例"""
+    global _auth_instance
+    _auth_instance = auth

fastv/auth/guard.py

@@ -0,0 +1,127 @@
+"""
+JWT Guard - JWT 认证守卫
+
+类似 Laravel 的 JWT Guard，负责：
+    - attempt(): 尝试登录，验证凭证并返回 token
+    - validate_token(): 验证 token 并返回用户
+    - user(): 获取当前认证用户
+    - check(): 检查是否已认证
+    - id(): 获取当前用户 ID
+    - logout(): 登出
+"""
+
+from typing import Optional
+
+from fastv.auth.jwt_manager import JwtManager
+from fastv.auth.password_hasher import PasswordHasher
+
+
+class JwtGuard:
+    """JWT 认证守卫"""
+
+    def __init__(self, user_model, jwt_manager: JwtManager):
+        self.user_model = user_model
+        self.jwt_manager = jwt_manager
+        self.password_hasher = PasswordHasher()
+        self._user = None
+        self._user_id = None
+
+    async def attempt(self, credentials: dict) -> Optional[dict]:
+        """
+        尝试登录
+
+        Args:
+            credentials: 登录凭证，包含 account_name/email 和 password
+
+        Returns:
+            成功返回 {"token": "...", "user": {...}}，失败返回 None
+        """
+        # 根据凭证查找用户
+        user = await self.user_model.find_by_credentials(credentials)
+        if not user:
+            return None
+
+        # 验证密码
+        password = credentials.get("password", "")
+        if not self.password_hasher.check(password, user.password or ""):
+            return None
+
+        # 检查用户状态
+        if hasattr(user, "is_active") and not user.is_active():
+            return None
+
+        # 生成 JWT token
+        token = self.jwt_manager.encode({
+            "user_id": user.id,
+            "account_name": user.account_name,
+        })
+
+        # 设置当前用户
+        self._user = user
+        self._user_id = user.id
+
+        # 返回 token 和用户信息
+        user_data = user.to_dict(hide=["password"]) if hasattr(user, "to_dict") else {
+            "id": user.id,
+            "account_name": user.account_name,
+            "real_name": user.real_name,
+            "email": user.email,
+        }
+
+        return {
+            "token": token,
+            "user": user_data,
+        }
+
+    async def validate_token(self, token: str) -> Optional[object]:
+        """
+        验证 token 并返回用户
+
+        Args:
+            token: JWT token
+
+        Returns:
+            成功返回用户对象，失败返回 None
+        """
+        try:
+            # 解析 token
+            payload = self.jwt_manager.decode(token)
+            user_id = payload.get("user_id")
+
+            if not user_id:
+                return None
+
+            # 从数据库获取用户
+            user = await self.user_model.find(user_id)
+            if not user:
+                return None
+
+            # 检查用户状态
+            if hasattr(user, "is_active") and not user.is_active():
+                return None
+
+            # 设置当前用户
+            self._user = user
+            self._user_id = user.id
+
+            return user
+
+        except Exception:
+            return None
+
+    def user(self) -> Optional[object]:
+        """获取当前认证用户"""
+        return self._user
+
+    def check(self) -> bool:
+        """检查是否已认证"""
+        return self._user is not None
+
+    def id(self) -> Optional[int]:
+        """获取当前用户 ID"""
+        return self._user_id
+
+    def logout(self):
+        """登出（清除当前用户）"""
+        self._user = None
+        self._user_id = None