@ctil/gql 1.0.0

package/src/builders/query.ts

@@ -0,0 +1,180 @@
+import { buildWhere, buildFields,toPascalCase } from './baseType.ts';
+import type { WhereInput, FieldInput } from './baseType.ts';
+// 列表查询入参
+export interface QueryInput {
+  operationName: string;
+  fields?: FieldInput[];
+  variables?: Record<string, any>; // 传入的变量名和初始值
+  where?: WhereInput;
+  orderBy?: Record<string, any>;
+  distinctOn?: string[];
+  limit?: number;
+  offset?: number;
+}
+
+// 分页查询入参
+export interface QueryPageListInput {
+  operationName: string;
+  fields: FieldInput[];
+  variables?: Record<string, any>; // 传入的变量名和初始值
+  where?: WhereInput;
+  orderBy?: Record<string, any>;
+  distinctOn?: string[];
+  size?: number;
+  page?: number;
+}
+
+// 根据ID查询入参
+export interface QueryByIdInput {
+  operationName: string;
+  fields: FieldInput[];
+  pk: string | number
+}
+
+// =================== 聚合查询 InputType ===================
+export interface QueryAggregateInput {
+  operationName: string; // 操作名称，例如 user
+  fields: FieldInput[];  // 节点数据的字段
+  aggregateFields?: AggregateFieldInput; // 聚合字段配置
+  variables?: Record<string, any>;
+  where?: WhereInput;
+  distinctOn?: string[];
+}
+
+export interface AggregateFieldInput {
+  count?: boolean;             // count 不带子字段
+  sum?: string[];              // sum { age salary }
+  avg?: string[];
+  max?: string[];
+  min?: string[];
+}
+
+
+/** 生成完整 query，包括变量定义 */
+export function buildGraphQLQueryList(input: QueryInput) {
+  const { operationName, fields, variables, where, orderBy, distinctOn, limit, offset } = input;
+
+  // 生成顶层变量定义
+  const varDefs = variables
+    ? Object.keys(variables)
+      .map(k => `$${k}: String!`) // 暂时默认全部 String!
+      .join(", ")
+    : "";
+
+  const topArgs: string[] = [];
+  if (where) topArgs.push(`where: { ${buildWhere(where)} }`);
+  if (distinctOn) topArgs.push(`distinct_on: [${distinctOn.map(s => `${s}`).join(" ")}]`);
+  if (orderBy)
+    topArgs.push(
+      `order_by: {${Object.entries(orderBy)
+        .map(([k, v]) => `${k}: ${v}`) // 顶层 order_by 值不加引号
+        .join(" ")}}`
+    );
+  if (limit !== undefined) topArgs.push(`limit: ${limit}`);
+  if (offset !== undefined) topArgs.push(`offset: ${offset}`);
+  const topArgsStr = topArgs.length ? `(${topArgs.join(" ")})` : "";
+  const query = `query ${operationName}${varDefs ? `(${varDefs})` : ""} { ${operationName}${topArgsStr} ${fields? '{'+buildFields(fields)+'}':''} }`;
+  return { query, variables };
+}
+
+/** 生成按 ID 查询的 GraphQL query（固定主键参数名为 id） */
+export function buildGraphQLQueryByIdFixed(queryByIdInput: QueryByIdInput) {
+  const { pk, fields, operationName } = queryByIdInput
+  const variables: Record<string, any> = { id: pk };
+
+  const query = `query ${operationName + '_by_pk'}($id: Long!) {
+    ${operationName + '_by_pk'}(id: $id) {
+      ${buildFields(fields)}
+    }
+  }`;
+
+  return { query, variables };
+}
+
+/** 生成分页查询的输入 */
+export function buildGraphQLQueryPageList(input: QueryPageListInput) {
+  const { operationName, fields, variables, where, orderBy, distinctOn, page, size } = input;
+
+  // 生成顶层变量定义
+  const varDefs = variables
+    ? Object.keys(variables)
+      .map(k => `$${k}: String!`) // 暂时默认全部 String!
+      .join(", ")
+    : "";
+
+  const topArgs: string[] = [];
+  if (where) topArgs.push(`where: { ${buildWhere(where)} }`);
+  if (distinctOn) topArgs.push(`distinct_on: [${distinctOn.map(s => `${s}`).join(" ")}]`);
+  if (orderBy)
+    topArgs.push(
+      `order_by: {${Object.entries(orderBy)
+        .map(([k, v]) => `${k}: ${v}`) // 顶层 order_by 值不加引号
+        .join(" ")}}`
+    );
+  if (size !== undefined) topArgs.push(`size: ${size}`);
+  if (page !== undefined) topArgs.push(`page: ${page}`);
+  const topArgsStr = topArgs.length ? `(${topArgs.join(" ")})` : "";
+
+
+  const query = `query ${'get' + toPascalCase(operationName) + 'PageList'}${varDefs ? `(${varDefs})` : ""} { ${'get' + toPascalCase(operationName) + 'PageList'}${topArgsStr} { hasMore  list{${buildFields(fields)}} page size total  } }`;
+
+  return { query, variables };
+}
+
+
+// =================== 构造聚合查询函数 ===================
+export function buildGraphQLQueryAggregate(input: QueryAggregateInput) {
+  const { operationName, fields, aggregateFields, variables, where, distinctOn } = input;
+
+  // 变量定义
+  const varDefs = variables
+    ? Object.keys(variables)
+      .map(k => `$${k}: String!`)
+      .join(", ")
+    : "";
+
+  // 顶层参数
+  const topArgs: string[] = [];
+  if (where) topArgs.push(`where: { ${buildWhere(where)} }`);
+  if (distinctOn) topArgs.push(`distinct_on: [${distinctOn.map(s => `${s}`).join(" ")}]`);
+
+  const topArgsStr = topArgs.length ? `(${topArgs.join(" ")})` : "";
+
+  // ✅ 构建 aggregate 字段
+  const aggregateParts: string[] = [];
+
+  if (aggregateFields) {
+    if (aggregateFields.count) aggregateParts.push("count");
+
+    (["sum", "avg", "max", "min"] as const).forEach(key => {
+      const fields = aggregateFields[key];
+      if (fields && fields.length > 0) {
+        aggregateParts.push(`${key} { ${fields.join(" ")} }`);
+      }
+    });
+  } else {
+    // 默认只取 count
+    aggregateParts.push("count");
+  }
+
+  const aggregateStr = aggregateParts.join(" ");
+
+  // ✅ 拼接 query
+  const query = `
+    query ${operationName + '_aggregateount'}${varDefs ? `(${varDefs})` : ""} {
+      ${operationName}_aggregateount${topArgsStr} {
+        aggregate { ${aggregateStr} }
+        nodes { ${buildFields(fields)} }
+      }
+    }
+  `;
+
+  return { query, variables };
+}
+
+
+
+
+
+
+

