knowai/auth/auth-service.ts

/**
 * 认证服务实现
 * 集成事件管理、会话管理和存储适配器功能
 * 完全实现AuthService接口定义
 */
import type { ApiClient } from '@/api/types';
import type { User } from '@/types';
import type {
  AuthService,
  AuthEventType
} from './types';
import type {
  LoginRequest,
  LoginResponse,
  RegisterRequest,
  RegisterResponse
} from '@/types/user';
import { AuthError } from './errors';
import { authEventManager } from './event-manager';
import { createSessionManager } from './session-manager';
import { createStorageAdapter } from './storage-adapter';

/**
 * 默认认证服务实现
 */
export class DefaultAuthService implements AuthService {
  private readonly apiClient: ApiClient;
  private readonly sessionManager: ReturnType<typeof createSessionManager>;
  private readonly storage: ReturnType<typeof createStorageAdapter>;

  constructor(apiClient: ApiClient) {
    this.apiClient = apiClient;
    this.storage = createStorageAdapter('memory');
    this.sessionManager = createSessionManager(apiClient, this.storage);
  }

  /**
   * 用户登录
   * @param credentials 登录凭证
   * @returns 登录响应，包含用户信息和会话ID
   */
  async login(credentials: LoginRequest): Promise<LoginResponse> {
    try {
      const response = await this.apiClient.post<LoginResponse>('/auth/login', credentials);

      // 触发登录成功事件
      authEventManager.emit('login', response.user);

      // 更新会话管理器中的用户信息
      await this.sessionManager.getUserInfo();

      return response;
    } catch (error) {
      throw AuthError.loginFailed('Login failed', error);
    }
  }

  /**
   * 用户注册
   * @param userData 注册数据
   * @returns 注册响应，包含用户信息和会话ID
   */
  async register(userData: RegisterRequest): Promise<RegisterResponse> {
    try {
      const response = await this.apiClient.post<RegisterResponse>('/auth/register', userData);

      // 触发注册成功事件
      authEventManager.emit('register', response.user);

      // 更新会话管理器中的用户信息
      await this.sessionManager.getUserInfo();

      return response;
    } catch (error) {
      throw AuthError.registerFailed('Registration failed', error);
    }
  }

  /**
   * 用户登出
   * 调用服务器端登出API，清除会话
   */
  async logout(): Promise<void> {
    try {
      // 调用服务器端登出API
      await this.apiClient.post('/auth/logout');

      // 清除本地缓存
      this.sessionManager.clearCache();

      // 触发登出事件
      authEventManager.emit('logout');
    } catch (error) {
      // 即使API调用失败，也要清除本地状态
      this.sessionManager.clearCache();
      throw AuthError.logoutFailed('Logout failed', error);
    }
  }

  /**
   * 获取当前用户信息
   * @returns 当前用户信息
   */
  async getCurrentUser(): Promise<User> {
    try {
      const user = await this.sessionManager.getUserInfo();
      if (!user) {
        throw AuthError.notAuthenticated();
      }
      return user;
    } catch (error) {
      // 如果已经是AuthError，直接抛出
      if (error instanceof AuthError) {
        throw error;
      }
      throw AuthError.userNotFound('Failed to get current user', error);
    }
  }

  /**
   * 检查用户是否已认证
   * @returns 是否已认证
   */
  async isAuthenticated(): Promise<boolean> {
    try {
      return await this.sessionManager.isAuthenticated();
    } catch (error) {
      // 如果已经是AuthError，直接抛出
      if (error instanceof AuthError) {
        throw error;
      }
      throw AuthError.unknown('Authentication check failed', error);
    }
  }

  /**
   * 添加认证事件监听器
   * @param event 事件类型
   * @param listener 事件监听器
   */
  on(event: AuthEventType, listener: (...args: unknown[]) => void): void {
    authEventManager.on(event, listener);
  }

  /**
   * 移除认证事件监听器
   * @param event 事件类型
   * @param listener 事件监听器
   */
  off(event: AuthEventType, listener: (...args: unknown[]) => void): void {
    authEventManager.off(event, listener);
  }

  /**
   * 清除本地缓存
   * 不影响服务器端session
   */
  clearCache(): void {
    this.sessionManager.clearCache();
  }
}

/**
 * 创建认证服务实例
 * @param apiClient API客户端
 * @returns 认证服务实例
 */
export function createAuthService(apiClient: ApiClient): AuthService {
  return new DefaultAuthService(apiClient);
}