qing-client 0.0.2

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "qing-client",
+  "version": "0.0.2",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "coverage": "jest --coverage",
+    "tree": "tree -l 10 -o tree-out.txt --ignore node_modules/ --ignore build/ --ignore dist/ --ignore migrations/",
+    "lint": "eslint",
+    "dev": "ts-node-dev src/index.ts",
+    "t": "ts-node-dev src/test/testRunner.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "rele": "bash release.sh"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@faker-js/faker": "^10.0.0",
+    "@types/formidable": "^3.4.5",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.3.1",
+    "@types/qs": "^6.14.0",
+    "@typescript-eslint/eslint-plugin": "^8.43.0",
+    "@typescript-eslint/parser": "^8.43.0",
+    "eslint": "^8.2.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-node": "^11.1.0",
+    "jest": "^30.1.3",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.9.2"
+  },
+  "description": "",
+  "dependencies": {
+    "axios": "^1.11.0",
+    "qs": "^6.14.0"
+  },
+  "files": [
+    "dist",
+    "lib",
+    "src",
+    "types",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/client/BaseClient.ts

@@ -0,0 +1,230 @@
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosError, RawAxiosRequestHeaders } from 'axios';
+import {
+  UserContext,
+  ClientConfig,
+  RequestOptions,
+  TokenStorage,
+  ApiResponse,
+  PaginatedResponse
+} from '../types';
+
+// 默认内存存储实现
+const memoryTokenStorage: TokenStorage & { token?: string } = {
+  token: undefined,
+  async getToken() {
+    return this.token;
+  },
+  async setToken(token: string) {
+    this.token = token;
+  },
+  async clearToken() {
+    this.token = undefined;
+  }
+};
+
+export abstract class BaseClient {
+  protected axiosInstance: AxiosInstance;
+  protected userContext?: UserContext;
+  protected isFrontendMode: boolean;
+  protected serviceBasePath: string;
+  protected tokenStorage: TokenStorage;
+
+  constructor(
+    protected config: ClientConfig,
+    protected serviceName: string
+  ) {
+    this.isFrontendMode = !!config.gatewayUrl;
+    this.serviceBasePath = `/api/${serviceName}`;
+
+    // 设置令牌存储
+    this.tokenStorage = config.tokenStorage || memoryTokenStorage;
+
+    // 创建Axios实例
+    this.axiosInstance = axios.create({
+      baseURL: this.getBaseUrl(),
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+      }
+    });
+
+    // 添加请求拦截器
+    this.axiosInstance.interceptors.request.use(async (config: any) => {
+      let headers: RawAxiosRequestHeaders = config.headers || {};
+
+      // 1. 注入用户上下文（后端模式）
+      if (!this.isFrontendMode && this.userContext) headers = {
+        ...headers,
+        ...this.initUserContext(this.userContext)
+      }
+      // 2. 注入认证令牌
+      const token = await this.tokenStorage.getToken();
+      if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+      }
+
+      // 合并自定义头
+      if (config.headers) {
+        Object.assign(headers, config.headers);
+      }
+
+      return {
+        ...config,
+        headers
+      };
+    });
+  }
+
+  initUserContext(context: UserContext): RawAxiosRequestHeaders {
+    return {
+      'v-user-id': context.userId,
+      'v-user-role': context.role,
+      'v-project-id': context.projectId
+    };
+  }
+
+  // 设置用户上下文（后端模式使用）
+  setUserContext(context: UserContext): this {
+    this.userContext = context;
+    return this;
+  }
+
+  // 设置令牌存储（可在运行时更换存储策略）
+  setTokenStorage(storage: TokenStorage): this {
+    this.tokenStorage = storage;
+    return this;
+  }
+
+  // 确定请求基础URL
+  private getBaseUrl(): string {
+    if (this.isFrontendMode) {
+      return this.config.gatewayUrl!;
+    }
+
+    // 后端模式使用服务专属URL
+    switch (this.serviceName) {
+      case 'auth': return this.config.authServiceUrl!;
+      case 'msg': return this.config.msgServiceUrl!;
+      case 'users': return this.config.userServiceUrl!;
+      case 'file': return this.config.fileServiceUrl!;
+      case 'survey': return this.config.surveyServiceUrl!;
+      case 'token': return this.config.tokenServiceUrl!;
+      default: throw new Error(`Unsupported service: ${this.serviceName}`);
+    }
+  }
+
+  // 设置认证令牌
+  async setToken(token: string): Promise<void> {
+    await this.tokenStorage.setToken(token);
+  }
+
+  // 清除认证令牌
+  async clearToken(): Promise<void> {
+    await this.tokenStorage.clearToken();
+  }
+
+  // 统一请求方法 - 处理标准API响应
+  protected async request<T>(
+    path: string,
+    options: RequestOptions = { method: 'GET' }
+  ): Promise<T> {
+    try {
+      const fullPath = this.isFrontendMode
+        ? `${this.serviceBasePath}${path}`
+        : path;
+      let headers: any = options.headers || {};
+      const context = options.userContext || this.userContext;
+      if (context) {
+        headers = { ...headers, ...this.initUserContext(context) };
+      }
+
+      const response = await this.axiosInstance.request<ApiResponse<T>>({
+        url: fullPath,
+        method: options.method,
+        headers,
+        params: options.params,
+        data: options.body
+      });
+      console.log('Request URL:', this.getBaseUrl() + fullPath);
+      console.log('Request params:', options.params);
+      // 检查业务成功状态
+      if (!response.data.success) {
+        throw new Error(response.data.message || `业务请求失败`);
+      }
+
+      // 返回实际数据
+      return response.data.data;
+    } catch (error) {
+      // 明确返回错误处理
+      return this.handleApiError(error as AxiosError, path);
+    }
+  }
+
+  // 分页请求方法 - 处理分页API响应
+  protected async paginatedRequest<T>(
+    path: string,
+    options: RequestOptions = { method: 'GET' }
+  ): Promise<PaginatedResponse<T>> {
+    try {
+      const fullPath = this.isFrontendMode
+        ? `${this.serviceBasePath}${path}`
+        : path;
+
+      const response = await this.axiosInstance.request<PaginatedResponse<T>>({
+        url: fullPath,
+        method: options.method,
+        headers: options.headers,
+        params: options.params,
+        data: options.body
+      });
+
+      // 检查业务成功状态
+      if (!response.data.success) {
+        throw new Error(response.data.message || `业务请求失败`);
+      }
+
+      // 返回分页数据 - 直接返回整个data部分
+      return response.data
+    } catch (error) {
+      this.handleApiError(error as AxiosError, path);
+    }
+  }
+
+  // 统一错误处理方法
+  private handleApiError(error: AxiosError, path: string): never {
+    let errorMessage = `[${this.serviceName}服务] `;
+
+    if (error.response) {
+      const responseData = error.response.data as any;
+
+      // 尝试从响应体中提取错误信息
+      if (responseData?.message) {
+        errorMessage += responseData.message;
+      } else if (responseData?.error) {
+        errorMessage += responseData.error;
+      } else {
+        errorMessage += `请求失败，状态码: ${error.response.status}`;
+      }
+
+      // 添加详细错误信息（开发环境）
+      if (process.env.NODE_ENV === 'development') {
+        errorMessage += ` | 状态码: ${error.response.status}`;
+        if (error.response.headers?.['x-request-id']) {
+          errorMessage += ` | 请求ID: ${error.response.headers['x-request-id']}`;
+        }
+      }
+    } else if (error.request) {
+      errorMessage += '服务器未响应';
+    } else {
+      errorMessage += error.message;
+    }
+
+    // 添加路径信息
+    errorMessage += ` (路径: ${path})`;
+
+    // 明确抛出错误
+    throw new Error(errorMessage);
+  }
+
+}