package/src/builders/sms.ts

@@ -0,0 +1,59 @@
+import {  buildFields, buildCommonResultSelection,buildDataValue } from './baseType.ts';
+import type {  FieldInput } from './baseType.ts';
+
+// ------------------- sendCode -------------------
+export interface SendCodeInput {
+    phone: string;
+    dataFields?: FieldInput[]; // SmsSendResult 字段
+    variables?: Record<string, any>;
+  }
+  
+  export function buildGraphQLMutationSendCode(input: SendCodeInput) {
+    const { phone } = input;
+    const finalVariables: Record<string, any> = { ...(input.variables || {}) };
+    if (finalVariables.phone === undefined) finalVariables.phone = phone;
+  
+    const varDefs = Object.keys(finalVariables).length
+      ? Object.keys(finalVariables).map(k => `$${k}: String!`).join(', ')
+      : '';
+  
+    const selection = buildCommonResultSelection(input.dataFields);
+  
+    const query = `mutation sendCode${varDefs ? `(${varDefs})` : ''} {
+      sendCode(phone: $phone) {
+        ${selection}
+      }
+    }`;
+  
+    return { query, variables: finalVariables };
+  }
+  
+  // ------------------- verifyCode -------------------
+  export interface VerifyCodeInput {
+    code: string;
+    phone: string;
+    variables?: Record<string, any>;
+  }
+  
+  export function buildGraphQLMutationVerifyCode(input: VerifyCodeInput) {
+    const { code, phone } = input;
+    const finalVariables: Record<string, any> = { ...(input.variables || {}) };
+    if (finalVariables.code === undefined) finalVariables.code = code;
+    if (finalVariables.phone === undefined) finalVariables.phone = phone;
+  
+    const varDefs = Object.keys(finalVariables).length
+      ? Object.keys(finalVariables).map(k => `$${k}: String!`).join(', ')
+      : '';
+  
+    const query = `mutation verifyCode${varDefs ? `(${varDefs})` : ''} {
+      verifyCode(code: $code, phone: $phone) {
+        ${buildCommonResultSelection()}
+      }
+    }`;
+  
+    return { query, variables: finalVariables };
+  }
+
+  
+  
+  

