Add readonly exporters (#2705)

* refactor

* bunch of save-only persister added

Author: yujonglee

apps/desktop/src/store/tinybase/persister/chat.ts

@@ -0,0 +1,125 @@
+import { writeTextFile } from "@tauri-apps/plugin-fs";
+import { createCustomPersister } from "tinybase/persisters/with-schemas";
+import type { MergeableStore, OptionalSchemas } from "tinybase/with-schemas";
+
+import type { ChatMessageStorage } from "@hypr/store";
+
+import {
+  ensureDirsExist,
+  getChatDir,
+  getDataDir,
+  iterateTableRows,
+  type TablesContent,
+} from "./utils";
+
+type ChatGroupData = {
+  id: string;
+  user_id: string;
+  created_at: string;
+  title: string;
+};
+
+type ChatMessageWithId = ChatMessageStorage & { id: string };
+
+type ChatJson = {
+  chat_group: ChatGroupData;
+  messages: ChatMessageWithId[];
+};
+
+function collectMessagesByChatGroup(
+  tables: TablesContent | undefined,
+): Map<string, { chatGroup: ChatGroupData; messages: ChatMessageWithId[] }> {
+  const messagesByChatGroup = new Map<
+    string,
+    { chatGroup: ChatGroupData; messages: ChatMessageWithId[] }
+  >();
+
+  const chatGroups = iterateTableRows(tables, "chat_groups");
+  const chatMessages = iterateTableRows(tables, "chat_messages");
+
+  const chatGroupMap = new Map<string, ChatGroupData>();
+  for (const group of chatGroups) {
+    chatGroupMap.set(group.id, group);
+  }
+
+  for (const message of chatMessages) {
+    const chatGroupId = message.chat_group_id;
+    if (!chatGroupId) continue;
+
+    const chatGroup = chatGroupMap.get(chatGroupId);
+    if (!chatGroup) continue;
+
+    const existing = messagesByChatGroup.get(chatGroupId);
+    if (existing) {
+      existing.messages.push(message);
+    } else {
+      messagesByChatGroup.set(chatGroupId, {
+        chatGroup,
+        messages: [message],
+      });
+    }
+  }
+
+  return messagesByChatGroup;
+}
+
+export function createChatPersister<Schemas extends OptionalSchemas>(
+  store: MergeableStore<Schemas>,
+) {
+  return createCustomPersister(
+    store,
+    async () => {
+      return undefined;
+    },
+    async (getContent) => {
+      const [tables] = getContent() as [TablesContent | undefined, unknown];
+      const dataDir = await getDataDir();
+
+      const messagesByChatGroup = collectMessagesByChatGroup(tables);
+      if (messagesByChatGroup.size === 0) {
+        return;
+      }
+
+      const dirs = new Set<string>();
+      const writeOperations: Array<{ path: string; content: string }> = [];
+
+      for (const [
+        chatGroupId,
+        { chatGroup, messages },
+      ] of messagesByChatGroup) {
+        const chatDir = getChatDir(dataDir, chatGroupId);
+        dirs.add(chatDir);
+
+        const json: ChatJson = {
+          chat_group: chatGroup,
+          messages: messages.sort(
+            (a, b) =>
+              new Date(a.created_at || 0).getTime() -
+              new Date(b.created_at || 0).getTime(),
+          ),
+        };
+        writeOperations.push({
+          path: `${chatDir}/_messages.json`,
+          content: JSON.stringify(json, null, 2),
+        });
+      }
+
+      try {
+        await ensureDirsExist(dirs);
+      } catch (e) {
+        console.error("Failed to ensure dirs exist:", e);
+        return;
+      }
+
+      for (const op of writeOperations) {
+        try {
+          await writeTextFile(op.path, op.content);
+        } catch (e) {
+          console.error(`Failed to write ${op.path}:`, e);
+        }
+      }
+    },
+    (listener) => setInterval(listener, 1000),
+    (interval) => clearInterval(interval),
+  );
+}

apps/desktop/src/store/tinybase/persister/events.ts

@@ -0,0 +1,86 @@
+import { readTextFile, writeTextFile } from "@tauri-apps/plugin-fs";
+import { createCustomPersister } from "tinybase/persisters/with-schemas";
+import type {
+  Content,
+  MergeableStore,
+  OptionalSchemas,
+} from "tinybase/with-schemas";
+
+import { commands as path2Commands } from "@hypr/plugin-path2";
+import type { EventStorage } from "@hypr/store";
+
+import { StoreOrMergeableStore } from "../store/shared";
+import type { PersisterMode } from "./utils";
+
+const FILENAME = "events.json";
+
+type EventsJson = Record<string, EventStorage>;
+
+async function getFilePath(): Promise<string> {
+  const base = await path2Commands.base();
+  return `${base}/${FILENAME}`;
+}
+
+export function jsonToContent<Schemas extends OptionalSchemas>(
+  data: EventsJson,
+): Content<Schemas> {
+  return [{ events: data }, {}] as unknown as Content<Schemas>;
+}
+
+export function storeToJson<Schemas extends OptionalSchemas>(
+  store: MergeableStore<Schemas>,
+): EventsJson {
+  const table = store.getTable("events") ?? {};
+  return table as unknown as EventsJson;
+}
+
+export function createEventPersister<Schemas extends OptionalSchemas>(
+  store: MergeableStore<Schemas>,
+  config: { mode: PersisterMode } = { mode: "load-and-save" },
+) {
+  const loadFn =
+    config.mode === "save-only"
+      ? async (): Promise<Content<Schemas> | undefined> => undefined
+      : async (): Promise<Content<Schemas> | undefined> => {
+          try {
+            const filePath = await getFilePath();
+            const content = await readTextFile(filePath);
+            const data = JSON.parse(content) as EventsJson;
+            return jsonToContent<Schemas>(data);
+          } catch (error) {
+            const errorStr = String(error);
+            if (
+              errorStr.includes("No such file or directory") ||
+              errorStr.includes("ENOENT") ||
+              errorStr.includes("not found")
+            ) {
+              return jsonToContent<Schemas>({});
+            }
+            console.error("[EventPersister] load error:", error);
+            return undefined;
+          }
+        };
+
+  const saveFn =
+    config.mode === "load-only"
+      ? async () => {}
+      : async () => {
+          try {
+            const data = storeToJson(store);
+            const filePath = await getFilePath();
+            await writeTextFile(filePath, JSON.stringify(data, null, 2));
+          } catch (error) {
+            console.error("[EventPersister] save error:", error);
+          }
+        };
+
+  return createCustomPersister(
+    store,
+    loadFn,
+    saveFn,
+    (listener) => setInterval(listener, 1000),
+    (handle) => clearInterval(handle),
+    (error) => console.error("[EventPersister]:", error),
+    StoreOrMergeableStore,
+  );
+}