package/src/client/index.ts

@@ -0,0 +1,27 @@
+import { AuthService } from "../srvice/AuthService";
+import { MsgService } from "../srvice/MsgService";
+import { TokenService } from "../srvice/TokenService";
+import { UserService } from "../srvice/UserService";
+import { ClientConfig, UserContext } from "../types";
+
+export class Client {
+    readonly auth: AuthService;
+    readonly msg: MsgService;
+    readonly user: UserService;
+    readonly token: TokenService;
+
+    constructor(protected config: ClientConfig) {
+        this.auth = new AuthService(config);
+        this.msg = new MsgService(config);
+        this.user = new UserService(config);
+        this.token = new TokenService(config);
+    }
+
+    setUserContext(context: UserContext): this {
+        this.auth.setUserContext(context);
+        this.msg.setUserContext(context);
+        this.user.setUserContext(context);
+        this.token.setUserContext(context);
+        return this;
+    }
+}

package/src/srvice/AuthService.ts

@@ -0,0 +1,50 @@
+import { BaseClient } from "../client/BaseClient";
+import { ClientConfig, RequestOptions } from "../types";
+import qs from 'qs'
+import { LoginResponse } from "../types/user";
+
+
+export class AuthService extends BaseClient {
+    constructor(config: ClientConfig) {
+        super(config, 'auth');
+    }
+
+    // 用户登录 - 匹配后端请求格式
+    async login(
+        identifier: string,
+        password: string,
+        projectId: number = 0,
+        options?: RequestOptions
+    ): Promise<LoginResponse> {
+        const body = qs.stringify({
+            grant_type: "password",
+            username: identifier,
+            password
+        });
+
+        return this.request<LoginResponse>('/login', {
+            ...options,
+            method: 'POST',
+            headers: {
+                ...options?.headers,
+                "Content-Type": "application/x-www-form-urlencoded"
+            },
+            params: {
+                project_id: projectId
+            },
+            body: body
+        });
+    }
+
+    // 用户登出 - 匹配后端请求格式
+    async logout(token: string, options?: RequestOptions): Promise<void> {
+        return this.request<void>('/logout', {
+            ...options,
+            method: 'POST',
+            headers: {
+                ...options?.headers,
+                Authorization: `Bearer ${token}`
+            }
+        });
+    }
+}

