@btst/stack 3.0.0-rc.1 → 3.0.0-rc.3

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

@@ -1,19 +1,36 @@
 "use client";
 import { useQuery } from '@tanstack/react-query';
-import { usePluginOverrides } from '@btst/stack/context';
+import { useIdentity, useIdentitySourceGeneration, usePluginOverrides } from '@btst/stack/context';
 import { kanban } from './kanban-resource.mjs';
+import { KANBAN_PLUGIN_ID } from '../constants.mjs';
 
+function useIdentityPartition() {
+  const { identity, isPending, error } = useIdentity();
+  const sourceGeneration = useIdentitySourceGeneration();
+  if (isPending) return `pending:${sourceGeneration}`;
+  if (error) return `error:${sourceGeneration}`;
+  return identity ?? void 0;
+}
+function isUnresolvedIdentityPartition(partition) {
+  return typeof partition === "string";
+}
 function useBoards(params) {
-  return kanban.boards.list.use([params]);
+  const identityPartition = useIdentityPartition();
+  return kanban.boards.list.use([params, identityPartition]);
 }
 function useSuspenseBoards(params) {
-  return kanban.boards.list.useSuspense([params]);
+  const identityPartition = useIdentityPartition();
+  return kanban.boards.list.useSuspense([params, identityPartition]);
 }
 function useBoard(boardId) {
-  return kanban.boards.detail.use([boardId], { enabled: !!boardId });
+  const identityPartition = useIdentityPartition();
+  return kanban.boards.detail.use([boardId, identityPartition], {
+    enabled: !!boardId
+  });
 }
 function useSuspenseBoard(boardId) {
-  return kanban.boards.detail.useSuspense([boardId]);
+  const identityPartition = useIdentityPartition();
+  return kanban.boards.detail.useSuspense([boardId, identityPartition]);
 }
 function useBoardForm(config) {
   return kanban.boards.useForm(config);
@@ -86,24 +103,36 @@ function useTaskMutations() {
     reorderError: reorderMutation.error
   };
 }
+function useKanbanUserCallbacks() {
+  const overrides = usePluginOverrides(KANBAN_PLUGIN_ID);
+  if (typeof overrides.resolveUser !== "function" || typeof overrides.searchUsers !== "function") {
+    throw new Error(
+      '[btst/kanban] Missing required StackProvider overrides for "kanban". Configure overrides={{ kanban: { resolveUser, searchUsers } }} when kanbanClientPlugin() is registered.'
+    );
+  }
+  return overrides;
+}
 function useResolveUser(userId) {
-  const { resolveUser } = usePluginOverrides("kanban");
+  const { resolveUser } = useKanbanUserCallbacks();
+  const identityPartition = useIdentityPartition();
   return useQuery({
-    queryKey: ["kanban", "users", userId],
+    queryKey: ["kanban", "users", userId, identityPartition],
     queryFn: async () => {
       if (!userId) return null;
       return resolveUser(userId);
     },
-    enabled: !!userId,
+    enabled: !!userId && !isUnresolvedIdentityPartition(identityPartition),
     staleTime: 5 * 60 * 1e3,
     gcTime: 10 * 60 * 1e3
   });
 }
 function useSearchUsers(query, boardId) {
-  const { searchUsers } = usePluginOverrides("kanban");
+  const { searchUsers } = useKanbanUserCallbacks();
+  const identityPartition = useIdentityPartition();
   return useQuery({
-    queryKey: ["kanban", "users", "search", query, boardId],
+    queryKey: ["kanban", "users", "search", query, boardId, identityPartition],
     queryFn: () => searchUsers(query, boardId),
+    enabled: !isUnresolvedIdentityPartition(identityPartition),
     staleTime: 3e4
   });
 }

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

@@ -3,9 +3,10 @@
 
 const hooks = require('@btst/stack/plugins/client/hooks');
 const plugins_kanban_queryKeys = require('../../../../../../../plugins/kanban/query-keys.cjs');
+const constants = require('../constants.cjs');
 
 const kanban = hooks.createResource({
-  plugin: "kanban",
+  plugin: constants.KANBAN_PLUGIN_ID,
   resources: plugins_kanban_queryKeys.kanbanResources
 });
 

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

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

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

@@ -2,16 +2,76 @@
 
 const jsxRuntime = require('react/jsx-runtime');
 const client = require('@btst/stack/plugins/client');
+const client$1 = require('@btst/stack/client');
 const yar = require('@btst/yar');
+const React = require('react');
 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');
+const utils = require('../../utils.cjs');
+const constants = require('./constants.cjs');
 
