@ctil/gql 1.0.0

package/src/core/core.ts

@@ -0,0 +1,281 @@
+import { GraphQLClient } from "graphql-request";
+import { print, DocumentNode } from "graphql";
+import { RequestConfig, RequestInterceptor, UserToken } from "./type.ts";
+import { getDeviceInfo } from "../device/index.ts";
+import { auth } from './api/auth.ts'
+import fs from "fs";
+import path from "path";
+
+// 环境判断
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+const isNode = typeof process !== 'undefined' && process.versions?.node != null;
+
+// Node.js 文件存储路径
+const NODE_LOGIN_FILE = path.resolve(process.cwd(), "loginInfo.json");
+const STORAGE_KEY = "GRAPHQL_LOGIN_INFO";
+
+// Node 内存存储
+let nodeLoginInfo: UserToken | null = null;
+
+export class CCRequest {
+  private client!: GraphQLClient;
+  private headers: Record<string, string>;
+  private deviceInfoPromise: Promise<{ deviceId: string; deviceName: string }>;
+  private interceptors: RequestInterceptor[] = [];
+
+  constructor(private config: RequestConfig) {
+    this.deviceInfoPromise = getDeviceInfo();
+    this.headers = this.buildHeaders(config);
+
+    // 尝试恢复登录信息
+    const loginInfo = this.loadLoginInfo();
+    if (loginInfo?.token) this.setToken(loginInfo.token);
+
+    this.buildClient();
+  }
+
+  /** 注册一个拦截器（支持多个） */
+  use(interceptor: RequestInterceptor) {
+    this.interceptors.push(interceptor);
+  }
+
+  /** 构建 GraphQLClient 实例 */
+  private buildClient() {
+    this.client = new GraphQLClient(this.config.endpoint || "/graphql", {
+      headers: this.headers,
+    });
+  }
+
+  /** 构建初始 headers */
+  private buildHeaders(config: RequestConfig): Record<string, string> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      ...config.headers,
+    };
+    if (config.Authorization) {
+      headers.Authorization = `Bearer ${config.Authorization}`;
+    }
+    return headers;
+  }
+
+  // ===== Token 管理 =====
+  setToken(token: string) {
+    this.config.Authorization = token;
+    this.headers.Authorization = `Bearer ${token}`;
+    this.buildClient();
+  }
+
+  removeToken() {
+    this.config.Authorization = undefined;
+    delete this.headers.Authorization;
+    this.buildClient();
+  }
+
+  // ===== LoginInfo 管理 =====
+  setLoginInfo(loginInfo: UserToken, remember: boolean = false) {
+    this.config.loginInfo = loginInfo;
+    if (loginInfo.token) this.setToken(loginInfo.token);
+
+    if (isBrowser) {
+      const storage = remember ? localStorage : sessionStorage;
+      storage.setItem(STORAGE_KEY, JSON.stringify(loginInfo));
+    } else if (isNode) {
+      nodeLoginInfo = loginInfo;
+      try {
+        fs.writeFileSync(NODE_LOGIN_FILE, JSON.stringify(loginInfo), "utf-8");
+      } catch (err) {
+        console.error("Failed to persist login info to file:", err);
+      }
+    }
+  }
+
+  /** 加载登录信息（含访问 token 和刷新 token 过期检查） */
+  /** 加载登录信息（仅负责加载，不负责刷新） */
+  loadLoginInfo(): UserToken | null {
+    let info: UserToken | null = null;
+
+    if (isBrowser) {
+      const str = localStorage.getItem(STORAGE_KEY) || sessionStorage.getItem(STORAGE_KEY);
+      if (str) {
+        try {
+          info = JSON.parse(str);
+        } catch {
+          info = null;
+        }
+      }
+    } else if (isNode) {
+      if (nodeLoginInfo) return nodeLoginInfo;
+      if (fs.existsSync(NODE_LOGIN_FILE)) {
+        try {
+          const raw = fs.readFileSync(NODE_LOGIN_FILE, "utf-8");
+          info = JSON.parse(raw);
+        } catch {
+          info = null;
+        }
+      }
+    }
+
+    // 🚫 不在这里判断过期，也不删除
+    if (info) this.config.loginInfo = info;
+    return info;
+  }
+
+
+  getLoginInfo(): UserToken | null {
+    if (this.config.loginInfo) return this.config.loginInfo;
+    return this.loadLoginInfo();
+  }
+
+  removeLoginInfo() {
+    delete this.config.loginInfo;
+    if (isBrowser) {
+      localStorage.removeItem(STORAGE_KEY);
+      sessionStorage.removeItem(STORAGE_KEY);
+    } else if (isNode) {
+      nodeLoginInfo = null;
+      try {
+        // if (fs.existsSync(NODE_LOGIN_FILE)) fs.unlinkSync(NODE_LOGIN_FILE);
+      } catch { }
+    }
+    this.removeToken();
+  }
+
+  // ===== Endpoint & Header 管理 =====
+  setEndpoint(endpoint: string) {
+    this.config.endpoint = endpoint;
+    this.buildClient();
+  }
+
+  setHeader(key: string, value: string) {
+    this.headers[key] = value;
+  }
+
+  setHeaders(headers: Record<string, string>) {
+    Object.assign(this.headers, headers);
+  }
+
+  removeHeader(key: string) {
+    delete this.headers[key];
+  }
+
+  clearHeaders() {
+    this.headers = { "Content-Type": "application/json" };
+  }
+
+
+  //无感刷新
+  private async ensureTokenValid(): Promise<void> {
+    const loginInfo = this.getLoginInfo();
+    if (!loginInfo) return;
+    const now = Date.now();
+    const accessExpired = new Date(loginInfo.expireAt).getTime() <= now;
+    const refreshExpired = new Date(loginInfo.refreshExpireAt).getTime() <= now;
+    if (refreshExpired) {
+      // refreshToken 也过期，直接登出
+      this.removeLoginInfo();
+      throw new Error("Login expired. Please login again.");
+    }
+
+    if (accessExpired && !refreshExpired) {
+      try {
+        const refreshResult = await auth.refreshToken({
+          refreshToken: loginInfo.refreshToken,
+          remember: true,
+        });
+        // ✅ 确保这里取到完整的 token 对象
+        const newInfo: UserToken = (refreshResult as any).refreshToken ?? refreshResult;
+
+        // 更新登录信息并覆盖原来的 headers
+        this.setLoginInfo(newInfo, true);
+      } catch (err) {
+        this.removeLoginInfo();
+        throw new Error("Failed to refresh token. Please login again.");
+      }
+    }
+
+  }
+
+  // ===== 请求逻辑 =====
+  async request<T = any>(
+    query: string | DocumentNode,
+    variables?: Record<string, any>
+  ): Promise<T> {
+    let queryStr = typeof query === "string" ? query : print(query);
+
+
+    // 🚫 如果是 refreshToken 请求，跳过 token 校验，避免死循环
+    if (!/refreshToken/i.test(queryStr)) {
+      await this.ensureTokenValid();
+    }
+
+
+    const { deviceId, deviceName } = await this.deviceInfoPromise;
+
+    let headersWithDevice: Record<string, string> = Object.fromEntries(
+      Object.entries({
+        ...this.headers,
+        "X-Device-Id": deviceId,
+        "X-Device-Name": deviceName,
+      }).filter(([_, v]) => v !== undefined)
+    ) as Record<string, string>;
+
+
+
+    // === 执行所有 onRequest 拦截器 ===
+    for (const interceptor of this.interceptors) {
+      if (interceptor.onRequest) {
+        const result = await interceptor.onRequest({
+          query: queryStr,
+          variables,
+          headers: headersWithDevice,
+        });
+        queryStr = result.query;
+        variables = result.variables;
+        headersWithDevice = Object.fromEntries(
+          Object.entries(result.headers).filter(([_, v]) => v !== undefined)
+        ) as Record<string, string>;
+      }
+    }
+
+    try {
+      const res = await this.client.rawRequest<T>(
+        queryStr,
+        variables,
+        headersWithDevice
+      );
+
+      let data = res.data;
+
+      // === 执行所有 onResponse 拦截器 ===
+      for (const interceptor of this.interceptors) {
+        if (interceptor.onResponse) {
+          data = await interceptor.onResponse(data);
+        }
+      }
+
+      return data;
+    } catch (err: any) {
+      const message = err.response?.errors?.[0]?.message ?? err.message;
+      const status = err.response?.errors?.[0]?.extensions?.code ?? 500;
+
+      const formattedError = {
+        message,
+        status,
+        data: err.response?.data ?? null,
+        errors: err.response?.errors ?? null,
+        request: err.request,
+      };
+
+      // === 执行所有 onError 拦截器 ===
+      for (const interceptor of this.interceptors) {
+        if (interceptor.onError) {
+          await interceptor.onError(formattedError);
+        }
+      }
+
+      throw formattedError;
+    }
+  }
+
+
+}