package/src/cache/memoryCache.ts

@@ -0,0 +1,34 @@
+interface CacheItem<T> {
+    data: T;
+    expire: number;
+  }
+  
+  export const DEFAULT_TTL = 5 * 60 * 1000; // 5 分钟
+  const cache = new Map<string, CacheItem<any>>();
+  
+  export function getCacheKey(key: string, variables?: any): string {
+    return variables ? `${key}::${JSON.stringify(variables)}` : key;
+  }
+  
+  export function getFromCache<T>(key: string): T | null {
+    const item = cache.get(key);
+    if (!item) return null;
+    if (Date.now() > item.expire) {
+      cache.delete(key);
+      return null;
+    }
+    return item.data;
+  }
+  
+  export function setCache<T>(key: string, data: T, ttl = DEFAULT_TTL) {
+    cache.set(key, { data, expire: Date.now() + ttl });
+  }
+  
+  export function deleteCache(key: string) {
+    cache.delete(key);
+  }
+  
+  export function clearCache() {
+    cache.clear();
+  }
+  

package/src/core/api/auth.ts

@@ -0,0 +1,86 @@
+import { execute } from '../executor.ts';
+import {
+  buildGraphQLMutationLogin,
+  buildGraphQLMutationRegisterUser,
+  buildGraphQLMutationLogout,
+  buildGraphQLMutationLogoutAllDevices,
+  buildGraphQLMutationLogoutDevice,
+  buildGraphQLMutationRefreshToken,
+} from '../../builders/index.ts';
+import type {
+  LoginInput,
+  RegisterUserInput,
+  RefreshTokenInput,
+} from '../../builders/index.ts';
+import type { UserToken, requestResult } from '../type.ts';
+import { rateLimit } from '../../rateLimit/rateLimit.ts';
+import { rateLimitConfig } from '../../rateLimit/rateLimitConfig.ts';
+import { clearCache } from '../../cache/memoryCache.ts';
+import {
+  setLoginInfo,
+  removeLoginInfo,
+  getLoginInfo
+} from '../../core/client.js';
+
+export const auth = {
+  async login<T = requestResult<UserToken>>(input: LoginInput) {
+    return rateLimit('login', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationLogin(input);
+      const result = await execute<T>({ query, variables });
+      setLoginInfo((result as any).login,input.remember)
+      clearCache(); // 登录后刷新缓存
+      return result;
+    }, rateLimitConfig);
+  },
+
+  async refreshToken<T = requestResult<UserToken>>(input: RefreshTokenInput) {
+    return rateLimit('refreshToken', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationRefreshToken(input);
+      const result = await execute<T>({ query, variables });
+      setLoginInfo((result as any).refreshToken,input.remember)
+      clearCache();
+      return result;
+    }, rateLimitConfig);
+  },
+
+  async register<T = requestResult<any>>(input: RegisterUserInput) {
+    return rateLimit('registerUser', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationRegisterUser(input);
+      const result = await execute<T>({ query, variables });
+      clearCache();
+      return result;
+    }, rateLimitConfig);
+  },
+
+  async logout<T = requestResult<any>>() {
+    return rateLimit('logout', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationLogout();
+      const result = await execute<T>({ query, variables });
+      removeLoginInfo()
+      clearCache();
+      return result;
+    }, rateLimitConfig);
+  },
+
+  async logoutAllDevices<T = requestResult<any>>() {
+    return rateLimit('logoutAllDevices', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationLogoutAllDevices();
+      const result = await execute<T>({ query, variables });
+      removeLoginInfo()
+      clearCache();
+      return result;
+    }, rateLimitConfig);
+  },
+
+  async logoutDevice<T = requestResult<any>>(deviceId: string) {
+    return rateLimit('logoutDevice', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationLogoutDevice({ deviceId });
+      const result = await execute<T>({ query, variables });
+      if (getLoginInfo()?.deviceId==deviceId) {
+        removeLoginInfo()
+      }
+      clearCache();
+      return result;
+    }, rateLimitConfig);
+  },
+};

package/src/core/api/gql.ts

