@btst/stack 1.11.0 → 2.0.0

package/dist/packages/stack/src/plugins/kanban/client/hooks/kanban-hooks.mjs

@@ -0,0 +1,381 @@
+"use client";
+import { useQuery, useSuspenseQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { createApiClient } from '@btst/stack/plugins/client';
+import { usePluginOverrides } from '@btst/stack/context';
+import { createKanbanQueryKeys } from '../../../../../../../plugins/kanban/query-keys.mjs';
+
+function isErrorResponse(response) {
+  return typeof response === "object" && response !== null && "error" in response && response.error !== null && response.error !== void 0;
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const errorObj = error;
+    const message = (typeof errorObj.message === "string" ? errorObj.message : null) || (typeof errorObj.error === "string" ? errorObj.error : null) || JSON.stringify(error);
+    const err = new Error(message);
+    Object.assign(err, error);
+    return err;
+  }
+  return new Error(String(error));
+}
+function useKanbanClient() {
+  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("kanban");
+  const client = createApiClient({
+    baseURL: apiBaseURL,
+    basePath: apiBasePath
+  });
+  return { client, headers };
+}
+function useBoards(params) {
+  const { client, headers } = useKanbanClient();
+  const queries = createKanbanQueryKeys(client, headers);
+  return useQuery({
+    ...queries.boards.list(params),
+    staleTime: 3e4
+  });
+}
+function useSuspenseBoards(params) {
+  const { client, headers } = useKanbanClient();
+  const queries = createKanbanQueryKeys(client, headers);
+  const result = useSuspenseQuery({
+    ...queries.boards.list(params),
+    staleTime: 3e4
+  });
+  if (result.error && !result.isFetching) {
+    throw result.error;
+  }
+  return result;
+}
+function useBoard(boardId) {
+  const { client, headers } = useKanbanClient();
+  const queries = createKanbanQueryKeys(client, headers);
+  return useQuery({
+    ...queries.boards.detail(boardId),
+    staleTime: 3e4,
+    enabled: !!boardId
+  });
+}
+function useSuspenseBoard(boardId) {
+  const { client, headers } = useKanbanClient();
+  const queries = createKanbanQueryKeys(client, headers);
+  const result = useSuspenseQuery({
+    ...queries.boards.detail(boardId),
+    staleTime: 3e4
+  });
+  if (result.error && !result.isFetching) {
+    throw result.error;
+  }
+  return result;
+}
+function useBoardMutations() {
+  const { client, headers } = useKanbanClient();
+  const queryClient = useQueryClient();
+  const createMutation = useMutation({
+    mutationFn: async (data) => {
+      const response = await client("@post/boards", {
+        method: "POST",
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const updateMutation = useMutation({
+    mutationFn: async ({
+      id,
+      data
+    }) => {
+      const response = await client("@put/boards/:id", {
+        method: "PUT",
+        params: { id },
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const deleteMutation = useMutation({
+    mutationFn: async (id) => {
+      const response = await client("@delete/boards/:id", {
+        method: "DELETE",
+        params: { id },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  return {
+    createBoard: createMutation.mutateAsync,
+    updateBoard: (id, data) => updateMutation.mutateAsync({ id, data }),
+    deleteBoard: deleteMutation.mutateAsync,
+    isCreating: createMutation.isPending,
+    isUpdating: updateMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    createError: createMutation.error,
+    updateError: updateMutation.error,
+    deleteError: deleteMutation.error
+  };
+}
+function useColumnMutations() {
+  const { client, headers } = useKanbanClient();
+  const queryClient = useQueryClient();
+  const createMutation = useMutation({
+    mutationFn: async (data) => {
+      const response = await client("@post/columns", {
+        method: "POST",
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const updateMutation = useMutation({
+    mutationFn: async ({
+      id,
+      data
+    }) => {
+      const response = await client("@put/columns/:id", {
+        method: "PUT",
+        params: { id },
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const deleteMutation = useMutation({
+    mutationFn: async (id) => {
+      const response = await client("@delete/columns/:id", {
+        method: "DELETE",
+        params: { id },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const reorderMutation = useMutation({
+    mutationFn: async ({
+      boardId,
+      columnIds
+    }) => {
+      const response = await client("@post/columns/reorder", {
+        method: "POST",
+        body: { boardId, columnIds },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  return {
+    createColumn: createMutation.mutateAsync,
+    updateColumn: (id, data) => updateMutation.mutateAsync({ id, data }),
+    deleteColumn: deleteMutation.mutateAsync,
+    reorderColumns: (boardId, columnIds) => reorderMutation.mutateAsync({ boardId, columnIds }),
+    isCreating: createMutation.isPending,
+    isUpdating: updateMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    isReordering: reorderMutation.isPending,
+    createError: createMutation.error,
+    updateError: updateMutation.error,
+    deleteError: deleteMutation.error,
+    reorderError: reorderMutation.error
+  };
+}
+function useTaskMutations() {
+  const { client, headers } = useKanbanClient();
+  const queryClient = useQueryClient();
+  const createMutation = useMutation({
+    mutationFn: async (data) => {
+      const response = await client("@post/tasks", {
+        method: "POST",
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const updateMutation = useMutation({
+    mutationFn: async ({
+      id,
+      data
+    }) => {
+      const response = await client("@put/tasks/:id", {
+        method: "PUT",
+        params: { id },
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const deleteMutation = useMutation({
+    mutationFn: async (id) => {
+      const response = await client("@delete/tasks/:id", {
+        method: "DELETE",
+        params: { id },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const moveMutation = useMutation({
+    mutationFn: async ({
+      taskId,
+      targetColumnId,
+      targetOrder
+    }) => {
+      const response = await client("@post/tasks/move", {
+        method: "POST",
+        body: { taskId, targetColumnId, targetOrder },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const reorderMutation = useMutation({
+    mutationFn: async ({
+      columnId,
+      taskIds
+    }) => {
+      const response = await client("@post/tasks/reorder", {
+        method: "POST",
+        body: { columnId, taskIds },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  return {
+    createTask: createMutation.mutateAsync,
+    updateTask: (id, data) => updateMutation.mutateAsync({ id, data }),
+    deleteTask: deleteMutation.mutateAsync,
+    moveTask: (taskId, targetColumnId, targetOrder) => moveMutation.mutateAsync({ taskId, targetColumnId, targetOrder }),
+    reorderTasks: (columnId, taskIds) => reorderMutation.mutateAsync({ columnId, taskIds }),
+    isCreating: createMutation.isPending,
+    isUpdating: updateMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    isMoving: moveMutation.isPending,
+    isReordering: reorderMutation.isPending,
+    createError: createMutation.error,
+    updateError: updateMutation.error,
+    deleteError: deleteMutation.error,
+    moveError: moveMutation.error,
+    reorderError: reorderMutation.error
+  };
+}
+function useResolveUser(userId) {
+  const { resolveUser } = usePluginOverrides("kanban");
+  return useQuery({
+    queryKey: ["kanban", "users", userId],
+    queryFn: async () => {
+      if (!userId) return null;
+      const result = await resolveUser(userId);
+      return result;
+    },
+    enabled: !!userId,
+    staleTime: 5 * 60 * 1e3,
+    // Cache user info for 5 minutes
+    gcTime: 10 * 60 * 1e3
+    // Keep in cache for 10 minutes
+  });
+}
+function useSearchUsers(query, boardId) {
+  const { searchUsers } = usePluginOverrides("kanban");
+  return useQuery({
+    queryKey: ["kanban", "users", "search", query, boardId],
+    queryFn: async () => {
+      const result = await searchUsers(query, boardId);
+      return result;
+    },
+    staleTime: 3e4
+    // Cache search results for 30 seconds
+  });
+}
+
+export { useBoard, useBoardMutations, useBoards, useColumnMutations, useResolveUser, useSearchUsers, useSuspenseBoard, useSuspenseBoards, useTaskMutations };

package/dist/packages/stack/src/plugins/kanban/client/plugin.cjs

@@ -0,0 +1,290 @@
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const client = require('@btst/stack/plugins/client');
+const yar = require('@btst/yar');
+const plugins_kanban_queryKeys = require('../../../../../../plugins/kanban/query-keys.cjs');
+const boardsListPage = require('./components/pages/boards-list-page.cjs');
+const newBoardPage = require('./components/pages/new-board-page.cjs');
+const boardPage = require('./components/pages/board-page.cjs');
+
+function createBoardsLoader(config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: "/kanban",
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadBoards) {
+          const canLoad = await hooks.beforeLoadBoards(context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadBoards hook");
+          }
+        }
+        const client$1 = client.createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath
+        });
+        const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(client$1, headers);
+        const listQuery = queries.boards.list({});
+        await queryClient.prefetchQuery(listQuery);
+        if (hooks?.afterLoadBoards) {
+          const boards = queryClient.getQueryData(
+            listQuery.queryKey
+          );
+          const canContinue = await hooks.afterLoadBoards(
+            boards || null,
+            context
+          );
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadBoards hook");
+          }
+        }
+        const queryState = queryClient.getQueryState(listQuery.queryKey);
+        if (queryState?.error && hooks?.onLoadError) {
+          const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
+          await hooks.onLoadError(error, context);
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createBoardLoader(boardId, config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: `/kanban/${boardId}`,
+        params: { boardId },
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadBoard) {
+          const canLoad = await hooks.beforeLoadBoard(boardId, context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadBoard hook");
+          }
+        }
+        const client$1 = client.createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath
+        });
+        const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(client$1, headers);
+        const boardQuery = queries.boards.detail(boardId);
+        await queryClient.prefetchQuery(boardQuery);
+        if (hooks?.afterLoadBoard) {
+          const board = queryClient.getQueryData(
+            boardQuery.queryKey
+          );
+          const canContinue = await hooks.afterLoadBoard(
+            board || null,
+            boardId,
+            context
+          );
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadBoard hook");
+          }
+        }
+        const queryState = queryClient.getQueryState(boardQuery.queryKey);
+        if (queryState?.error && hooks?.onLoadError) {
+          const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
+          await hooks.onLoadError(error, context);
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createNewBoardLoader(config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: "/kanban/new",
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadNewBoard) {
+          const canLoad = await hooks.beforeLoadNewBoard(context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadNewBoard hook");
+          }
+        }
+        if (hooks?.afterLoadNewBoard) {
+          const canContinue = await hooks.afterLoadNewBoard(context);
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadNewBoard hook");
+          }
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createBoardsListMeta(config) {
+  return () => {
+    const { siteBaseURL, siteBasePath, seo } = config;
+    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban`;
+    const title = "Kanban Boards";
+    const description = seo?.description || "Manage your projects with kanban boards";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: description },
+      { name: "robots", content: "index, follow" },
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:url", content: fullUrl },
+      ...seo?.siteName ? [{ property: "og:site_name", content: seo.siteName }] : [],
+      ...seo?.locale ? [{ property: "og:locale", content: seo.locale }] : [],
+      ...seo?.defaultImage ? [{ property: "og:image", content: seo.defaultImage }] : [],
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title },
+      { name: "twitter:description", content: description }
+    ];
+  };
+}
+function createBoardMeta(boardId, config) {
+  return () => {
+    const {
+      queryClient,
+      apiBaseURL,
+      apiBasePath,
+      siteBaseURL,
+      siteBasePath,
+      seo
+    } = config;
+    const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(
+      client.createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      })
+    );
+    const board = queryClient.getQueryData(
+      queries.boards.detail(boardId).queryKey
+    );
+    if (!board) {
+      return [
+        { title: "Board Not Found" },
+        { name: "robots", content: "noindex" }
+      ];
+    }
+    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban/${board.id}`;
+    const title = board.name;
+    const description = board.description || `Kanban board: ${board.name}`;
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: description },
+      { name: "robots", content: "index, follow" },
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:url", content: fullUrl },
+      ...seo?.siteName ? [{ property: "og:site_name", content: seo.siteName }] : [],
+      ...seo?.defaultImage ? [{ property: "og:image", content: seo.defaultImage }] : [],
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title }
+    ];
+  };
+}
+function createNewBoardMeta(config) {
+  return () => {
+    const { siteBaseURL, siteBasePath } = config;
+    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban/new`;
+    const title = "Create New Board";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: "Create a new kanban board" },
+      { name: "robots", content: "noindex, nofollow" },
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:url", content: fullUrl },
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title }
+    ];
+  };
+}
+const kanbanClientPlugin = (config) => client.defineClientPlugin({
+  name: "kanban",
+  routes: () => ({
+    boards: yar.createRoute("/kanban", () => {
+      return {
+        PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(boardsListPage.BoardsListPageComponent, {}),
+        loader: createBoardsLoader(config),
+        meta: createBoardsListMeta(config)
+      };
+    }),
+    newBoard: yar.createRoute("/kanban/new", () => {
+      return {
+        PageComponent: newBoardPage.NewBoardPageComponent,
+        loader: createNewBoardLoader(config),
+        meta: createNewBoardMeta(config)
+      };
+    }),
+    board: yar.createRoute("/kanban/:boardId", ({ params: { boardId } }) => {
+      return {
+        PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(boardPage.BoardPageComponent, { boardId }),
+        loader: createBoardLoader(boardId, config),
+        meta: createBoardMeta(boardId, config)
+      };
+    })
+  }),
+  sitemap: async () => {
+    const origin = `${config.siteBaseURL}${config.siteBasePath}`;
+    const indexUrl = `${origin}/kanban`;
+    const client$1 = client.createApiClient({
+      baseURL: config.apiBaseURL,
+      basePath: config.apiBasePath
+    });
+    let boards = [];
+    try {
+      const res = await client$1("/boards", {
+        method: "GET",
+        query: { limit: 100 }
+      });
+      boards = res.data ?? [];
+    } catch {
+    }
+    const entries = [
+      {
+        url: indexUrl,
+        lastModified: /* @__PURE__ */ new Date(),
+        changeFrequency: "daily",
+        priority: 0.7
+      },
+      ...boards.map((b) => ({
+        url: `${origin}/kanban/${b.id}`,
+        lastModified: b.updatedAt ? new Date(b.updatedAt) : void 0,
+        changeFrequency: "weekly",
+        priority: 0.6
+      }))
+    ];
+    return entries;
+  }
+});
+
+exports.kanbanClientPlugin = kanbanClientPlugin;