package/src/core/executor.ts

@@ -0,0 +1,19 @@
+// src/core/executor.ts
+import { getClient } from './client.ts';
+import type { DocumentNode } from 'graphql';
+
+interface GraphQLPayload {
+  query: string | DocumentNode;
+  variables?: Record<string, any>;
+}
+
+/**
+ * 通用执行函数
+ */
+export async function execute<T = any>(payload: GraphQLPayload) {
+  const client = getClient();
+  return client.request<T>(payload.query, payload.variables);
+}
+
+
+

package/src/core/type.ts

@@ -0,0 +1,76 @@
+export interface RequestConfig {
+  endpoint?: string;
+  Authorization?: string;
+  headers?: Record<string, string>;
+  loginInfo?:UserToken | null | undefined;
+}
+/** 拦截器接口 */
+export interface RequestInterceptor {
+  /** 请求发出前拦截，可修改 query、variables、headers */
+  onRequest?: (params: {
+    query: string;
+    variables?: Record<string, any>;
+    headers: Record<string, string | undefined> & {
+      "X-Device-Id"?: string;
+      "X-Device-Name"?: string;
+    };
+  }) => Promise<typeof params> | typeof params;
+
+  /** 响应成功拦截，可修改返回结构 */
+  onResponse?: (response: any) => Promise<any> | any;
+
+  /** 错误拦截，可做统一错误处理或重试 */
+  onError?: (error: any) => Promise<any> | any;
+}
+
+
+export interface requestResult<T = any> {
+  [key: string]: T
+}
+
+
+export interface UserToken {
+  /** 用户 ID */
+  userId: number;
+
+  /** 登录账号 */
+  loginAccount: string;
+
+  /** 访问 Token */
+  token: string;
+
+  /** 刷新 Token */
+  refreshToken: string;
+
+  /** 访问 Token 过期时间 */
+  expireAt: string; // ISO 时间字符串
+
+  /** 刷新 Token 过期时间 */
+  refreshExpireAt: string;
+
+  /** 设备 ID */
+  deviceId?: string;
+
+  /** 设备名称 */
+  deviceName?: string;
+
+  /** 登录时间 */
+  loginTime?: string;
+
+  /** 登录 IP */
+  requestIp?: string;
+
+  /** 客户端信息 */
+  userAgent?: string;
+
+  /** 上次刷新时间 */
+  lastRefreshTime?: string;
+
+  /** 用户角色编码列表 */
+  roles: string[];
+
+  /** 用户权限编码列表 */
+  permissions: string[];
+}
+
+