@@ -0,0 +1,22 @@
+// src/core/api/gql.ts
+import { execute } from '../executor.js';
+import type { DocumentNode } from 'graphql';
+import type { requestResult } from '../type.ts';
+/**
+ * 原生 GraphQL 执行模块
+ * 可执行任意 query / mutation / subscription
+ */
+export const gql = {
+  /**
+   * 执行任意 GraphQL 文本或 DocumentNode
+   * @param query 原生 GQL 文本或 DocumentNode
+   * @param variables 可选变量
+   * @returns Promise<T>
+   */
+  async execute<T = requestResult<any>>(
+    query: string | DocumentNode,
+    variables?: Record<string, any>
+  ): Promise<T> {
+    return execute<T>({ query, variables });
+  },
+};

package/src/core/api/mutation.ts

@@ -0,0 +1,100 @@
+import { execute } from '../executor.ts';
+import {
+  buildGraphQLMutationInsertOne,
+  buildGraphQLMutationBatchInsert,
+  
+  buildGraphQLMutationUpdate,
+  buildGraphQLMutationBatchUpdate,
+  buildGraphQLMutationUpdateByPk,
+
+  buildGraphQLMutationDelete,
+  buildGraphQLMutationDeleteById,
+} from '../../builders/index.ts';
+import type {
+  InsertOneInput,
+  BatchInsertInput,
+
+  DeleteInput,
+  DeleteByIdInput,
+
+
+  BatchUpdateInput,
+  UpdateByPkInput,
+  UpdateInput,
+} from '../../builders/index.ts';
+import type { requestResult } from '../type.ts';
+import { clearCache } from '../../cache/memoryCache.ts';
+import { rateLimit } from '../../rateLimit/rateLimit.ts';
+
+export const mutation = {
+  async insertOne<T = requestResult<any>>(input: InsertOneInput) {
+    return rateLimit('insertOne', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationInsertOne(input);
+      const result = await execute<T>({ query, variables });
+
+      // 清空缓存，保证数据一致
+      clearCache();
+      return result;
+    });
+  },
+
+  async batchInsert<T = requestResult<any>>(input: BatchInsertInput) {
+    return rateLimit('batchInsert', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationBatchInsert(input);
+      const result = await execute<T>({ query, variables });
+
+      clearCache();
+      return result;
+    });
+  },
+
+  async update<T = requestResult<any>>(input: UpdateInput) {
+    return rateLimit('update', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationUpdate(input);
+      const result = await execute<T>({ query, variables });
+
+      clearCache();
+      return result;
+    });
+  },
+
+  async batchUpdate<T = requestResult<any>>(input: BatchUpdateInput) {
+    return rateLimit('batchUpdate', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationBatchUpdate(input);
+      const result = await execute<T>({ query, variables });
+
+      clearCache();
+      return result;
+    });
+  },
+
+  async updateByPk<T = requestResult<any>>(input: UpdateByPkInput) {
+    return rateLimit('updateByPk', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationUpdateByPk(input);
+      const result = await execute<T>({ query, variables });
+
+      clearCache();
+      return result;
+    });
+  },
+
+  async delete<T = requestResult<any>>(input: DeleteInput) {
+    return rateLimit('delete', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationDelete(input);
+      const result = await execute<T>({ query, variables });
+
+      clearCache();
+      return result;
+    });
+  },
+
+  async deleteById<T = requestResult<any>>(input: DeleteByIdInput) {
+    return rateLimit('deleteById', 'mutation', async () => {
+      const { query, variables } = buildGraphQLMutationDeleteById(input);
+      const result = await execute<T>({ query, variables });
+
+      clearCache();
+      return result;
+    });
+  },
+};

package/src/core/api/query.ts

