@meistrari/chat-nuxt 1.2.3 → 1.4.0

package/dist/runtime/composables/useChatAction.d.ts

@@ -0,0 +1,10 @@
+export type ChatActionPayload = {
+    name: string;
+    data: unknown;
+    messageId?: string;
+};
+export type ChatActionHandler = (payload: ChatActionPayload) => void;
+export declare function provideChatAction(handler: ChatActionHandler): void;
+export declare function useChatAction(): {
+    emit(name: string, data?: unknown, messageId?: string): void;
+};

package/dist/runtime/composables/useChatAction.js

@@ -0,0 +1,12 @@
+const CHAT_ACTION_KEY = Symbol("chat-nuxt:action");
+export function provideChatAction(handler) {
+  provide(CHAT_ACTION_KEY, handler);
+}
+export function useChatAction() {
+  const handler = inject(CHAT_ACTION_KEY, null);
+  return {
+    emit(name, data, messageId) {
+      handler?.({ name, data, messageId });
+    }
+  };
+}

package/dist/runtime/composables/useEmbedConfig.d.ts

@@ -1,14 +1,23 @@
-import type { DeepReadonly, MaybeRefOrGetter, Ref } from 'vue';
+import type { Component, DeepReadonly, MaybeRefOrGetter, Ref } from 'vue';
+import type { ChatLoadingMessageMode } from '../utils/chat-loading-messages.js';
 import type { WorkspaceSettings } from './useWorkspaceSettings.js';
 export type EmbedConfig = {
     workspaceId: Ref<string>;
     workspaceSettings: Ref<DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null | undefined>;
     hideSidebar: Ref<boolean>;
+    loadingMessages: Ref<readonly string[] | null | undefined>;
+    loadingMessagesMode: Ref<ChatLoadingMessageMode | null | undefined>;
+    customComponents: Ref<Record<string, Component> | undefined>;
+    customHtmlTags: Ref<readonly string[] | undefined>;
 };
 type EmbedConfigInput = {
     workspaceId: MaybeRefOrGetter<string>;
     workspaceSettings?: MaybeRefOrGetter<DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null | undefined>;
     hideSidebar?: MaybeRefOrGetter<boolean | undefined>;
+    loadingMessages?: MaybeRefOrGetter<readonly string[] | null | undefined>;
+    loadingMessagesMode?: MaybeRefOrGetter<ChatLoadingMessageMode | null | undefined>;
+    customComponents?: MaybeRefOrGetter<Record<string, Component> | undefined>;
+    customHtmlTags?: MaybeRefOrGetter<readonly string[] | undefined>;
 };
 type ProvideEmbedConfigOptions = {
     syncGlobal?: boolean;

package/dist/runtime/composables/useEmbedConfig.js

@@ -1,17 +1,30 @@
 const EMBED_CONFIG_KEY = "embed-config";
+function useGlobalCustomComponentsState() {
+  const nuxtApp = useNuxtApp();
+  nuxtApp._chatEmbedConfigCustomComponents ??= shallowRef(void 0);
+  return nuxtApp._chatEmbedConfigCustomComponents;
+}
 function useGlobalEmbedConfigState() {
   return {
     provided: useState("chat-embed-config-provided", () => false),
     workspaceId: useState("chat-embed-config-workspace-id", () => ""),
     workspaceSettings: useState("chat-embed-config-workspace-settings", () => void 0),
-    hideSidebar: useState("chat-embed-config-hide-sidebar", () => void 0)
+    hideSidebar: useState("chat-embed-config-hide-sidebar", () => void 0),
+    loadingMessages: useState("chat-embed-config-loading-messages", () => void 0),
+    loadingMessagesMode: useState("chat-embed-config-loading-messages-mode", () => void 0),
+    customComponents: useGlobalCustomComponentsState(),
+    customHtmlTags: useState("chat-embed-config-custom-html-tags", () => void 0)
   };
 }
 export function provideEmbedConfig(input, options = {}) {
   const config = {
     workspaceId: computed(() => toValue(input.workspaceId)),
     workspaceSettings: computed(() => toValue(input.workspaceSettings)),
-    hideSidebar: computed(() => toValue(input.hideSidebar) ?? true)
+    hideSidebar: computed(() => toValue(input.hideSidebar) ?? true),
+    loadingMessages: computed(() => toValue(input.loadingMessages)),
+    loadingMessagesMode: computed(() => toValue(input.loadingMessagesMode)),
+    customComponents: computed(() => toValue(input.customComponents)),
+    customHtmlTags: computed(() => toValue(input.customHtmlTags))
   };
   const globalConfig = useGlobalEmbedConfigState();
   if (options.syncGlobal ?? true) {
@@ -20,6 +33,10 @@ export function provideEmbedConfig(input, options = {}) {
       globalConfig.workspaceId.value = config.workspaceId.value;
       globalConfig.workspaceSettings.value = config.workspaceSettings.value;
       globalConfig.hideSidebar.value = config.hideSidebar.value;
+      globalConfig.loadingMessages.value = config.loadingMessages.value;
+      globalConfig.loadingMessagesMode.value = config.loadingMessagesMode.value;
+      globalConfig.customComponents.value = config.customComponents.value;
+      globalConfig.customHtmlTags.value = config.customHtmlTags.value;
     });
   }
   provide(EMBED_CONFIG_KEY, config);
@@ -34,6 +51,10 @@ export function useEmbedConfig() {
   return {
     workspaceId: computed(() => globalConfig.workspaceId.value),
     workspaceSettings: computed(() => globalConfig.workspaceSettings.value),
-    hideSidebar: computed(() => globalConfig.hideSidebar.value ?? true)
+    hideSidebar: computed(() => globalConfig.hideSidebar.value ?? true),
+    loadingMessages: computed(() => globalConfig.loadingMessages.value),
+    loadingMessagesMode: computed(() => globalConfig.loadingMessagesMode.value),
+    customComponents: computed(() => globalConfig.customComponents.value),
+    customHtmlTags: computed(() => globalConfig.customHtmlTags.value)
   };
 }

package/dist/runtime/embed/components/ChatConfigurationModal.vue

@@ -18,6 +18,7 @@ const {
   fetchSettings,
   updateSettings
 } = useWorkspaceSettings();
+const features = useChatNuxtFeatures();
 const searchQuery = ref("");
 const activeTab = ref(props.initialTab);
 const showDiscardConfirm = ref(false);
@@ -34,14 +35,14 @@ const telaTools = useWorkspaceTelaTools(canvas, projects, searchQuery, currentCa
 const knowledgeSources = useWorkspaceKnowledgeSources(workstations, canvas, projects, searchQuery, currentKnowledgeSources);
 const contextFiles = useWorkspaceContextFiles(searchQuery, currentContextFiles);
 const externalSkills = useWorkspaceExternalSkills(currentExternalSkills, searchQuery);
-const settingsTabs = [
+const settingsTabs = computed(() => [
   { value: "personalization", label: "Personaliza\xE7\xE3o", icon: "i-ph-sliders" },
   { value: "context-files", label: "Arquivos de contexto", icon: "i-ph-file-text" },
   { value: "knowledge-sources", label: "Tela workstations", icon: "i-ph-database" },
   { value: "tela-tools", label: "Skills Tela", icon: "i-ph-puzzle-piece" },
   { value: "external-skills", label: "Skills Externas", icon: "i-ph-wrench" },
-  { value: "credentials", label: "Credenciais", icon: "i-ph-password-bold" }
-];
+  ...features.credentials ? [{ value: "credentials", label: "Credenciais", icon: "i-ph-password-bold" }] : []
+]);
 const hasChanges = computed(
   () => personalization.hasChanges.value || contextFiles.hasChanges.value || telaTools.hasChanges.value || knowledgeSources.hasChanges.value || externalSkills.hasChanges.value
 );
@@ -84,9 +85,10 @@ function initializeConfigurationState() {
   externalSkills.initialize();
 }
 function activateTab(tab) {
-  activeTab.value = tab;
+  const isVisible = settingsTabs.value.some((t) => t.value === tab);
+  activeTab.value = isVisible ? tab : "personalization";
   searchQuery.value = "";
-  if (tab === "external-skills")
+  if (activeTab.value === "external-skills")
     void externalSkills.fetchGitHubConnection();
 }
 async function loadSettings() {
@@ -336,7 +338,7 @@ function cancelDiscard() {
                     />
 
                     <ChatConfigurationCredentialsTab
-                        v-else-if="activeTab === 'credentials'"
+                        v-else-if="activeTab === 'credentials' && features.credentials"
                         :search-query="searchQuery"
                         @update:search-query="searchQuery = $event"
                     />

package/dist/runtime/embed/components/ChatEmbed.d.vue.ts

@@ -1,20 +1,27 @@
-import type { DeepReadonly } from 'vue';
+import type { Component, DeepReadonly } from 'vue';
+import { type ChatActionPayload } from '../../composables/useChatAction.js';
 import type { WorkspaceSettings } from '../../composables/useWorkspaceSettings.js';
+import type { ChatLoadingMessageMode } from '../../utils/chat-loading-messages.js';
 import type { ChatActor, ChatFeatureConfig } from '../../utils/tela-chat.js';
 type EmbedUser = ChatActor;
 type __VLS_Props = {
-    workspaceId: string;
     workspaceSettings?: DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null;
     conversationId?: string | null;
     initialConversationId?: string | null;
     hideSidebar?: boolean;
     user?: EmbedUser | null;
     features?: Partial<ChatFeatureConfig>;
+    loadingMessages?: readonly string[] | null;
+    loadingMessagesMode?: ChatLoadingMessageMode | null;
+    customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:conversationId": (value: string | null) => any;
+    action: (payload: ChatActionPayload) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:conversationId"?: ((value: string | null) => any) | undefined;
+    onAction?: ((payload: ChatActionPayload) => any) | undefined;
 }>, {
     initialConversationId: string | null;
     hideSidebar: boolean;

package/dist/runtime/embed/components/ChatEmbed.vue

@@ -1,32 +1,41 @@
 <script setup>
 import { provideEmbedConfig, useEmbedConfig } from "../../composables/useEmbedConfig";
+import { provideChatAction } from "../../composables/useChatAction";
 import ChatEmbedInner from "./ChatEmbedInner.vue";
 const props = defineProps({
-  workspaceId: { type: String, required: true },
   workspaceSettings: { type: null, required: false },
   conversationId: { type: [String, null], required: false },
   initialConversationId: { type: [String, null], required: false, default: null },
   hideSidebar: { type: Boolean, required: false, default: true },
   user: { type: [Object, null], required: false },
-  features: { type: Object, required: false }
+  features: { type: Object, required: false },
+  loadingMessages: { type: [Array, null], required: false },
+  loadingMessagesMode: { type: [String, null], required: false },
+  customComponents: { type: Object, required: false },
+  customHtmlTags: { type: Array, required: false }
 });
-defineEmits(["update:conversationId"]);
+const emit = defineEmits(["update:conversationId", "action"]);
 const parentEmbedConfig = useEmbedConfig();
-if (import.meta.dev && parentEmbedConfig) {
-  watchEffect(() => {
-    const parentWorkspaceId = parentEmbedConfig.workspaceId.value.trim();
-    const propWorkspaceId = props.workspaceId.trim();
-    if (parentWorkspaceId && propWorkspaceId && parentWorkspaceId !== propWorkspaceId) {
-      console.warn(`[MeistrariChatEmbed] workspaceId prop (${propWorkspaceId}) differs from parent embed config (${parentWorkspaceId}); using prop value for this embed.`);
-    }
-  });
-}
-provideEmbedConfig(props, { syncGlobal: !parentEmbedConfig });
+const { activeOrganization } = useTelaApplicationAuth();
+const workspaceId = computed(() => activeOrganization.value?.id?.trim() ?? "");
+provideEmbedConfig({
+  workspaceId,
+  workspaceSettings: computed(() => props.workspaceSettings),
+  hideSidebar: computed(() => props.hideSidebar),
+  loadingMessages: computed(() => props.loadingMessages),
+  loadingMessagesMode: computed(() => props.loadingMessagesMode),
+  customComponents: computed(() => props.customComponents),
+  customHtmlTags: computed(() => props.customHtmlTags)
+}, { syncGlobal: !parentEmbedConfig });
+provideChatAction((payload) => {
+  emit("action", payload);
+});
 </script>
 
 <template>
     <!-- Force a clean state namespace when the workspace changes. -->
     <ChatEmbedInner
+        v-if="workspaceId"
         :key="workspaceId"
         :conversation-id="conversationId"
         :initial-conversation-id="initialConversationId"

package/dist/runtime/embed/components/ChatEmbed.vue.d.ts

@@ -1,20 +1,27 @@
-import type { DeepReadonly } from 'vue';
+import type { Component, DeepReadonly } from 'vue';
+import { type ChatActionPayload } from '../../composables/useChatAction.js';
 import type { WorkspaceSettings } from '../../composables/useWorkspaceSettings.js';
+import type { ChatLoadingMessageMode } from '../../utils/chat-loading-messages.js';
 import type { ChatActor, ChatFeatureConfig } from '../../utils/tela-chat.js';
 type EmbedUser = ChatActor;
 type __VLS_Props = {
-    workspaceId: string;
     workspaceSettings?: DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null;
     conversationId?: string | null;
     initialConversationId?: string | null;
     hideSidebar?: boolean;
     user?: EmbedUser | null;
     features?: Partial<ChatFeatureConfig>;
+    loadingMessages?: readonly string[] | null;
+    loadingMessagesMode?: ChatLoadingMessageMode | null;
+    customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:conversationId": (value: string | null) => any;
+    action: (payload: ChatActionPayload) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:conversationId"?: ((value: string | null) => any) | undefined;
+    onAction?: ((payload: ChatActionPayload) => any) | undefined;
 }>, {
     initialConversationId: string | null;
     hideSidebar: boolean;

package/dist/runtime/embed/components/ChatEmbedInner.vue

@@ -28,7 +28,11 @@ const activeConversationId = ref(
 );
 const loadingConversationId = ref(null);
 const isReady = ref(false);
-const resolvedFeatures = computed(() => resolveChatFeatures(props.features));
+const moduleFeatures = useChatNuxtFeatures();
+const resolvedFeatures = computed(() => resolveChatFeatures({
+  showUsageTab: moduleFeatures.usage ?? props.features?.showUsageTab,
+  showDebugOption: props.features?.showDebugOption
+}));
 const dropZoneRef = ref(null);
 const activeTab = ref("chat");
 const messageInputRef = ref(null);

package/dist/runtime/server/api/conversations/[id]/messages/[messageId]/retry.post.js

@@ -13,6 +13,7 @@ import {
   serializeResolvedWorkspaceSettings
 } from "#chat-runtime/server/utils/chat-workspace-settings";
 import { resolveWorkspaceCredentials } from "#chat-runtime/server/utils/workspace";
+import { useChatNuxtFeatures } from "#chat-runtime/utils/features";
 import { mergeFileUrls } from "#chat-runtime/utils/file";
 import { isValidModel } from "#chat-runtime/types/chat";
 export default defineEventHandler(async (event) => {
@@ -107,10 +108,12 @@ export default defineEventHandler(async (event) => {
     try {
       if (needsNewThread) {
         let environmentVariables = {};
-        try {
-          environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
-        } catch (error) {
-          logger.warn({ conversationId, messageId, error }, "Failed to resolve workspace credentials on retry, proceeding without env vars");
+        if (useChatNuxtFeatures().credentials) {
+          try {
+            environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
+          } catch (error) {
+            logger.warn({ conversationId, messageId, error }, "Failed to resolve workspace credentials on retry, proceeding without env vars");
+          }
         }
         const hasEnvironmentVariables = Object.keys(environmentVariables).length > 0;
         const result = await createChatAgentSession(token, {

package/dist/runtime/server/api/conversations/[id]/messages/index.get.js

@@ -131,7 +131,7 @@ export default defineEventHandler(async (event) => {
       }
       if (agentSession.status === "completed" || agentSession.status === "waiting_messages") {
         if (hasNewReasoning) {
-          const content = extractContentFromSession(agentSession, newReasoning);
+          const content = extractContentFromSession(agentSession);
           updateData.content = content;
           updateData.status = "completed";
           updateData.updatedAt = /* @__PURE__ */ new Date();

package/dist/runtime/server/api/conversations/[id]/messages/index.post.js

@@ -9,10 +9,12 @@ import { logger } from "#chat-runtime/server/utils/logger";
 import {
   getConversationAppliedSettings,
   getWorkspaceSettingsUpdatedAt,
+  parseWorkspaceSettingsSnapshot,
   resolveWorkspaceSettings,
   serializeResolvedWorkspaceSettings
 } from "#chat-runtime/server/utils/chat-workspace-settings";
 import { resolveWorkspaceCredentials } from "#chat-runtime/server/utils/workspace";
+import { useChatNuxtFeatures } from "#chat-runtime/utils/features";
 import { mergeFileUrls } from "#chat-runtime/utils/file";
 import { isValidModel } from "#chat-runtime/types/chat";
 export default defineEventHandler(async (event) => {
@@ -52,14 +54,16 @@ export default defineEventHandler(async (event) => {
     });
   }
   const effectiveModel = body.model ?? (isValidModel(conversation.model) ? conversation.model : void 0);
-  const trustedSettings = conversation.appliedSettingsSnapshot ? null : await resolveWorkspaceSettings(event, context, db);
-  const appliedSettings = getConversationAppliedSettings(conversation, trustedSettings);
+  const explicitSettings = !conversation.appliedSettingsSnapshot && body.workspaceSettingsSnapshot !== void 0 ? parseWorkspaceSettingsSnapshot(body.workspaceSettingsSnapshot) : void 0;
+  const trustedSettings = conversation.appliedSettingsSnapshot || explicitSettings ? null : await resolveWorkspaceSettings(event, context, db);
+  const appliedSettings = getConversationAppliedSettings(conversation, trustedSettings, explicitSettings);
   const now = /* @__PURE__ */ new Date();
   const assistantCreatedAt = new Date(now.getTime() + 1);
-  if (!conversation.appliedSettingsSnapshot && trustedSettings) {
+  const snapshotSettings = explicitSettings ?? trustedSettings;
+  if (!conversation.appliedSettingsSnapshot && snapshotSettings) {
     await db.update(schema.conversations).set({
-      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(trustedSettings),
-      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(trustedSettings),
+      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(snapshotSettings),
+      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(snapshotSettings),
       updatedAt: now
     }).where(and(
       eq(schema.conversations.id, conversationId),
@@ -113,10 +117,12 @@ export default defineEventHandler(async (event) => {
   const skills = externalSkillRefs.length > 0 ? externalSkillRefs : void 0;
   if (needsNewThread) {
     let environmentVariables = {};
-    try {
-      environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
-    } catch (error) {
-      logger.warn({ conversationId, error }, "Failed to resolve workspace credentials, proceeding without env vars");
+    if (useChatNuxtFeatures().credentials) {
+      try {
+        environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
+      } catch (error) {
+        logger.warn({ conversationId, error }, "Failed to resolve workspace credentials, proceeding without env vars");
+      }
     }
     const hasEnvironmentVariables = Object.keys(environmentVariables).length > 0;
     createChatAgentSession(token, {

package/dist/runtime/server/api/conversations/[id]/usage.get.js

@@ -31,7 +31,7 @@ export default defineEventHandler(async (event) => {
       eq(schema.conversationUsage.workspaceId, context.workspaceId)
     )
   );
-  const billing = await getWorkspaceBilling(context.workspaceId);
+  const billing = await getWorkspaceBilling(event);
   if (!usage) {
     return { usage: null, billing };
   }

package/dist/runtime/server/api/conversations/generate-title.post.js

@@ -3,7 +3,20 @@ import { useRuntimeConfig } from "nitropack/runtime";
 import { createTelaClient } from "@meistrari/tela-sdk-js";
 import { logger } from "#chat-runtime/server/utils/logger";
 import { requireUser } from "#chat-runtime/server/utils/auth";
+import { useChatNuxtFeatures } from "#chat-runtime/utils/features";
 const TITLE_CANVAS_ID = "ba06c4a0-ef05-4fb6-b4ef-5af3d63a1ba2";
+const FALLBACK_TITLE_MAX_LENGTH = 60;
+const FALLBACK_TITLE_DEFAULT = "New chat";
+function buildFallbackTitle(userMessage) {
+  const normalized = userMessage.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return FALLBACK_TITLE_DEFAULT;
+  }
+  if (normalized.length <= FALLBACK_TITLE_MAX_LENGTH) {
+    return normalized;
+  }
+  return `${normalized.slice(0, FALLBACK_TITLE_MAX_LENGTH - 1).trimEnd()}\u2026`;
+}
 export default defineEventHandler(async (event) => {
   requireUser(event);
   const { userMessage, assistantResponse } = await readBody(event);
@@ -14,11 +27,11 @@ export default defineEventHandler(async (event) => {
     });
   }
   const { telaApiKey } = useRuntimeConfig();
-  if (!telaApiKey) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: "Tela API key not configured"
-    });
+  const features = useChatNuxtFeatures();
+  if (!features.generateTitle || !telaApiKey) {
+    const fallback = buildFallbackTitle(userMessage);
+    logger.debug({ titleLength: fallback.length, reason: !features.generateTitle ? "feature-disabled" : "no-tela-api-key" }, "Title generated via fallback");
+    return { title: fallback };
   }
   try {
     const tela = createTelaClient({

package/dist/runtime/server/api/workspace/usage.get.js

@@ -54,7 +54,7 @@ export default defineEventHandler(async (event) => {
   }).from(schema.conversationUsage).where(and(...conditions)).orderBy(desc(schema.conversationUsage.createdAt)).limit(limit + 1);
   const hasMore = records.length > limit;
   const paginatedRecords = records.slice(0, limit);
-  const billing = await getWorkspaceBilling(session.workspace.id);
+  const billing = await getWorkspaceBilling(event);
   const formattedRecords = paginatedRecords.map((r) => {
     const transformedCosts = transformCostForBilling({
       promptCost: Number(r.promptCost),

package/dist/runtime/server/db/index.d.ts

@@ -1,6 +1,23 @@
+import { drizzle as drizzlePostgres } from 'drizzle-orm/postgres-js';
+import type { PgliteDatabase } from 'drizzle-orm/pglite';
 import * as schema from './schema.js';
 export type { ContextFile, ExternalSkill } from './schema.js';
-export declare function useDb(): import("drizzle-orm/postgres-js").PostgresJsDatabase<Record<string, unknown>> & {
-    $client: import("postgres").Sql<{}>;
-};
+type PostgresDb = ReturnType<typeof drizzlePostgres<typeof schema>>;
+type PgliteDb = PgliteDatabase<typeof schema>;
+type AnyDb = PostgresDb | PgliteDb;
+export declare function isPgliteUrl(url: string): boolean;
+/**
+ * Eagerly initializes the database during Nitro startup. Idempotent. Both
+ * Postgres and pglite paths now run migrations on boot, so the chat-nuxt
+ * tables in the `chat` Postgres schema are guaranteed to exist before the
+ * first request hits a route that calls useDb().
+ */
+export declare function initDb(): Promise<AnyDb>;
+/**
+ * Returns the initialized database instance. initDb() must have already run
+ * via the boot plugin so migrations have been applied — bare useDb() now
+ * throws if called before init, regardless of driver, instead of silently
+ * skipping migrations on the Postgres path.
+ */
+export declare function useDb(): AnyDb;
 export { schema };

package/dist/runtime/server/db/index.js

@@ -1,20 +1,159 @@
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
 import { useRuntimeConfig } from "nitropack/runtime";
+import { sql } from "drizzle-orm";
 import postgres from "postgres";
-import { drizzle } from "drizzle-orm/postgres-js";
+import { drizzle as drizzlePostgres } from "drizzle-orm/postgres-js";
+import { migrate as migratePostgres } from "drizzle-orm/postgres-js/migrator";
 import * as schema from "./schema/index.js";
-import { logger } from "#chat-runtime/server/utils/logger";
+import { CHAT_SCHEMA_NAME } from "./schema/_schema.js";
+import { logger } from "../utils/logger.js";
 let dbInstance = null;
-export function useDb() {
+let dbInitPromise = null;
+const LEGACY_MIGRATIONS_SCHEMA = "drizzle";
+const MIGRATIONS_TABLE = "__drizzle_migrations";
+const MIGRATIONS_LEDGER_LOCK_KEY = 581073927;
+export function isPgliteUrl(url) {
+  return url.startsWith("pglite:") || url.startsWith("file:");
+}
+function resolvePgliteDataDir(url) {
+  if (url.startsWith("pglite:")) {
+    return url.slice("pglite:".length);
+  }
+  if (url.startsWith("file://")) {
+    return url.slice("file://".length);
+  }
+  if (url.startsWith("file:")) {
+    return url.slice("file:".length);
+  }
+  return url;
+}
+const IGNORED_NOTICE_CODES = /* @__PURE__ */ new Set(["42P06", "42P07"]);
+function getRows(result) {
+  if (Array.isArray(result)) {
+    return result;
+  }
+  if (result && typeof result === "object" && "rows" in result && Array.isArray(result.rows)) {
+    return result.rows;
+  }
+  return [];
+}
+async function tableExists(db, schemaName, tableName) {
+  const result = await db.execute(sql`
+        select exists (
+            select 1
+            from information_schema.tables
+            where table_schema = ${schemaName}
+                and table_name = ${tableName}
+        ) as "exists"
+    `);
+  const [row] = getRows(result);
+  return row?.exists ?? false;
+}
+async function tableHasRows(db, schemaName, tableName) {
+  const result = await db.execute(sql`
+        select exists (
+            select 1
+            from ${sql.identifier(schemaName)}.${sql.identifier(tableName)}
+        ) as "exists"
+    `);
+  const [row] = getRows(result);
+  return row?.exists ?? false;
+}
+async function seedChatMigrationsLedger(db) {
+  await db.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(CHAT_SCHEMA_NAME)}`);
+  await db.execute(sql`
+        CREATE TABLE IF NOT EXISTS ${sql.identifier(CHAT_SCHEMA_NAME)}.${sql.identifier(MIGRATIONS_TABLE)} (
+            id SERIAL PRIMARY KEY,
+            hash text NOT NULL,
+            created_at bigint
+        )
+    `);
+  if (await tableHasRows(db, CHAT_SCHEMA_NAME, MIGRATIONS_TABLE)) {
+    return;
+  }
+  if (!await tableExists(db, LEGACY_MIGRATIONS_SCHEMA, MIGRATIONS_TABLE)) {
+    return;
+  }
+  await db.execute(sql`
+        INSERT INTO ${sql.identifier(CHAT_SCHEMA_NAME)}.${sql.identifier(MIGRATIONS_TABLE)} ("hash", "created_at")
+        SELECT "hash", "created_at"
+        FROM ${sql.identifier(LEGACY_MIGRATIONS_SCHEMA)}.${sql.identifier(MIGRATIONS_TABLE)}
+        ORDER BY "created_at"
+    `);
+}
+async function initPostgresAsync(databaseUrl, migrationsDir) {
+  const client = postgres(databaseUrl, {
+    max: 10,
+    onnotice: (notice) => {
+      if (notice.code && IGNORED_NOTICE_CODES.has(notice.code))
+        return;
+      logger.info({ notice }, "Postgres notice");
+    }
+  });
+  const db = drizzlePostgres(client, { schema });
+  if (migrationsDir) {
+    await db.transaction(async (tx) => {
+      await tx.execute(sql`SELECT pg_advisory_xact_lock(${MIGRATIONS_LEDGER_LOCK_KEY})`);
+      await seedChatMigrationsLedger(tx);
+    });
+    await migratePostgres(db, { migrationsFolder: migrationsDir, migrationsSchema: CHAT_SCHEMA_NAME });
+    logger.info({ migrationsSchema: CHAT_SCHEMA_NAME }, "Postgres connection pool initialized and migrations applied");
+  } else {
+    logger.warn("Postgres connection pool initialized without migrations directory \u2014 schema may be out of date");
+  }
+  return db;
+}
+async function initPgliteAsync(databaseUrl, migrationsDir) {
+  const dataDir = resolvePgliteDataDir(databaseUrl);
+  await mkdir(dirname(dataDir), { recursive: true });
+  const [{ PGlite }, { drizzle }, { migrate }] = await Promise.all([
+    import("@electric-sql/pglite"),
+    import("drizzle-orm/pglite"),
+    import("drizzle-orm/pglite/migrator")
+  ]);
+  const client = new PGlite(dataDir);
+  const db = drizzle(client, { schema });
+  if (migrationsDir) {
+    await seedChatMigrationsLedger(db);
+    await migrate(db, { migrationsFolder: migrationsDir, migrationsSchema: CHAT_SCHEMA_NAME });
+    logger.info({ dataDir, migrationsSchema: CHAT_SCHEMA_NAME }, "pglite database initialized and migrated");
+  } else {
+    logger.warn({ dataDir }, "pglite database initialized without migrations directory \u2014 schema may be empty");
+  }
+  return db;
+}
+export async function initDb() {
   if (dbInstance) {
     return dbInstance;
   }
-  const config = useRuntimeConfig();
-  if (!config.databaseUrl) {
-    throw new Error("DATABASE_URL is not configured");
+  if (dbInitPromise) {
+    return dbInitPromise;
+  }
+  dbInitPromise = (async () => {
+    const config = useRuntimeConfig();
+    const databaseUrl = config.databaseUrl;
+    const migrationsDir = config.chatNuxt?.migrationsDir ?? "";
+    if (!databaseUrl) {
+      throw new Error("DATABASE_URL is not configured and no pglite fallback path was set");
+    }
+    const db = isPgliteUrl(databaseUrl) ? await initPgliteAsync(databaseUrl, migrationsDir) : await initPostgresAsync(databaseUrl, migrationsDir);
+    dbInstance = db;
+    return db;
+  })();
+  try {
+    return await dbInitPromise;
+  } catch (error) {
+    dbInitPromise = null;
+    throw error;
+  }
+}
+export function useDb() {
+  if (dbInstance) {
+    return dbInstance;
   }
-  const client = postgres(config.databaseUrl, { max: 10 });
-  dbInstance = drizzle(client, { schema });
-  logger.info("Database connection pool initialized");
-  return dbInstance;
+  throw new Error(
+    "chat-nuxt database is not initialized. The chat-nuxt boot plugin should have called initDb() before any request \u2014 check that the module registered server/plugins/init-db.ts."
+  );
 }
 export { schema };

package/dist/runtime/server/db/schema/_schema.d.ts

@@ -0,0 +1,2 @@
+export declare const CHAT_SCHEMA_NAME = "chat";
+export declare const chatSchema: import("drizzle-orm/pg-core").PgSchema<"chat">;

package/dist/runtime/server/db/schema/_schema.js

@@ -0,0 +1,3 @@
+import { pgSchema } from "drizzle-orm/pg-core";
+export const CHAT_SCHEMA_NAME = "chat";
+export const chatSchema = pgSchema(CHAT_SCHEMA_NAME);