@kevisual/query 0.0.6 → 0.0.7-alpha.2

package/dist/query-browser.d.ts

@@ -0,0 +1,125 @@
+import { StoreApi } from 'zustand/vanilla';
+
+type AdapterOpts = {
+    url: string;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+    timeout?: number;
+};
+declare const adapter: (opts: AdapterOpts) => Promise<any>;
+
+type QueryWsStore = {
+    connected: boolean;
+    status: 'connecting' | 'connected' | 'disconnected';
+    setConnected: (connected: boolean) => void;
+    setStatus: (status: QuerySelectState) => void;
+};
+type QuerySelectState = 'connecting' | 'connected' | 'disconnected';
+type QueryWsOpts = {
+    url?: string;
+    store?: StoreApi<QueryWsStore>;
+    ws?: WebSocket;
+};
+declare class QueryWs {
+    url: string;
+    store: StoreApi<QueryWsStore>;
+    ws: WebSocket;
+    constructor(opts?: QueryWsOpts);
+    /**
+     * 连接 WebSocket
+     */
+    connect(opts?: {
+        timeout?: number;
+    }): Promise<unknown>;
+    listenConnect(callback: () => void): () => void;
+    onMessage<T = any, U = any>(fn: (data: U, event: MessageEvent) => void, opts?: {
+        isJson?: boolean;
+        selector?: (data: T) => U;
+    }): () => void;
+    close(): void;
+    send<T = any, U = any>(data: T, opts?: {
+        isJson?: boolean;
+        wrapper?: (data: T) => U;
+    }): void;
+    getOpen(): boolean;
+}
+
+type Fn = (opts: {
+    url?: string;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+    [key: string]: any;
+    timeout?: number;
+}) => Promise<Record<string, any>>;
+type QueryOpts$1 = {
+    url?: string;
+    adapter?: typeof adapter;
+    headers?: Record<string, string>;
+    timeout?: number;
+};
+type Data = {
+    path?: string;
+    key?: string;
+    payload?: Record<string, any>;
+    [key: string]: any;
+};
+type Result<S = any> = {
+    code: number;
+    data?: S;
+    message?: string;
+    success: boolean;
+};
+type DataOpts = Partial<QueryOpts$1> & {
+    beforeRequest?: Fn;
+    afterResponse?: (result: Result) => Promise<any>;
+};
+/**
+ * const query = new Query();
+ * const res = await query.post({
+ *   path: 'demo',
+ *   key: '1',
+ *  });
+ *
+ * U是参数 V是返回值
+ */
+declare class Query<U = any, V = any> {
+    adapter: typeof adapter;
+    url: string;
+    beforeRequest?: Fn;
+    afterResponse?: (result: Result) => Promise<any>;
+    headers?: Record<string, string>;
+    timeout?: number;
+    constructor(opts?: QueryOpts$1);
+    get<T = any, S = any>(params: Record<string, any> & Data & U & T, options?: DataOpts): Promise<Result<V & S>>;
+    post<T = any, S = any>(body: Record<string, any> & Data & T, options?: DataOpts): Promise<Result<S>>;
+    before(fn: Fn): void;
+    after(fn: (result: Result) => Promise<any>): void;
+}
+
+type QueryOpts = {
+    url?: string;
+    adapter?: typeof adapter;
+    headers?: Record<string, string>;
+    timeout?: number;
+};
+/**
+ * 前端调用后端QueryRouter
+ */
+declare class QueryClient<U = any, V = any> extends Query<U, V> {
+    tokenName: string;
+    storage: Storage;
+    token: string;
+    qws: QueryWs;
+    constructor(opts?: QueryOpts & {
+        tokenName?: string;
+        storage?: Storage;
+        io?: boolean;
+    });
+    createWs(opts?: QueryWsOpts): void;
+    getToken(): string;
+    saveToken(token: string): void;
+    removeToken(): void;
+}
+declare const client: QueryClient<any, any>;
+
+export { QueryClient, type QueryOpts, QueryWs, adapter, client };

