@omnistreamai/data-core 0.1.0

package/src/store.test.ts

@@ -0,0 +1,452 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Store } from "./store.js";
+import { AdapterType, type QueryOptions, type QueryResult } from "./types.js";
+import type { LocalAdapter, RemoteAdapter } from "./types.js";
+
+// Mock adapters
+class MockLocalAdapter implements LocalAdapter {
+  readonly type = AdapterType.Local;
+  readonly name = "MockLocalAdapter";
+  private data: Map<string, Record<string, unknown>> = new Map();
+
+  async add<T extends Record<string, unknown>>(
+    storeName: string,
+    data: T,
+    idKey?: string
+  ): Promise<T> {
+    const key = String(data[idKey ?? "id"]);
+    this.data.set(key, data);
+    return data;
+  }
+
+  async update<T extends Record<string, unknown>>(
+    storeName: string,
+    id: string,
+    data: Partial<T>,
+    idKey?: string
+  ): Promise<T> {
+    const existing = this.data.get(id) as T | undefined;
+    if (!existing) {
+      throw new Error(`Data with id ${id} not found`);
+    }
+    const updated = { ...existing, ...data } as T;
+    this.data.set(id, updated);
+    return updated;
+  }
+
+  async delete(storeName: string, id: string, idKey?: string): Promise<void> {
+    this.data.delete(id);
+  }
+
+  async getData<T extends Record<string, unknown>>(
+    storeName: string,
+    id: string,
+    idKey?: string
+  ): Promise<T | null> {
+    return (this.data.get(id) as T) || null;
+  }
+
+  async getList<T extends Record<string, unknown>>(
+    storeName: string,
+    options?: unknown,
+    idKey?: string
+  ): Promise<T[]> {
+    return Array.from(this.data.values()) as T[];
+  }
+
+
+
+  async clear(storeName: string): Promise<void> {
+    this.data.clear();
+  }
+
+  async initStore(
+    storeName: string,
+    indexes?: string[],
+    idKey?: string
+  ): Promise<void> {
+    // Mock implementation
+  }
+}
+
+class MockRemoteAdapter implements RemoteAdapter {
+  readonly type = AdapterType.Remote;
+  readonly name = "MockRemoteAdapter";
+  private data: Map<string, Record<string, unknown>> = new Map();
+
+  async add<T extends Record<string, unknown>>(
+    storeName: string,
+    data: T,
+    idKey?: string
+  ): Promise<T> {
+    const key = String(data[idKey ?? "id"]);
+    this.data.set(key, data);
+    return data;
+  }
+
+  async update<T extends Record<string, unknown>>(
+    storeName: string,
+    id: string,
+    data: Partial<T>,
+    idKey?: string
+  ): Promise<T> {
+    const existing = this.data.get(id) as T | undefined;
+    if (!existing) {
+      throw new Error(`Data with id ${id} not found`);
+    }
+    const updated = { ...existing, ...data } as T;
+    this.data.set(id, updated);
+    return updated;
+  }
+
+  async delete(storeName: string, id: string, idKey?: string): Promise<void> {
+    this.data.delete(id);
+  }
+
+  async getData<T extends Record<string, unknown>>(
+    storeName: string,
+    id: string,
+    idKey?: string
+  ): Promise<T | null> {
+    return (this.data.get(id) as T) || null;
+  }
+
+  async getList<T extends Record<string, unknown>>(
+    storeName: string,
+    options?: QueryOptions<T>,
+    idKey?: string
+  ) {
+    let allData = Array.from(this.data.values()) as T[];
+
+    // 应用条件筛选
+    if (options?.where) {
+      const whereKeys = Object.keys(options.where);
+      allData = allData.filter((item) => {
+        return whereKeys.every((key) => {
+          return item[key] === options.where?.[key];
+        });
+      });
+    }
+
+    // 应用分页
+    let page = options?.page ?? 1;
+    let limit = options?.limit ?? (allData.length || 10);
+    const start = (page - 1) * limit;
+    const end = start + limit;
+    const paginatedData = allData.slice(start, end);
+
+    return {
+      data: paginatedData,
+      totalCount: allData.length,
+      page,
+      limit,
+    };
+  }
+
+  async getListQuery<T extends Record<string, unknown>>(
+    storeName: string,
+    options?: QueryOptions<T>,
+    idKey?: string
+  ): Promise<QueryResult<T[]>> {
+    return {
+      queryKey: ["store", storeName, "remote", options],
+      queryFn: async () => {
+        const result = await this.getList<T>(storeName, options, idKey);
+        return result.data;
+      },
+      getInitialData: async () => [],
+    };
+  }
+
+  async clear(storeName: string): Promise<void> {
+    this.data.clear();
+  }
+
+  async initStore(
+    storeName: string,
+    indexes?: string[],
+    idKey?: string
+  ): Promise<void> {
+    // Mock implementation
+  }
+
+  setService(service: unknown): void {
+    // Mock implementation
+  }
+}
+
+describe("Store", () => {
+  let localAdapter: LocalAdapter;
+  let remoteAdapter: RemoteAdapter;
+  let store: Store<{ id: string; username: string; email?: string }>;
+
+  beforeEach(async () => {
+    localAdapter = new MockLocalAdapter();
+    remoteAdapter = new MockRemoteAdapter();
+
+    store = new Store("user", {
+      localAdapter,
+      remoteAdapter,
+      idKey: "id",
+      indexes: ["username"],
+      maxLocalEntries: 100,
+      notThrowLocalError: false,
+    });
+
+    await store.init();
+  });
+
+  describe("add", () => {
+    it("应该能够添加数据", async () => {
+      const data = {
+        id: "1",
+        username: "test-user",
+        email: "test@example.com",
+      };
+
+      const result = await store.add(data);
+      expect(result).toEqual(data);
+    });
+
+    it("应该同时更新本地和远程适配器", async () => {
+      const data = {
+        id: "1",
+        username: "test-user",
+      };
+
+      await store.add(data);
+
+      const localData = await localAdapter.getData("user", "1", "id");
+      const remoteData = await remoteAdapter.getData("user", "1", "id");
+
+      expect(localData).toEqual(data);
+      expect(remoteData).toEqual(data);
+    });
+  });
+
+  describe("getData", () => {
+    it("应该能够根据 ID 获取数据", async () => {
+      const data = {
+        id: "1",
+        username: "test-user",
+        email: "test@example.com",
+      };
+
+      await store.add(data);
+      const result = await store.getData("1");
+      expect(result).toEqual(data);
+    });
+
+    it("当数据不存在时应该返回 null", async () => {
+      const result = await store.getData("non-existent");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("getList", () => {
+    it("应该能够获取列表数据", async () => {
+      const data1 = { id: "1", username: "user1" };
+      const data2 = { id: "2", username: "user2" };
+
+      await store.add(data1);
+      await store.add(data2);
+
+      const result = await store.getList();
+      expect(result).toHaveLength(2);
+    });
+
+    it("应该支持从本地源读取数据", async () => {
+      const data = { id: "1", username: "user1" };
+      await store.add(data);
+
+      const result = await store.getList({ source: "local" });
+      expect(result).toHaveLength(1);
+    });
+
+    it("应该支持分页查询", async () => {
+      const data1 = { id: "1", username: "user1" };
+      const data2 = { id: "2", username: "user2" };
+
+      await store.add(data1);
+      await store.add(data2);
+
+      const result = await store.getList({ page: 1, limit: 1 });
+      expect(result).toHaveLength(1);
+    });
+
+    it("应该支持条件筛选", async () => {
+      const data1 = { id: "1", username: "user1" };
+      const data2 = { id: "2", username: "user2" };
+
+      await store.add(data1);
+      await store.add(data2);
+
+      const result = await store.getList({ where: { username: "user1" } });
+      expect(result).toHaveLength(1);
+      expect(result[0]?.username).toBe("user1");
+    });
+
+    it("应该返回 queryKey 和 queryFn", async () => {
+      const result = await store.getListQuery({
+        where: { username: "user1" },
+      });
+
+      expect(result.queryKey).toBeDefined();
+      expect(result.queryFn).toBeDefined();
+      expect(result.getInitialData).toBeDefined();
+
+      const data = await result.queryFn();
+      expect(Array.isArray(data)).toBe(true);
+    });
+  });
+
+  describe("update", () => {
+    it("应该能够更新数据", async () => {
+      const data = {
+        id: "1",
+        username: "test-user",
+        email: "test@example.com",
+      };
+
+      await store.add(data);
+      const updated = await store.update("1", { email: "updated@example.com" });
+
+      expect(updated.email).toBe("updated@example.com");
+      expect(updated.username).toBe("test-user");
+    });
+
+    it("应该同时更新本地和远程适配器", async () => {
+      const data = { id: "1", username: "test-user" };
+      await store.add(data);
+
+      await store.update("1", { email: "updated@example.com" });
+
+      const localData = await localAdapter.getData("user", "1", "id");
+      const remoteData = await remoteAdapter.getData("user", "1", "id");
+
+      expect(localData?.email).toBe("updated@example.com");
+      expect(remoteData?.email).toBe("updated@example.com");
+    });
+  });
+
+  describe("delete", () => {
+    it("应该能够删除数据", async () => {
+      const data = {
+        id: "1",
+        username: "test-user",
+      };
+
+      await store.add(data);
+      await store.delete("1");
+
+      const result = await store.getData("1");
+      expect(result).toBeNull();
+    });
+
+    it("应该同时从本地和远程适配器删除", async () => {
+      const data = { id: "1", username: "test-user" };
+      await store.add(data);
+
+      await store.delete("1");
+
+      const localData = await localAdapter.getData("user", "1", "id");
+      const remoteData = await remoteAdapter.getData("user", "1", "id");
+
+      expect(localData).toBeNull();
+      expect(remoteData).toBeNull();
+    });
+  });
+
+  describe("onChange", () => {
+    it("应该在数据变更时触发 onChange 回调", async () => {
+      const onChange = vi.fn();
+      const storeWithCallback = new Store("user2", {
+        localAdapter,
+        remoteAdapter,
+        idKey: "id",
+        onChange,
+        notThrowLocalError: true,
+      });
+
+      await storeWithCallback.init();
+      await storeWithCallback.add({ id: "1", username: "test" });
+
+      expect(onChange).toHaveBeenCalled();
+    });
+  });
+
+  describe("maxLocalEntries", () => {
+    it("应该限制本地存储的条目数量", async () => {
+      const limitedStore = new Store<{ id: string; name: string }>("test-store", {
+        localAdapter,
+        remoteAdapter: null, // 只使用本地适配器
+        idKey: "id",
+        maxLocalEntries: 3,
+        notThrowLocalError: false,
+      });
+
+      await limitedStore.init();
+
+      // 添加超过限制的条目
+      await limitedStore.add({ id: "1", name: "Item 1" });
+      await limitedStore.add({ id: "2", name: "Item 2" });
+      await limitedStore.add({ id: "3", name: "Item 3" });
+      await limitedStore.add({ id: "4", name: "Item 4" });
+      await limitedStore.add({ id: "5", name: "Item 5" });
+
+      // 检查本地存储中的条目数量
+      const localData = await localAdapter.getList("test-store");
+      expect(localData.length).toBeLessThanOrEqual(3);
+    });
+
+    it("当 maxLocalEntries 未设置时不应该限制条目数量", async () => {
+      const unlimitedStore = new Store<{ id: string; name: string }>("test-store-unlimited", {
+        localAdapter,
+        remoteAdapter: null,
+        idKey: "id",
+        notThrowLocalError: false,
+      });
+
+      await unlimitedStore.init();
+
+      // 添加多个条目
+      await unlimitedStore.add({ id: "1", name: "Item 1" });
+      await unlimitedStore.add({ id: "2", name: "Item 2" });
+      await unlimitedStore.add({ id: "3", name: "Item 3" });
+      await unlimitedStore.add({ id: "4", name: "Item 4" });
+      await unlimitedStore.add({ id: "5", name: "Item 5" });
+
+      // 检查本地存储中的条目数量
+      const localData = await localAdapter.getList("test-store-unlimited");
+      expect(localData.length).toBe(5);
+    });
+
+    it("应该根据 sortByKey 参数排序后删除最旧的条目", async () => {
+      const sortedStore = new Store<{ id: string; name: string; timestamp: number }>("test-store-sorted", {
+        localAdapter,
+        remoteAdapter: null, // 只使用本地适配器
+        idKey: "id",
+        maxLocalEntries: 3,
+        sortByKey: "timestamp", // 按时间戳排序
+        notThrowLocalError: false,
+      });
+
+      await sortedStore.init();
+
+      // 添加带时间戳的条目（时间戳从小到大）
+      await sortedStore.add({ id: "1", name: "Item 1", timestamp: 1000 });
+      await sortedStore.add({ id: "2", name: "Item 2", timestamp: 2000 });
+      await sortedStore.add({ id: "3", name: "Item 3", timestamp: 3000 });
+      await sortedStore.add({ id: "4", name: "Item 4", timestamp: 4000 });
+      await sortedStore.add({ id: "5", name: "Item 5", timestamp: 5000 });
+
+      // 检查本地存储中的条目数量和内容
+      const localData = await localAdapter.getList("test-store-sorted");
+      expect(localData.length).toBe(3);
+      
+      // 应该保留时间戳最大的3个条目（删除了 timestamp: 1000, 2000 的条目）
+      const timestamps = localData.map(item => item.timestamp).sort((a, b) => a - b);
+      expect(timestamps).toEqual([3000, 4000, 5000]);
+    });
+  });
+});