@btst/stack 1.0.1 → 1.1.1

package/dist/api/index.cjs

@@ -2,6 +2,7 @@
 
 const betterCall = require('better-call');
 const db = require('@btst/db');
+const node = require('better-call/node');
 
 function betterStack(config) {
   const { plugins, adapter, dbSchema, basePath } = config;
@@ -27,5 +28,5 @@ function betterStack(config) {
   };
 }
 
-exports.createEndpoint = betterCall.createEndpoint;
+exports.toNodeHandler = node.toNodeHandler;
 exports.betterStack = betterStack;

package/dist/api/index.d.cts

@@ -1,8 +1,9 @@
-import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.DORw_1ps.cjs';
-export { B as BackendPlugin } from '../shared/stack.DORw_1ps.cjs';
-export { createEndpoint } from 'better-call';
+import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.cjs';
+export { B as BackendPlugin } from '../shared/stack.ByOugz9d.cjs';
+export { toNodeHandler } from 'better-call/node';
 import '@btst/yar';
 import '@btst/db';
+import 'better-call';
 
 /**
  * Creates the backend library with plugin support

package/dist/api/index.d.mts

@@ -1,8 +1,9 @@
-import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.DORw_1ps.mjs';
-export { B as BackendPlugin } from '../shared/stack.DORw_1ps.mjs';
-export { createEndpoint } from 'better-call';
+import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.mjs';
+export { B as BackendPlugin } from '../shared/stack.ByOugz9d.mjs';
+export { toNodeHandler } from 'better-call/node';
 import '@btst/yar';
 import '@btst/db';
+import 'better-call';
 
 /**
  * Creates the backend library with plugin support

package/dist/api/index.d.ts

@@ -1,8 +1,9 @@
-import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.DORw_1ps.js';
-export { B as BackendPlugin } from '../shared/stack.DORw_1ps.js';
-export { createEndpoint } from 'better-call';
+import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.js';
+export { B as BackendPlugin } from '../shared/stack.ByOugz9d.js';
+export { toNodeHandler } from 'better-call/node';
 import '@btst/yar';
 import '@btst/db';
+import 'better-call';
 
 /**
  * Creates the backend library with plugin support

package/dist/api/index.mjs

@@ -1,6 +1,6 @@
 import { createRouter } from 'better-call';
-export { createEndpoint } from 'better-call';
 import { defineDb } from '@btst/db';
+export { toNodeHandler } from 'better-call/node';
 
 function betterStack(config) {
   const { plugins, adapter, dbSchema, basePath } = config;

package/dist/client/components/compose.cjs

@@ -0,0 +1,68 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const errorBoundary = require('./error-boundary.cjs');
+
+function RouteRenderer({
+  router,
+  path,
+  NotFoundComponent,
+  onNotFound,
+  onError,
+  props
+}) {
+  const route = router.getRoute(path);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ComposedRoute,
+    {
+      path,
+      PageComponent: route?.PageComponent,
+      ErrorComponent: route?.ErrorComponent,
+      LoadingComponent: route?.LoadingComponent,
+      onNotFound,
+      NotFoundComponent,
+      onError,
+      props
+    }
+  );
+}
+function ComposedRoute({
+  path,
+  PageComponent,
+  ErrorComponent,
+  LoadingComponent,
+  onNotFound,
+  NotFoundComponent,
+  props,
+  onError
+}) {
+  if (PageComponent) {
+    const content = /* @__PURE__ */ jsxRuntime.jsx(PageComponent, { ...props });
+    const isBrowser = typeof window !== "undefined";
+    const suspenseFallback = isBrowser && LoadingComponent ? /* @__PURE__ */ jsxRuntime.jsx(LoadingComponent, {}) : null;
+    if (ErrorComponent) {
+      return /* @__PURE__ */ jsxRuntime.jsx(React.Suspense, { fallback: suspenseFallback, children: /* @__PURE__ */ jsxRuntime.jsx(
+        errorBoundary.ErrorBoundary,
+        {
+          FallbackComponent: ErrorComponent,
+          resetKeys: [path],
+          onError,
+          children: /* @__PURE__ */ jsxRuntime.jsx(React.Suspense, { fallback: suspenseFallback, children: content }, `inner-${path}`)
+        }
+      ) }, `outer-${path}`);
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(React.Suspense, { fallback: suspenseFallback, children: content }, path);
+  } else {
+    if (onNotFound) {
+      onNotFound();
+    }
+    if (NotFoundComponent) {
+      return /* @__PURE__ */ jsxRuntime.jsx(NotFoundComponent, { message: `Unknown route: ${path}` });
+    }
+  }
+}
+
+exports.ComposedRoute = ComposedRoute;
+exports.RouteRenderer = RouteRenderer;