package/src/device/index.ts

@@ -0,0 +1,116 @@
+import { v4 as uuidv4 } from "uuid";
+
+export interface DeviceInfo {
+  deviceId: string;
+  deviceName: string;
+  env: "node" | "browser";
+}
+
+/** 浏览器 IndexedDB 存取 deviceId */
+function getDeviceIdFromIndexedDB(): Promise<string | null> {
+  return new Promise((resolve) => {
+    if (typeof indexedDB === "undefined") return resolve(null);
+
+    const request = indexedDB.open("DeviceDB", 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      db.createObjectStore("info");
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      const tx = db.transaction("info", "readonly");
+      const store = tx.objectStore("info");
+      const getReq = store.get("deviceId");
+      getReq.onsuccess = () => resolve(getReq.result ?? null);
+      getReq.onerror = () => resolve(null);
+    };
+    request.onerror = () => resolve(null);
+  });
+}
+
+function setDeviceIdToIndexedDB(id: string): Promise<void> {
+  return new Promise((resolve) => {
+    if (typeof indexedDB === "undefined") return resolve();
+
+    const request = indexedDB.open("DeviceDB", 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      db.createObjectStore("info");
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      const tx = db.transaction("info", "readwrite");
+      const store = tx.objectStore("info");
+      store.put(id, "deviceId");
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => resolve();
+    };
+    request.onerror = () => resolve();
+  });
+}
+
+/** 浏览器端设备信息 */
+export async function getBrowserDeviceInfo(): Promise<DeviceInfo> {
+  let deviceId: string;
+
+  try {
+    const { load } = await import("@fingerprintjs/fingerprintjs");
+    const fp = await load();
+    const result = await fp.get();
+    deviceId = result.visitorId;
+  } catch {
+    // FingerprintJS 不可用，使用 IndexedDB + UUID
+    let id = await getDeviceIdFromIndexedDB();
+    if (!id) {
+      id = uuidv4();
+      await setDeviceIdToIndexedDB(id);
+    }
+    deviceId = id;
+  }
+
+  // 生成 deviceName，不依赖 userAgent
+  const deviceName = (() => {
+    const platform = navigator.platform || "unknown";
+    const width = screen.width || 0;
+    const height = screen.height || 0;
+    const colorDepth = screen.colorDepth || 24;
+    return `${platform}-${width}x${height}x${colorDepth}`;
+  })();
+
+  return {
+    deviceId,
+    deviceName,
+    env: "browser",
+  };
+}
+
+/** Node 端设备信息 */
+async function getNodeDeviceInfo(): Promise<DeviceInfo> {
+  const os = await import("os");
+  const machine = await import("node-machine-id");
+
+  const machineIdSync =
+    (machine as any).machineIdSync ||
+    (machine as any).default?.machineIdSync;
+
+  if (typeof machineIdSync !== "function") {
+    throw new Error("node-machine-id: machineIdSync not found");
+  }
+
+  const id = machineIdSync(true);
+  return {
+    deviceId: id,
+    deviceName: os.hostname(),
+    env: "node",
+  };
+}
+
+/** 跨平台获取设备信息 */
+export async function getDeviceInfo(): Promise<DeviceInfo> {
+  const isBrowser =
+    typeof window !== "undefined" &&
+    typeof navigator !== "undefined" &&
+    typeof screen !== "undefined";
+
+  return isBrowser ? getBrowserDeviceInfo() : getNodeDeviceInfo();
+}