package/src/srvice/MsgService.ts

@@ -0,0 +1,28 @@
+import { BaseClient } from "../client/BaseClient";
+import { ClientConfig, RequestOptions } from "../types";
+import { FeishuMessage, MailRequest } from "../types/msg";
+
+
+export class MsgService extends BaseClient {
+  constructor(config: ClientConfig) {
+    super(config, 'msg');
+  }
+
+  // 发送邮件 - 返回实际结果
+  async sendMail(request: MailRequest, options?: RequestOptions): Promise<void> {
+    return this.request<void>('/mail/send', {
+      ...options,
+      method: 'POST',
+      body: request
+    });
+  }
+
+  // 发送飞书消息 - 返回实际结果
+  async sendFeishuMessage(message: FeishuMessage, options?: RequestOptions): Promise<void> {
+    return this.request<void>('/webhook/feishu/send', {
+      ...options,
+      method: 'POST',
+      body: message
+    });
+  }
+}

package/src/srvice/TokenService.ts

@@ -0,0 +1,66 @@
+import { BaseClient } from "../client/BaseClient";
+import {
+    ClientConfig,
+    RequestOptions,
+} from "../types";
+import {
+    WxOfficialAccountTokenResponse,
+    WxJsapiTicketResponse,
+    WxSignatureRequest,
+    WxSignatureResponse,
+    WxMiniProgramTokenResponse
+} from "../types/token";
+
+export class TokenService extends BaseClient {
+    constructor(config: ClientConfig) {
+        super(config, 'token');
+    }
+
+    // 获取微信公众号access_token
+    async getWxOfficialAccountToken(
+        appid: string,
+        options?: RequestOptions
+    ): Promise<WxOfficialAccountTokenResponse> {
+        return this.request<WxOfficialAccountTokenResponse>('/wxh5/accesstoken', {
+            ...options,
+            method: 'GET',
+            params: { appid }
+        });
+    }
+
+    // 获取微信公众号jsapi_ticket
+    async getWxJsapiTicket(
+        appid: string,
+        options?: RequestOptions
+    ): Promise<WxJsapiTicketResponse> {
+        return this.request<WxJsapiTicketResponse>('/wxh5/jsapi_ticket', {
+            ...options,
+            method: 'GET',
+            params: { appid }
+        });
+    }
+
+    // 获取微信公众号签名
+    async getWxSignature(
+        signatureRequest: WxSignatureRequest,
+        options?: RequestOptions
+    ): Promise<WxSignatureResponse> {
+        return this.request<WxSignatureResponse>('/wxh5/signature', {
+            ...options,
+            method: 'POST',
+            body: signatureRequest
+        });
+    }
+
+    // 获取微信小程序access_token
+    async getWxMiniProgramToken(
+        appid: string,
+        options?: RequestOptions
+    ): Promise<WxMiniProgramTokenResponse> {
+        return this.request<WxMiniProgramTokenResponse>('/wxmp/accesstoken', {
+            ...options,
+            method: 'GET',
+            params: { appid }
+        });
+    }
+}

package/src/srvice/UserService.ts

