@btst/stack 2.12.2 → 3.0.0-rc.2

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

@@ -1,136 +1,27 @@
 "use client";
-import { useQuery, useSuspenseQuery, useQueryClient, useMutation } from '@tanstack/react-query';
-import { createApiClient } from '@btst/stack/plugins/client';
+import { useQuery } from '@tanstack/react-query';
 import { usePluginOverrides } from '@btst/stack/context';
-import { createKanbanQueryKeys } from '../../../../../../../plugins/kanban/query-keys.mjs';
+import { kanban } from './kanban-resource.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,
-    refetchOnWindowFocus: true
-  });
+  return kanban.boards.list.use([params]);
 }
 function useSuspenseBoards(params) {
-  const { client, headers } = useKanbanClient();
-  const queries = createKanbanQueryKeys(client, headers);
-  const result = useSuspenseQuery({
-    ...queries.boards.list(params),
-    staleTime: 3e4,
-    refetchOnWindowFocus: true
-  });
-  if (result.error && !result.isFetching) {
-    throw result.error;
-  }
-  return result;
+  return kanban.boards.list.useSuspense([params]);
 }
 function useBoard(boardId) {
-  const { client, headers } = useKanbanClient();
-  const queries = createKanbanQueryKeys(client, headers);
-  return useQuery({
-    ...queries.boards.detail(boardId),
-    staleTime: 3e4,
-    refetchOnWindowFocus: true,
-    enabled: !!boardId
-  });
+  return kanban.boards.detail.use([boardId], { enabled: !!boardId });
 }
 function useSuspenseBoard(boardId) {
-  const { client, headers } = useKanbanClient();
-  const queries = createKanbanQueryKeys(client, headers);
-  const result = useSuspenseQuery({
-    ...queries.boards.detail(boardId),
-    staleTime: 3e4,
-    refetchOnWindowFocus: true
-  });
-  if (result.error && !result.isFetching) {
-    throw result.error;
-  }
-  return result;
+  return kanban.boards.detail.useSuspense([boardId]);
+}
+function useBoardForm(config) {
+  return kanban.boards.useForm(config);
 }
 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"] });
-    }
-  });
+  const createMutation = kanban.boards.create.use();
+  const updateMutation = kanban.boards.update.use();
+  const deleteMutation = kanban.boards.delete.use();
   return {
     createBoard: createMutation.mutateAsync,
     updateBoard: (id, data) => updateMutation.mutateAsync({ id, data }),
@@ -143,84 +34,14 @@ function useBoardMutations() {
     deleteError: deleteMutation.error
   };
 }
+function useColumnForm(config) {
+  return kanban.columns.useForm(config);
+}
 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"] });
-    }
-  });
+  const createMutation = kanban.columns.create.use();
+  const updateMutation = kanban.columns.update.use();
+  const deleteMutation = kanban.columns.delete.use();
+  const reorderMutation = kanban.columns.reorder.use();
   return {
     createColumn: createMutation.mutateAsync,
     updateColumn: (id, data) => updateMutation.mutateAsync({ id, data }),
@@ -236,105 +57,17 @@ function useColumnMutations() {
     reorderError: reorderMutation.error
   };
 }
+function useTaskForm(config) {
+  return kanban.tasks.useForm(
+    config
+  );
+}
 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"] });
-    }
-  });
+  const createMutation = kanban.tasks.create.use();
+  const updateMutation = kanban.tasks.update.use();
+  const deleteMutation = kanban.tasks.delete.use();
+  const moveMutation = kanban.tasks.move.use();
+  const reorderMutation = kanban.tasks.reorder.use();
   return {
     createTask: createMutation.mutateAsync,
     updateTask: (id, data) => updateMutation.mutateAsync({ id, data }),
@@ -359,27 +92,20 @@ function useResolveUser(userId) {
     queryKey: ["kanban", "users", userId],
     queryFn: async () => {
       if (!userId) return null;
-      const result = await resolveUser(userId);
-      return result;
+      return resolveUser(userId);
     },
     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;
-    },
+    queryFn: () => searchUsers(query, boardId),
     staleTime: 3e4
-    // Cache search results for 30 seconds
   });
 }
 