package/src/index.ts

@@ -0,0 +1,60 @@
+// src/index.ts
+
+// 1️⃣ GraphQL client 初始化与获取
+export {
+    initGraphQLClient,
+    useInterceptor,
+    getClient,
+    setToken,
+    removeToken,
+    setEndpoint,
+    setHeader,
+    setHeaders,
+    removeHeader,
+    clearHeaders
+} from './core/client.js';
+
+// 2️⃣ 类型定义（统一导出）
+export type * from './core/type.js';
+
+// 3️⃣ GraphQL 构建器（buildXXX 方法）
+export type {
+    //Query
+    QueryInput,
+    QueryPageListInput,
+    QueryByIdInput,
+    QueryAggregateInput,
+    AggregateFieldInput,
+    //Mutation
+    InsertOneInput,
+    BatchInsertInput,
+    DeleteInput,
+    DeleteByIdInput,
+    BatchUpdateInput,
+    UpdateByPkInput,
+    UpdateInput,
+    //鉴权
+    LoginInput,
+    RegisterUserInput,
+    LogoutInput,
+    LogoutDeviceInput,
+    RefreshTokenInput,
+    //SMS
+    SendCodeInput,
+    VerifyCodeInput
+} from './builders/index.ts';
+
+// 4️⃣ 业务 API 模块（每个模块有默认泛型）
+export * from './core/api/auth.js';
+export * from './core/api/query.js';
+export * from './core/api/mutation.js';
+export * from './core/api/sms.js';
+export * from './core/api/gql.js';
+
+
+
+// 5️⃣ 设备信息
+export * from './device/index.ts'
+
+
+// 6️⃣7️⃣8️⃣9️⃣🔟

package/src/rateLimit/rateLimit.ts

