@kevisual/api 0.0.1 → 0.0.6

package/mod.ts

@@ -0,0 +1 @@
+export * from './query/query-proxy/index.ts';

package/package.json

@@ -1,30 +1,39 @@
 {
   "name": "@kevisual/api",
-  "version": "0.0.1",
+  "version": "0.0.6",
   "description": "",
-  "main": "index.js",
+  "main": "mod.ts",
   "scripts": {
-    "build": "bun bun.config.mjs"
+    "build": "bun run bun.config.ts",
+    "postbuild": "bun bun.copy.config.mjs"
   },
-  "keywords": [],
-  "files": [
-    "src",
-    "query",
-    "dist"
-  ],
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "query",
+    "mod.ts"
+  ],
+  "keywords": [],
   "author": "abearxiong <xiongxiao@xiongxiao.me> (https://www.xiongxiao.me)",
   "license": "MIT",
-  "packageManager": "pnpm@10.6.2",
+  "packageManager": "pnpm@10.26.2",
   "type": "module",
-  "dependencies": {
-    "@kevisual/query": "^0.0.18",
-    "@kevisual/router": "^0.0.20"
-  },
   "devDependencies": {
+    "@kevisual/cache": "^0.0.4",
+    "@kevisual/query": "^0.0.33",
+    "@kevisual/router": "^0.0.51",
     "@kevisual/types": "^0.0.10",
-    "@types/node": "^22.15.27"
+    "@kevisual/use-config": "^1.0.21",
+    "@types/bun": "^1.3.5",
+    "@types/node": "^25.0.3",
+    "dotenv": "^17.2.3",
+    "fast-glob": "^3.3.3"
+  },
+  "dependencies": {
+    "@kevisual/load": "^0.0.6",
+    "es-toolkit": "^1.43.0",
+    "nanoid": "^5.1.6"
   }
 }

package/query/kevisual.json