-export { useBoard, useBoardMutations, useBoards, useColumnMutations, useResolveUser, useSearchUsers, useSuspenseBoard, useSuspenseBoards, useTaskMutations };
+export { useBoard, useBoardForm, useBoardMutations, useBoards, useColumnForm, useColumnMutations, useResolveUser, useSearchUsers, useSuspenseBoard, useSuspenseBoards, useTaskForm, useTaskMutations };

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

@@ -0,0 +1,12 @@
+"use client";
+'use strict';
+
+const hooks = require('@btst/stack/plugins/client/hooks');
+const plugins_kanban_queryKeys = require('../../../../../../../plugins/kanban/query-keys.cjs');
+
+const kanban = hooks.createResource({
+  plugin: "kanban",
+  resources: plugins_kanban_queryKeys.kanbanResources
+});
+
+exports.kanban = kanban;

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

@@ -0,0 +1,10 @@
+"use client";
+import { createResource } from '@btst/stack/plugins/client/hooks';
+import { kanbanResources } from '../../../../../../../plugins/kanban/query-keys.mjs';
+
+const kanban = createResource({
+  plugin: "kanban",
+  resources: kanbanResources
+});
+
+export { kanban };

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

@@ -21,10 +21,7 @@ function createBoardsLoader(config) {
       };
       try {
         if (hooks?.beforeLoadBoards) {
-          await client.runClientHookWithShim(
-            () => hooks.beforeLoadBoards(context),
-            "Load prevented by beforeLoadBoards hook"
-          );
+          await hooks.beforeLoadBoards(context);
         }
         const client$1 = client.createApiClient({
           baseURL: apiBaseURL,
@@ -37,10 +34,7 @@ function createBoardsLoader(config) {
           const boards = queryClient.getQueryData(
             listQuery.queryKey
           );
-          await client.runClientHookWithShim(
-            () => hooks.afterLoadBoards(boards || null, context),
-            "Load prevented by afterLoadBoards hook"
-          );
+          await hooks.afterLoadBoards(boards || null, context);
         }
         const queryState = queryClient.getQueryState(listQuery.queryKey);
         if (queryState?.error && hooks?.onLoadError) {
@@ -74,10 +68,7 @@ function createBoardLoader(boardId, config) {
       };
       try {
         if (hooks?.beforeLoadBoard) {
-          await client.runClientHookWithShim(
-            () => hooks.beforeLoadBoard(boardId, context),
-            "Load prevented by beforeLoadBoard hook"
-          );
+          await hooks.beforeLoadBoard(boardId, context);
         }
         const client$1 = client.createApiClient({
           baseURL: apiBaseURL,
@@ -90,10 +81,7 @@ function createBoardLoader(boardId, config) {
           const board = queryClient.getQueryData(
             boardQuery.queryKey
           );
-          await client.runClientHookWithShim(
-            () => hooks.afterLoadBoard(board || null, boardId, context),
-            "Load prevented by afterLoadBoard hook"
-          );
+          await hooks.afterLoadBoard(board || null, boardId, context);
         }
         const queryState = queryClient.getQueryState(boardQuery.queryKey);
         if (queryState?.error && hooks?.onLoadError) {
@@ -126,16 +114,10 @@ function createNewBoardLoader(config) {
       };
       try {
         if (hooks?.beforeLoadNewBoard) {
-          await client.runClientHookWithShim(
-            () => hooks.beforeLoadNewBoard(context),
-            "Load prevented by beforeLoadNewBoard hook"
-          );
+          await hooks.beforeLoadNewBoard(context);
         }
         if (hooks?.afterLoadNewBoard) {
-          await client.runClientHookWithShim(
-            () => hooks.afterLoadNewBoard(context),
-            "Load prevented by afterLoadNewBoard hook"
-          );
+          await hooks.afterLoadNewBoard(context);
         }
       } catch (error) {
         if (hooks?.onLoadError) {
@@ -233,32 +215,26 @@ function createNewBoardMeta(config) {
 }
 const kanbanClientPlugin = (config) => client.defineClientPlugin({
   name: "kanban",
-  routes: () => ({
-    boards: yar.createRoute("/kanban", () => {
-      const CustomBoards = config.pageComponents?.boards;
-      return {
-        PageComponent: CustomBoards ?? (() => /* @__PURE__ */ jsxRuntime.jsx(boardsListPage.BoardsListPageComponent, {})),
+  routes: () => yar.defineRoutes(
+    {
+      boards: yar.defineRoute("/kanban", {
+        page: boardsListPage.BoardsListPageComponent,
         loader: createBoardsLoader(config),
         meta: createBoardsListMeta(config)
-      };
-    }),
-    newBoard: yar.createRoute("/kanban/new", () => {
-      const CustomNewBoard = config.pageComponents?.newBoard;
-      return {
-        PageComponent: CustomNewBoard ?? newBoardPage.NewBoardPageComponent,
+      }),
+      newBoard: yar.defineRoute("/kanban/new", {
+        page: newBoardPage.NewBoardPageComponent,
         loader: createNewBoardLoader(config),
         meta: createNewBoardMeta(config)
-      };
-    }),
-    board: yar.createRoute("/kanban/:boardId", ({ params: { boardId } }) => {
-      const CustomBoard = config.pageComponents?.board;
-      return {
-        PageComponent: CustomBoard ? () => /* @__PURE__ */ jsxRuntime.jsx(CustomBoard, { boardId }) : () => /* @__PURE__ */ jsxRuntime.jsx(boardPage.BoardPageComponent, { boardId }),
-        loader: createBoardLoader(boardId, config),
-        meta: createBoardMeta(boardId, config)
-      };
-    })
-  }),
+      }),
+      board: yar.defineRoute("/kanban/:boardId", {
+        page: ({ params }) => /* @__PURE__ */ jsxRuntime.jsx(boardPage.BoardPageComponent, { boardId: params.boardId }),
+        loader: ({ params }) => createBoardLoader(params.boardId, config)(),
+        meta: ({ params }) => createBoardMeta(params.boardId, config)()
+      })
+    },
+    { pages: config.pageComponents }
+  ),
   sitemap: async () => {
     const origin = `${config.siteBaseURL}${config.siteBasePath}`;
     const indexUrl = `${origin}/kanban`;

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

@@ -1,6 +1,6 @@
 import { jsx } from 'react/jsx-runtime';
-import { defineClientPlugin, createApiClient, runClientHookWithShim, isConnectionError } from '@btst/stack/plugins/client';
-import { createRoute } from '@btst/yar';
+import { defineClientPlugin, createApiClient, isConnectionError } from '@btst/stack/plugins/client';
+import { defineRoutes, defineRoute } from '@btst/yar';
 import { createKanbanQueryKeys } from '../../../../../../plugins/kanban/query-keys.mjs';
 import { BoardsListPageComponent } from './components/pages/boards-list-page.mjs';
 import { NewBoardPageComponent } from './components/pages/new-board-page.mjs';
@@ -19,10 +19,7 @@ function createBoardsLoader(config) {
       };
       try {
         if (hooks?.beforeLoadBoards) {
-          await runClientHookWithShim(
-            () => hooks.beforeLoadBoards(context),
-            "Load prevented by beforeLoadBoards hook"
-          );
+          await hooks.beforeLoadBoards(context);
         }
         const client = createApiClient({
           baseURL: apiBaseURL,
@@ -35,10 +32,7 @@ function createBoardsLoader(config) {
           const boards = queryClient.getQueryData(
             listQuery.queryKey
           );
-          await runClientHookWithShim(
-            () => hooks.afterLoadBoards(boards || null, context),
-            "Load prevented by afterLoadBoards hook"
-          );
+          await hooks.afterLoadBoards(boards || null, context);
         }
         const queryState = queryClient.getQueryState(listQuery.queryKey);
         if (queryState?.error && hooks?.onLoadError) {
@@ -72,10 +66,7 @@ function createBoardLoader(boardId, config) {
       };
       try {
         if (hooks?.beforeLoadBoard) {
-          await runClientHookWithShim(
-            () => hooks.beforeLoadBoard(boardId, context),
-            "Load prevented by beforeLoadBoard hook"
-          );
+          await hooks.beforeLoadBoard(boardId, context);
         }
         const client = createApiClient({
           baseURL: apiBaseURL,
@@ -88,10 +79,7 @@ function createBoardLoader(boardId, config) {
           const board = queryClient.getQueryData(
             boardQuery.queryKey
           );
-          await runClientHookWithShim(
-            () => hooks.afterLoadBoard(board || null, boardId, context),
-            "Load prevented by afterLoadBoard hook"
-          );
+          await hooks.afterLoadBoard(board || null, boardId, context);
         }
         const queryState = queryClient.getQueryState(boardQuery.queryKey);
         if (queryState?.error && hooks?.onLoadError) {
@@ -124,16 +112,10 @@ function createNewBoardLoader(config) {
       };
       try {
         if (hooks?.beforeLoadNewBoard) {
-          await runClientHookWithShim(
-            () => hooks.beforeLoadNewBoard(context),
-            "Load prevented by beforeLoadNewBoard hook"
-          );
+          await hooks.beforeLoadNewBoard(context);
         }
         if (hooks?.afterLoadNewBoard) {
-          await runClientHookWithShim(
-            () => hooks.afterLoadNewBoard(context),
-            "Load prevented by afterLoadNewBoard hook"
-          );
+          await hooks.afterLoadNewBoard(context);
         }
       } catch (error) {
         if (hooks?.onLoadError) {
@@ -231,32 +213,26 @@ function createNewBoardMeta(config) {
 }
 const kanbanClientPlugin = (config) => defineClientPlugin({
   name: "kanban",
-  routes: () => ({
-    boards: createRoute("/kanban", () => {
-      const CustomBoards = config.pageComponents?.boards;
-      return {
-        PageComponent: CustomBoards ?? (() => /* @__PURE__ */ jsx(BoardsListPageComponent, {})),
+  routes: () => defineRoutes(
+    {
+      boards: defineRoute("/kanban", {
+        page: BoardsListPageComponent,
         loader: createBoardsLoader(config),
         meta: createBoardsListMeta(config)
-      };
-    }),
-    newBoard: createRoute("/kanban/new", () => {
-      const CustomNewBoard = config.pageComponents?.newBoard;
-      return {
-        PageComponent: CustomNewBoard ?? NewBoardPageComponent,
+      }),
+      newBoard: defineRoute("/kanban/new", {
+        page: NewBoardPageComponent,
         loader: createNewBoardLoader(config),
         meta: createNewBoardMeta(config)
-      };
-    }),
-    board: createRoute("/kanban/:boardId", ({ params: { boardId } }) => {
-      const CustomBoard = config.pageComponents?.board;
-      return {
-        PageComponent: CustomBoard ? () => /* @__PURE__ */ jsx(CustomBoard, { boardId }) : () => /* @__PURE__ */ jsx(BoardPageComponent, { boardId }),
-        loader: createBoardLoader(boardId, config),
-        meta: createBoardMeta(boardId, config)
-      };
-    })
-  }),
+      }),
+      board: defineRoute("/kanban/:boardId", {
+        page: ({ params }) => /* @__PURE__ */ jsx(BoardPageComponent, { boardId: params.boardId }),
+        loader: ({ params }) => createBoardLoader(params.boardId, config)(),
+        meta: ({ params }) => createBoardMeta(params.boardId, config)()
+      })
+    },
+    { pages: config.pageComponents }
+  ),
   sitemap: async () => {
     const origin = `${config.siteBaseURL}${config.siteBasePath}`;
     const indexUrl = `${origin}/kanban`;

package/dist/packages/stack/src/plugins/kanban/utils.cjs

@@ -37,13 +37,6 @@ function getPriorityConfig(priority) {
       };
   }
 }
-const PRIORITY_OPTIONS = [
-  { value: "LOW", label: "Low" },
-  { value: "MEDIUM", label: "Medium" },
-  { value: "HIGH", label: "High" },
-  { value: "URGENT", label: "Urgent" }
-];
 
-exports.PRIORITY_OPTIONS = PRIORITY_OPTIONS;
 exports.getPriorityConfig = getPriorityConfig;
 exports.slugify = slugify;

package/dist/packages/stack/src/plugins/kanban/utils.mjs

@@ -35,11 +35,5 @@ function getPriorityConfig(priority) {
       };
   }
 }
-const PRIORITY_OPTIONS = [
-  { value: "LOW", label: "Low" },
-  { value: "MEDIUM", label: "Medium" },
-  { value: "HIGH", label: "High" },
-  { value: "URGENT", label: "Urgent" }
-];
 
-export { PRIORITY_OPTIONS, getPriorityConfig, slugify };
+export { getPriorityConfig, slugify };