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

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

@@ -8,7 +8,44 @@ import { NewPostPageComponent } from './components/pages/new-post-page.mjs';
 import { EditPostPageComponent } from './components/pages/edit-post-page.mjs';
 import { TagPageComponent } from './components/pages/tag-page.mjs';
 import { PostPageComponent } from './components/pages/post-page.mjs';
+import { BLOG_PLUGIN_ID } from './constants.mjs';
 
+function resolveBlogClientConfig(config, runtime) {
+  return {
+    seo: config.seo,
+    hooks: config.hooks,
+    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 createBlogApiClient(config) {
+  return 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 createPostsLoader(published, config) {
   return async () => {
     if (typeof window === "undefined") {
@@ -20,12 +57,10 @@ function createPostsLoader(published, config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
       const limit = 10;
-      const client = createApiClient({
-        baseURL: apiBaseURL,
-        basePath: apiBasePath
-      });
-      const queries = createBlogQueryKeys(client, headers);
+      const client = createBlogApiClient(config);
+      const queries = createBlogQueryKeys(client);
       const listQuery = queries.posts.list({
         query: void 0,
         limit,
@@ -45,17 +80,16 @@ function createPostsLoader(published, config) {
           const posts = queryClient.getQueryData(listQuery.queryKey) || null;
           await hooks.afterLoadPosts(posts, { published }, context);
         }
-        const queryState = queryClient.getQueryState(listQuery.queryKey);
-        if (queryState?.error) {
-          if (hooks?.onLoadError) {
-            const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
-            await hooks.onLoadError(error, context);
-          }
+        const listState = queryClient.getQueryState(listQuery.queryKey);
+        const tagsState = queryClient.getQueryState(tagsQuery.queryKey);
+        const queryError = listState?.error ?? tagsState?.error;
+        if (queryError) {
+          await reportError(queryError);
         }
       } catch (error) {
         if (isConnectionError(error)) {
           console.warn(
-            "[btst/blog] route.loader() failed \u2014 no server running at build time. Use myStack.api.blog.prefetchForRoute() for SSG data prefetching."
+            "[btst/blog] route.loader() failed \u2014 no server running at build time. Use myStack.raw.blog.prefetchForRoute() for SSG data prefetching."
           );
         } else {
           const errToStore = createSanitizedSSRLoaderError();
@@ -68,9 +102,7 @@ function createPostsLoader(published, config) {
             retry: false
           });
         }
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -87,15 +119,13 @@ function createPostLoader(slug, config, path) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
       try {
         if (hooks?.beforeLoadPost) {
           await hooks.beforeLoadPost(slug, context);
         }
-        const client = createApiClient({
-          baseURL: apiBaseURL,
-          basePath: apiBasePath
-        });
-        const queries = createBlogQueryKeys(client, headers);
+        const client = createBlogApiClient(config);
+        const queries = createBlogQueryKeys(client);
         const postQuery = queries.posts.detail(slug);
         await queryClient.prefetchQuery(postQuery);
         if (hooks?.afterLoadPost) {
@@ -104,20 +134,15 @@ function createPostLoader(slug, config, path) {
         }
         const queryState = queryClient.getQueryState(postQuery.queryKey);
         if (queryState?.error) {
-          if (hooks?.onLoadError) {
-            const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
-            await hooks.onLoadError(error, context);
-          }
+          await reportError(queryState.error);
         }
       } catch (error) {
         if (isConnectionError(error)) {
           console.warn(
-            "[btst/blog] route.loader() failed \u2014 no server running at build time. Use myStack.api.blog.prefetchForRoute() for SSG data prefetching."
+            "[btst/blog] route.loader() failed \u2014 no server running at build time. Use myStack.raw.blog.prefetchForRoute() for SSG data prefetching."
           );
         }
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -133,6 +158,7 @@ function createNewPostLoader(config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
       try {
         if (hooks?.beforeLoadNewPost) {
           await hooks.beforeLoadNewPost(context);
@@ -141,9 +167,7 @@ function createNewPostLoader(config) {
           await hooks.afterLoadNewPost(context);
         }
       } catch (error) {
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -160,13 +184,11 @@ function createTagLoader(tagSlug, config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
       try {
         const limit = 10;
-        const client = createApiClient({
-          baseURL: apiBaseURL,
-          basePath: apiBasePath
-        });
-        const queries = createBlogQueryKeys(client, headers);
+        const client = createBlogApiClient(config);
+        const queries = createBlogQueryKeys(client);
         const listQuery = queries.posts.list({
           query: void 0,
           limit,
@@ -182,19 +204,16 @@ function createTagLoader(tagSlug, config) {
         const listState = queryClient.getQueryState(listQuery.queryKey);
         const tagsState = queryClient.getQueryState(tagsQuery.queryKey);
         const queryError = listState?.error || tagsState?.error;
-        if (queryError && hooks?.onLoadError) {
-          const error = queryError instanceof Error ? queryError : new Error(String(queryError));
-          await hooks.onLoadError(error, context);
+        if (queryError) {
+          await reportError(queryError);
         }
       } catch (error) {
         if (isConnectionError(error)) {
           console.warn(
-            "[btst/blog] route.loader() failed \u2014 no server running at build time. Use myStack.api.blog.prefetchForRoute() for SSG data prefetching."
+            "[btst/blog] route.loader() failed \u2014 no server running at build time. Use myStack.raw.blog.prefetchForRoute() for SSG data prefetching."
           );
         }
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -239,13 +258,8 @@ function createPostsListMeta(published, config) {
 function createPostMeta(slug, config) {
   return () => {
     const { queryClient } = config;
-    const { apiBaseURL, apiBasePath, siteBaseURL, siteBasePath, seo } = config;
-    const queries = createBlogQueryKeys(
-      createApiClient({
-        baseURL: apiBaseURL,
-        basePath: apiBasePath
-      })
-    );
+    const { siteBaseURL, siteBasePath, seo } = config;
+    const queries = createBlogQueryKeys(createBlogApiClient(config));
     const post = queryClient.getQueryData(
       queries.posts.detail(slug).queryKey
     );
@@ -317,13 +331,8 @@ function createPostMeta(slug, config) {
 function createTagMeta(tagSlug, config) {
   return () => {
     const { queryClient } = config;
-    const { apiBaseURL, apiBasePath, siteBaseURL, siteBasePath, seo } = config;
-    const queries = createBlogQueryKeys(
-      createApiClient({
-        baseURL: apiBaseURL,
-        basePath: apiBasePath
-      })
-    );
+    const { siteBaseURL, siteBasePath, seo } = config;
+    const queries = createBlogQueryKeys(createBlogApiClient(config));
     const tags = queryClient.getQueryData(
       queries.tags.list().queryKey
     );
@@ -382,13 +391,8 @@ function createNewPostMeta(config) {
 function createEditPostMeta(slug, config) {
   return () => {
     const { queryClient } = config;
-    const { apiBaseURL, apiBasePath, siteBaseURL, siteBasePath } = config;
-    const queries = createBlogQueryKeys(
-      createApiClient({
-        baseURL: apiBaseURL,
-        basePath: apiBasePath
-      })
-    );
+    const { siteBaseURL, siteBasePath } = config;
+    const queries = createBlogQueryKeys(createBlogApiClient(config));
     const post = queryClient.getQueryData(
       queries.posts.detail(slug).queryKey
     );
@@ -409,107 +413,109 @@ function createEditPostMeta(slug, config) {
     ];
   };
 }
-const blogClientPlugin = (config) => defineClientPlugin({
-  name: "blog",
-  routes: () => defineRoutes(
-    {
-      posts: defineRoute("/blog", {
-        page: () => /* @__PURE__ */ jsx(HomePageComponent, { published: true }),
-        loader: createPostsLoader(true, config),
-        meta: createPostsListMeta(true, config)
-      }),
-      drafts: defineRoute("/blog/drafts", {
-        page: () => /* @__PURE__ */ jsx(HomePageComponent, { published: false }),
-        loader: createPostsLoader(false, config),
-        meta: createPostsListMeta(false, config)
-      }),
-      newPost: defineRoute("/blog/new", {
-        page: NewPostPageComponent,
-        loader: createNewPostLoader(config),
-        meta: createNewPostMeta(config)
-      }),
-      editPost: defineRoute("/blog/:slug/edit", {
-        page: ({ params }) => /* @__PURE__ */ jsx(EditPostPageComponent, { slug: params.slug }),
-        loader: ({ params }) => createPostLoader(
-          params.slug,
-          config,
-          `/blog/${params.slug}/edit`
-        )(),
-        meta: ({ params }) => createEditPostMeta(params.slug, config)()
-      }),
-      tag: defineRoute("/blog/tag/:tagSlug", {
-        page: ({ params }) => /* @__PURE__ */ jsx(TagPageComponent, { tagSlug: params.tagSlug }),
-        loader: ({ params }) => createTagLoader(params.tagSlug, config)(),
-        meta: ({ params }) => createTagMeta(params.tagSlug, config)()
-      }),
-      post: defineRoute("/blog/:slug", {
-        page: ({ params }) => /* @__PURE__ */ jsx(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`;
-    const client = createApiClient({
-      baseURL: config.apiBaseURL,
-      basePath: config.apiBasePath
-    });
-    const limit = 100;
-    let offset = 0;
-    const posts = [];
-    while (true) {
-      const res = await client("/posts", {
-        method: "GET",
-        query: {
-          offset,
-          limit,
-          published: "true"
-        }
-      });
-      const page = res.data?.items ?? [];
-      posts.push(...page);
-      if (page.length < limit) break;
-      offset += limit;
-    }
-    const tagsRes = await client("/tags", {
-      method: "GET"
-    });
-    const tags = tagsRes.data ?? [];
-    const getLastModified = (p) => {
-      const dates = [p.updatedAt, p.publishedAt, p.createdAt].filter(
-        Boolean
-      );
-      if (dates.length === 0) return void 0;
-      const times = dates.map((d) => new Date(d).getTime()).filter((t) => !Number.isNaN(t));
-      if (times.length === 0) return void 0;
-      return new Date(Math.max(...times));
-    };
-    const latestTime = posts.map((p) => getLastModified(p)?.getTime() ?? 0).reduce((a, b) => Math.max(a, b), 0);
-    const entries = [
+function createResolvedBlogPlugin(resolvedConfig) {
+  return {
+    routes: () => defineRoutes(
       {
-        url: indexUrl,
-        lastModified: latestTime ? new Date(latestTime) : void 0,
-        changeFrequency: "daily",
-        priority: 0.7
+        posts: defineRoute("/blog", {
+          page: () => /* @__PURE__ */ jsx(HomePageComponent, { published: true }),
+          loader: createPostsLoader(true, resolvedConfig),
+          meta: createPostsListMeta(true, resolvedConfig)
+        }),
+        drafts: defineRoute("/blog/drafts", {
+          page: () => /* @__PURE__ */ jsx(HomePageComponent, { published: false }),
+          loader: createPostsLoader(false, resolvedConfig),
+          meta: createPostsListMeta(false, resolvedConfig)
+        }),
+        newPost: defineRoute("/blog/new", {
+          page: NewPostPageComponent,
+          loader: createNewPostLoader(resolvedConfig),
+          meta: createNewPostMeta(resolvedConfig)
+        }),
+        editPost: defineRoute("/blog/:slug/edit", {
+          page: ({ params }) => /* @__PURE__ */ jsx(EditPostPageComponent, { slug: params.slug }),
+          loader: ({ params }) => createPostLoader(
+            params.slug,
+            resolvedConfig,
+            `/blog/${params.slug}/edit`
+          )(),
+          meta: ({ params }) => createEditPostMeta(params.slug, resolvedConfig)()
+        }),
+        tag: defineRoute("/blog/tag/:tagSlug", {
+          page: ({ params }) => /* @__PURE__ */ jsx(TagPageComponent, { tagSlug: params.tagSlug }),
+          loader: ({ params }) => createTagLoader(params.tagSlug, resolvedConfig)(),
+          meta: ({ params }) => createTagMeta(params.tagSlug, resolvedConfig)()
+        }),
+        post: defineRoute("/blog/:slug", {
+          page: ({ params }) => /* @__PURE__ */ jsx(PostPageComponent, { slug: params.slug }),
+          loader: ({ params }) => createPostLoader(params.slug, resolvedConfig)(),
+          meta: ({ params }) => createPostMeta(params.slug, resolvedConfig)()
+        })
       },
-      ...posts.map((p) => ({
-        url: `${origin}/blog/${p.slug}`,
-        lastModified: getLastModified(p),
-        changeFrequency: "monthly",
-        priority: 0.6
-      })),
-      ...tags.map((t) => ({
-        url: `${origin}/blog/tag/${t.slug}`,
-        lastModified: t.updatedAt ? new Date(t.updatedAt) : void 0,
-        changeFrequency: "weekly",
-        priority: 0.5
-      }))
-    ];
-    return entries;
-  }
+      { pages: resolvedConfig.pageComponents }
+    ),
+    sitemap: async () => {
+      const origin = `${resolvedConfig.siteBaseURL}${resolvedConfig.siteBasePath}`;
+      const indexUrl = `${origin}/blog`;
+      const client = createBlogApiClient(resolvedConfig);
+      const limit = 100;
+      let offset = 0;
+      const posts = [];
+      while (true) {
+        const res = await client("/posts", {
+          method: "GET",
+          query: {
+            offset,
+            limit,
+            published: "true"
+          }
+        });
+        const page = res.data?.items ?? [];
+        posts.push(...page);
+        if (page.length < limit) break;
+        offset += limit;
+      }
+      const tagsRes = await client("/tags", {
+        method: "GET"
+      });
+      const tags = tagsRes.data ?? [];
+      const getLastModified = (p) => {
+        const dates = [p.updatedAt, p.publishedAt, p.createdAt].filter(
+          Boolean
+        );
+        if (dates.length === 0) return void 0;
+        const times = dates.map((d) => new Date(d).getTime()).filter((t) => !Number.isNaN(t));
+        if (times.length === 0) return void 0;
+        return new Date(Math.max(...times));
+      };
+      const latestTime = posts.map((p) => getLastModified(p)?.getTime() ?? 0).reduce((a, b) => Math.max(a, b), 0);
+      const entries = [
+        {
+          url: indexUrl,
+          lastModified: latestTime ? new Date(latestTime) : void 0,
+          changeFrequency: "daily",
+          priority: 0.7
+        },
+        ...posts.map((p) => ({
+          url: `${origin}/blog/${p.slug}`,
+          lastModified: getLastModified(p),
+          changeFrequency: "monthly",
+          priority: 0.6
+        })),
+        ...tags.map((t) => ({
+          url: `${origin}/blog/tag/${t.slug}`,
+          lastModified: t.updatedAt ? new Date(t.updatedAt) : void 0,
+          changeFrequency: "weekly",
+          priority: 0.5
+        }))
+      ];
+      return entries;
+    }
+  };
+}
+const blogClientPlugin = (config = {}) => defineClientPlugin()({
+  id: BLOG_PLUGIN_ID,
+  resolve: (runtime) => createResolvedBlogPlugin(resolveBlogClientConfig(config, runtime))
 });
 
 export { blogClientPlugin };

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

@@ -9,8 +9,7 @@ const useForm = require('./use-form.cjs');
 const useSelect = require('./use-select.cjs');
 
 function createQueryHooks(plugin, resourceName, queryName, def) {
-  const useQueryConfig = (args) => {
-    const context = internal.useResourceContext(plugin);
+  const queryConfig = (args, context) => {
     return {
       queryKey: queries.buildQueryKey(resourceName, queryName, def, args),
       queryFn: (queryContext) => queries.runResourceQuery(
@@ -39,30 +38,46 @@ function createQueryHooks(plugin, resourceName, queryName, def) {
   };
   return {
     use(args = [], options) {
-      return reactQuery.useQuery({
-        ...useQueryConfig(args),
-        ...options?.enabled !== void 0 ? { enabled: options.enabled } : {}
-      });
+      const context = internal.useResourceContext(plugin);
+      return reactQuery.useQuery(
+        {
+          ...queryConfig(args, context),
+          ...options?.enabled !== void 0 ? { enabled: options.enabled } : {}
+        },
+        context.queryClient
+      );
     },
     useSuspense(args = []) {
-      const result = reactQuery.useSuspenseQuery(useQueryConfig(args));
+      const context = internal.useResourceContext(plugin);
+      const result = reactQuery.useSuspenseQuery(
+        queryConfig(args, context),
+        context.queryClient
+      );
       if (result.error && !result.isFetching) {
         throw result.error;
       }
       return result;
     },
     useInfinite(args = [], options) {
-      return reactQuery.useInfiniteQuery({
-        ...useQueryConfig(args),
-        ...infiniteExtras(args),
-        ...options?.enabled !== void 0 ? { enabled: options.enabled } : {}
-      });
+      const context = internal.useResourceContext(plugin);
+      return reactQuery.useInfiniteQuery(
+        {
+          ...queryConfig(args, context),
+          ...infiniteExtras(args),
+          ...options?.enabled !== void 0 ? { enabled: options.enabled } : {}
+        },
+        context.queryClient
+      );
     },
     useSuspenseInfinite(args = []) {
-      const result = reactQuery.useSuspenseInfiniteQuery({
-        ...useQueryConfig(args),
-        ...infiniteExtras(args)
-      });
+      const context = internal.useResourceContext(plugin);
+      const result = reactQuery.useSuspenseInfiniteQuery(
+        {
+          ...queryConfig(args, context),
+          ...infiniteExtras(args)
+        },
+        context.queryClient
+      );
       if (result.error && !result.isFetching) {
         throw result.error;
       }

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

@@ -7,8 +7,7 @@ import { createUseForm } from './use-form.mjs';
 import { createUseSelect } from './use-select.mjs';
 
 function createQueryHooks(plugin, resourceName, queryName, def) {
-  const useQueryConfig = (args) => {
-    const context = useResourceContext(plugin);
+  const queryConfig = (args, context) => {
     return {
       queryKey: buildQueryKey(resourceName, queryName, def, args),
       queryFn: (queryContext) => runResourceQuery(
@@ -37,30 +36,46 @@ function createQueryHooks(plugin, resourceName, queryName, def) {
   };
   return {
     use(args = [], options) {
-      return useQuery({
-        ...useQueryConfig(args),
-        ...options?.enabled !== void 0 ? { enabled: options.enabled } : {}
-      });
+      const context = useResourceContext(plugin);
+      return useQuery(
+        {
+          ...queryConfig(args, context),
+          ...options?.enabled !== void 0 ? { enabled: options.enabled } : {}
+        },
+        context.queryClient
+      );
     },
     useSuspense(args = []) {
-      const result = useSuspenseQuery(useQueryConfig(args));
+      const context = useResourceContext(plugin);
+      const result = useSuspenseQuery(
+        queryConfig(args, context),
+        context.queryClient
+      );
       if (result.error && !result.isFetching) {
         throw result.error;
       }
       return result;
     },
     useInfinite(args = [], options) {
-      return useInfiniteQuery({
-        ...useQueryConfig(args),
-        ...infiniteExtras(args),
-        ...options?.enabled !== void 0 ? { enabled: options.enabled } : {}
-      });
+      const context = useResourceContext(plugin);
+      return useInfiniteQuery(
+        {
+          ...queryConfig(args, context),
+          ...infiniteExtras(args),
+          ...options?.enabled !== void 0 ? { enabled: options.enabled } : {}
+        },
+        context.queryClient
+      );
     },
     useSuspenseInfinite(args = []) {
-      const result = useSuspenseInfiniteQuery({
-        ...useQueryConfig(args),
-        ...infiniteExtras(args)
-      });
+      const context = useResourceContext(plugin);
+      const result = useSuspenseInfiniteQuery(
+        {
+          ...queryConfig(args, context),
+          ...infiniteExtras(args)
+        },
+        context.queryClient
+      );
       if (result.error && !result.isFetching) {
         throw result.error;
       }