package/dist/client/components/compose.mjs

@@ -0,0 +1,65 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { Suspense } from 'react';
+import { ErrorBoundary } from './error-boundary.mjs';
+
+function RouteRenderer({
+  router,
+  path,
+  NotFoundComponent,
+  onNotFound,
+  onError,
+  props
+}) {
+  const route = router.getRoute(path);
+  return /* @__PURE__ */ jsx(
+    ComposedRoute,
+    {
+      path,
+      PageComponent: route?.PageComponent,
+      ErrorComponent: route?.ErrorComponent,
+      LoadingComponent: route?.LoadingComponent,
+      onNotFound,
+      NotFoundComponent,
+      onError,
+      props
+    }
+  );
+}
+function ComposedRoute({
+  path,
+  PageComponent,
+  ErrorComponent,
+  LoadingComponent,
+  onNotFound,
+  NotFoundComponent,
+  props,
+  onError
+}) {
+  if (PageComponent) {
+    const content = /* @__PURE__ */ jsx(PageComponent, { ...props });
+    const isBrowser = typeof window !== "undefined";
+    const suspenseFallback = isBrowser && LoadingComponent ? /* @__PURE__ */ jsx(LoadingComponent, {}) : null;
+    if (ErrorComponent) {
+      return /* @__PURE__ */ jsx(Suspense, { fallback: suspenseFallback, children: /* @__PURE__ */ jsx(
+        ErrorBoundary,
+        {
+          FallbackComponent: ErrorComponent,
+          resetKeys: [path],
+          onError,
+          children: /* @__PURE__ */ jsx(Suspense, { fallback: suspenseFallback, children: content }, `inner-${path}`)
+        }
+      ) }, `outer-${path}`);
+    }
+    return /* @__PURE__ */ jsx(Suspense, { fallback: suspenseFallback, children: content }, path);
+  } else {
+    if (onNotFound) {
+      onNotFound();
+    }
+    if (NotFoundComponent) {
+      return /* @__PURE__ */ jsx(NotFoundComponent, { message: `Unknown route: ${path}` });
+    }
+  }
+}
+
+export { ComposedRoute, RouteRenderer };

package/dist/client/components/error-boundary.cjs

@@ -0,0 +1,24 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const reactErrorBoundary = require('react-error-boundary');
+
+function ErrorBoundary({
+  children,
+  FallbackComponent,
+  resetKeys,
+  onError
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactErrorBoundary.ErrorBoundary,
+    {
+      FallbackComponent,
+      onError,
+      resetKeys,
+      children
+    }
+  );
+}
+
+exports.ErrorBoundary = ErrorBoundary;

package/dist/client/components/error-boundary.mjs

@@ -0,0 +1,22 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { ErrorBoundary as ErrorBoundary$1 } from 'react-error-boundary';
+
+function ErrorBoundary({
+  children,
+  FallbackComponent,
+  resetKeys,
+  onError
+}) {
+  return /* @__PURE__ */ jsx(
+    ErrorBoundary$1,
+    {
+      FallbackComponent,
+      onError,
+      resetKeys,
+      children
+    }
+  );
+}
+
+export { ErrorBoundary };

package/dist/client/components/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+const compose = require('./compose.cjs');
+const errorBoundary = require('./error-boundary.cjs');
+
+
+
+exports.ComposedRoute = compose.ComposedRoute;
+exports.RouteRenderer = compose.RouteRenderer;
+exports.ErrorBoundary = errorBoundary.ErrorBoundary;