package/dist/{index.js → query-browser.js}

@@ -1,7 +1,7 @@
 const adapter = async (opts) => {
     const controller = new AbortController();
     const signal = controller.signal;
-    const timeout = opts.timeout || 60000; // 默认超时时间为 60s
+    const timeout = opts.timeout || 60000 * 3; // 默认超时时间为 60s * 3
     const timer = setTimeout(() => {
         controller.abort();
     }, timeout);
@@ -117,22 +117,31 @@ class QueryWs {
     /**
      * 连接 WebSocket
      */
-    connect() {
+    async connect(opts) {
         const store = this.store;
         const connected = store.getState().connected;
         if (connected) {
-            return;
+            return Promise.resolve(true);
         }
-        const ws = this.ws || new WebSocket(this.url);
-        ws.onopen = () => {
-            store.getState().setConnected(true);
-            store.getState().setStatus('connected');
-        };
-        ws.onclose = () => {
-            store.getState().setConnected(false);
-            store.getState().setStatus('disconnected');
-            this.ws = null;
-        };
+        return new Promise((resolve, reject) => {
+            const ws = this.ws || new WebSocket(this.url);
+            const timeout = opts?.timeout || 5 * 60 * 1000; // 默认 2 分钟
+            let timer = setTimeout(() => {
+                console.error('WebSocket 连接超时');
+                reject('timeout');
+            }, timeout);
+            ws.onopen = () => {
+                store.getState().setConnected(true);
+                store.getState().setStatus('connected');
+                resolve(true);
+                clearTimeout(timer);
+            };
+            ws.onclose = () => {
+                store.getState().setConnected(false);
+                store.getState().setStatus('disconnected');
+                this.ws = null;
+            };
+        });
     }
     listenConnect(callback) {
         const store = this.store;
@@ -205,6 +214,12 @@ class QueryWs {
             ws.send(data);
         }
     }
+    getOpen() {
+        if (!this.ws) {
+            return false;
+        }
+        return this.ws.readyState === WebSocket.OPEN;
+    }
 }
 
 /**
@@ -229,7 +244,7 @@ class Query {
         this.headers = opts?.headers || {
             'Content-Type': 'application/json',
         };
-        this.timeout = opts?.timeout || 60000; // 默认超时时间为 60s
+        this.timeout = opts?.timeout || 60000 * 3; // 默认超时时间为 60s * 3
     }
     async get(params, options) {
         return this.post(params, options);
@@ -265,6 +280,7 @@ class Query {
         this.afterResponse = fn;
     }
 }
+
 /**
  * 前端调用后端QueryRouter
  */
@@ -287,7 +303,12 @@ class QueryClient extends Query {
             }
             return opts;
         };
-        this.qws = new QueryWs({ url: opts?.url });
+        if (opts?.io) {
+            this.createWs();
+        }
+    }
+    createWs(opts) {
+        this.qws = new QueryWs({ url: this.url, ...opts });
     }
     getToken() {
         return this.storage.getItem(this.tokenName);
@@ -299,5 +320,6 @@ class QueryClient extends Query {
         this.storage.removeItem(this.tokenName);
     }
 }
+const client = new QueryClient();
 
-export { Query, QueryClient, adapter };
+export { QueryClient, QueryWs, adapter, client };

package/dist/{ws.d.ts → query-ws.d.ts}

@@ -1,26 +1,27 @@
 import { StoreApi } from 'zustand/vanilla';
+
 type QueryWsStore = {
     connected: boolean;
     status: 'connecting' | 'connected' | 'disconnected';
     setConnected: (connected: boolean) => void;
     setStatus: (status: QuerySelectState) => void;
 };
