@btst/stack 2.12.2 → 3.0.0-rc.1

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

@@ -1,44 +1,10 @@
 "use client";
-import { createApiClient } from '@btst/stack/plugins/client';
-import { useInfiniteQuery, useSuspenseInfiniteQuery, useQuery, useSuspenseQuery, useQueryClient, useMutation } from '@tanstack/react-query';
-import { useDebounce } from './use-debounce.mjs';
 import { useRef, useEffect } from 'react';
-import { createBlogQueryKeys } from '../../../../../../../plugins/blog/query-keys.mjs';
-import { usePluginOverrides } from '@btst/stack/context';
+import { blog } from './blog-resource.mjs';
+import { useDebounce } from '@btst/stack/plugins/client/hooks';
 
-const SHARED_QUERY_CONFIG = {
-  retry: false,
-  refetchOnWindowFocus: false,
-  refetchOnMount: false,
-  refetchOnReconnect: false,
-  staleTime: 1e3 * 60 * 5,
-  // 5 minutes
-  gcTime: 1e3 * 60 * 10
-  // 10 minutes
-};
 function usePosts(options = {}) {
-  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const {
-    tag,
-    tagSlug,
-    limit = 10,
-    enabled = true,
-    query,
-    published
-  } = options;
-  const queries = createBlogQueryKeys(client, headers);
-  const queryParams = {
-    tag,
-    tagSlug,
-    limit,
-    query,
-    published
-  };
-  const basePosts = queries.posts.list(queryParams);
+  const { tagSlug, limit = 10, enabled = true, query, published } = options;
   const {
     data,
     isLoading,
@@ -47,16 +13,8 @@ function usePosts(options = {}) {
     hasNextPage,
     isFetchingNextPage,
     refetch
-  } = useInfiniteQuery({
-    ...basePosts,
-    ...SHARED_QUERY_CONFIG,
-    initialPageParam: 0,
-    getNextPageParam: (lastPage, allPages) => {
-      const posts2 = lastPage;
-      if (posts2.length < limit) return void 0;
-      return allPages.length * limit;
-    },
-    enabled: enabled && !!client
+  } = blog.posts.list.useInfinite([{ tagSlug, limit, query, published }], {
+    enabled
   });
   const posts = data?.pages?.flat() ?? [];
   return {
@@ -70,43 +28,8 @@ function usePosts(options = {}) {
   };
 }
 function useSuspensePosts(options = {}) {
-  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const {
-    tag,
-    tagSlug,
-    limit = 10,
-    enabled = true,
-    query,
-    published
-  } = options;
-  const queries = createBlogQueryKeys(client, headers);
-  const queryParams = { tag, tagSlug, limit, query, published };
-  const basePosts = queries.posts.list(queryParams);
-  const {
-    data,
-    fetchNextPage,
-    hasNextPage,
-    isFetchingNextPage,
-    refetch,
-    error,
-    isFetching
-  } = useSuspenseInfiniteQuery({
-    ...basePosts,
-    ...SHARED_QUERY_CONFIG,
-    initialPageParam: 0,
-    getNextPageParam: (lastPage, allPages) => {
-      const posts2 = lastPage;
-      if (posts2.length < limit) return void 0;
-      return allPages.length * limit;
-    }
-  });
-  if (error && !isFetching) {
-    throw error;
-  }
+  const { tagSlug, limit = 10, query, published } = options;
+  const { data, fetchNextPage, hasNextPage, isFetchingNextPage, refetch } = blog.posts.list.useSuspenseInfinite([{ tagSlug, limit, query, published }]);
   const posts = data.pages?.flat() ?? [];
   return {
     posts,
@@ -117,18 +40,10 @@ function useSuspensePosts(options = {}) {
   };
 }
 function usePost(slug) {
-  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queries = createBlogQueryKeys(client, headers);
-  const basePost = queries.posts.detail(slug ?? "");
-  const { data, isLoading, error, refetch } = useQuery({
-    ...basePost,
-    ...SHARED_QUERY_CONFIG,
-    enabled: !!client && !!slug
-  });
+  const { data, isLoading, error, refetch } = blog.posts.detail.use(
+    [slug ?? ""],
+    { enabled: !!slug }
+  );
   return {
     post: data || null,
     isLoading,
@@ -137,35 +52,11 @@ function usePost(slug) {
   };
 }
 function useSuspensePost(slug) {
-  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queries = createBlogQueryKeys(client, headers);
-  const basePost = queries.posts.detail(slug);
-  const { data, refetch, error, isFetching } = useSuspenseQuery({
-    ...basePost,
-    ...SHARED_QUERY_CONFIG
-  });
-  if (error && !isFetching) {
-    throw error;
-  }
+  const { data, refetch } = blog.posts.detail.useSuspense([slug]);
   return { post: data || null, refetch };
 }
 function useTags() {
-  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queries = createBlogQueryKeys(client, headers);
-  const baseTags = queries.tags.list();
-  const { data, isLoading, error, refetch } = useQuery({
-    ...baseTags,
-    ...SHARED_QUERY_CONFIG,
-    enabled: !!client
-  });
+  const { data, isLoading, error, refetch } = blog.tags.list.use([]);
   return {
     tags: data ?? [],
     isLoading,
@@ -174,127 +65,23 @@ function useTags() {
   };
 }
 function useSuspenseTags() {
-  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queries = createBlogQueryKeys(client, headers);
-  const baseTags = queries.tags.list();
-  const { data, refetch, error, isFetching } = useSuspenseQuery({
-    ...baseTags,
-    ...SHARED_QUERY_CONFIG
-  });
-  if (error && !isFetching) {
-    throw error;
-  }
+  const { data, refetch } = blog.tags.list.useSuspense([]);
   return {
     tags: data ?? [],
     refetch
   };
 }
+function usePostForm(config) {
+  return blog.posts.useForm(config);
+}
 function useCreatePost() {
-  const { refresh, apiBaseURL, apiBasePath } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queryClient = useQueryClient();
-  const queries = createBlogQueryKeys(client);
-  return useMutation({
-    mutationKey: [...queries.posts._def, "create"],
-    mutationFn: async (postData) => {
-      const response = await client("@post/posts", {
-        method: "POST",
-        body: postData
-      });
-      return response.data;
-    },
-    onSuccess: async (created) => {
-      if (created?.slug) {
-        queryClient.setQueryData(
-          queries.posts.detail(created.slug).queryKey,
-          created
-        );
-      }
-      await queryClient.invalidateQueries({
-        queryKey: queries.posts.list._def
-      });
-      await queryClient.invalidateQueries({
-        queryKey: queries.drafts.list._def
-      });
-      if (refresh) {
-        await refresh();
-      }
-    }
-  });
+  return blog.posts.create.use();
 }
 function useUpdatePost() {
-  const { refresh, apiBaseURL, apiBasePath } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queryClient = useQueryClient();
-  const queries = createBlogQueryKeys(client);
-  return useMutation({
-    mutationKey: [...queries.posts._def, "update"],
-    mutationFn: async ({ id, data }) => {
-      const response = await client(`@put/posts/:id`, {
-        method: "PUT",
-        params: { id },
-        body: data
-      });
-      return response.data;
-    },
-    onSuccess: async (updated) => {
-      if (updated?.slug) {
-        queryClient.setQueryData(
-          queries.posts.detail(updated.slug).queryKey,
-          updated
-        );
-      }
-      await queryClient.invalidateQueries({
-        queryKey: queries.posts.list._def
-      });
-      await queryClient.invalidateQueries({
-        queryKey: queries.drafts.list._def
-      });
-      if (refresh) {
-        await refresh();
-      }
-    }
-  });
+  return blog.posts.update.use();
 }
 function useDeletePost() {
-  const { refresh, apiBaseURL, apiBasePath } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queryClient = useQueryClient();
-  const queries = createBlogQueryKeys(client);
-  return useMutation({
-    mutationKey: [...queries.posts._def, "delete"],
-    mutationFn: async ({ id }) => {
-      const response = await client(`@delete/posts/:id`, {
-        method: "DELETE",
-        params: { id }
-      });
-      return response.data;
-    },
-    onSuccess: async () => {
-      await queryClient.invalidateQueries({
-        queryKey: queries.posts._def
-      });
-      await queryClient.invalidateQueries({
-        queryKey: queries.drafts.list._def
-      });
-      if (refresh) {
-        await refresh();
-      }
-    }
-  });
+  return blog.posts.delete.use();
 }
 function usePostSearch({
   query,
@@ -333,19 +120,11 @@ function usePostSearch({
   };
 }
 function useNextPreviousPosts(createdAt, options = {}) {
-  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queries = createBlogQueryKeys(client, headers);
   const dateValue = typeof createdAt === "string" ? new Date(createdAt) : createdAt;
-  const baseQuery = queries.posts.nextPrevious(dateValue);
-  const { data, isLoading, error, refetch } = useQuery({
-    ...baseQuery,
-    ...SHARED_QUERY_CONFIG,
-    enabled: (options.enabled ?? true) && !!client
-  });
+  const { data, isLoading, error, refetch } = blog.posts.nextPrevious.use(
+    [dateValue],
+    { enabled: options.enabled ?? true }
+  );
   return {
     previousPost: data?.previous ?? null,
     nextPost: data?.next ?? null,
@@ -355,21 +134,10 @@ function useNextPreviousPosts(createdAt, options = {}) {
   };
 }
 function useRecentPosts(options = {}) {
-  const { apiBaseURL, apiBasePath, headers } = usePluginOverrides("blog");
-  const client = createApiClient({
-    baseURL: apiBaseURL,
-    basePath: apiBasePath
-  });
-  const queries = createBlogQueryKeys(client, headers);
-  const baseQuery = queries.posts.recent({
-    limit: options.limit ?? 5,
-    excludeSlug: options.excludeSlug
-  });
-  const { data, isLoading, error, refetch } = useQuery({
-    ...baseQuery,
-    ...SHARED_QUERY_CONFIG,
-    enabled: (options.enabled ?? true) && !!client
-  });
+  const { data, isLoading, error, refetch } = blog.posts.recent.use(
+    [{ limit: options.limit ?? 5, excludeSlug: options.excludeSlug }],
+    { enabled: options.enabled ?? true }
+  );
   return {
     recentPosts: data ?? [],
     isLoading,
@@ -378,4 +146,4 @@ function useRecentPosts(options = {}) {
   };
 }
 
-export { useCreatePost, useDeletePost, useNextPreviousPosts, usePost, usePostSearch, usePosts, useRecentPosts, useSuspensePost, useSuspensePosts, useSuspenseTags, useTags, useUpdatePost };
+export { useCreatePost, useDeletePost, useNextPreviousPosts, usePost, usePostForm, usePostSearch, usePosts, useRecentPosts, useSuspensePost, useSuspensePosts, useSuspenseTags, useTags, useUpdatePost };

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

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

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

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

package/dist/packages/stack/src/plugins/blog/client/hooks/use-debounce.cjs

@@ -2,17 +2,8 @@
 
 const utils = require('../../utils.cjs');
 const React = require('react');
+const hooks = require('@btst/stack/plugins/client/hooks');
 
-function useDebounce(value, delay) {
-  const [debouncedValue, setDebouncedValue] = React.useState(value);
-  React.useEffect(() => {
-    const timer = setTimeout(() => setDebouncedValue(value), delay || 500);
-    return () => {
-      clearTimeout(timer);
-    };
-  }, [value, delay]);
-  return debouncedValue;
-}
 function useThrottle(value, wait) {
   const [throttledValue, setThrottledValue] = React.useState(value);
   const valueRef = React.useRef(value);
@@ -34,5 +25,5 @@ function useThrottle(value, wait) {
   return throttledValue;
 }
 
-exports.useDebounce = useDebounce;
+exports.useDebounce = hooks.useDebounce;
 exports.useThrottle = useThrottle;

package/dist/packages/stack/src/plugins/blog/client/hooks/use-debounce.mjs

@@ -1,16 +1,7 @@
 import { throttle } from '../../utils.mjs';
-import { useState, useEffect, useRef, useMemo } from 'react';
+import { useState, useRef, useMemo, useEffect } from 'react';
+export { useDebounce } from '@btst/stack/plugins/client/hooks';
 
-function useDebounce(value, delay) {
-  const [debouncedValue, setDebouncedValue] = useState(value);
-  useEffect(() => {
-    const timer = setTimeout(() => setDebouncedValue(value), delay || 500);
-    return () => {
-      clearTimeout(timer);
-    };
-  }, [value, delay]);
-  return debouncedValue;
-}
 function useThrottle(value, wait) {
   const [throttledValue, setThrottledValue] = useState(value);
   const valueRef = useRef(value);
@@ -32,4 +23,4 @@ function useThrottle(value, wait) {
   return throttledValue;
 }
 
-export { useDebounce, useThrottle };
+export { useThrottle };

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

@@ -35,10 +35,7 @@ function createPostsLoader(published, config) {
       });
       try {
         if (hooks?.beforeLoadPosts) {
-          await client.runClientHookWithShim(
-            () => hooks.beforeLoadPosts({ published }, context),
-            "Load prevented by beforeLoadPosts hook"
-          );
+          await hooks.beforeLoadPosts({ published }, context);
         }
         await queryClient.prefetchInfiniteQuery({
           ...listQuery,
@@ -48,10 +45,7 @@ function createPostsLoader(published, config) {
         await queryClient.prefetchQuery(tagsQuery);
         if (hooks?.afterLoadPosts) {
           const posts = queryClient.getQueryData(listQuery.queryKey) || null;
-          await client.runClientHookWithShim(
-            () => hooks.afterLoadPosts(posts, { published }, context),
-            "Load prevented by afterLoadPosts hook"
-          );
+          await hooks.afterLoadPosts(posts, { published }, context);
         }
         const queryState = queryClient.getQueryState(listQuery.queryKey);
         if (queryState?.error) {
@@ -97,10 +91,7 @@ function createPostLoader(slug, config, path) {
       };
       try {
         if (hooks?.beforeLoadPost) {
-          await client.runClientHookWithShim(
-            () => hooks.beforeLoadPost(slug, context),
-            "Load prevented by beforeLoadPost hook"
-          );
+          await hooks.beforeLoadPost(slug, context);
         }
         const client$1 = client.createApiClient({
           baseURL: apiBaseURL,
@@ -111,10 +102,7 @@ function createPostLoader(slug, config, path) {
         await queryClient.prefetchQuery(postQuery);
         if (hooks?.afterLoadPost) {
           const post = queryClient.getQueryData(postQuery.queryKey) || null;
-          await client.runClientHookWithShim(
-            () => hooks.afterLoadPost(post, slug, context),
-            "Load prevented by afterLoadPost hook"
-          );
+          await hooks.afterLoadPost(post, slug, context);
         }
         const queryState = queryClient.getQueryState(postQuery.queryKey);
         if (queryState?.error) {
@@ -149,16 +137,10 @@ function createNewPostLoader(config) {
       };
       try {
         if (hooks?.beforeLoadNewPost) {
-          await client.runClientHookWithShim(
-            () => hooks.beforeLoadNewPost(context),
-            "Load prevented by beforeLoadNewPost hook"
-          );
+          await hooks.beforeLoadNewPost(context);
         }
         if (hooks?.afterLoadNewPost) {
-          await client.runClientHookWithShim(
-            () => hooks.afterLoadNewPost(context),
-            "Load prevented by afterLoadNewPost hook"
-          );
+          await hooks.afterLoadNewPost(context);
         }
       } catch (error) {
         if (hooks?.onLoadError) {
@@ -431,56 +413,45 @@ function createEditPostMeta(slug, config) {
 }
 const blogClientPlugin = (config) => client.defineClientPlugin({
   name: "blog",
-  routes: () => ({
-    posts: yar.createRoute("/blog", () => {
-      const CustomPosts = config.pageComponents?.posts;
-      return {
-        PageComponent: CustomPosts ?? (() => /* @__PURE__ */ jsxRuntime.jsx(homePage.HomePageComponent, { published: true })),
+  routes: () => yar.defineRoutes(
+    {
+      posts: yar.defineRoute("/blog", {
+        page: () => /* @__PURE__ */ jsxRuntime.jsx(homePage.HomePageComponent, { published: true }),
         loader: createPostsLoader(true, config),
         meta: createPostsListMeta(true, config)
-      };
-    }),
-    drafts: yar.createRoute("/blog/drafts", () => {
-      const CustomDrafts = config.pageComponents?.drafts;
-      return {
-        PageComponent: CustomDrafts ?? (() => /* @__PURE__ */ jsxRuntime.jsx(homePage.HomePageComponent, { published: false })),
+      }),
+      drafts: yar.defineRoute("/blog/drafts", {
+        page: () => /* @__PURE__ */ jsxRuntime.jsx(homePage.HomePageComponent, { published: false }),
         loader: createPostsLoader(false, config),
         meta: createPostsListMeta(false, config)
-      };
-    }),
-    newPost: yar.createRoute("/blog/new", () => {
-      const CustomNewPost = config.pageComponents?.newPost;
-      return {
-        PageComponent: CustomNewPost ?? newPostPage.NewPostPageComponent,
+      }),
+      newPost: yar.defineRoute("/blog/new", {
+        page: newPostPage.NewPostPageComponent,
         loader: createNewPostLoader(config),
         meta: createNewPostMeta(config)
-      };
-    }),
-    editPost: yar.createRoute("/blog/:slug/edit", ({ params: { slug } }) => {
-      const CustomEditPost = config.pageComponents?.editPost;
-      return {
-        PageComponent: CustomEditPost ? () => /* @__PURE__ */ jsxRuntime.jsx(CustomEditPost, { slug }) : () => /* @__PURE__ */ jsxRuntime.jsx(editPostPage.EditPostPageComponent, { slug }),
-        loader: createPostLoader(slug, config, `/blog/${slug}/edit`),
-        meta: createEditPostMeta(slug, config)
-      };
-    }),
-    tag: yar.createRoute("/blog/tag/:tagSlug", ({ params: { tagSlug } }) => {
-      const CustomTag = config.pageComponents?.tag;
-      return {
-        PageComponent: CustomTag ? () => /* @__PURE__ */ jsxRuntime.jsx(CustomTag, { tagSlug }) : () => /* @__PURE__ */ jsxRuntime.jsx(tagPage.TagPageComponent, { tagSlug }),
-        loader: createTagLoader(tagSlug, config),
-        meta: createTagMeta(tagSlug, config)
-      };
-    }),
-    post: yar.createRoute("/blog/:slug", ({ params: { slug } }) => {
-      const CustomPost = config.pageComponents?.post;
-      return {
-        PageComponent: CustomPost ? () => /* @__PURE__ */ jsxRuntime.jsx(CustomPost, { slug }) : () => /* @__PURE__ */ jsxRuntime.jsx(postPage.PostPageComponent, { slug }),
-        loader: createPostLoader(slug, config),
-        meta: createPostMeta(slug, config)
-      };
-    })
-  }),
+      }),
+      editPost: yar.defineRoute("/blog/:slug/edit", {
+        page: ({ params }) => /* @__PURE__ */ jsxRuntime.jsx(editPostPage.EditPostPageComponent, { slug: params.slug }),
+        loader: ({ params }) => createPostLoader(
+          params.slug,
+          config,
+          `/blog/${params.slug}/edit`
+        )(),
+        meta: ({ params }) => createEditPostMeta(params.slug, config)()
+      }),
+      tag: yar.defineRoute("/blog/tag/:tagSlug", {
+        page: ({ params }) => /* @__PURE__ */ jsxRuntime.jsx(tagPage.TagPageComponent, { tagSlug: params.tagSlug }),
+        loader: ({ params }) => createTagLoader(params.tagSlug, config)(),
+        meta: ({ params }) => createTagMeta(params.tagSlug, config)()
+      }),
+      post: yar.defineRoute("/blog/:slug", {
+        page: ({ params }) => /* @__PURE__ */ jsxRuntime.jsx(postPage.PostPageComponent, { slug: params.slug }),
+        loader: ({ params }) => createPostLoader(params.slug, config)(),
+        meta: ({ params }) => createPostMeta(params.slug, config)()
+      })
+    },
+    { pages: config.pageComponents }
+  ),
   sitemap: async () => {
     const origin = `${config.siteBaseURL}${config.siteBasePath}`;
     const indexUrl = `${origin}/blog`;