@btst/stack 1.3.1 → 1.4.0

package/dist/packages/better-stack/src/plugins/ai-chat/client/plugin.cjs

@@ -0,0 +1,241 @@
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const client = require('@btst/stack/plugins/client');
+const yar = require('@btst/yar');
+const plugins_aiChat_queryKeys = require('../../../../../../plugins/ai-chat/query-keys.cjs');
+const chatLayout = require('./components/chat-layout.cjs');
+
+function createConversationsLoader(config) {
+  return async () => {
+    if (config.mode === "public") {
+      return;
+    }
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: "/chat",
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadConversations) {
+          const canLoad = await hooks.beforeLoadConversations(context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadConversations hook");
+          }
+        }
+        const client$1 = client.createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath
+        });
+        const queries = plugins_aiChat_queryKeys.createAiChatQueryKeys(client$1, headers);
+        const listQuery = queries.conversations.list();
+        await queryClient.prefetchQuery(listQuery);
+        if (hooks?.afterLoadConversations) {
+          const conversations = queryClient.getQueryData(
+            listQuery.queryKey
+          ) || null;
+          const canContinue = await hooks.afterLoadConversations(
+            conversations,
+            context
+          );
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadConversations hook");
+          }
+        }
+        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);
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createConversationLoader(id, config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: `/chat/${id}`,
+        params: { id },
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadConversation) {
+          const canLoad = await hooks.beforeLoadConversation(id, context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadConversation hook");
+          }
+        }
+        const client$1 = client.createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath
+        });
+        const queries = plugins_aiChat_queryKeys.createAiChatQueryKeys(client$1, headers);
+        const conversationQuery = queries.conversations.detail(id);
+        const listQuery = queries.conversations.list();
+        await Promise.all([
+          queryClient.prefetchQuery(conversationQuery),
+          queryClient.prefetchQuery(listQuery)
+        ]);
+        if (hooks?.afterLoadConversation) {
+          const conversation = queryClient.getQueryData(conversationQuery.queryKey) || null;
+          const canContinue = await hooks.afterLoadConversation(
+            conversation,
+            id,
+            context
+          );
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadConversation hook");
+          }
+        }
+        const queryState = queryClient.getQueryState(
+          conversationQuery.queryKey
+        );
+        if (queryState?.error && hooks?.onLoadError) {
+          const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
+          await hooks.onLoadError(error, context);
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createChatHomeMeta(config) {
+  return () => {
+    const { siteBaseURL, siteBasePath, seo } = config;
+    const fullUrl = `${siteBaseURL}${siteBasePath}/chat`;
+    const title = "Chat";
+    const description = seo?.description || "Start a conversation with AI";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: description },
+      { name: "robots", content: "noindex, nofollow" },
+      // Chat pages typically shouldn't be indexed
+      // Open Graph
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:url", content: fullUrl },
+      ...seo?.siteName ? [{ property: "og:site_name", content: seo.siteName }] : [],
+      ...seo?.locale ? [{ property: "og:locale", content: seo.locale }] : [],
+      ...seo?.defaultImage ? [{ property: "og:image", content: seo.defaultImage }] : [],
+      // Twitter
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title },
+      { name: "twitter:description", content: description }
+    ];
+  };
+}
+function createConversationMeta(id, config) {
+  return () => {
+    const {
+      queryClient,
+      apiBaseURL,
+      apiBasePath,
+      siteBaseURL,
+      siteBasePath,
+      seo
+    } = config;
+    const queries = plugins_aiChat_queryKeys.createAiChatQueryKeys(
+      client.createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      })
+    );
+    const conversation = queryClient.getQueryData(queries.conversations.detail(id).queryKey);
+    const fullUrl = `${siteBaseURL}${siteBasePath}/chat/${id}`;
+    const title = conversation?.title || "Chat";
+    const description = seo?.description || "AI conversation";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: description },
+      { name: "robots", content: "noindex, nofollow" },
+      // Open Graph
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:url", content: fullUrl },
+      ...seo?.siteName ? [{ property: "og:site_name", content: seo.siteName }] : [],
+      // Twitter
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title }
+    ];
+  };
+}
+const aiChatClientPlugin = (config) => {
+  const isPublicMode = config.mode === "public";
+  if (isPublicMode) {
+    return client.defineClientPlugin({
+      name: "ai-chat",
+      routes: () => ({
+        // Chat home - simple chat interface without history
+        chat: yar.createRoute("/chat", () => ({
+          PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(
+            chatLayout.ChatLayout,
+            {
+              apiBaseURL: config.apiBaseURL,
+              apiBasePath: config.apiBasePath,
+              showSidebar: false
+            }
+          ),
+          loader: createConversationsLoader(config),
+          meta: createChatHomeMeta(config)
+        }))
+      }),
+      sitemap: async () => []
+    });
+  }
+  return client.defineClientPlugin({
+    name: "ai-chat",
+    routes: () => ({
+      // Chat home - new conversation or list
+      chat: yar.createRoute("/chat", () => ({
+        PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(
+          chatLayout.ChatLayout,
+          {
+            apiBaseURL: config.apiBaseURL,
+            apiBasePath: config.apiBasePath
+          }
+        ),
+        loader: createConversationsLoader(config),
+        meta: createChatHomeMeta(config)
+      })),
+      // Existing conversation
+      chatConversation: yar.createRoute("/chat/:id", ({ params }) => ({
+        PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(
+          chatLayout.ChatLayout,
+          {
+            apiBaseURL: config.apiBaseURL,
+            apiBasePath: config.apiBasePath,
+            conversationId: params.id
+          }
+        ),
+        loader: createConversationLoader(params.id, config),
+        meta: createConversationMeta(params.id, config)
+      }))
+    }),
+    // Chat pages typically shouldn't be in sitemap, but we provide the option
+    sitemap: async () => {
+      return [];
+    }
+  });
+};
+
+exports.aiChatClientPlugin = aiChatClientPlugin;