+const BoardsListPageComponent = React.lazy(
+  () => import('./components/pages/boards-list-page.cjs').then((module) => ({
+    default: module.BoardsListPageComponent
+  }))
+);
+const NewBoardPageComponent = React.lazy(
+  () => import('./components/pages/new-board-page.cjs').then((module) => ({
+    default: module.NewBoardPageComponent
+  }))
+);
+const BoardPageComponent = React.lazy(
+  () => import('./components/pages/board-page.cjs').then((module) => ({
+    default: module.BoardPageComponent
+  }))
+);
+function resolveKanbanClientConfig(config, runtime) {
+  return {
+    seo: config.seo,
+    hooks: config.hooks,
+    identityPartition: config.identityPartition,
+    pageComponents: config.pageComponents,
+    apiBaseURL: runtime.api.baseURL,
+    apiBasePath: runtime.api.basePath,
+    siteBaseURL: runtime.site.baseURL,
+    siteBasePath: runtime.site.basePath,
+    queryClient: runtime.queryClient,
+    ...runtime.api.headers ? { headers: runtime.api.headers } : {},
+    ...runtime.api.credentials ? { credentials: runtime.api.credentials } : {}
+  };
+}
+function createKanbanApiClient(config) {
+  return client.createApiClient({
+    baseURL: config.apiBaseURL,
+    basePath: config.apiBasePath,
+    headers: config.headers,
+    credentials: config.credentials
+  });
+}
+function createLoadErrorReporter(hooks, context) {
+  let reported = false;
+  return async (error) => {
+    if (reported || !hooks?.onErrorLoad) return;
+    reported = true;
+    try {
+      await hooks.onErrorLoad(
+        error instanceof Error ? error : new Error(String(error)),
+        context
+      );
+    } catch {
+    }
+  };
+}
 function createBoardsLoader(config) {
   return async () => {
     if (typeof window === "undefined") {
-      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const {
+        queryClient,
+        apiBasePath,
+        apiBaseURL,
+        hooks,
+        headers,
+        identityPartition
+      } = config;
       const context = {
         path: "/kanban",
         isSSR: true,
@@ -19,16 +79,13 @@ function createBoardsLoader(config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
+      const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(createKanbanApiClient(config));
+      const listQuery = queries.boards.list({}, identityPartition);
       try {
         if (hooks?.beforeLoadBoards) {
           await hooks.beforeLoadBoards(context);
         }
-        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(
@@ -37,19 +94,25 @@ function createBoardsLoader(config) {
           await hooks.afterLoadBoards(boards || null, context);
         }
         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);
+        if (queryState?.error) {
+          await reportError(queryState.error);
         }
       } catch (error) {
         if (client.isConnectionError(error)) {
           console.warn(
-            "[btst/kanban] route.loader() failed \u2014 no server running at build time. Use myStack.api.kanban.prefetchForRoute() for SSG data prefetching."
+            "[btst/kanban] route.loader() failed \u2014 no server running at build time. Use myStack.raw.kanban.prefetchForRoute() for SSG data prefetching."
           );
+        } else {
+          const errToStore = utils.createSanitizedSSRLoaderError();
+          await queryClient.prefetchQuery({
+            queryKey: listQuery.queryKey,
+            queryFn: () => {
+              throw errToStore;
+            },
+            retry: false
+          });
         }
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -57,7 +120,14 @@ function createBoardsLoader(config) {
 function createBoardLoader(boardId, config) {
   return async () => {
     if (typeof window === "undefined") {
-      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const {
+        queryClient,
+        apiBasePath,
+        apiBaseURL,
+        hooks,
+        headers,
+        identityPartition
+      } = config;
       const context = {
         path: `/kanban/${boardId}`,
         params: { boardId },
@@ -66,16 +136,13 @@ function createBoardLoader(boardId, config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
+      const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(createKanbanApiClient(config));
+      const boardQuery = queries.boards.detail(boardId, identityPartition);
       try {
         if (hooks?.beforeLoadBoard) {
           await hooks.beforeLoadBoard(boardId, context);
         }
-        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(
@@ -84,19 +151,25 @@ function createBoardLoader(boardId, config) {
           await hooks.afterLoadBoard(board || null, boardId, context);
         }
         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);
+        if (queryState?.error) {
+          await reportError(queryState.error);
         }
       } catch (error) {
         if (client.isConnectionError(error)) {
           console.warn(
-            "[btst/kanban] route.loader() failed \u2014 no server running at build time. Use myStack.api.kanban.prefetchForRoute() for SSG data prefetching."
+            "[btst/kanban] route.loader() failed \u2014 no server running at build time. Use myStack.raw.kanban.prefetchForRoute() for SSG data prefetching."
           );
+        } else {
+          const errToStore = utils.createSanitizedSSRLoaderError();
+          await queryClient.prefetchQuery({
+            queryKey: boardQuery.queryKey,
+            queryFn: () => {
+              throw errToStore;
+            },
+            retry: false
+          });
         }
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -112,6 +185,7 @@ function createNewBoardLoader(config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
       try {
         if (hooks?.beforeLoadNewBoard) {
           await hooks.beforeLoadNewBoard(context);
@@ -120,9 +194,7 @@ function createNewBoardLoader(config) {
           await hooks.afterLoadNewBoard(context);
         }
       } catch (error) {
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -130,7 +202,9 @@ function createNewBoardLoader(config) {
 function createBoardsListMeta(config) {
   return () => {
     const { siteBaseURL, siteBasePath, seo } = config;
-    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban`;
+    const fullUrl = `${siteBaseURL}${client$1.normalizePath(
+      [siteBasePath, "kanban"].join("/")
+    )}`;
     const title = "Kanban Boards";
     const description = seo?.description || "Manage your projects with kanban boards";
     return [
@@ -153,22 +227,10 @@ function createBoardsListMeta(config) {
 }
 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 { queryClient, siteBaseURL, siteBasePath, seo, identityPartition } = config;
+    const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(createKanbanApiClient(config));
     const board = queryClient.getQueryData(
-      queries.boards.detail(boardId).queryKey
+      queries.boards.detail(boardId, identityPartition).queryKey
     );
     if (!board) {
       return [
@@ -176,7 +238,9 @@ function createBoardMeta(boardId, config) {
         { name: "robots", content: "noindex" }
       ];
     }
-    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban/${board.id}`;
+    const fullUrl = `${siteBaseURL}${client$1.normalizePath(
+      [siteBasePath, "kanban", board.id].join("/")
+    )}`;
     const title = board.name;
     const description = board.description || `Kanban board: ${board.name}`;
     return [
@@ -198,7 +262,9 @@ function createBoardMeta(boardId, config) {
 function createNewBoardMeta(config) {
   return () => {
     const { siteBaseURL, siteBasePath } = config;
-    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban/new`;
+    const fullUrl = `${siteBaseURL}${client$1.normalizePath(
+      [siteBasePath, "kanban", "new"].join("/")
+    )}`;
     const title = "Create New Board";
     return [
       { title },
@@ -213,60 +279,67 @@ function createNewBoardMeta(config) {
     ];
   };
 }
-const kanbanClientPlugin = (config) => client.defineClientPlugin({
-  name: "kanban",
-  routes: () => yar.defineRoutes(
-    {
-      boards: yar.defineRoute("/kanban", {
-        page: boardsListPage.BoardsListPageComponent,
-        loader: createBoardsLoader(config),
-        meta: createBoardsListMeta(config)
-      }),
-      newBoard: yar.defineRoute("/kanban/new", {
-        page: newBoardPage.NewBoardPageComponent,
-        loader: createNewBoardLoader(config),
-        meta: createNewBoardMeta(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`;
-    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?.items ?? [];
-    } catch {
-    }
-    const entries = [
+function createResolvedKanbanPlugin(config) {
+  return {
+    routes: () => yar.defineRoutes(
       {
-        url: indexUrl,
-        lastModified: /* @__PURE__ */ new Date(),
-        changeFrequency: "daily",
-        priority: 0.7
+        boards: yar.defineRoute("/kanban", {
+          page: BoardsListPageComponent,
+          loader: createBoardsLoader(config),
+          meta: createBoardsListMeta(config)
+        }),
+        newBoard: yar.defineRoute("/kanban/new", {
+          page: NewBoardPageComponent,
+          loader: createNewBoardLoader(config),
+          meta: createNewBoardMeta(config)
+        }),
+        board: yar.defineRoute("/kanban/:boardId", {
+          page: ({ params }) => /* @__PURE__ */ jsxRuntime.jsx(BoardPageComponent, { boardId: params.boardId }),
+          loader: ({ params }) => createBoardLoader(params.boardId, config)(),
+          meta: ({ params }) => createBoardMeta(params.boardId, config)()
+        })
       },
-      ...boards.map((b) => ({
-        url: `${origin}/kanban/${b.id}`,
-        lastModified: b.updatedAt ? new Date(b.updatedAt) : void 0,
-        changeFrequency: "weekly",
-        priority: 0.6
-      }))
-    ];
-    return entries;
-  }
+      { pages: config.pageComponents }
+    ),
+    sitemap: async () => {
+      const origin = `${config.siteBaseURL}${client$1.normalizePath(
+        config.siteBasePath
+      )}`.replace(/\/$/, "");
+      const indexUrl = `${origin}/kanban`;
+      const client$2 = client.createApiClient({
+        baseURL: config.apiBaseURL,
+        basePath: config.apiBasePath
+      });
+      try {
+        const res = await client$2("/boards", {
+          method: "GET",
+          query: { limit: 100 }
+        });
+        if (client.isErrorResponse(res)) return [];
+        const boards = res.data?.items ?? [];
+        return [
+          {
+            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
+          }))
+        ];
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+const kanbanClientPlugin = (config = {}) => client.defineClientPlugin()({
+  id: constants.KANBAN_PLUGIN_ID,
+  resolve: (runtime) => createResolvedKanbanPlugin(resolveKanbanClientConfig(config, runtime))
 });
 
 exports.kanbanClientPlugin = kanbanClientPlugin;