@kevisual/api 0.0.41 → 0.0.43

package/dist/query-config.js

@@ -0,0 +1,336 @@
+// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query-browser.js
+var isTextForContentType = (contentType) => {
+  if (!contentType)
+    return false;
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  return textTypes.some((type) => contentType.includes(type));
+};
+var adapter = async (opts = {}, overloadOpts) => {
+  const controller = new AbortController;
+  const signal = controller.signal;
+  const isPostFile = opts.isPostFile || false;
+  let responseType = opts.responseType || "json";
+  if (opts.isBlob) {
+    responseType = "blob";
+  } else if (opts.isText) {
+    responseType = "text";
+  }
+  const timeout = opts.timeout || 60000 * 3;
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  let method = overloadOpts?.method || opts?.method || "POST";
+  let headers = { ...opts?.headers, ...overloadOpts?.headers };
+  let origin = "";
+  let url;
+  if (opts?.url?.startsWith("http")) {
+    url = new URL(opts.url);
+  } else {
+    origin = window?.location?.origin || "http://localhost:51515";
+    url = new URL(opts.url, origin);
+  }
+  const isGet = method === "GET";
+  const oldSearchParams = url.searchParams;
+  if (isGet) {
+    let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts.body });
+    url.search = searchParams.toString();
+  } else {
+    const params = {
+      ...Object.fromEntries(oldSearchParams),
+      ...opts.params
+    };
+    const searchParams = new URLSearchParams(params);
+    if (typeof opts.body === "object" && opts.body !== null) {
+      let body2 = opts.body || {};
+      if (!params.path && body2?.path) {
+        searchParams.set("path", body2.path);
+        if (body2?.key) {
+          searchParams.set("key", body2.key);
+        }
+      }
+    }
+    url.search = searchParams.toString();
+  }
+  let body = undefined;
+  if (isGet) {
+    body = undefined;
+  } else if (isPostFile) {
+    body = opts.body;
+  } else {
+    headers = {
+      "Content-Type": "application/json",
+      ...headers
+    };
+    body = JSON.stringify(opts.body);
+  }
+  return fetch(url, {
+    method: method.toUpperCase(),
+    signal,
+    body,
+    ...overloadOpts,
+    headers
+  }).then(async (response) => {
+    const contentType = response.headers.get("Content-Type");
+    if (responseType === "blob") {
+      return await response.blob();
+    }
+    const isText = responseType === "text";
+    const isJson = contentType && contentType.includes("application/json");
+    if (isJson && !isText) {
+      return await response.json();
+    } else if (isTextForContentType(contentType)) {
+      return {
+        code: response.status,
+        status: response.status,
+        data: await response.text()
+      };
+    } else {
+      return response;
+    }
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+};
+var wrapperError = ({ code, message }) => {
+  const result = {
+    code: code || 500,
+    success: false,
+    message: message || "api request error",
+    showError: (fn) => {},
+    noMsg: true
+  };
+  return result;
+};
+
+class Query {
+  adapter;
+  url;
+  beforeRequest;
+  afterResponse;
+  headers;
+  timeout;
+  stop;
+  qws;
+  isClient = false;
+  constructor(opts) {
+    this.adapter = opts?.adapter || adapter;
+    const defaultURL = opts?.isClient ? "/client/router" : "/api/router";
+    this.url = opts?.url || defaultURL;
+    this.headers = opts?.headers || {
+      "Content-Type": "application/json"
+    };
+    this.timeout = opts?.timeout || 60000 * 3;
+    if (opts.beforeRequest) {
+      this.beforeRequest = opts.beforeRequest;
+    } else {
+      this.beforeRequest = async (opts2) => {
+        const token = globalThis?.localStorage?.getItem("token");
+        if (token) {
+          opts2.headers = {
+            ...opts2.headers,
+            Authorization: `Bearer ${token}`
+          };
+        }
+        return opts2;
+      };
+    }
+  }
+  setQueryWs(qws) {
+    this.qws = qws;
+  }
+  setStop(stop) {
+    this.stop = stop;
+  }
+  async get(params, options) {
+    return this.post(params, options);
+  }
+  async post(body, options) {
+    const url = options?.url || this.url;
+    const { headers, adapter: adapter2, beforeRequest, afterResponse, timeout, ...rest } = options || {};
+    const _headers = { ...this.headers, ...headers };
+    const _adapter = adapter2 || this.adapter;
+    const _beforeRequest = beforeRequest || this.beforeRequest;
+    const _afterResponse = afterResponse || this.afterResponse;
+    const _timeout = timeout || this.timeout;
+    const req = {
+      url,
+      headers: _headers,
+      body,
+      timeout: _timeout,
+      ...rest
+    };
+    try {
+      if (_beforeRequest) {
+        const res = await _beforeRequest(req);
+        if (res === false) {
+          return wrapperError({
+            code: 500,
+            message: "request is cancel",
+            req
+          });
+        }
+      }
+    } catch (e) {
+      console.error("request beforeFn error", e, req);
+      return wrapperError({
+        code: 500,
+        message: "api request beforeFn error"
+      });
+    }
+    if (this.stop && !options?.noStop) {
+      const that = this;
+      await new Promise((resolve) => {
+        let timer = 0;
+        const detect = setInterval(() => {
+          if (!that.stop) {
+            clearInterval(detect);
+            resolve(true);
+          }
+          timer++;
+          if (timer > 30) {
+            console.error("request stop: timeout", req.url, timer);
+          }
+        }, 1000);
+      });
+    }
+    return _adapter(req).then(async (res) => {
+      try {
+        if (_afterResponse) {
+          return await _afterResponse(res, {
+            req,
+            res,
+            fetch: adapter2
+          });
+        }
+        return res;
+      } catch (e) {
+        console.error("request afterFn error", e, req);
+        return wrapperError({
+          code: 500,
+          message: "api request afterFn error"
+        });
+      }
+    });
+  }
+  before(fn) {
+    this.beforeRequest = fn;
+  }
+  after(fn) {
+    this.afterResponse = fn;
+  }
+  async fetchText(urlOrOptions, options) {
+    let _options = { ...options };
+    if (typeof urlOrOptions === "string" && !_options.url) {
+      _options.url = urlOrOptions;
+    }
+    if (typeof urlOrOptions === "object") {
+      _options = { ...urlOrOptions, ..._options };
+    }
+    const res = await adapter({
+      method: "GET",
+      ..._options,
+      headers: {
+        ...this.headers,
+        ..._options?.headers || {}
+      }
+    });
+    if (res && !res.code) {
+      return {
+        code: 200,
+        data: res
+      };
+    }
+    return res;
+  }
+}
+
+// query/query-config/query-config.ts
+var defaultConfigKeys = ["upload.json", "workspace.json", "ai.json", "user.json", "life.json"];
+
+class QueryConfig {
+  query;
+  constructor(opts) {
+    this.query = opts?.query || new Query;
+  }
+  async post(data) {
+    return this.query.post({ path: "config", ...data });
+  }
+  async getConfig({ id, key }, opts) {
+    return this.post({
+      key: "get",
+      data: {
+        id,
+        key
+      },
+      ...opts
+    });
+  }
+  async updateConfig(data, opts) {
+    return this.post({
+      key: "update",
+      data,
+      ...opts
+    });
+  }
+  async deleteConfig(data, opts) {
+    console.log("Delete Config Params:", data);
+    return this.post({
+      key: "delete",
+      data
+    });
+  }
+  async listConfig(opts) {
+    return this.post({
+      key: "list",
+      ...opts
+    });
+  }
+  async getUploadConfig(opts) {
+    return this.post({
+      key: "getUploadConfig",
+      ...opts
+    });
+  }
+  async updateUploadConfig(data, opts) {
+    return this.post({
+      key: "updateUploadConfig",
+      data,
+      ...opts
+    });
+  }
+  async detectConfig(opts) {
+    return this.post({
+      key: "detect",
+      ...opts
+    });
+  }
+  async getConfigByKey(key, opts) {
+    return this.post({
+      key: "defaultConfig",
+      configKey: key,
+      ...opts
+    });
+  }
+  async getByKey(key, opts) {
+    return this.post({
+      key: "get",
+      ...opts,
+      data: { key }
+    });
+  }
+}
+export {
+  defaultConfigKeys,
+  QueryConfig
+};

package/dist/query-login.d.ts

@@ -0,0 +1,299 @@
+import { BaseQuery, Query } from '@kevisual/query';
+import { DataOpts, Result } from '@kevisual/query/query';
+
+interface Cache {
+    /**
+     * @update 获取缓存
+     */
+    get(key: string): Promise<any>;
+    /**
+     * @update 设置缓存
+     */
+    set(key: string, value: any): Promise<any>;
+    /**
+     * @update 删除缓存
+     */
+    del(): Promise<void>;
+    /**
+     * 初始化
+     */
+    init?: () => Promise<any>;
+}
+type User = {
+    avatar?: string;
+    description?: string;
+    id?: string;
+    needChangePassword?: boolean;
+    orgs?: string[];
+    type?: string;
+    username?: string;
+};
+type CacheLoginUser = {
+    user?: User;
+    id?: string;
+    accessToken?: string;
+    refreshToken?: string;
+};
+type CacheLogin = {
+    loginUsers: CacheLoginUser[];
+} & CacheLoginUser;
+type CacheStore<T = Cache> = {
+    name: string;
+    /**
+     * 缓存数据
+     * @important 需要先调用init
+     */
+    cacheData: CacheLogin;
+    /**
+     * 实际操作的cache, 需要先调用init
+     */
+    cache: T;
+    /**
+     * 设置当前用户
+     */
+    setLoginUser(user: CacheLoginUser): Promise<void>;
+    /**
+     * 获取当前用户
+     */
+    getCurrentUser(): Promise<User>;
+    /**
+     * 获取当前用户列表
+     */
+    getCurrentUserList(): Promise<CacheLoginUser[]>;
+    /**
+     * 获取缓存的refreshToken
+     */
+    getRefreshToken(): Promise<string>;
+    /**
+     * 获取缓存的accessToken
+     */
+    getAccessToken(): Promise<string>;
+    /**
+     * 清除当前用户
+     */
+    clearCurrentUser(): Promise<void>;
+    /**
+     * 清除所有用户
+     */
+    clearAll(): Promise<void>;
+    getValue(): Promise<CacheLogin>;
+    setValue(value: CacheLogin): Promise<CacheLogin>;
+    delValue(): Promise<void>;
+    init(): Promise<any>;
+};
+
+type QueryLoginOpts = {
+    query?: Query;
+    isBrowser?: boolean;
+    onLoad?: () => void;
+    storage?: Storage;
+    cache: Cache;
+};
+type QueryLoginData = {
+    username?: string;
+    password: string;
+    email?: string;
+};
+type QueryLoginResult = {
+    accessToken: string;
+    refreshToken: string;
+};
+declare class QueryLogin extends BaseQuery {
+    /**
+     * query login cache， 非实际操作， 一个cache的包裹模块
+     */
+    cacheStore: CacheStore;
+    isBrowser: boolean;
+    load?: boolean;
+    storage: Storage;
+    onLoad?: () => void;
+    constructor(opts?: QueryLoginOpts);
+    setQuery(query: Query): void;
+    private init;
+    post<T = any>(data: any, opts?: DataOpts): Promise<any>;
+    /**
+     * 登录,
+     * @param data
+     * @returns
+     */
+    login(data: QueryLoginData): Promise<any>;
+    /**
+     * 手机号登录
+     * @param data
+     * @returns
+     */
+    loginByCode(data: {
+        phone: string;
+        code: string;
+    }): Promise<any>;
+    /**
+     * 设置token
+     * @param token
+     */
+    setLoginToken(token: {
+        accessToken: string;
+        refreshToken: string;
+    }): Promise<void>;
+    loginByWechat(data: {
+        code: string;
+    }): Promise<any>;
+    /**
+     * 检测微信登录，登陆成功后，调用onSuccess，否则调用onError
+     * @param param0
+     */
+    checkWechat({ onSuccess, onError }: {
+        onSuccess?: (res: QueryLoginResult) => void;
+        onError?: (res: any) => void;
+    }): Promise<void>;
+    /**
+     * 登陆成功，需要获取用户信息进行缓存
+     * @param param0
+     */
+    beforeSetLoginUser({ accessToken, refreshToken, check401 }: {
+        accessToken?: string;
+        refreshToken?: string;
+        check401?: boolean;
+    }): Promise<void>;
+    /**
+     * 刷新token
+     * @param refreshToken
+     * @returns
+     */
+    queryRefreshToken(refreshToken?: string): Promise<any>;
+    /**
+     * 检查401错误，并刷新token, 如果refreshToken存在，则刷新token, 否则返回401
+     * 拦截请求，请使用run401Action， 不要直接使用 afterCheck401ToRefreshToken
+     * @param response
+     * @param ctx
+     * @param refetch
+     * @returns
+     */
+    afterCheck401ToRefreshToken(response: Result, ctx?: {
+        req?: any;
+        res?: any;
+        fetch?: any;
+    }, refetch?: boolean): Promise<any>;
+    /**
+     * 一个简单的401处理， 如果401，则刷新token, 如果refreshToken不存在，则返回401
+     * refetch 是否重新请求, 会有bug，无限循环，按需要使用
+     * TODO:
+     * @param response
+     * @param ctx
+     * @param opts
+     * @returns
+     */
+    run401Action(response: Result, ctx?: {
+        req?: any;
+        res?: any;
+        fetch?: any;
+    }, opts?: {
+        /**
+         * 是否重新请求, 会有bug，无限循环，按需要使用
+         */
+        refetch?: boolean;
+        /**
+         * check之后的回调
+         */
+        afterCheck?: (res: Result) => any;
+        /**
+         * 401处理后， 还是401， 则回调
+         */
+        afterAlso401?: (res: Result) => any;
+    }): Promise<any>;
+    /**
+     * 获取用户信息
+     * @param token
+     * @returns
+     */
+    getMe(token?: string, check401?: boolean): Promise<any>;
+    /**
+     * 检查本地用户，如果本地用户存在，则返回本地用户，否则返回null
+     * @returns
+     */
+    checkLocalUser(): Promise<{
+        avatar?: string;
+        description?: string;
+        id?: string;
+        needChangePassword?: boolean;
+        orgs?: string[];
+        type?: string;
+        username?: string;
+    }>;
+    /**
+     * 检查本地token是否存在，简单的判断是否已经属于登陆状态
+     * @returns
+     */
+    checkLocalToken(): Promise<boolean>;
+    /**
+     * 检查本地用户列表
+     * @returns
+     */
+    getToken(): Promise<string>;
+    beforeRequest(opts?: any): Promise<any>;
+    /**
+     * 请求更新，切换用户， 使用switchUser
+     * @param username
+     * @returns
+     */
+    private postSwitchUser;
+    /**
+     * 切换用户
+     * @param username
+     * @returns
+     */
+    switchUser(username: string): Promise<any>;
+    /**
+     * 退出登陆，去掉token， 并删除缓存
+     * @returns
+     */
+    logout(): Promise<any>;
+    /**
+     * 检查用户名的组，这个用户是否存在
+     * @param username
+     * @returns
+     */
+    hasUser(username: string): Promise<any>;
+    /**
+     * 检查登录状态
+     * @param token
+     * @returns
+     */
+    checkLoginStatus(token: string): Promise<any>;
+    /**
+     * 使用web登录,创建url地址, 需要MD5和jsonwebtoken
+     *
+     *
+  
+  import MD5 from 'crypto-js/md5.js';
+  import jsonwebtoken from 'jsonwebtoken';
+  
+     */
+    loginWithWeb(baseURL: string, { MD5, jsonwebtoken }: {
+        MD5?: any;
+        jsonwebtoken?: any;
+    }): {
+        url: string;
+        token: string;
+        tokenSecret: string;
+    };
+    /**
+     *轮询登录状态
+     *
+     *
+     *
+  const res = queryLogin.loginWithWeb(baseURL, { MD5, jsonwebtoken });
+  await pollLoginStatus(res.token, { tokenSecret: res.tokenSecret });
+     * 轮询登录状态
+     */
+    pollLoginStatus(data: {
+        token: string;
+        tokenSecret: string;
+    }): Promise<boolean>;
+}
+
+type QueryLoginNodeOptsWithoutCache = Omit<QueryLoginOpts, 'cache'>;
+declare class QueryLoginBrowser extends QueryLogin {
+    constructor(opts: QueryLoginNodeOptsWithoutCache);
+}
+
+export { QueryLoginBrowser };