@@ -0,0 +1,51 @@
+import { rateLimitConfig as defaultConfig } from './rateLimitConfig.ts';
+
+interface RateLimitRule {
+    max: number;
+    window: number;  // 秒
+    debounce: number; // 毫秒
+}
+
+interface TrackerItem {
+    timestamps: number[];
+    timeout?: NodeJS.Timeout;
+}
+
+const trackers = new Map<string, TrackerItem>();
+
+function getRule(operateName: string, type: 'query' | 'mutation', config: any): RateLimitRule {
+    return config.custom?.[operateName] || config.defaultRules[type];
+}
+
+export function rateLimit<T>(
+    operateName: string,
+    type: 'query' | 'mutation',
+    fn: () => Promise<T>,
+    config = defaultConfig   // <-- 默认使用内置配置
+): Promise<T> {
+    const rule = getRule(operateName, type, config);
+    const now = Date.now();
+    const key = `${type}::${operateName}`;
+
+    if (!trackers.has(key)) trackers.set(key, { timestamps: [] });
+    const tracker = trackers.get(key)!;
+
+    tracker.timestamps = tracker.timestamps.filter(ts => now - ts < rule.window * 1000);
+
+    return new Promise((resolve, reject) => {
+        const exec = () => {
+            if (tracker.timestamps.length >= rule.max) {
+                return reject(new Error(`Rate limit exceeded for ${operateName}`));
+            }
+            tracker.timestamps.push(Date.now());
+            fn().then(resolve).catch(reject);
+        };
+
+        if (rule.debounce > 0) {
+            if (tracker.timeout) clearTimeout(tracker.timeout);
+            tracker.timeout = setTimeout(exec, rule.debounce);
+        } else {
+            exec();
+        }
+    });
+}

package/src/rateLimit/rateLimitConfig.ts

@@ -0,0 +1,12 @@
+export const rateLimitConfig = {
+    defaultRules: {
+      query: { max: 10, window: 1, debounce: 0 },
+      mutation: { max: 3, window: 1, debounce: 200 },
+    },
+    custom: {
+      login: { max: 1, window: 5, debounce: 0 },
+      refreshToken: { max: 2, window: 5, debounce: 0 },
+      
+    },
+  };
+  

package/src/test.ts

@@ -0,0 +1,80 @@
+import { initGraphQLClient,auth,query,setToken,removeToken,useInterceptor } from "./index.ts";  // 本地调试用相对路径
+
+const client = initGraphQLClient({
+  endpoint: "http://localhost:9526/graphql",
+ 
+  // Authorization:"eyJhbGciOiJIUzI1NiJ9.eyJ1c2VySWQiOjEwMDAwMDAwMDAsImxvZ2luQWNjb3VudCI6ImNhaWNhaSIsInR5cGUiOiJhY2Nlc3MiLCJkZXZpY2VJZCI6IjEwMDAwMDgiLCJqdGkiOiJjMTJjNjQ5ZS05OTIwLTRkNDgtOWRjZS0yYWJkZGMzYTc1OWIiLCJpYXQiOjE3NjE3MzIxMzEsImV4cCI6MTc2MTczMzkzMX0.CkJf3fYdto7zugkkej8sfLCw03Yrgc1zMAoPL2PaFUk"
+});
+
+
+// ✅ 注册请求 / 响应 / 错误拦截器
+useInterceptor({
+  onRequest: async ({ query, variables, headers }) => {
+    // console.log("[Request Interceptor]", { query, variables, headers });
+    // 可以在这里加上时间戳或日志
+    return { query, variables, headers };
+  },
+  onResponse: async (response) => {
+    // console.log("[Response Interceptor]", response);
+    // 可以在这里统一处理响应结构，比如包装 data
+    return response;
+  },
+  onError: async (error) => {
+    // console.error("[Error Interceptor]", error);
+    // 比如 token 过期时可以自动重试或刷新
+    if (error.status === 401) {
+      console.log("⚠️ Token expired, redirecting to login...");
+    }
+    // 返回错误或重新抛出
+    throw error;
+  },
+});
+
+async function test() {
+
+  try {
+    // const loginRs=await auth.login({
+    //   account:"caicai",
+    //   password:"caicai"
+    // })
+    // console.log(loginRs.login.token);
+    
+    // setToken(loginRs.login.token);
+    // debugger;
+    // console.log(loginRs);
+  //  const rs=await query.byId({
+  //     operationName:"user",
+  //     pk:"1000000000",
+  //     fields:["id","username","nickname","phone",{
+  //       roles:{
+  //         fields:["id","roleCode","roleName"]
+  //       }
+  //     }]
+  //   })
+  //   // debugger;
+  //   console.log(rs);
+
+  //   removeToken()
+
+  // const res=await query.byId({
+  //     operationName:"user",
+  //     pk:"1000000000",
+  //     fields:["id","username","nickname","phone",{
+  //       roles:{
+  //         fields:["id","roleCode","roleName"]
+  //       }
+  //     }]
+  //   })
+  //   debugger;
+  //   console.log(res);
+
+  } catch (err:any) {
+    
+    // debugger;
+    console.error("GraphQL request failed:", err);
+    console.error("GraphQL request failed:", err.message);
+  }
+}
+
+
+test();