package/dist/packages/better-stack/src/plugins/ai-chat/client/plugin.mjs

@@ -0,0 +1,239 @@
+import { jsx } from 'react/jsx-runtime';
+import { defineClientPlugin, createApiClient } from '@btst/stack/plugins/client';
+import { createRoute } from '@btst/yar';
+import { createAiChatQueryKeys } from '../../../../../../plugins/ai-chat/query-keys.mjs';
+import { ChatLayout } from './components/chat-layout.mjs';
+
+function createConversationsLoader(config) {
+  return async () => {
+    if (config.mode === "public") {
+      return;
+    }
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: "/chat",
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadConversations) {
+          const canLoad = await hooks.beforeLoadConversations(context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadConversations hook");
+          }
+        }
+        const client = createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath
+        });
+        const queries = createAiChatQueryKeys(client, headers);
+        const listQuery = queries.conversations.list();
+        await queryClient.prefetchQuery(listQuery);
+        if (hooks?.afterLoadConversations) {
+          const conversations = queryClient.getQueryData(
+            listQuery.queryKey
+          ) || null;
+          const canContinue = await hooks.afterLoadConversations(
+            conversations,
+            context
+          );
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadConversations hook");
+          }
+        }
+        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);
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createConversationLoader(id, config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: `/chat/${id}`,
+        params: { id },
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadConversation) {
+          const canLoad = await hooks.beforeLoadConversation(id, context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadConversation hook");
+          }
+        }
+        const client = createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath
+        });
+        const queries = createAiChatQueryKeys(client, headers);
+        const conversationQuery = queries.conversations.detail(id);
+        const listQuery = queries.conversations.list();
+        await Promise.all([
+          queryClient.prefetchQuery(conversationQuery),
+          queryClient.prefetchQuery(listQuery)
+        ]);
+        if (hooks?.afterLoadConversation) {
+          const conversation = queryClient.getQueryData(conversationQuery.queryKey) || null;
+          const canContinue = await hooks.afterLoadConversation(
+            conversation,
+            id,
+            context
+          );
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadConversation hook");
+          }
+        }
+        const queryState = queryClient.getQueryState(
+          conversationQuery.queryKey
+        );
+        if (queryState?.error && hooks?.onLoadError) {
+          const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
+          await hooks.onLoadError(error, context);
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createChatHomeMeta(config) {
+  return () => {
+    const { siteBaseURL, siteBasePath, seo } = config;
+    const fullUrl = `${siteBaseURL}${siteBasePath}/chat`;
+    const title = "Chat";
+    const description = seo?.description || "Start a conversation with AI";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: description },
+      { name: "robots", content: "noindex, nofollow" },
+      // Chat pages typically shouldn't be indexed
+      // Open Graph
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:url", content: fullUrl },
+      ...seo?.siteName ? [{ property: "og:site_name", content: seo.siteName }] : [],
+      ...seo?.locale ? [{ property: "og:locale", content: seo.locale }] : [],
+      ...seo?.defaultImage ? [{ property: "og:image", content: seo.defaultImage }] : [],
+      // Twitter
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title },
+      { name: "twitter:description", content: description }
+    ];
+  };
+}
+function createConversationMeta(id, config) {
+  return () => {
+    const {
+      queryClient,
+      apiBaseURL,
+      apiBasePath,
+      siteBaseURL,
+      siteBasePath,
+      seo
+    } = config;
+    const queries = createAiChatQueryKeys(
+      createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      })
+    );
+    const conversation = queryClient.getQueryData(queries.conversations.detail(id).queryKey);
+    const fullUrl = `${siteBaseURL}${siteBasePath}/chat/${id}`;
+    const title = conversation?.title || "Chat";
+    const description = seo?.description || "AI conversation";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: description },
+      { name: "robots", content: "noindex, nofollow" },
+      // Open Graph
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:url", content: fullUrl },
+      ...seo?.siteName ? [{ property: "og:site_name", content: seo.siteName }] : [],
+      // Twitter
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title }
+    ];
+  };
+}
+const aiChatClientPlugin = (config) => {
+  const isPublicMode = config.mode === "public";
+  if (isPublicMode) {
+    return defineClientPlugin({
+      name: "ai-chat",
+      routes: () => ({
+        // Chat home - simple chat interface without history
+        chat: createRoute("/chat", () => ({
+          PageComponent: () => /* @__PURE__ */ jsx(
+            ChatLayout,
+            {
+              apiBaseURL: config.apiBaseURL,
+              apiBasePath: config.apiBasePath,
+              showSidebar: false
+            }
+          ),
+          loader: createConversationsLoader(config),
+          meta: createChatHomeMeta(config)
+        }))
+      }),
+      sitemap: async () => []
+    });
+  }
+  return defineClientPlugin({
+    name: "ai-chat",
+    routes: () => ({
+      // Chat home - new conversation or list
+      chat: createRoute("/chat", () => ({
+        PageComponent: () => /* @__PURE__ */ jsx(
+          ChatLayout,
+          {
+            apiBaseURL: config.apiBaseURL,
+            apiBasePath: config.apiBasePath
+          }
+        ),
+        loader: createConversationsLoader(config),
+        meta: createChatHomeMeta(config)
+      })),
+      // Existing conversation
+      chatConversation: createRoute("/chat/:id", ({ params }) => ({
+        PageComponent: () => /* @__PURE__ */ jsx(
+          ChatLayout,
+          {
+            apiBaseURL: config.apiBaseURL,
+            apiBasePath: config.apiBasePath,
+            conversationId: params.id
+          }
+        ),
+        loader: createConversationLoader(params.id, config),
+        meta: createConversationMeta(params.id, config)
+      }))
+    }),
+    // Chat pages typically shouldn't be in sitemap, but we provide the option
+    sitemap: async () => {
+      return [];
+    }
+  });
+};
+
+export { aiChatClientPlugin };