@@ -0,0 +1,82 @@
+import { execute } from '../executor.ts';
+import {
+  buildGraphQLQueryList,
+  buildGraphQLQueryByIdFixed,
+  buildGraphQLQueryPageList,
+  buildGraphQLQueryAggregate,
+} from '../../builders/index.ts';
+import type {
+  QueryInput,
+  QueryByIdInput,
+  QueryPageListInput,
+  QueryAggregateInput,
+} from '../../builders/index.ts';
+import type { requestResult } from '../type.ts';
+import { getCacheKey, getFromCache, setCache, DEFAULT_TTL } from '../../cache/memoryCache.ts';
+import { rateLimit } from '../../rateLimit/rateLimit.ts';
+
+export const query = {
+  async list<T = requestResult<any>>(input: QueryInput, useCache = true, ttl?: number) {
+    return rateLimit('list', 'query', async () => {
+      const { query: q, variables } = buildGraphQLQueryList(input);
+      const key = getCacheKey(q, variables);
+
+      if (useCache) {
+        const cached = getFromCache<T>(key);
+        if (cached) return cached;
+      }
+
+      const result = await execute<T>({ query: q, variables });
+      if (useCache) setCache(key, result, ttl ?? DEFAULT_TTL);
+      return result;
+    });
+  },
+
+  async byId<T = requestResult<any>>(input: QueryByIdInput, useCache = true, ttl?: number) {
+    return rateLimit('byId', 'query', async () => {
+      const { query: q, variables } = buildGraphQLQueryByIdFixed(input);
+      const key = getCacheKey(q, variables);
+
+      if (useCache) {
+        const cached = getFromCache<T>(key);
+        if (cached) return cached;
+      }
+
+      const result = await execute<T>({ query: q, variables });
+      if (useCache) setCache(key, result, ttl ?? DEFAULT_TTL);
+      return result;
+    });
+  },
+
+  async page<T = requestResult<any>>(input: QueryPageListInput, useCache = true, ttl?: number) {
+    return rateLimit('page', 'query', async () => {
+      const { query: q, variables } = buildGraphQLQueryPageList(input);
+      const key = getCacheKey(q, variables);
+
+      if (useCache) {
+        const cached = getFromCache<T>(key);
+        if (cached) return cached;
+      }
+
+      const result = await execute<T>({ query: q, variables });
+      if (useCache) setCache(key, result, ttl ?? DEFAULT_TTL);
+      return result;
+    });
+  },
+
+  async aggregate<T = requestResult<any>>(input: QueryAggregateInput, useCache = true, ttl?: number) {
+    return rateLimit('aggregate', 'query', async () => {
+      const { query: q, variables } = buildGraphQLQueryAggregate(input);
+      const key = getCacheKey(q, variables);
+
+      if (useCache) {
+        const cached = getFromCache<T>(key);
+        if (cached) return cached;
+      }
+
+      const result = await execute<T>({ query: q, variables });
+      if (useCache) setCache(key, result, ttl ?? DEFAULT_TTL);
+      return result;
+    });
+  },
+};

package/src/core/api/sms.ts

@@ -0,0 +1,18 @@
+import { execute } from '../executor.ts';
+import {
+  buildGraphQLMutationSendCode,
+  buildGraphQLMutationVerifyCode,
+} from '../../builders/index.ts';
+import type { SendCodeInput, VerifyCodeInput } from '../../builders/index.ts';
+import type { requestResult } from '../type.ts';
+export const sms = {
+  async send<T = requestResult<any>>(input: SendCodeInput) {
+    const { query, variables } = buildGraphQLMutationSendCode(input);
+    return execute<T>({ query, variables });
+  },
+
+  async verify<T = requestResult<any>>(input: VerifyCodeInput) {
+    const { query, variables } = buildGraphQLMutationVerifyCode(input);
+    return execute<T>({ query, variables });
+  },
+};

package/src/core/client.ts

@@ -0,0 +1,47 @@
+// src/core/client.ts
+import { CCRequest } from './core.ts';
+import type { RequestConfig, RequestInterceptor, UserToken } from './type.ts';
+
+let client: CCRequest | null = null;
+
+/** 初始化全局客户端 */
+export function initGraphQLClient(config: RequestConfig): CCRequest {
+  client = new CCRequest(config);
+  return client;
+}
+
+/** 获取全局客户端实例 */
+export function getClient(): CCRequest {
+  if (!client) throw new Error('GraphQL client not initialized. Call initGraphQLClient() first.');
+  return client;
+}
+/** 注册全局拦截器 */
+export const useInterceptor = (interceptor: RequestInterceptor) =>
+  getClient().use(interceptor);
+
+
+
+// ===== 便捷操作函数 =====
+// token 修改 → 重建实例
+export const setToken = (token: string) => getClient().setToken(token);
+export const removeToken = () => getClient().removeToken();
+
+// 登录信息 
+export const setLoginInfo = (loginInfo: UserToken, remember: boolean = false) => getClient().setLoginInfo(loginInfo,remember)
+export const removeLoginInfo = () => getClient().removeLoginInfo()
+export const getLoginInfo = () => getClient().getLoginInfo()
+
+
+
+
+
+// endpoint 修改 → 重建实例
+export const setEndpoint = (endpoint: string) => getClient().setEndpoint(endpoint);
+
+// 普通 header 操作 → 不重建实例
+export const setHeader = (key: string, value: string) => getClient().setHeader(key, value);
+export const setHeaders = (headers: Record<string, string>) => getClient().setHeaders(headers);
+export const removeHeader = (key: string) => getClient().removeHeader(key);
+export const clearHeaders = () => getClient().clearHeaders();
+
+