@kevisual/api 0.0.47 → 0.0.49

package/dist/query-login.js

@@ -1,4 +1,4 @@
-// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query-browser.js
+// node_modules/.pnpm/@kevisual+query@0.0.40/node_modules/@kevisual/query/dist/query-browser.js
 var isTextForContentType = (contentType) => {
   if (!contentType)
     return false;
@@ -27,12 +27,12 @@ var adapter = async (opts = {}, overloadOpts) => {
     url = new URL(opts.url);
   } else {
     origin = window?.location?.origin || "http://localhost:51515";
-    url = new URL(opts.url, origin);
+    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 });
+    let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts?.params, ...opts?.body });
     url.search = searchParams.toString();
   } else {
     const params = {
@@ -57,11 +57,13 @@ var adapter = async (opts = {}, overloadOpts) => {
   } else if (isPostFile) {
     body = opts.body;
   } else {
-    headers = {
-      "Content-Type": "application/json",
-      ...headers
-    };
-    body = JSON.stringify(opts.body);
+    if (opts.body && typeof opts.body === "object" && !(opts.body instanceof FormData)) {
+      headers = {
+        "Content-Type": "application/json",
+        ...headers
+      };
+      body = JSON.stringify(opts.body);
+    }
   }
   return fetch(url, {
     method: method.toUpperCase(),
@@ -131,7 +133,7 @@ class Query {
       "Content-Type": "application/json"
     };
     this.timeout = opts?.timeout || 60000 * 3;
-    if (opts.beforeRequest) {
+    if (opts?.beforeRequest) {
       this.beforeRequest = opts.beforeRequest;
     } else {
       this.beforeRequest = async (opts2) => {
@@ -280,7 +282,7 @@ class BaseQuery {
   }
 }
 
-// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query.js
+// node_modules/.pnpm/@kevisual+query@0.0.40/node_modules/@kevisual/query/dist/query.js
 var setBaseResponse = (res) => {
   res.success = res.code === 200;
   res.showError = (fn) => {
@@ -350,6 +352,8 @@ class LoginCacheStore {
     this.cacheData.id = user.id;
     this.cacheData.accessToken = user.accessToken;
     this.cacheData.refreshToken = user.refreshToken;
+    this.cacheData.accessTokenExpiresIn = user.accessTokenExpiresIn;
+    this.cacheData.createdAt = user.createdAt;
     await this.setValue(this.cacheData);
   }
   getCurrentUser() {
@@ -854,7 +858,7 @@ class QueryLogin extends BaseQuery {
     this.isBrowser = opts?.isBrowser ?? true;
     this.init();
     this.onLoad = opts?.onLoad;
-    this.storage = opts?.storage || localStorage;
+    this.storage = opts?.storage || globalThis?.localStorage;
   }
   setQuery(query) {
     this.query = query;
@@ -877,32 +881,32 @@ class QueryLogin extends BaseQuery {
   async login(data) {
     const res = await this.post({ key: "login", ...data });
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
   async loginByCode(data) {
     const res = await this.post({ path: "sms", key: "login", data });
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
   async setLoginToken(token) {
-    const { accessToken, refreshToken } = token;
+    const { accessToken, refreshToken, accessTokenExpiresIn } = token;
     this.storage.setItem("token", accessToken || "");
-    await this.beforeSetLoginUser({ accessToken, refreshToken });
+    await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
   }
   async loginByWechat(data) {
     const res = await this.post({ path: "wx", key: "open-login", code: data.code });
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
@@ -919,7 +923,7 @@ class QueryLogin extends BaseQuery {
       }
     }
   }
-  async beforeSetLoginUser({ accessToken, refreshToken, check401 }) {
+  async beforeSetLoginUser({ accessToken, refreshToken, check401, accessTokenExpiresIn }) {
     if (accessToken && refreshToken) {
       const resUser = await this.getMe(accessToken, check401);
       if (resUser.code === 200) {
@@ -929,7 +933,9 @@ class QueryLogin extends BaseQuery {
             user,
             id: user.id,
             accessToken,
-            refreshToken
+            refreshToken,
+            accessTokenExpiresIn,
+            createdAt: Date.now()
           });
         } else {
           console.error("登录失败");
@@ -962,9 +968,9 @@ class QueryLogin extends BaseQuery {
       if (hasRefreshToken) {
         const res = await that.queryRefreshToken(hasRefreshToken);
         if (res.code === 200) {
-          const { accessToken, refreshToken } = res?.data || {};
+          const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
           that.storage.setItem("token", accessToken || "");
-          await that.beforeSetLoginUser({ accessToken, refreshToken, check401: false });
+          await that.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn, check401: false });
           if (refetch && ctx && ctx.req && ctx.req.url && ctx.fetch) {
             await new Promise((resolve) => setTimeout(resolve, 1500));
             const url = ctx.req?.url;
@@ -1057,12 +1063,17 @@ class QueryLogin extends BaseQuery {
     const user = localUserList.find((userItem) => userItem.user.username === username);
     if (user) {
       this.storage.setItem("token", user.accessToken || "");
-      await this.beforeSetLoginUser({ accessToken: user.accessToken, refreshToken: user.refreshToken });
+      await this.beforeSetLoginUser({
+        accessToken: user.accessToken,
+        refreshToken: user.refreshToken,
+        accessTokenExpiresIn: user.accessTokenExpiresIn
+      });
       return {
         code: 200,
         data: {
           accessToken: user.accessToken,
-          refreshToken: user.refreshToken
+          refreshToken: user.refreshToken,
+          accessTokenExpiresIn: user.accessTokenExpiresIn
         },
         success: true,
         message: "切换用户成功"
@@ -1070,9 +1081,9 @@ class QueryLogin extends BaseQuery {
     }
     const res = await this.postSwitchUser(username);
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
@@ -1110,9 +1121,9 @@ class QueryLogin extends BaseQuery {
       loginToken: token
     });
     if (res.code === 200) {
-      const accessToken = res.data?.accessToken;
+      const { accessTokenExpiresIn, accessToken, refreshToken } = res.data;
       this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken: res.data?.refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
       return res;
     }
     return false;

package/dist/query-mark.d.ts

@@ -0,0 +1,128 @@
+import { Query } from '@kevisual/query';
+import { Result, DataOpts } from '@kevisual/query/query';
+
+type SimpleObject = Record<string, any>;
+declare const markType: readonly ["simple", "md", "mdx", "wallnote", "excalidraw", "chat"];
+type MarkType = (typeof markType)[number];
+type MarkData = {
+    nodes?: any[];
+    edges?: any[];
+    elements?: any[];
+    permission?: any;
+    [key: string]: any;
+};
+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;
+};
+type ShowMarkPick = Pick<Mark, 'id' | 'title' | 'description' | 'summary' | 'link' | 'tags' | 'thumbnail' | 'updatedAt'>;
+type SearchOpts = {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    sort?: string;
+    markType?: MarkType;
+    [key: string]: any;
+};
+type QueryMarkOpts<T extends SimpleObject = SimpleObject> = {
+    query?: Query;
+    isBrowser?: boolean;
+    onLoad?: () => void;
+} & T;
+type ResultMarkList = {
+    list: Mark[];
+    pagination: {
+        pageSize: number;
+        current: number;
+        total: number;
+    };
+};
+type QueryMarkData = {
+    id?: string;
+    title?: string;
+    description?: string;
+    [key: string]: any;
+};
+type QueryMarkResult = {
+    accessToken: string;
+    refreshToken: string;
+};
+declare class QueryMarkBase<T extends SimpleObject = SimpleObject> {
+    query: Query;
+    isBrowser: boolean;
+    load?: boolean;
+    storage?: Storage;
+    onLoad?: () => void;
+    constructor(opts?: QueryMarkOpts<T>);
+    setQuery(query: Query): void;
+    private init;
+    post<T = Result<any>>(data: any, opts?: DataOpts): Promise<T>;
+    getMarkList(search: SearchOpts, opts?: DataOpts): Promise<{
+        code: number;
+        data?: ResultMarkList | undefined;
+        message?: string;
+    }>;
+    getMark(id: string, opts?: DataOpts): Promise<{
+        code: number;
+        data?: Mark | undefined;
+        message?: string;
+    }>;
+    getVersion(id: string, opts?: DataOpts): Promise<{
+        code: number;
+        data?: {
+            version: number;
+            id: string;
+        } | undefined;
+        message?: string;
+    }>;
+    /**
+     * 检查版本
+     * 当需要更新时，返回true
+     * @param id
+     * @param version
+     * @param opts
+     * @returns
+     */
+    checkVersion(id: string, version?: number, opts?: DataOpts): Promise<boolean>;
+    updateMark(data: any, opts?: DataOpts): Promise<{
+        code: number;
+        data?: Mark | undefined;
+        message?: string;
+    }>;
+    deleteMark(id: string, opts?: DataOpts): Promise<{
+        code: number;
+        data?: Mark | undefined;
+        message?: string;
+    }>;
+}
+declare class QueryMark extends QueryMarkBase<SimpleObject> {
+    markType: string;
+    constructor(opts?: QueryMarkOpts & {
+        markType?: MarkType;
+    });
+    getMarkList(search?: SearchOpts, opts?: DataOpts): Promise<{
+        code: number;
+        data?: ResultMarkList | undefined;
+        message?: string;
+    }>;
+    updateMark(data: any, opts?: DataOpts): Promise<{
+        code: number;
+        data?: Mark | undefined;
+        message?: string;
+    }>;
+}
+
+export { QueryMark, QueryMarkBase, markType };
+export type { Mark, MarkData, MarkType, QueryMarkData, QueryMarkOpts, QueryMarkResult, ResultMarkList, SearchOpts, ShowMarkPick, SimpleObject };

package/dist/query-mark.js

@@ -0,0 +1,342 @@
+// node_modules/.pnpm/@kevisual+query@0.0.40/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?.params, ...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 {
+    if (opts.body && typeof opts.body === "object" && !(opts.body instanceof FormData)) {
+      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-mark/index.ts
+var markType = ["simple", "md", "mdx", "wallnote", "excalidraw", "chat"];
+
+class QueryMarkBase {
+  query;
+  isBrowser;
+  load;
+  storage;
+  onLoad;
+  constructor(opts) {
+    this.query = opts?.query || new Query;
+    this.isBrowser = opts?.isBrowser ?? true;
+    this.init();
+    this.onLoad = opts?.onLoad;
+  }
+  setQuery(query) {
+    this.query = query;
+  }
+  async init() {
+    this.load = true;
+    this.onLoad?.();
+  }
+  async post(data, opts) {
+    try {
+      return this.query.post({ path: "mark", ...data }, opts);
+    } catch (error) {
+      console.log("error", error);
+      return {
+        code: 400
+      };
+    }
+  }
+  async getMarkList(search, opts) {
+    return this.post({ key: "list", ...search }, opts);
+  }
+  async getMark(id, opts) {
+    return this.post({ key: "get", id }, opts);
+  }
+  async getVersion(id, opts) {
+    return this.post({ key: "getVersion", id }, opts);
+  }
+  async checkVersion(id, version, opts) {
+    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, opts) {
+    return this.post({ key: "update", data }, opts);
+  }
+  async deleteMark(id, opts) {
+    return this.post({ key: "delete", id }, opts);
+  }
+}
+
+class QueryMark extends QueryMarkBase {
+  markType;
+  constructor(opts) {
+    super(opts);
+    this.markType = opts?.markType || "simple";
+  }
+  async getMarkList(search, opts) {
+    return this.post({ key: "list", ...search, markType: this.markType }, opts);
+  }
+  async updateMark(data, opts) {
+    if (!data.id) {
+      data.markType = this.markType || "simple";
+    }
+    return super.updateMark(data, opts);
+  }
+}
+export {
+  markType,
+  QueryMarkBase,
+  QueryMark
+};

package/dist/query-proxy.d.ts

@@ -145,7 +145,7 @@ declare class QueryProxy {
         token?: string;
         routerViewData?: RouterViewData;
     });
-    getDefulatToken(): string;
+    getDefulatToken(): string | undefined;
     initRouterViewQuery(): void;
     initRouterView(item: RouterViewItem): RouterViewItem<{}>;
     /**
@@ -175,8 +175,8 @@ declare class QueryProxy {
     listRoutes(filterFn?: (item: Route) => boolean, opts?: {
         viewId?: string;
         query?: string;
-    }): Promise<any>;
-    getViewQuery(viewId: string): Promise<string>;
+    }): Promise<any[]>;
+    getViewQuery(viewId: string): Promise<string | undefined>;
     /**
      * 运行路由
      * @param msg
@@ -207,7 +207,7 @@ declare const initApi: (opts: {
      */
     exclude?: string;
 }) => Promise<{
-    code: any;
+    code: number;
     message: string;
 }>;