package/dist/packages/better-stack/src/plugins/ai-chat/db.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+const db = require('@btst/db');
+
+const aiChatSchema = db.createDbPlugin("aiChat", {
+  conversation: {
+    modelName: "conversation",
+    fields: {
+      id: {
+        type: "string",
+        required: true,
+        unique: true
+      },
+      userId: {
+        type: "string",
+        required: false
+      },
+      title: {
+        type: "string",
+        required: true
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  },
+  message: {
+    modelName: "message",
+    fields: {
+      id: {
+        type: "string",
+        required: true,
+        unique: true
+      },
+      conversationId: {
+        type: "string",
+        required: true,
+        references: {
+          model: "conversation",
+          field: "id",
+          onDelete: "cascade"
+        }
+      },
+      role: {
+        type: "string",
+        required: true
+      },
+      content: {
+        type: "string",
+        required: true
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  }
+});
+
+exports.aiChatSchema = aiChatSchema;

package/dist/packages/better-stack/src/plugins/ai-chat/db.mjs

@@ -0,0 +1,63 @@
+import { createDbPlugin } from '@btst/db';
+
+const aiChatSchema = createDbPlugin("aiChat", {
+  conversation: {
+    modelName: "conversation",
+    fields: {
+      id: {
+        type: "string",
+        required: true,
+        unique: true
+      },
+      userId: {
+        type: "string",
+        required: false
+      },
+      title: {
+        type: "string",
+        required: true
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  },
+  message: {
+    modelName: "message",
+    fields: {
+      id: {
+        type: "string",
+        required: true,
+        unique: true
+      },
+      conversationId: {
+        type: "string",
+        required: true,
+        references: {
+          model: "conversation",
+          field: "id",
+          onDelete: "cascade"
+        }
+      },
+      role: {
+        type: "string",
+        required: true
+      },
+      content: {
+        type: "string",
+        required: true
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  }
+});
+
+export { aiChatSchema };

package/dist/packages/better-stack/src/plugins/ai-chat/schemas.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+const zod = require('zod');
+
+const createConversationSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  title: zod.z.string().optional()
+});
+const updateConversationSchema = zod.z.object({
+  title: zod.z.string().optional()
+});
+const chatRequestSchema = zod.z.object({
+  messages: zod.z.array(
+    zod.z.union([
+      // Format with content string
+      zod.z.object({
+        role: zod.z.enum(["system", "user", "assistant", "data"]),
+        content: zod.z.string(),
+        id: zod.z.string().optional()
+      }),
+      // Format with parts array (from UIMessage)
+      zod.z.object({
+        role: zod.z.enum(["system", "user", "assistant", "data"]),
+        parts: zod.z.array(
+          zod.z.object({
+            type: zod.z.string(),
+            text: zod.z.string().optional()
+            // Allow other properties that might be present
+          }).loose()
+        ),
+        id: zod.z.string().optional(),
+        metadata: zod.z.any().optional()
+      })
+    ])
+  ),
+  conversationId: zod.z.string().optional(),
+  model: zod.z.string().optional()
+});
+
+exports.chatRequestSchema = chatRequestSchema;
+exports.createConversationSchema = createConversationSchema;
+exports.updateConversationSchema = updateConversationSchema;

package/dist/packages/better-stack/src/plugins/ai-chat/schemas.mjs

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+
+const createConversationSchema = z.object({
+  id: z.string().optional(),
+  title: z.string().optional()
+});
+const updateConversationSchema = z.object({
+  title: z.string().optional()
+});
+const chatRequestSchema = z.object({
+  messages: z.array(
+    z.union([
+      // Format with content string
+      z.object({
+        role: z.enum(["system", "user", "assistant", "data"]),
+        content: z.string(),
+        id: z.string().optional()
+      }),
+      // Format with parts array (from UIMessage)
+      z.object({
+        role: z.enum(["system", "user", "assistant", "data"]),
+        parts: z.array(
+          z.object({
+            type: z.string(),
+            text: z.string().optional()
+            // Allow other properties that might be present
+          }).loose()
+        ),
+        id: z.string().optional(),
+        metadata: z.any().optional()
+      })
+    ])
+  ),
+  conversationId: z.string().optional(),
+  model: z.string().optional()
+});
+
+export { chatRequestSchema, createConversationSchema, updateConversationSchema };