-export type QuerySelectState = 'connecting' | 'connected' | 'disconnected';
-export type QueryWsStoreListener = (newState: QueryWsStore, oldState: QueryWsStore) => void;
+type QuerySelectState = 'connecting' | 'connected' | 'disconnected';
+type QueryWsStoreListener = (newState: QueryWsStore, oldState: QueryWsStore) => void;
 type QueryWsOpts = {
     url?: string;
     store?: StoreApi<QueryWsStore>;
     ws?: WebSocket;
 };
-export type WsSend<T = any, U = any> = (data: T, opts?: {
+type WsSend<T = any, U = any> = (data: T, opts?: {
     isJson?: boolean;
     wrapper?: (data: T) => U;
 }) => any;
-export type WsOnMessage<T = any, U = any> = (fn: (data: U, event: MessageEvent) => void, opts?: {
+type WsOnMessage<T = any, U = any> = (fn: (data: U, event: MessageEvent) => void, opts?: {
     isJson?: boolean;
     selector?: (data: T) => U;
 }) => any;
-export declare class QueryWs {
+declare class QueryWs {
     url: string;
     store: StoreApi<QueryWsStore>;
     ws: WebSocket;
@@ -28,7 +29,9 @@ export declare class QueryWs {
     /**
      * 连接 WebSocket
      */
-    connect(): void;
+    connect(opts?: {
+        timeout?: number;
+    }): Promise<unknown>;
     listenConnect(callback: () => void): () => void;
     onMessage<T = any, U = any>(fn: (data: U, event: MessageEvent) => void, opts?: {
         isJson?: boolean;
@@ -39,5 +42,7 @@ export declare class QueryWs {
         isJson?: boolean;
         wrapper?: (data: T) => U;
     }): void;
+    getOpen(): boolean;
 }
-export {};
+
+export { type QuerySelectState, QueryWs, type QueryWsOpts, type QueryWsStoreListener, type WsOnMessage, type WsSend };

package/dist/{ws.js → query-ws.js}

@@ -76,22 +76,31 @@ class QueryWs {
     /**
      * 连接 WebSocket
      */
-    connect() {
+    async connect(opts) {
         const store = this.store;
         const connected = store.getState().connected;
         if (connected) {
-            return;
+            return Promise.resolve(true);
         }
-        const ws = this.ws || new WebSocket(this.url);
-        ws.onopen = () => {
-            store.getState().setConnected(true);
-            store.getState().setStatus('connected');
-        };
-        ws.onclose = () => {
-            store.getState().setConnected(false);
-            store.getState().setStatus('disconnected');
-            this.ws = null;
-        };
+        return new Promise((resolve, reject) => {
+            const ws = this.ws || new WebSocket(this.url);
+            const timeout = opts?.timeout || 5 * 60 * 1000; // 默认 2 分钟
+            let timer = setTimeout(() => {
+                console.error('WebSocket 连接超时');
+                reject('timeout');
+            }, timeout);
+            ws.onopen = () => {
+                store.getState().setConnected(true);
+                store.getState().setStatus('connected');
+                resolve(true);
+                clearTimeout(timer);
+            };
+            ws.onclose = () => {
+                store.getState().setConnected(false);
+                store.getState().setStatus('disconnected');
+                this.ws = null;
+            };
+        });
     }
     listenConnect(callback) {
         const store = this.store;
@@ -164,6 +173,12 @@ class QueryWs {
             ws.send(data);
         }
     }
+    getOpen() {
+        if (!this.ws) {
+            return false;
+        }
+        return this.ws.readyState === WebSocket.OPEN;
+    }
 }
 
 export { QueryWs };

package/dist/{index.d.ts → query.d.ts}

@@ -1,6 +1,11 @@
-import { adapter } from './adapter.ts';
-import { QueryWs } from './ws.ts';
-export { QueryOpts };
+type AdapterOpts = {
+    url: string;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+    timeout?: number;
+};
+declare const adapter: (opts: AdapterOpts) => Promise<any>;
+
 type Fn = (opts: {
     url?: string;
     headers?: Record<string, string>;
@@ -39,7 +44,7 @@ type DataOpts = Partial<QueryOpts> & {
  *
  * U是参数 V是返回值
  */
-export declare class Query<U = any, V = any> {
+declare class Query<U = any, V = any> {
     adapter: typeof adapter;
     url: string;
     beforeRequest?: Fn;
@@ -52,20 +57,5 @@ export declare class Query<U = any, V = any> {
     before(fn: Fn): void;
     after(fn: (result: Result) => Promise<any>): void;
 }
-/**
- * 前端调用后端QueryRouter
- */
-export declare class QueryClient<U = any, V = any> extends Query<U, V> {
-    tokenName: string;
-    storage: Storage;
-    token: string;
-    qws: QueryWs;
-    constructor(opts?: QueryOpts & {
-        tokenName?: string;
-        storage?: Storage;
-    });
-    getToken(): string;
-    saveToken(token: string): void;
-    removeToken(): void;
-}
-export { adapter };
+
+export { Query, type QueryOpts, adapter };

package/dist/query.js

@@ -0,0 +1,101 @@
+const adapter = async (opts) => {
+    const controller = new AbortController();
+    const signal = controller.signal;
+    const timeout = opts.timeout || 60000 * 3; // 默认超时时间为 60s * 3
+    const timer = setTimeout(() => {
+        controller.abort();
+    }, timeout);
+    return fetch(opts.url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...opts.headers,
+        },
+        body: JSON.stringify(opts.body),
+        signal,
+    })
+        .then((response) => {
+        // 获取 Content-Type 头部信息
+        const contentType = response.headers.get('Content-Type');
+        // 判断返回的数据类型
+        if (contentType && contentType.includes('application/json')) {
+            return response.json(); // 解析为 JSON
+        }
+        else {
+            return response.text(); // 解析为文本
+        }
+    })
+        .catch((err) => {
+        if (err.name === 'AbortError') {
+            console.log('Request timed out and was aborted');
+        }
+        console.error(err);
+        return {
+            code: 500,
+        };
+    })
+        .finally(() => {
+        clearTimeout(timer);
+    });
+};
+
+/**
+ * const query = new Query();
+ * const res = await query.post({
+ *   path: 'demo',
+ *   key: '1',
+ *  });
+ *
+ * U是参数 V是返回值
+ */
+class Query {
+    adapter;
+    url;
+    beforeRequest;
+    afterResponse;
+    headers;
+    timeout;
+    constructor(opts) {
+        this.adapter = opts?.adapter || adapter;
+        this.url = opts?.url || '/api/router';
+        this.headers = opts?.headers || {
+            'Content-Type': 'application/json',
+        };
+        this.timeout = opts?.timeout || 60000 * 3; // 默认超时时间为 60s * 3
+    }
+    async get(params, options) {
+        return this.post(params, options);
+    }
+    async post(body, options) {
+        const url = options?.url || this.url;
+        const headers = { ...this.headers, ...options?.headers };
+        const adapter = options?.adapter || this.adapter;
+        const beforeRequest = options?.beforeRequest || this.beforeRequest;
+        const afterResponse = options?.afterResponse || this.afterResponse;
+        const timeout = options?.timeout || this.timeout;
+        const req = {
+            url: url,
+            headers: headers,
+            body,
+            timeout,
+        };
+        if (beforeRequest) {
+            await beforeRequest(req);
+        }
+        return adapter(req).then(async (res) => {
+            res.success = res.code === 200;
+            if (afterResponse) {
+                return await afterResponse(res);
+            }
+            return res;
+        });
+    }
+    before(fn) {
+        this.beforeRequest = fn;
+    }
+    after(fn) {
+        this.afterResponse = fn;
+    }
+}
+
+export { Query, adapter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kevisual/query",
-  "version": "0.0.6",
+  "version": "0.0.7-alpha.2",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,7 @@
   "type": "module",
   "scripts": {
     "build": "npm run clean && rollup -c",
-    "test": "NODE_ENV=development node --experimental-vm-modules node_modules/jest/bin/jest.js --detectOpenHandles",
+    "build:app": "npm run build && rsync dist/* ../deploy/dist",
     "clean": "rm -rf dist"
   },
   "files": [
@@ -27,8 +27,9 @@
     "rollup": "^4.21.2",
     "ts-node": "^10.9.2",
     "tslib": "^2.7.0",
+    "typescript": "^5.5.4",
     "zustand": "^4.5.5",
-    "typescript": "^5.5.4"
+    "rollup-plugin-dts": "^6.1.1"
   },
   "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447",
   "publishConfig": {
@@ -40,16 +41,17 @@
   },
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
+      "import": "./dist/query-browser.js",
+      "require": "./dist/query-browser.js"
     },
-    "./node": {
-      "import": "./dist/node-adapter.js",
-      "require": "./dist/node-adapter.js"
+    "./query": {
+      "import": "./dist/query.js",
+      "require": "./dist/query.js"
     },
     "./ws": {
-      "import": "./dist/ws.js",
-      "require": "./dist/ws.js"
+      "import": "./dist/query-ws.js",
+      "require": "./dist/query-ws.js"
     }
-  }
+  },
+  "dependencies": {}
 }

package/readme.md

@@ -4,6 +4,8 @@
 
 主要目的：请求路径默认`/api/router`，使用`post`,`post`的数据分流使用`path`和`key`.
 
+适配后端的项目 [@kevisual/router](https://git.xiongxiao.me/kevisual/router)
+
 ## query
 
 

package/dist/adapter.d.ts

@@ -1,8 +0,0 @@
-type AdapterOpts = {
-    url: string;
-    headers?: Record<string, string>;
-    body?: Record<string, any>;
-    timeout?: number;
-};
-export declare const adapter: (opts: AdapterOpts) => Promise<any>;
-export {};

package/dist/node-adapter.d.ts

@@ -1,8 +0,0 @@
-type AdapterOpts = {
-    url: string;
-    headers?: Record<string, string>;
-    body?: Record<string, any>;
-};
-export declare const nodeAdapter: (opts: AdapterOpts) => Promise<any>;
-export declare const adapter: (opts: AdapterOpts) => Promise<any>;
-export {};

package/dist/node-adapter.js

@@ -1,49 +0,0 @@
-import http from 'http';
-
-const nodeAdapter = async (opts) => {
-    return new Promise((resolve, reject) => {
-        const postData = JSON.stringify(opts.body || '');
-        const _url = new URL(opts.url);
-        const { hostname, port, pathname } = _url;
-        const options = {
-            hostname: hostname,
-            port: port,
-            path: pathname || '/api/router',
-            method: 'POST', // Assuming it's a POST request
-            headers: {
-                'Content-Type': 'application/json',
-                'Content-Length': Buffer.byteLength(postData),
-                ...opts.headers,
-            },
-        };
-        const req = http.request(options, (res) => {
-            let data = '';
-            // Collect data chunks
-            res.on('data', (chunk) => {
-                data += chunk;
-            });
-            // Resolve when the response is complete
-            res.on('end', () => {
-                try {
-                    const parsedData = JSON.parse(data);
-                    resolve(parsedData);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        });
-        // Handle request errors
-        req.on('error', (error) => {
-            reject(error);
-        });
-        // Write the request body and end the request
-        if (opts.body) {
-            req.write(postData);
-        }
-        req.end();
-    });
-};
-const adapter = nodeAdapter;
-
-export { adapter, nodeAdapter };

package/dist/utils.d.ts

@@ -1,2 +0,0 @@
-export declare const parseUrl: (url: string) => string;
-export declare const parseWsUrl: (url: string) => string;