@@ -0,0 +1,74 @@
+import { BaseClient } from "../client/BaseClient";
+import {
+  ClientConfig,
+  RequestOptions,
+  PaginatedResponse
+} from "../types";
+import { User, UserCreateRequest, UserUpdateRequest } from "../types/user";
+
+export class UserService extends BaseClient {
+  constructor(config: ClientConfig) {
+    super(config, 'users');
+  }
+
+  // 获取当前用户信息 - 返回完整响应
+  async getCurrentUser(options?: RequestOptions): Promise<User> {
+    return this.request<User>('/me', {
+      ...options,
+      method: 'GET'
+    });
+  }
+
+  // 创建用户（管理员） - 匹配后端请求格式
+  async createUser(userData: UserCreateRequest, options?: RequestOptions): Promise<User> {
+    return this.request<User>('', {
+      ...options,
+      method: 'POST',
+      body: {
+        username: userData.username,
+        email: userData.email,
+        password: userData.password,
+        name: userData.name,
+        role: userData.role,
+        phone: userData.phone,
+        project_id: userData.project_id
+      }
+    });
+  }
+
+  // 更新用户信息 - 匹配后端请求格式
+  async updateUser(userId: number, updateData: UserUpdateRequest, options?: RequestOptions): Promise<User> {
+    return this.request<User>(`/${userId}`, {
+      ...options,
+      method: 'PUT',
+      body: {
+        name: updateData.name,
+        avatar: updateData.avatar,
+        phone: updateData.phone,
+        role: updateData.role,
+        project_id: updateData.project_id
+      }
+    });
+  }
+
+  // 获取用户列表（管理员） - 返回分页数据
+  async listUsers(
+    includeInactive: boolean = false,
+    page: number = 1,
+    perPage: number = 10,
+    options?: RequestOptions
+  ): Promise<PaginatedResponse<User>> {
+    const response = await this.paginatedRequest<User>('', {
+      ...options,
+      method: 'GET',
+      params: {
+        include_inactive: includeInactive,
+        page,
+        per_page: perPage
+      }
+    });
+
+    // 直接返回分页响应
+    return response;
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,58 @@
+// 统一API响应格式
+export interface ApiResponse<T = any> {
+  success: boolean;
+  message: string;
+  data: T;
+}
+
+// 分页信息
+export interface Pagination {
+  page: number;
+  per_page: number;
+  total: number;
+  total_pages: number;
+}
+
+// 分页响应
+export interface PaginatedResponse<T> {
+  data: T[];
+  success: boolean;
+  message: string;
+  pagination: Pagination;
+}
+
+
+// 添加令牌存储接口
+export interface TokenStorage {
+  getToken(): Promise<string | undefined>;
+  setToken(token: string): Promise<void>;
+  clearToken(): Promise<void>;
+}
+
+// 扩展客户端配置
+export interface ClientConfig {
+  gatewayUrl?: string;
+  authServiceUrl?: string;
+  msgServiceUrl?: string;
+  userServiceUrl?: string;
+  fileServiceUrl?: string;
+  surveyServiceUrl?: string;
+  tokenServiceUrl?: string; 
+
+  // 令牌存储策略
+  tokenStorage?: TokenStorage;
+}
+export interface UserContext {
+  userId: string;
+  role: 'SUPER_ADMIN' | 'ADMIN' | 'STAFF' | 'USER' | 'SYSTEM';
+  projectId: string;
+}
+
+export interface RequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  headers?: Record<string, string>;
+  params?: Record<string, any>;
+  body?: any;
+  userContext?: UserContext; 
+}
+

package/src/types/msg.ts

@@ -0,0 +1,32 @@
+export interface MailRequest {
+    to: string[];
+    subject: string;
+    text?: string;
+    html?: string;
+    from?: string;
+    cc?: string[];
+    bcc?: string[];
+    attachments?: Array<{
+        filename: string;
+        content: string; // base64编码
+        contentType?: string;
+    }>;
+}
+
+export interface FeishuMessage {
+    url: string;
+    title?: string;
+    bgColor?: string;
+    elements: Array<{
+        title: string;
+        text: string;
+        color?: string;
+    }>;
+    noticeUser?: Array<{
+        userId: string;
+    }>;
+    actions?: Array<{
+        text: string;
+        url: string;
+    }>;
+}

package/src/types/token.ts

@@ -0,0 +1,31 @@
+// 微信公众号Token响应
+export interface WxOfficialAccountTokenResponse {
+    access_token: string;
+}
+
+// 微信公众号JsapiTicket响应
+export interface WxJsapiTicketResponse {
+    jsapi_ticket: string;
+}
+
+// 微信公众号签名请求
+export interface WxSignatureRequest {
+    appid: string;
+    url: string;
+    imgUrl?: string;
+}
+
+// 微信公众号签名响应
+export interface WxSignatureResponse {
+    appId: string;
+    timestamp: number;
+    nonceStr: string;
+    signature: string;
+    url: string;
+    imgUrl: string;
+}
+
+// 微信小程序Token响应
+export interface WxMiniProgramTokenResponse {
+    access_token: string;
+}

package/src/types/user.ts

@@ -0,0 +1,43 @@
+// 用户模型
+export interface User {
+    id: number;
+    username: string;
+    email: string;
+    name?: string;
+    avatar?: string;
+    phone?: string;
+    role: string;
+    project_id: number;
+    is_active: boolean;
+    last_login_ip?: string;
+    last_login?: string; 
+    created_at: string; 
+    updated_at: string; 
+}
+
+// 用户创建请求
+export interface UserCreateRequest {
+    username: string;
+    email: string;
+    password: string;
+    name?: string;
+    role?: string;
+    phone?: string;
+    project_id?: number;
+}
+
+// 用户更新请求
+export interface UserUpdateRequest {
+    name?: string;
+    avatar?: string;
+    phone?: string;
+    role?: string;
+    project_id?: number;
+}
+
+export interface LoginResponse {
+    access_token: string;
+    token_type: string;
+    expires_at: string;
+    project_id: number;
+}