@@ -1,24 +1,20 @@
 {
-  "$schema": "https://kevisual.xiongxiao.me/root/ai/kevisual/tools/kevisual-sync/schema.json?v=2",
   "metadata": {
+    "name": "kevisual",
     "share": "public"
   },
-  "checkDir": {
-    "src/query": {
-      "url": "https://kevisual.xiongxiao.me/root/ai/code/registry/query",
+  "registry": "https://kevisual.cn/root/ai/kevisual/common/query/api",
+  "clone": {
+    ".": {
       "enabled": true
     }
   },
-  "syncDirectory": [
+  "syncd": [
     {
       "files": [
-        "src/query/**/*"
+        "**/*"
       ],
-      "ignore": [],
-      "registry": "https://kevisual.xiongxiao.me/root/ai/code/registry",
-      "replace": {
-        "src/": ""
-      }
+      "registry": ""
     }
   ],
   "sync": {}

package/query/query-ai/defines/ai.ts

@@ -1,4 +1,4 @@
-import { QueryUtil } from '@/query/index.ts';
+import { QueryUtil } from '../../../query/index.ts';
 
 type Message = {
   role?: 'user' | 'assistant' | 'system' | 'tool';

package/query/query-app/defines/user-app-list.ts

@@ -1,4 +1,4 @@
-import { QueryUtil } from '@/query/index.ts';
+import { QueryUtil } from '../../../query/index.ts';
 
 export const appDefine = QueryUtil.create({
   getApp: {

package/query/query-app/defines/user-app.ts

@@ -1,4 +1,4 @@
-import { QueryUtil } from '@/query/index.ts';
+import { QueryUtil } from '../../../query/index.ts';
 
 export const userAppDefine = QueryUtil.create({
   listUserApps: {

package/query/query-app/query-app.ts

@@ -15,4 +15,18 @@ export class QueryApp extends BaseQuery {
   getList(data: any, opts?: DataOpts) {
     return this.appDefine.queryChain('listApps').post(data, opts);
   }
+  getPublicApp(data: any, opts?: DataOpts) {
+    return this.query.post({
+      path: 'app',
+      key: 'getApp',
+      data: data,
+    }, opts);
+  }
+  getApp(data: any, opts?: DataOpts) {
+    return this.query.post({
+      path: 'app',
+      key: 'get',
+      data: data,
+    }, opts);
+  }
 }

package/query/query-config/query-config.ts

@@ -0,0 +1,121 @@
+/**
+ * 配置查询
+ * @updatedAt 2025-12-03 10:33:00
+ */
+import { Query } from '@kevisual/query';
+import type { Result } from '@kevisual/query/query';
+type QueryConfigOpts = {
+  query?: Query;
+};
+export type Config<T = any> = {
+  id?: string;
+  title?: string;
+  key?: string;
+  description?: string;
+  data?: T;
+  createdAt?: string;
+  updatedAt?: string;
+};
+export type UploadConfig = {
+  key?: string;
+  version?: string;
+};
+type PostOpts = {
+  token?: string;
+  payload?: Record<string, any>;
+};
+export const defaultConfigKeys = ['upload.json', 'workspace.json', 'ai.json', 'user.json', 'life.json'] as const;
+type DefaultConfigKey = (typeof defaultConfigKeys)[number];
+
+export class QueryConfig {
+  query: Query;
+  constructor(opts?: QueryConfigOpts) {
+    this.query = opts?.query || new Query();
+  }
+  async post<T = Config>(data: any) {
+    return this.query.post<T>({ path: 'config', ...data });
+  }
+  async getConfig({ id, key }: { id?: string; key?: string }, opts?: PostOpts) {
+    return this.post({
+      key: 'get',
+      data: {
+        id,
+        key,
+      },
+      ...opts,
+    });
+  }
+  async updateConfig(data: Config, opts?: PostOpts) {
+    return this.post({
+      key: 'update',
+      data,
+      ...opts,
+    });
+  }
+  async deleteConfig(data: { id?: string, key?: string }, opts?: PostOpts) {
+    console.log('Delete Config Params:', data);
+    return this.post({
+      key: 'delete',
+      data,
+    });
+  }
+  async listConfig(opts?: PostOpts) {
+    return this.post<{ list: Config[] }>({
+      key: 'list',
+      ...opts,
+    });
+  }
+  /**
+   * 获取上传配置
+   * @returns
+   */
+  async getUploadConfig(opts?: PostOpts) {
+    return this.post<Result<Config<UploadConfig>>>({
+      key: 'getUploadConfig',
+      ...opts,
+    });
+  }
+  /**
+   * 更新上传配置
+   * @param data
+   * @returns
+   */
+  async updateUploadConfig(data: Config, opts?: PostOpts) {
+    return this.post<Result<Config<UploadConfig>>>({
+      key: 'updateUploadConfig',
+      data,
+      ...opts,
+    });
+  }
+
+  /**
+   * 检测配置是否存在
+   * @param id
+   * @returns
+   */
+  async detectConfig(opts?: PostOpts) {
+    return this.post<{ updateList: Config[] }>({
+      key: 'detect',
+      ...opts,
+    });
+  }
+  /**
+   * 获取配置, 获取默认的配置项
+   * @param key
+   * @returns
+   */
+  async getConfigByKey(key: DefaultConfigKey, opts?: PostOpts) {
+    return this.post<Result<Config>>({
+      key: 'defaultConfig',
+      configKey: key,
+      ...opts,
+    });
+  }
+  async getByKey<T = any>(key: string, opts?: PostOpts) {
+    return this.post<Result<Config<T>>>({
+      key: 'get',
+      ...opts,
+      data: { key },
+    });
+  }
+}

package/query/query-login/query-login.ts

@@ -3,7 +3,7 @@ import type { Result, DataOpts } from '@kevisual/query/query';
 import { setBaseResponse } from '@kevisual/query/query';
 import { LoginCacheStore, CacheStore } from './login-cache.ts';
 import { Cache } from './login-cache.ts';
-
+import { BaseLoad } from '@kevisual/load';
 export type QueryLoginOpts = {
   query?: Query;
   isBrowser?: boolean;
@@ -418,6 +418,12 @@ export class QueryLogin extends BaseQuery {
   }
   /**
    * 使用web登录,创建url地址, 需要MD5和jsonwebtoken
+   * 
+   * 
+
+import MD5 from 'crypto-js/md5.js';
+import jsonwebtoken from 'jsonwebtoken';
+
    */
   loginWithWeb(baseURL: string, { MD5, jsonwebtoken }: { MD5: any; jsonwebtoken: any }) {
     const randomId = Math.random().toString(36).substring(2, 15);
@@ -431,4 +437,46 @@ export class QueryLogin extends BaseQuery {
     const url = `${baseURL}/api/router?path=user&key=webLogin&p&loginToken=${token}&sign=${sign}&randomId=${randomId}`;
     return { url, token, tokenSecret };
   }
+  /**
+   *轮询登录状态
+   * 
+   * 
+   * 
+const res = queryLogin.loginWithWeb(baseURL, { MD5, jsonwebtoken });
+await pollLoginStatus(res.token, { tokenSecret: res.tokenSecret });
+   * 轮询登录状态
+   */
+  async pollLoginStatus(data: { token: string; tokenSecret: string }) {
+    const token = data.token;
+    const load = new BaseLoad();
+    load.load(
+      async () => {
+        const res = await this.checkLoginStatus(token);
+        if (res.code === 500) {
+          load.cancel('check-login-status');
+        }
+        return res;
+      },
+      {
+        key: 'check-login-status',
+        isReRun: true,
+        checkSuccess: (data) => {
+          return data?.code === 200;
+        },
+      },
+    );
+    const res = await load.hasLoaded('check-login-status', {
+      timeout: 60 * 3 * 1000, // 3分钟超时
+    });
+    if (res.code === 200 && res.data?.code === 200) {
+      try {
+        console.log('网页登录成功');
+        return;
+      } catch (error) {
+        console.log('登录失败', error);
+        return;
+      }
+    }
+    console.log('登录失败', res);
+  }
 }

package/query/query-proxy/index.ts

@@ -0,0 +1,68 @@
+import { Query } from '@kevisual/query/query';
+import { QueryRouterServer, Route } from '@kevisual/router/src/route.ts';
+export class QueryProxy {
+  query: Query;
+  router: QueryRouterServer;
+  token?: string;
+  constructor(opts?: { query: Query, router?: QueryRouterServer, token?: string }) {
+    this.query = opts?.query || new Query();
+    this.router = opts?.router || new QueryRouterServer();
+    this.token = opts?.token;
+  }
+  /**
+   * 初始化路由
+   * @returns 
+   */
+  async init() {
+    const that = this;
+    const res = await this.query.post<{ list: RouterItem[] }>({ path: "router", key: 'list', token: this.token });
+    if (res.code !== 200) {
+      console.error('Failed to init query proxy router:', res.message);
+      return
+    }
+    const _list = res.data?.list || []
+    for (const item of _list) {
+      if (item.path && item.key) {
+        console.log(`Register route: [${item.path}] ${item.key}`);
+        this.router.route({
+          path: item.path,
+          key: item.key,
+          description: item.description,
+          metadata: item.metadata,
+        }).define(async (ctx) => {
+          const msg = { ...ctx.query };
+          if (msg.token === undefined && that.token !== undefined) {
+            msg.token = that.token;
+          }
+          const r = await that.query.post<any>({ path: item.path, key: item.key, ...msg });
+          ctx.forward(r)
+        }).addTo(that.router);
+      }
+    }
+  }
+  /**
+   * 列出路由
+   * @param filter 
+   * @returns 
+   */
+  async listRoutes(filter?: (item: Route) => boolean) {
+    return this.router.routes.filter(filter || (() => true));
+  }
+  /**
+   * 运行路由
+   * @param msg 
+   * @returns 
+   */
+  async run(msg: { id?: string, path?: string, key?: string }) {
+    return await this.router.run(msg);
+  }
+}
+
+type RouterItem = {
+  id?: string;
+  path?: string;
+  key?: string;
+  description?: string;
+  middleware?: string[];
+  metadata?: Record<string, any>;
+}

package/query/query-secret/query-secret.ts

@@ -0,0 +1,64 @@
+/**
+ * 配置查询
+ * @updatedAt 2025-12-03 10:33:00
+ */
+import { Query } from '@kevisual/query';
+type QueryConfigOpts = {
+  query?: Query;
+};
+export type Config<T = any> = {
+  id?: string;
+  title?: string;
+  key?: string;
+  description?: string;
+  data?: T;
+  createdAt?: string;
+  updatedAt?: string;
+};
+export type UploadConfig = {
+  key?: string;
+  version?: string;
+};
+type PostOpts = {
+  token?: string;
+  payload?: Record<string, any>;
+};
+
+export class QueryConfig {
+  query: Query;
+  constructor(opts?: QueryConfigOpts) {
+    this.query = opts?.query || new Query();
+  }
+  async post<T = Config>(data: any) {
+    return this.query.post<T>({ path: 'secret', ...data });
+  }
+  async getItem({ id, key }: { id?: string; key?: string }, opts?: PostOpts) {
+    return this.post({
+      key: 'get',
+      data: {
+        id,
+        key,
+      },
+      ...opts,
+    });
+  }
+  async updateItem(data: Config, opts?: PostOpts) {
+    return this.post({
+      key: 'update',
+      data,
+      ...opts,
+    });
+  }
+  async deleteItem(data: { id?: string, key?: string }, opts?: PostOpts) {
+    return this.post({
+      key: 'delete',
+      data,
+    });
+  }
+  async listItems(opts?: PostOpts) {
+    return this.post<{ list: Config[] }>({
+      key: 'list',
+      ...opts,
+    });
+  }
+}

package/query/query-shop/defines/query-shop-define.ts

@@ -1,4 +1,4 @@
-import { QueryUtil } from '@/query/index.ts';
+import { QueryUtil } from '../../../query/index.ts';
 
 export const shopDefine = QueryUtil.create({
   getRegistry: {

package/query/query-shop/query-shop.ts

@@ -4,14 +4,13 @@ import { BaseQuery, DataOpts, Query } from '@kevisual/query/query';
 
 export { shopDefine };
 
-export class QueryShop<T extends Query = Query> extends BaseQuery<T, typeof shopDefine> {
+export class QueryShop<T extends Query = Query> extends BaseQuery<T> {
   constructor(opts?: { query: T }) {
     super({
       query: opts?.query!,
-      queryDefine: shopDefine,
     });
   }
   getInstall(data: any, opts?: DataOpts) {
-    return this.queryDefine.queryChain('install').post(data, opts);
+    return this.query.post(data, opts);
   }
 }

package/query/query-upload/query-upload.ts

@@ -5,7 +5,8 @@ import { UploadProgress } from './core/upload-progress.ts';
 
 export { uploadFiles, uploadFileChunked, UploadProgress };
 
-export * from './utils/to-file.ts';
+export { toTextFile, toFile, getDirectoryAndName } from './utils/to-file.ts';
+
 export { randomId } from './utils/random-id.ts';
 
 export { filterFiles } from './utils/filter-files.ts';

package/readme.md

@@ -0,0 +1,169 @@
+# @kevisual/api
+
+对 kevisual 相关的query router 的模块整理
+
+包含的模块：
+
+## query-config - 配置管理模块
+
+提供配置的增删改查功能，支持默认配置项管理。
+
+**主要功能：**
+- 配置的获取、更新、删除
+- 上传配置管理
+- 默认配置项支持（upload.json, workspace.json, ai.json, user.json, life.json）
+- 配置检测功能
+
+**使用示例：**
+```typescript
+import { QueryConfig } from './query-config/query-config';
+
+const config = new QueryConfig();
+await config.getConfig({ key: 'upload.json' });
+await config.updateConfig({ key: 'config.json', data: { setting: true } });
+```
+
+## query-secret - 密钥管理模块
+
+用于管理敏感信息和密钥的存储与检索。
+
+**主要功能：**
+- 密钥的存储和获取
+- 支持按ID或key检索
+- 密钥列表管理
+
+## query-proxy - 代理路由模块
+
+提供动态路由代理功能，可以将请求转发到不同的后端服务。
+
+**主要功能：**
+- 动态路由注册
+- 请求转发代理
+- 路由列表管理
+- Token认证支持
+
+**使用示例：**
+```typescript
+import { QueryProxy } from './query-proxy/index';
+
+const proxy = new QueryProxy({
+  query: new Query(),
+  token: 'your-token'
+});
+await proxy.init(); // 初始化路由
+const result = await proxy.run({ path: 'api', key: 'getData' });
+```
+
+## query-upload - 文件上传模块
+
+功能完整的文件上传解决方案，支持多种上传方式。
+
+**主要功能：**
+- 普通文件上传
+- 分片上传（大文件）
+- 上传进度跟踪
+- 文件过滤工具
+- 文件格式转换
+
+**核心组件：**
+- `uploadFiles` - 基础文件上传
+- `uploadFileChunked` - 分片上传
+- `UploadProgress` - 进度管理
+- `filterFiles` - 文件过滤
+- `toFile` - 格式转换
+
+**使用示例：**
+```typescript
+import { uploadFiles, UploadProgress } from './query-upload/query-upload';
+
+const progress = new UploadProgress();
+await uploadFiles(files, {
+  onProgress: (loaded, total) => {
+    console.log(`上传进度: ${loaded}/${total}`);
+  }
+});
+```
+
+## query-app - 应用管理模块
+
+管理应用的注册、获取和列表功能。
+
+**主要功能：**
+- 获取应用列表
+- 获取公开应用
+- 获取私有应用
+- 应用定义管理
+
+## query-shop - 应用商店模块
+
+应用商店功能，处理应用的安装和获取。
+
+**主要功能：**
+- 应用安装
+- 商店应用管理
+
+## query-ai - AI对话模块
+
+集成AI聊天功能，支持多种模型和对话管理。
+
+**主要功能：**
+- AI对话（支持GPT等模型）
+- 模型列表获取
+- 聊天使用统计
+- 缓存管理
+- 使用限制管理
+
+**使用示例：**
+```typescript
+import { QueryAI } from './query-ai/query-ai';
+
+const ai = new QueryAI({ query: new Query() });
+const models = await ai.getModelList();
+const response = await ai.chat(
+  { message: '你好' },
+  { username: 'user', model: 'gpt-3.5', group: 'default' }
+);
+```
+
+## query-login - 登录认证模块
+
+完整的登录认证解决方案，支持token管理和缓存。
+
+**主要功能：**
+- 用户登录认证
+- Token管理（access/refresh token）
+- 登录状态缓存
+- 浏览器/Node.js环境支持
+- 自动token刷新
+
+**核心组件：**
+- `QueryLogin` - 主登录类
+- `LoginCacheStore` - 登录缓存
+- `Cache` - 通用缓存接口
+
+## query-resources - 资源管理模块
+
+管理用户资源的访问和获取。
+
+**主要功能：**
+- 资源文件获取
+- 资源列表管理
+- 用户认证支持
+- 文件预览功能
+
+**使用示例：**
+```typescript
+import { QueryResources } from './query-resources/index';
+
+const resources = new QueryResources({ username: 'user' });
+const fileList = await resources.getList('images/');
+const fileContent = await resources.fetchFile('document.pdf');
+```
+
+## 架构特点
+
+- **模块化设计**：每个模块职责单一，可独立使用
+- **统一接口**：基于 `@kevisual/query` 的统一查询接口
+- **环境兼容**：支持浏览器和Node.js环境
+- **类型安全**：完整的TypeScript类型定义
+- **扩展性**：易于扩展和自定义

package/query/query-mark/query-mark.ts

@@ -1,154 +0,0 @@
-import { Query } from '@kevisual/query';
-import type { Result, DataOpts } from '@kevisual/query/query';
-
-export type SimpleObject = Record<string, any>;
-export const markType = ['simple', 'md', 'mdx', 'wallnote', 'excalidraw', 'chat'] as const;
-export type MarkType = (typeof markType)[number];
-export type MarkData = {
-  nodes?: any[];
-  edges?: any[];
-  elements?: any[];
-  permission?: any;
-
-  [key: string]: any;
-};
-export type Mark = {
-  id: string;
-  title: string;
-  description: string;
-  markType: MarkType;
-  link: string;
-  data?: MarkData;
-  uid: string;
-  puid: string;
-  summary: string;
-  thumbnail?: string;
-  tags: string[];
-  createdAt: string;
-  updatedAt: string;
-  version: number;
-};
-export type ShowMarkPick = Pick<Mark, 'id' | 'title' | 'description' | 'summary' | 'link' | 'tags' | 'thumbnail' | 'updatedAt'>;
-
-export type SearchOpts = {
-  page?: number;
-  pageSize?: number;
-  search?: string;
-  sort?: string; // DESC, ASC
-  markType?: MarkType; // 类型
-  [key: string]: any;
-};
-
-export type QueryMarkOpts<T extends SimpleObject = SimpleObject> = {
-  query?: Query;
-  isBrowser?: boolean;
-  onLoad?: () => void;
-} & T;
-
-export type ResultMarkList = {
-  list: Mark[];
-  pagination: {
-    pageSize: number;
-    current: number;
-    total: number;
-  };
-};
-export type QueryMarkData = {
-  id?: string;
-  title?: string;
-  description?: string;
-  [key: string]: any;
-};
-export type QueryMarkResult = {
-  accessToken: string;
-  refreshToken: string;
-};
-
-export class QueryMarkBase<T extends SimpleObject = SimpleObject> {
-  query: Query;
-  isBrowser: boolean;
-  load?: boolean;
-  storage?: Storage;
-  onLoad?: () => void;
-
-  constructor(opts?: QueryMarkOpts<T>) {
-    this.query = opts?.query || new Query();
-    this.isBrowser = opts?.isBrowser ?? true;
-    this.init();
-    this.onLoad = opts?.onLoad;
-  }
-  setQuery(query: Query) {
-    this.query = query;
-  }
-  private async init() {
-    this.load = true;
-    this.onLoad?.();
-  }
-
-  async post<T = Result<any>>(data: any, opts?: DataOpts): Promise<T> {
-    try {
-      return this.query.post({ path: 'mark', ...data }, opts) as Promise<T>;
-    } catch (error) {
-      console.log('error', error);
-      return {
-        code: 400,
-      } as any;
-    }
-  }
-
-  async getMarkList(search: SearchOpts, opts?: DataOpts) {
-    return this.post<Result<ResultMarkList>>({ key: 'list', ...search }, opts);
-  }
-
-  async getMark(id: string, opts?: DataOpts) {
-    return this.post<Result<Mark>>({ key: 'get', id }, opts);
-  }
-  async getVersion(id: string, opts?: DataOpts) {
-    return this.post<Result<{ version: number; id: string }>>({ key: 'getVersion', id }, opts);
-  }
-  /**
-   * 检查版本
-   * 当需要更新时，返回true
-   * @param id
-   * @param version
-   * @param opts
-   * @returns
-   */
-  async checkVersion(id: string, version?: number, opts?: DataOpts) {
-    if (!version) {
-      return true;
-    }
-    const res = await this.getVersion(id, opts);
-    if (res.code === 200) {
-      if (res.data!.version > version) {
-        return true;
-      }
-      return false;
-    }
-    return true;
-  }
-
-  async updateMark(data: any, opts?: DataOpts) {
-    return this.post<Result<Mark>>({ key: 'update', data }, opts);
-  }
-
-  async deleteMark(id: string, opts?: DataOpts) {
-    return this.post<Result<Mark>>({ key: 'delete', id }, opts);
-  }
-}
-export class QueryMark extends QueryMarkBase<SimpleObject> {
-  markType: string;
-  constructor(opts?: QueryMarkOpts & { markType?: MarkType }) {
-    super(opts);
-    this.markType = opts?.markType || 'simple';
-  }
-  async getMarkList(search?: SearchOpts, opts?: DataOpts) {
-    return this.post<Result<ResultMarkList>>({ key: 'list', ...search, markType: this.markType }, opts);
-  }
-  async updateMark(data: any, opts?: DataOpts) {
-    if (!data.id) {
-      data.markType = this.markType || 'simple';
-    }
-    return super.updateMark(data, opts);
-  }
-}