@kevisual/api 0.0.48 → 0.0.50

package/query/query-proxy/proxy.ts

@@ -62,7 +62,7 @@ export type RouterViewWorker = {
 } & RouteViewBase;
 
 /**
- * 去掉不需要保存都服务器的数据
+ * 去掉不需要保存的服务器的数据
  * @param item 
  * @returns 
  */
@@ -86,7 +86,7 @@ export const pickRouterViewData = (item: RouterViewItem) => {
   return rest
 }
 /**
- * 注入 js 的url地址，使用importScripts加载
+ * 注入 js 的url地址，使用 importScripts 加载
  */
 export type RouteViewPage = {
   type: 'page',
@@ -100,6 +100,9 @@ export type RouterViewQuery = {
   query: string,
   title: string
 }
+/**
+ * 后端存储结构
+ */
 export type RouterViewData = {
   data: { items: RouterViewItem[]; }
   views: RouterViewQuery[];
@@ -121,7 +124,7 @@ export class QueryProxy {
     this.initRouterViewQuery();
     this.emitter = new EventEmitter();
   }
-  getDefulatToken() {
+  private getDefulatToken() {
     try {
       if (typeof window !== 'undefined' && typeof window.localStorage !== 'undefined') {
         return localStorage.getItem('token') || undefined;
@@ -139,7 +142,7 @@ export class QueryProxy {
     });
   }
 
-  initRouterView(item: RouterViewItem) {
+  private initRouterView(item: RouterViewItem) {
     if (item.type === 'api' && item.api?.url) {
       const url = item.api.url;
       if (item?.api?.query) return item;
@@ -253,6 +256,7 @@ export class QueryProxy {
       console.debug(`注册路由: [${r.path}] ${r?.key}`, 'Context');
       let metadata = r.metadata || {};
       metadata.viewItem = item;
+      metadata.source = 'query-proxy-context';
       this.router.route({
         path: r.path,
         key: r.key || '',
@@ -268,7 +272,7 @@ export class QueryProxy {
   generateId() {
     return 'route_' + Math.random().toString(36).substring(2, 9);
   }
-  async callWorker(msg: any, viewItem: RouterViewWorker['worker']): Promise<Result> {
+  private async callWorker(msg: any, viewItem: RouterViewWorker['worker']): Promise<Result> {
     const that = this;
     const requestId = this.generateId();
     const worker = viewItem?.worker;
@@ -296,7 +300,7 @@ export class QueryProxy {
       });
     });
   }
-  async initWorker(item?: RouterViewWorker, initRoutes: boolean = true) {
+  private async initWorker(item?: RouterViewWorker, initRoutes: boolean = true) {
     const that = this;
     if (!item?.worker?.url) {
       console.warn('Worker URL not provided');
@@ -347,6 +351,7 @@ export class QueryProxy {
         console.debug(`注册路由: [${r.path}] ${r?.key}`, 'API');
         let metadata = r.metadata || {};
         metadata.viewItem = item;
+        metadata.source = 'query-proxy-worker';
         this.router.route({
           path: r.path,
           key: r.key || '',
@@ -364,7 +369,7 @@ export class QueryProxy {
       }
     }
   }
-  async initPage(item?: RouteViewPage) {
+  private async initPage(item?: RouteViewPage) {
     if (!item?.page?.url) {
       console.warn('Page地址未提供');
       return;
@@ -381,7 +386,7 @@ export class QueryProxy {
       return;
     }
   }
-  getQueryByViewId(viewId: string): string | undefined {
+  private getQueryByViewId(viewId: string): string | undefined {
     const view = this.views.find(v => v.id === viewId);
     if (view) {
       return view.query;
@@ -465,7 +470,7 @@ export class QueryProxy {
       item.response = res;
       return item;
     }
-    item.response = { code: 500, message: '无法处理的路由类型' };
+    item.response = { code: 500, message: '无法处理的路由类型', data: item };
     return item;
   }
 }
@@ -477,4 +482,15 @@ export type RouterItem = {
   description?: string;
   middleware?: string[];
   metadata?: Record<string, any>;
+}
+
+export const createViewData = (routerViewData: RouterViewItem | RouterViewItem[], data?: RouterViewData): RouterViewData => {
+  return {
+    views: [],
+    viewId: undefined,
+    data: {
+      items: Array.isArray(routerViewData) ? routerViewData : [routerViewData],
+    },
+    ...data
+  }
 }

package/query/query-proxy/router-api-proxy.ts

@@ -38,6 +38,7 @@ export const initApi = async (opts: {
       let metadata = r.metadata || {};
       metadata.viewItem = item;
       metadata.url = query.url;
+      metadata.source = 'query-proxy-api';
       router.route({
         path: r.path,
         key: r.key || '',

package/store/store-auth/index.ts

@@ -0,0 +1,66 @@
+'use strict';
+import { create } from 'zustand';
+import { toast } from 'sonner';
+import { useContextKey } from '@kevisual/context';
+import { type QueryLoginBrowser } from '@/query/query-login/index.ts'
+const queryLogin = useContextKey<QueryLoginBrowser>('queryLogin');
+
+type Me = {
+  id?: string;
+  username?: string;
+  nickname?: string | null;
+  needChangePassword?: boolean;
+  role?: string;
+  description?: string | null;
+  type?: 'user' | 'org';
+  orgs?: string[];
+  avatar?: string;
+};
+export type LayoutStore = {
+  open: boolean;
+  setOpen: (open: boolean) => void;
+  me: Me;
+  setMe: (me: Me) => void;
+  getMe: () => Promise<void>;
+  openUser: boolean;
+  setOpenUser: (openUser: boolean) => void;
+  switchOrg: (username?: string, type?: 'user' | 'org') => Promise<void>;
+  isAdmin: boolean;
+  setIsAdmin: (isAdmin: boolean) => void;
+  checkHasOrg: () => boolean;
+};
+export const useLayoutStore = create<LayoutStore>((set, get) => ({
+  open: false,
+  setOpen: (open) => set({ open }),
+  me: {},
+  setMe: (me) => set({ me }),
+  getMe: async () => {
+    const res = await queryLogin.getMe();
+    if (res.code === 200) {
+      set({ me: res.data });
+      set({ isAdmin: res.data.orgs?.includes('admin') });
+    }
+  },
+  openUser: false,
+  setOpenUser: (openUser) => set({ openUser }),
+  switchOrg: async (username?: string, type?: string) => {
+    const res = await queryLogin.switchUser(username || '');
+    if (res.code === 200) {
+      toast.success('Switch success');
+      setTimeout(() => {
+        window.location.reload();
+      }, 1000);
+    } else {
+      toast.error(res.message || 'Request failed');
+    }
+  },
+  isAdmin: false,
+  setIsAdmin: (isAdmin) => set({ isAdmin }),
+  checkHasOrg: () => {
+    const user = get().me || {};
+    if (!user.orgs) {
+      return false;
+    }
+    return user?.orgs?.length > 0;
+  },
+}));

package/store/store-mark/index.ts

@@ -0,0 +1,132 @@
+import { create } from 'zustand';
+import { type Result } from '@kevisual/query/query';
+import { MarkType, Mark, QueryMark } from '@kevisual/api/query-mark';
+import { uniqBy } from 'es-toolkit';
+import { useContextKey } from '@kevisual/context';
+import { type QueryLoginBrowser } from '@/query/query-login/index.ts'
+const queryClient = useContextKey<QueryLoginBrowser>('queryLogin');
+
+type ManagerStore = {
+  /** 当前选中的Mark */
+  currentMarkId: string;
+  setCurrentMarkId: (markId: string) => void;
+  markData?: Mark | undefined;
+  setMarkData: (mark?: Partial<Mark>) => void;
+  /** 获取Mark列表 */
+  getList: () => Promise<any>;
+  getMarkFromList: (markId: string) => Mark | undefined;
+  updateMark: (mark: Mark) => Promise<any>;
+  getMark: (markId: string) => Promise<Result<Mark>>;
+  deleteMark: (markId: string) => Promise<any>;
+  /** Mark列表 */
+  list: Mark[];
+  setList: (list: Mark[]) => void;
+  pagination: {
+    current: number;
+    pageSize: number;
+    total: number;
+  };
+  setPagination: (pagination: { current: number; pageSize: number; total: number }) => void;
+  /** 搜索 */
+  search: string;
+  setSearch: (search: string) => void;
+  /** 初始化 */
+  init: (markType: MarkType) => Promise<void>;
+  queryMark?: QueryMark;
+  markType?: MarkType;
+  open: boolean;
+  setOpen: (open: boolean) => void;
+};
+export const useMarkStore = create<ManagerStore>((set, get) => {
+  return {
+    currentMarkId: '',
+    setCurrentMarkId: (markId: string) => set(() => ({ currentMarkId: markId })),
+    open: false,
+    setOpen: (open: boolean) => set(() => ({ open })),
+    getList: async () => {
+      const queryMark = get().queryMark!;
+      const { search, pagination } = get();
+      const res = await queryMark.getMarkList({ page: pagination.current, pageSize: pagination.pageSize, search });
+      const oldList = get().list;
+      if (res.code === 200) {
+        const { pagination, list } = res.data || {};
+        const newList = [...oldList, ...list!];
+        const uniqueList = uniqBy(newList, (item) => item.id);
+        set(() => ({ list: uniqueList }));
+        set(() => ({ pagination: { current: pagination!.current, pageSize: pagination!.pageSize, total: pagination!.total } }));
+      }
+    },
+    getMarkFromList: (markId: string) => {
+      return get().list.find((item) => item.id === markId);
+    },
+    updateMark: async (mark: Mark) => {
+      const queryMark = get().queryMark!;
+      const res = await queryMark.updateMark(mark);
+      if (res.code === 200) {
+        set((state) => {
+          const oldList = state.list;
+          const resMark = res.data!;
+          const newList = oldList.map((item) => (item.id === mark.id ? mark : item));
+          if (!mark.id) {
+            newList.unshift(resMark);
+          }
+          return {
+            list: newList,
+          };
+        });
+      }
+      return res;
+    },
+    getMark: async (markId: string) => {
+      const queryMark = get().queryMark!;
+      const res = await queryMark.getMark(markId);
+      return res;
+    },
+    list: [],
+    setList: (list: any[]) => set(() => ({ list })),
+    init: async (markType: MarkType = 'wallnote') => {
+      // await get().getList();
+      console.log('init', set, get);
+      const queryMark = new QueryMark({
+        query: queryClient as any,
+        markType,
+      });
+      const url = new URL(window.location.href);
+      const pageSize = url.searchParams.get('pageSize') || '10';
+      set({ queryMark, markType, list: [], pagination: { current: 1, pageSize: parseInt(pageSize), total: 0 }, currentMarkId: '', markData: undefined });
+      setTimeout(async () => {
+        console.log('get', get);
+        get().getList();
+      }, 1000);
+    },
+    deleteMark: async (markId: string) => {
+      const queryMark = get().queryMark!;
+      const res = await queryMark.deleteMark(markId);
+      const currentMarkId = get().currentMarkId;
+      if (res.code === 200) {
+        // get().getList();
+        set((state) => ({
+          list: state.list.filter((item) => item.id !== markId),
+        }));
+        if (currentMarkId === markId) {
+          set(() => ({ currentMarkId: '', markData: undefined }));
+        }
+      }
+      return res;
+    },
+    queryMark: undefined,
+    markType: 'simple',
+    markData: undefined,
+    setMarkData: (mark?: Partial<Mark>) => set(() => ({ markData: mark as Mark })),
+    pagination: {
+      current: 1,
+      pageSize: 10,
+      total: 0,
+    },
+    setPagination: (pagination: { current: number; pageSize: number; total: number }) => set(() => ({ pagination })),
+    /** 搜索 */
+    search: '',
+    setSearch: (search: string) => set(() => ({ search, list: [], pagination: { current: 1, pageSize: 10, total: 0 } })),
+  };
+});
+