@assistant-ui/core 0.2.20 → 0.2.22

package/src/react/adapters/LocalStorageThreadListAdapter.test.ts

@@ -0,0 +1,304 @@
+import { describe, expect, it } from "vitest";
+import type { AsyncStorageLike } from "./LocalStorageThreadListAdapter";
+import {
+  createLocalStorageAdapter,
+  parseStoredMessageRepository,
+  parseStoredThreadMetadata,
+} from "./LocalStorageThreadListAdapter";
+
+const storedMessage = (
+  id: string,
+  role: "user" | "assistant" | "system" = "user",
+) => ({
+  id,
+  role,
+  createdAt: "2026-01-01T00:00:00.000Z",
+  content: [],
+  metadata: { custom: {} },
+  ...(role === "user" ? { attachments: [] } : undefined),
+  ...(role === "assistant"
+    ? { status: { type: "complete", reason: "stop" } }
+    : undefined),
+});
+
+const createStorage = (
+  entries: Record<string, string> = {},
+): AsyncStorageLike & { get(key: string): string | undefined } => {
+  const values = new Map(Object.entries(entries));
+  return {
+    get: (key) => values.get(key),
+    getItem: async (key) => values.get(key) ?? null,
+    setItem: async (key, value) => {
+      values.set(key, value);
+    },
+    removeItem: async (key) => {
+      values.delete(key);
+    },
+  };
+};
+
+describe("parseStoredThreadMetadata", () => {
+  it("returns an empty list for invalid JSON", () => {
+    expect(parseStoredThreadMetadata("{not-json")).toEqual([]);
+  });
+
+  it("skips malformed thread records while preserving valid records", () => {
+    const threads = parseStoredThreadMetadata(
+      JSON.stringify([
+        { remoteId: "thread-1", status: "regular", title: "Trip plan" },
+        { remoteId: 123, status: "regular" },
+        { remoteId: "thread-2", status: "archived", custom: { pinned: true } },
+        { remoteId: "thread-3", status: "deleted" },
+      ]),
+    );
+
+    expect(threads).toEqual([
+      { remoteId: "thread-1", status: "regular", title: "Trip plan" },
+      { remoteId: "thread-2", status: "archived", custom: { pinned: true } },
+    ]);
+  });
+
+  it("defaults old thread records without status to regular", () => {
+    expect(
+      parseStoredThreadMetadata(JSON.stringify([{ remoteId: "old" }])),
+    ).toEqual([{ remoteId: "old", status: "regular" }]);
+  });
+});
+
+describe("parseStoredMessageRepository", () => {
+  it("returns empty history for invalid JSON", () => {
+    expect(parseStoredMessageRepository("{not-json")).toEqual({ messages: [] });
+  });
+
+  it("skips malformed message records", () => {
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        headId: "message-2",
+        messages: [
+          {
+            message: storedMessage("message-1"),
+            parentId: null,
+          },
+          { message: { role: "user", content: [] }, parentId: null },
+          {
+            message: storedMessage("message-2", "assistant"),
+            parentId: "message-1",
+          },
+        ],
+      }),
+    );
+
+    expect(repo.messages.map((item) => item.message.id)).toEqual([
+      "message-1",
+      "message-2",
+    ]);
+    expect(repo.headId).toBe("message-2");
+  });
+
+  it("drops a head id that points at a skipped message", () => {
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        headId: "missing",
+        messages: [
+          {
+            message: storedMessage("message-1"),
+            parentId: null,
+          },
+        ],
+      }),
+    );
+
+    expect(repo.headId).toBeUndefined();
+    expect(repo.messages.map((item) => item.message.id)).toEqual(["message-1"]);
+  });
+
+  it("skips messages missing the required thread message shell", () => {
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        messages: [
+          { message: { id: "missing-role" }, parentId: null },
+          {
+            message: {
+              ...storedMessage("missing-content"),
+              content: undefined,
+            },
+            parentId: null,
+          },
+          {
+            message: { ...storedMessage("missing-metadata"), metadata: {} },
+            parentId: null,
+          },
+          {
+            message: storedMessage("valid"),
+            parentId: null,
+          },
+        ],
+      }),
+    );
+
+    expect(repo.messages.map((item) => item.message.id)).toEqual(["valid"]);
+  });
+
+  it("skips messages whose parent is missing, skipped, or appears later", () => {
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        headId: "child-of-root",
+        messages: [
+          {
+            message: storedMessage("child-of-missing"),
+            parentId: "missing",
+          },
+          {
+            message: storedMessage("child-of-invalid"),
+            parentId: "invalid",
+          },
+          {
+            message: { id: "invalid" },
+            parentId: null,
+          },
+          {
+            message: storedMessage("child-before-parent"),
+            parentId: "late-parent",
+          },
+          {
+            message: storedMessage("late-parent"),
+            parentId: null,
+          },
+          {
+            message: storedMessage("child-of-root"),
+            parentId: "late-parent",
+          },
+        ],
+      }),
+    );
+
+    expect(
+      repo.messages.map((item) => ({
+        id: item.message.id,
+        parentId: item.parentId,
+      })),
+    ).toEqual([
+      { id: "late-parent", parentId: null },
+      { id: "child-of-root", parentId: "late-parent" },
+    ]);
+    expect(repo.headId).toBe("child-of-root");
+  });
+});
+
+describe("createLocalStorageAdapter", () => {
+  it("lists no threads when the stored thread list is invalid JSON", async () => {
+    const storage = createStorage({ "@assistant-ui:threads": "{not-json" });
+    const adapter = createLocalStorageAdapter({ storage });
+
+    await expect(adapter.list()).resolves.toEqual({ threads: [] });
+  });
+
+  it("overwrites malformed thread storage when initializing a thread", async () => {
+    const storage = createStorage({ "@assistant-ui:threads": "{not-json" });
+    const adapter = createLocalStorageAdapter({ storage });
+
+    await expect(adapter.initialize("thread-1")).resolves.toEqual({
+      remoteId: "thread-1",
+      externalId: undefined,
+    });
+
+    expect(JSON.parse(storage.get("@assistant-ui:threads") ?? "")).toEqual([
+      { remoteId: "thread-1", status: "regular" },
+    ]);
+  });
+
+  it("preserves concurrent metadata mutations across adapters", async () => {
+    const threadsKey = "@assistant-ui:threads";
+    const values = new Map<string, string>();
+    let metadataReads = 0;
+    let metadataWrites = 0;
+    let markFirstWriteStarted!: () => void;
+    let releaseFirstWrite!: () => void;
+    const firstWriteStarted = new Promise<void>((resolve) => {
+      markFirstWriteStarted = resolve;
+    });
+    const firstWriteCanFinish = new Promise<void>((resolve) => {
+      releaseFirstWrite = resolve;
+    });
+    const storage: AsyncStorageLike = {
+      getItem: async (key) => {
+        if (key === threadsKey) metadataReads += 1;
+        return values.get(key) ?? null;
+      },
+      setItem: async (key, value) => {
+        if (key === threadsKey) {
+          metadataWrites += 1;
+          if (metadataWrites === 1) {
+            markFirstWriteStarted();
+            await firstWriteCanFinish;
+          }
+        }
+        values.set(key, value);
+      },
+      removeItem: async (key) => {
+        values.delete(key);
+      },
+    };
+    const firstAdapter = createLocalStorageAdapter({ storage });
+    const secondAdapter = createLocalStorageAdapter({ storage });
+
+    const firstInitialization = firstAdapter.initialize("thread-1");
+    await firstWriteStarted;
+    const secondInitialization = secondAdapter.initialize("thread-2");
+    const readsWhileFirstWritePending = metadataReads;
+
+    releaseFirstWrite();
+    await Promise.all([firstInitialization, secondInitialization]);
+
+    expect(readsWhileFirstWritePending).toBe(1);
+    expect(JSON.parse(values.get(threadsKey) ?? "")).toEqual([
+      { remoteId: "thread-2", status: "regular" },
+      { remoteId: "thread-1", status: "regular" },
+    ]);
+  });
+
+  it("continues processing mutations after a storage failure", async () => {
+    const threadsKey = "@assistant-ui:threads";
+    const values = new Map<string, string>();
+    let shouldFail = true;
+    const storage: AsyncStorageLike = {
+      getItem: async (key) => values.get(key) ?? null,
+      setItem: async (key, value) => {
+        if (shouldFail) {
+          shouldFail = false;
+          throw new Error("Storage unavailable");
+        }
+        values.set(key, value);
+      },
+      removeItem: async (key) => {
+        values.delete(key);
+      },
+    };
+    const adapter = createLocalStorageAdapter({ storage });
+
+    await expect(adapter.initialize("thread-1")).rejects.toThrow(
+      "Storage unavailable",
+    );
+    await expect(adapter.initialize("thread-2")).resolves.toEqual({
+      remoteId: "thread-2",
+      externalId: undefined,
+    });
+
+    expect(JSON.parse(values.get(threadsKey) ?? "")).toEqual([
+      { remoteId: "thread-2", status: "regular" },
+    ]);
+  });
+
+  it("includes the thread id when a stored thread cannot be fetched", async () => {
+    const storage = createStorage({
+      "@assistant-ui:threads": JSON.stringify([
+        { remoteId: "thread-1", status: "regular" },
+      ]),
+    });
+    const adapter = createLocalStorageAdapter({ storage });
+
+    await expect(adapter.fetch("missing-thread")).rejects.toThrow(
+      'Stored thread "missing-thread" not found while fetching thread metadata.',
+    );
+  });
+});