fix: remove monorepo

app/lib/persistence/ChatDescription.client.tsx

@@ -0,0 +1,6 @@
+import { useStore } from '@nanostores/react';
+import { description } from './useChatHistory';
+
+export function ChatDescription() {
+  return useStore(description);
+}

app/lib/persistence/db.ts

@@ -0,0 +1,160 @@
+import type { Message } from 'ai';
+import { createScopedLogger } from '~/utils/logger';
+import type { ChatHistoryItem } from './useChatHistory';
+
+const logger = createScopedLogger('ChatHistory');
+
+// this is used at the top level and never rejects
+export async function openDatabase(): Promise<IDBDatabase | undefined> {
+  return new Promise((resolve) => {
+    const request = indexedDB.open('boltHistory', 1);
+
+    request.onupgradeneeded = (event: IDBVersionChangeEvent) => {
+      const db = (event.target as IDBOpenDBRequest).result;
+
+      if (!db.objectStoreNames.contains('chats')) {
+        const store = db.createObjectStore('chats', { keyPath: 'id' });
+        store.createIndex('id', 'id', { unique: true });
+        store.createIndex('urlId', 'urlId', { unique: true });
+      }
+    };
+
+    request.onsuccess = (event: Event) => {
+      resolve((event.target as IDBOpenDBRequest).result);
+    };
+
+    request.onerror = (event: Event) => {
+      resolve(undefined);
+      logger.error((event.target as IDBOpenDBRequest).error);
+    };
+  });
+}
+
+export async function getAll(db: IDBDatabase): Promise<ChatHistoryItem[]> {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('chats', 'readonly');
+    const store = transaction.objectStore('chats');
+    const request = store.getAll();
+
+    request.onsuccess = () => resolve(request.result as ChatHistoryItem[]);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export async function setMessages(
+  db: IDBDatabase,
+  id: string,
+  messages: Message[],
+  urlId?: string,
+  description?: string,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('chats', 'readwrite');
+    const store = transaction.objectStore('chats');
+
+    const request = store.put({
+      id,
+      messages,
+      urlId,
+      description,
+      timestamp: new Date().toISOString(),
+    });
+
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export async function getMessages(db: IDBDatabase, id: string): Promise<ChatHistoryItem> {
+  return (await getMessagesById(db, id)) || (await getMessagesByUrlId(db, id));
+}
+
+export async function getMessagesByUrlId(db: IDBDatabase, id: string): Promise<ChatHistoryItem> {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('chats', 'readonly');
+    const store = transaction.objectStore('chats');
+    const index = store.index('urlId');
+    const request = index.get(id);
+
+    request.onsuccess = () => resolve(request.result as ChatHistoryItem);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export async function getMessagesById(db: IDBDatabase, id: string): Promise<ChatHistoryItem> {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('chats', 'readonly');
+    const store = transaction.objectStore('chats');
+    const request = store.get(id);
+
+    request.onsuccess = () => resolve(request.result as ChatHistoryItem);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export async function deleteById(db: IDBDatabase, id: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('chats', 'readwrite');
+    const store = transaction.objectStore('chats');
+    const request = store.delete(id);
+
+    request.onsuccess = () => resolve(undefined);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export async function getNextId(db: IDBDatabase): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('chats', 'readonly');
+    const store = transaction.objectStore('chats');
+    const request = store.getAllKeys();
+
+    request.onsuccess = () => {
+      const highestId = request.result.reduce((cur, acc) => Math.max(+cur, +acc), 0);
+      resolve(String(+highestId + 1));
+    };
+
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export async function getUrlId(db: IDBDatabase, id: string): Promise<string> {
+  const idList = await getUrlIds(db);
+
+  if (!idList.includes(id)) {
+    return id;
+  } else {
+    let i = 2;
+
+    while (idList.includes(`${id}-${i}`)) {
+      i++;
+    }
+
+    return `${id}-${i}`;
+  }
+}
+
+async function getUrlIds(db: IDBDatabase): Promise<string[]> {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('chats', 'readonly');
+    const store = transaction.objectStore('chats');
+    const idList: string[] = [];
+
+    const request = store.openCursor();
+
+    request.onsuccess = (event: Event) => {
+      const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result;
+
+      if (cursor) {
+        idList.push(cursor.value.urlId);
+        cursor.continue();
+      } else {
+        resolve(idList);
+      }
+    };
+
+    request.onerror = () => {
+      reject(request.error);
+    };
+  });
+}

app/lib/persistence/index.ts

@@ -0,0 +1,2 @@
+export * from './db';
+export * from './useChatHistory';

app/lib/persistence/useChatHistory.ts

@@ -0,0 +1,109 @@
+import { useLoaderData, useNavigate } from '@remix-run/react';
+import { useState, useEffect } from 'react';
+import { atom } from 'nanostores';
+import type { Message } from 'ai';
+import { toast } from 'react-toastify';
+import { workbenchStore } from '~/lib/stores/workbench';
+import { getMessages, getNextId, getUrlId, openDatabase, setMessages } from './db';
+
+export interface ChatHistoryItem {
+  id: string;
+  urlId?: string;
+  description?: string;
+  messages: Message[];
+  timestamp: string;
+}
+
+const persistenceEnabled = !import.meta.env.VITE_DISABLE_PERSISTENCE;
+
+export const db = persistenceEnabled ? await openDatabase() : undefined;
+
+export const chatId = atom<string | undefined>(undefined);
+export const description = atom<string | undefined>(undefined);
+
+export function useChatHistory() {
+  const navigate = useNavigate();
+  const { id: mixedId } = useLoaderData<{ id?: string }>();
+
+  const [initialMessages, setInitialMessages] = useState<Message[]>([]);
+  const [ready, setReady] = useState<boolean>(false);
+  const [urlId, setUrlId] = useState<string | undefined>();
+
+  useEffect(() => {
+    if (!db) {
+      setReady(true);
+
+      if (persistenceEnabled) {
+        toast.error(`Chat persistence is unavailable`);
+      }
+
+      return;
+    }
+
+    if (mixedId) {
+      getMessages(db, mixedId)
+        .then((storedMessages) => {
+          if (storedMessages && storedMessages.messages.length > 0) {
+            setInitialMessages(storedMessages.messages);
+            setUrlId(storedMessages.urlId);
+            description.set(storedMessages.description);
+            chatId.set(storedMessages.id);
+          } else {
+            navigate(`/`, { replace: true });
+          }
+
+          setReady(true);
+        })
+        .catch((error) => {
+          toast.error(error.message);
+        });
+    }
+  }, []);
+
+  return {
+    ready: !mixedId || ready,
+    initialMessages,
+    storeMessageHistory: async (messages: Message[]) => {
+      if (!db || messages.length === 0) {
+        return;
+      }
+
+      const { firstArtifact } = workbenchStore;
+
+      if (!urlId && firstArtifact?.id) {
+        const urlId = await getUrlId(db, firstArtifact.id);
+
+        navigateChat(urlId);
+        setUrlId(urlId);
+      }
+
+      if (!description.get() && firstArtifact?.title) {
+        description.set(firstArtifact?.title);
+      }
+
+      if (initialMessages.length === 0 && !chatId.get()) {
+        const nextId = await getNextId(db);
+
+        chatId.set(nextId);
+
+        if (!urlId) {
+          navigateChat(nextId);
+        }
+      }
+
+      await setMessages(db, chatId.get() as string, messages, urlId, description.get());
+    },
+  };
+}
+
+function navigateChat(nextId: string) {
+  /**
+   * FIXME: Using the intended navigate function causes a rerender for <Chat /> that breaks the app.
+   *
+   * `navigate(`/chat/${nextId}`, { replace: true });`
+   */
+  const url = new URL(window.location.href);
+  url.pathname = `/chat/${nextId}`;
+
+  window.history.replaceState({}, '', url);
+}