package/dist/client/components/index.d.cts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import react__default, { ErrorInfo } from 'react';
+import { FallbackProps } from 'react-error-boundary';
+export { FallbackProps } from 'react-error-boundary';
+import { createRouter } from '@btst/yar';
+
+/**
+ * Route type with optional components
+ */
+type RouteWithComponents = {
+    PageComponent?: react__default.ComponentType;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent?: react__default.ComponentType;
+} | null | undefined;
+/**
+ * Composes the route content with Suspense and Error Boundary
+ * Resolves the route on the client-side where component references are available
+ *
+ * This is marked "use client" so it can access component references safely
+ */
+declare function RouteRenderer({ router, path, NotFoundComponent, onNotFound, onError, props, }: {
+    router: ReturnType<typeof createRouter>;
+    path: string;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    onNotFound?: () => never;
+    onError: (error: Error, info: ErrorInfo) => void;
+    props?: any;
+}): react_jsx_runtime.JSX.Element;
+declare function ComposedRoute({ path, PageComponent, ErrorComponent, LoadingComponent, onNotFound, NotFoundComponent, props, onError, }: {
+    path: string;
+    PageComponent: react__default.ComponentType<any>;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent: react__default.ComponentType;
+    onNotFound?: () => never;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    props?: any;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element | undefined;
+
+declare function ErrorBoundary({ children, FallbackComponent, resetKeys, onError, }: {
+    children: React.ReactNode;
+    FallbackComponent: React.ComponentType<FallbackProps>;
+    resetKeys?: Array<string | number | boolean | null | undefined>;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element;
+
+export { ComposedRoute, ErrorBoundary, RouteRenderer };
+export type { RouteWithComponents };

package/dist/client/components/index.d.mts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import react__default, { ErrorInfo } from 'react';
+import { FallbackProps } from 'react-error-boundary';
+export { FallbackProps } from 'react-error-boundary';
+import { createRouter } from '@btst/yar';
+
+/**
+ * Route type with optional components
+ */
+type RouteWithComponents = {
+    PageComponent?: react__default.ComponentType;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent?: react__default.ComponentType;
+} | null | undefined;
+/**
+ * Composes the route content with Suspense and Error Boundary
+ * Resolves the route on the client-side where component references are available
+ *
+ * This is marked "use client" so it can access component references safely
+ */
+declare function RouteRenderer({ router, path, NotFoundComponent, onNotFound, onError, props, }: {
+    router: ReturnType<typeof createRouter>;
+    path: string;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    onNotFound?: () => never;
+    onError: (error: Error, info: ErrorInfo) => void;
+    props?: any;
+}): react_jsx_runtime.JSX.Element;
+declare function ComposedRoute({ path, PageComponent, ErrorComponent, LoadingComponent, onNotFound, NotFoundComponent, props, onError, }: {
+    path: string;
+    PageComponent: react__default.ComponentType<any>;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent: react__default.ComponentType;
+    onNotFound?: () => never;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    props?: any;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element | undefined;
+
+declare function ErrorBoundary({ children, FallbackComponent, resetKeys, onError, }: {
+    children: React.ReactNode;
+    FallbackComponent: React.ComponentType<FallbackProps>;
+    resetKeys?: Array<string | number | boolean | null | undefined>;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element;
+
+export { ComposedRoute, ErrorBoundary, RouteRenderer };
+export type { RouteWithComponents };

package/dist/client/components/index.d.ts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import react__default, { ErrorInfo } from 'react';
+import { FallbackProps } from 'react-error-boundary';
+export { FallbackProps } from 'react-error-boundary';
+import { createRouter } from '@btst/yar';
+
+/**
+ * Route type with optional components
+ */
+type RouteWithComponents = {
+    PageComponent?: react__default.ComponentType;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent?: react__default.ComponentType;
+} | null | undefined;
+/**
+ * Composes the route content with Suspense and Error Boundary
+ * Resolves the route on the client-side where component references are available
+ *
+ * This is marked "use client" so it can access component references safely
+ */
+declare function RouteRenderer({ router, path, NotFoundComponent, onNotFound, onError, props, }: {
+    router: ReturnType<typeof createRouter>;
+    path: string;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    onNotFound?: () => never;
+    onError: (error: Error, info: ErrorInfo) => void;
+    props?: any;
+}): react_jsx_runtime.JSX.Element;
+declare function ComposedRoute({ path, PageComponent, ErrorComponent, LoadingComponent, onNotFound, NotFoundComponent, props, onError, }: {
+    path: string;
+    PageComponent: react__default.ComponentType<any>;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent: react__default.ComponentType;
+    onNotFound?: () => never;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    props?: any;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element | undefined;
+
+declare function ErrorBoundary({ children, FallbackComponent, resetKeys, onError, }: {
+    children: React.ReactNode;
+    FallbackComponent: React.ComponentType<FallbackProps>;
+    resetKeys?: Array<string | number | boolean | null | undefined>;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element;
+
+export { ComposedRoute, ErrorBoundary, RouteRenderer };
+export type { RouteWithComponents };

package/dist/client/components/index.mjs

@@ -0,0 +1,2 @@
+export { ComposedRoute, RouteRenderer } from './compose.mjs';
+export { ErrorBoundary } from './error-boundary.mjs';

package/dist/client/index.cjs

@@ -1,8 +1,9 @@
 'use strict';
 
 const yar = require('@btst/yar');
-const utils = require('../shared/stack.CktCg4PJ.cjs');
-require('better-call/client');
+const sitemapUtils = require('./sitemap-utils.cjs');
+const metaUtils = require('./meta-utils.cjs');
+const pathUtils = require('./path-utils.cjs');
 
 function createStackClient(config) {
   const { plugins } = config;
@@ -13,10 +14,28 @@ function createStackClient(config) {
   }
   const router = yar.createRouter(allRoutes);
   return {
-    router
+    router,
+    async generateSitemap() {
+      const sitemapEntries = [];
+      for (const plugin of Object.values(plugins)) {
+        if (typeof plugin.sitemap === "function") {
+          const entries = await plugin.sitemap();
+          if (Array.isArray(entries)) sitemapEntries.push(...entries);
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      const deduped = [];
+      for (const entry of sitemapEntries) {
+        if (!entry?.url || seen.has(entry.url)) continue;
+        seen.add(entry.url);
+        deduped.push(entry);
+      }
+      return deduped;
+    }
   };
 }
 
-exports.createRoute = yar.createRoute;
-exports.createApiClient = utils.createApiClient;
+exports.sitemapEntryToXmlString = sitemapUtils.sitemapEntryToXmlString;
+exports.metaElementsToObject = metaUtils.metaElementsToObject;
+exports.normalizePath = pathUtils.normalizePath;
 exports.createStackClient = createStackClient;

package/dist/client/index.d.cts

@@ -1,9 +1,99 @@
-import { C as ClientPlugin, P as PluginRoutes, a as ClientLibConfig, b as ClientLib } from '../shared/stack.DORw_1ps.cjs';
-export { createRoute } from '@btst/yar';
-export { c as createApiClient } from '../shared/stack.DrUAVfIH.cjs';
+import { S as Sitemap, C as ClientPlugin, a as PluginRoutes, b as ClientLibConfig, c as ClientLib } from '../shared/stack.ByOugz9d.cjs';
+import '@btst/yar';
 import '@btst/db';
 import 'better-call';
-import 'better-call/client';
+
+/**
+ * Converts an array of sitemap entries into an XML string following the sitemap.org protocol.
+ *
+ * @param entries - Array of sitemap entries from `lib.generateSitemap()`
+ * @returns Complete XML string for the sitemap
+ *
+ * @example
+ * ```ts
+ * const entries = await lib.generateSitemap();
+ * const xml = sitemapEntryToXmlString(entries);
+ * return new Response(xml, {
+ *   headers: { "Content-Type": "application/xml; charset=utf-8" }
+ * });
+ * ```
+ */
+declare function sitemapEntryToXmlString(entries: Sitemap): string;
+
+interface Metadata {
+    title: string;
+    description?: string;
+    keywords?: string[];
+    applicationName?: string;
+    generator?: string;
+    referrer?: "no-referrer" | "origin" | "no-referrer-when-downgrade" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin";
+    themeColor?: string;
+    viewport?: string;
+    creator?: string;
+    publisher?: string;
+    authors?: {
+        name: string;
+    }[];
+    abstract?: string;
+    robots?: string;
+    alternates?: Partial<{
+        canonical: string;
+    }>;
+    twitter?: Partial<{
+        title: string;
+        description: string;
+        site: string;
+        creator: string;
+        images?: string[];
+    }>;
+    openGraph?: Partial<{
+        title: string;
+        description: string;
+        url: string;
+        siteName: string;
+        locale: string;
+        images?: string[];
+        videos?: string[];
+        audio?: string[];
+    }>;
+}
+/**
+ * Converts an array of meta elements to a metadata object
+ * @param metaElements - An array of meta elements
+ * @example
+ * ```ts
+ * const metaElements = [
+ *   { name: "title", content: "My Page" },
+ *   { name: "description", content: "This is my page" },
+ * ];
+ * const metadata = metaElementsToObject(metaElements);
+ * console.log(metadata);
+ * ```
+ */
+declare function metaElementsToObject(metaElements: Array<React.JSX.IntrinsicElements["meta"] | undefined>): Metadata;
+
+/**
+ * Normalizes path segments from framework route params into a consistent path string.
+ *
+ * Handles different framework param formats:
+ * - Next.js: `pathParams.all` (string[])
+ * - React Router: `params["*"]` (string)
+ * - TanStack Router: `params._splat` (string)
+ *
+ * @param path - Path segments as string, string array, or undefined
+ * @returns Normalized path string starting with "/" (or "/" for empty/undefined)
+ *
+ * @example
+ * ```ts
+ * // Next.js
+ * normalizePath(pathParams?.all) // ["blog", "post"] => "/blog/post"
+ *
+ * // React Router / TanStack Router
+ * normalizePath(params["*"]) // "blog/post" => "/blog/post"
+ * normalizePath(undefined) // => "/"
+ * ```
+ */
+declare function normalizePath(path?: string | Array<string> | undefined): string;
 
 /**
  * Creates the client library with plugin support
@@ -13,12 +103,39 @@ import 'better-call/client';
  * // For Next.js with SSR:
  * const lib = createStackClient({
  *   plugins: {
- *     messages: messagesPlugin.client
+ *     blog: blogPlugin.client
  *   }
  * });
  *
- * // Access router for page routing
- * const route = lib.router.getRoute('/messages');
+ * // SPA usage - just render the route
+ * function Page() {
+ *   return lib.resolveRoute('/blog');
+ * }
+ *
+ * // SSR usage - prefetch data with loader, then render
+ * async function Page({ params }) {
+ *   const path = '/blog';
+ *
+ *   // Load data server-side if loader exists
+ *   const loader = lib.getLoader(path);
+ *   if (loader) await loader(queryClient, baseURL, basePath);
+ *
+ *   // Render with built-in Suspense + Error Boundary
+ *   return lib.resolveRoute(path);
+ * }
+ *
+ * // Next.js with notFound() function
+ * import { notFound } from 'next/navigation';
+ *
+ * async function Page({ params }) {
+ *   const path = '/blog';
+ *   const loader = lib.getLoader(path);
+ *   if (loader) await loader(queryClient, baseURL);
+ *
+ *   return lib.resolveRoute(path, {
+ *     onNotFound: notFound // Calls Next.js notFound() instead of rendering
+ *   });
+ * }
  *
  * ```
  *
@@ -27,4 +144,4 @@ import 'better-call/client';
  */
 declare function createStackClient<TPlugins extends Record<string, ClientPlugin<any, any>>, TRoutes extends PluginRoutes<TPlugins> = PluginRoutes<TPlugins>>(config: ClientLibConfig<TPlugins>): ClientLib<TRoutes>;
 
-export { ClientLib, ClientLibConfig, ClientPlugin, createStackClient };
+export { ClientLib, ClientLibConfig, ClientPlugin, createStackClient, metaElementsToObject, normalizePath, sitemapEntryToXmlString };