@omnistreamai/data-core 0.1.0

package/src/store.ts

@@ -0,0 +1,469 @@
+import {
+  type LocalAdapter,
+  type RemoteAdapter,
+  type QueryOptions,
+  type QueryResult,
+} from "./types.js";
+
+/**
+ * Store configuration
+ */
+export interface StoreOptions<_T extends Record<string, unknown>> {
+  localAdapter: LocalAdapter | null;
+  remoteAdapter: RemoteAdapter | null;
+  idKey: string;
+  indexes?: string[];
+  /**
+   * Maximum number of local storage entries
+   * When local storage entries exceed this limit, oldest entries will be automatically deleted
+   * Can be used with sortByKey parameter to specify sorting field for deletion order
+   * If not set, no limit on local storage entries
+   */
+  maxLocalEntries?: number;
+  /**
+   * Field name for sorting when maxLocalEntries is in effect
+   * If this field is specified, entries will be sorted by this field's value before deleting oldest entries
+   * If not specified, entries will be deleted in default array order (usually insertion order)
+   * Supports number and string type field values
+   */
+  sortByKey?: string;
+  onChange?: () => void;
+  notThrowLocalError: boolean;
+}
+
+/**
+ * Store class
+ */
+export class Store<T extends Record<string, unknown>> {
+  private storeName: string;
+  private localAdapter: LocalAdapter | null;
+  private remoteAdapter: RemoteAdapter | null;
+  private idKey: string;
+  private indexes?: string[];
+  private maxLocalEntries?: number;
+  private sortByKey?: string;
+  private onChange?: () => void;
+  private notThrowLocalError: boolean;
+  private initialized = false;
+
+  constructor(storeName: string, options: StoreOptions<T>) {
+    this.storeName = storeName;
+    this.localAdapter = options.localAdapter;
+    this.remoteAdapter = options.remoteAdapter;
+    this.idKey = options.idKey;
+    this.indexes = options.indexes;
+    this.maxLocalEntries = options.maxLocalEntries;
+    this.sortByKey = options.sortByKey;
+    this.onChange = options.onChange;
+    this.notThrowLocalError = options.notThrowLocalError;
+  }
+
+  /**
+   * Initialize Store
+   */
+  async init(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    const promises: Promise<void | null>[] = [];
+
+    if (this.localAdapter) {
+      promises.push(
+        this.executeLocal(() =>
+          this.localAdapter!.initStore(
+            this.storeName,
+            this.indexes,
+            this.idKey,
+          ),
+        ),
+      );
+    }
+
+    if (this.remoteAdapter) {
+      promises.push(
+        this.executeRemote(() =>
+          this.remoteAdapter!.initStore(
+            this.storeName,
+            this.indexes,
+            this.idKey,
+          ),
+        ),
+      );
+    }
+
+    await Promise.all(promises);
+    this.initialized = true;
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+
+  private triggerChange(): void {
+    if (this.onChange) {
+      this.onChange();
+    }
+  }
+
+  private async executeLocal<TResult>(
+    operation: () => Promise<TResult>,
+  ): Promise<TResult | null> {
+    if (!this.localAdapter) {
+      return null;
+    }
+
+    try {
+      return await operation();
+    } catch (error) {
+      if (this.notThrowLocalError) {
+        console.warn("Local adapter error:", error);
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  private async executeRemote<TResult>(
+    operation: () => Promise<TResult>,
+  ): Promise<TResult> {
+    return await operation();
+  }
+
+  /**
+   * Enforce maximum local storage entries limit
+   */
+  private async enforceMaxLocalEntries(): Promise<void> {
+    if (!this.localAdapter || !this.maxLocalEntries) {
+      return;
+    }
+
+    try {
+      let currentEntries = await this.localAdapter.getList<T>(
+        this.storeName,
+        {},
+        this.idKey,
+      );
+
+      if (currentEntries.length > this.maxLocalEntries) {
+        // If sorting field is specified, sort by that field
+        if (this.sortByKey) {
+          currentEntries = this.sortEntries(currentEntries, this.sortByKey);
+        }
+
+        // Calculate number of entries to delete
+        const entriesToDelete = currentEntries.length - this.maxLocalEntries;
+
+        // Delete oldest entries (first element after sorting is the oldest)
+        for (let i = 0; i < entriesToDelete; i++) {
+          const entryToDelete = currentEntries[i];
+          if (entryToDelete) {
+            const id = String(entryToDelete[this.idKey]);
+            await this.executeLocal(() =>
+              this.localAdapter!.delete(this.storeName, id, this.idKey),
+            );
+          }
+        }
+      }
+    } catch (error) {
+      if (this.notThrowLocalError) {
+        console.warn("Failed to enforce max local entries:", error);
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Sort entries by specified field
+   * @param entries Array of entries to sort
+   * @param key Sorting field name
+   * @returns Sorted array of entries
+   */
+  private sortEntries(entries: T[], key: string): T[] {
+    return [...entries].sort((a, b) => {
+      const aValue = a[key];
+      const bValue = b[key];
+
+      // Handle undefined or null values
+      if (aValue == null && bValue == null) return 0;
+      if (aValue == null) return 1; // null/undefined at the end
+      if (bValue == null) return -1; // null/undefined at the end
+
+      // Number type sorting
+      if (typeof aValue === "number" && typeof bValue === "number") {
+        return aValue - bValue;
+      }
+
+      // String type sorting
+      if (typeof aValue === "string" && typeof bValue === "string") {
+        return aValue.localeCompare(bValue);
+      }
+
+      // Date type sorting (if string format date)
+      if (typeof aValue === "string" && typeof bValue === "string") {
+        const aDate = new Date(aValue);
+        const bDate = new Date(bValue);
+        if (!isNaN(aDate.getTime()) && !isNaN(bDate.getTime())) {
+          return aDate.getTime() - bDate.getTime();
+        }
+      }
+
+      // Convert other types to string for comparison
+      return String(aValue).localeCompare(String(bValue));
+    });
+  }
+
+  /**
+   * Add data
+   */
+  async add(data: T): Promise<T> {
+    await this.ensureInitialized();
+
+    // Write to both local and remote simultaneously
+    const promises: Promise<T>[] = [];
+
+    if (this.localAdapter) {
+      const localResult = await this.executeLocal(() =>
+        this.localAdapter!.add(this.storeName, data, this.idKey),
+      );
+      if (localResult) {
+        promises.push(Promise.resolve(localResult));
+
+          // Check local storage entries limit
+        await this.enforceMaxLocalEntries();
+      }
+    }
+
+    if (this.remoteAdapter) {
+      promises.push(this.remoteAdapter.add(this.storeName, data, this.idKey));
+    }
+
+    await Promise.all(promises);
+    this.triggerChange();
+    return data;
+  }
+
+  /**
+   * Update data
+   */
+  async update(id: string, data: Partial<T>): Promise<T> {
+    await this.ensureInitialized();
+
+    const promises: Promise<T>[] = [];
+
+    if (this.localAdapter) {
+      const localResult = await this.executeLocal(() =>
+        this.localAdapter!.update<T>(this.storeName, id, data, this.idKey),
+      );
+      if (localResult) {
+        promises.push(Promise.resolve(localResult));
+      }
+    }
+
+    if (this.remoteAdapter) {
+      promises.push(
+        this.remoteAdapter.update<T>(this.storeName, id, data, this.idKey),
+      );
+    }
+
+    const results = await Promise.all(promises);
+    this.triggerChange();
+    // Return first non-null result
+    const firstResult = results.find(
+      (result) => result !== null && result !== undefined,
+    );
+    return firstResult as T;
+  }
+
+  /**
+   * Delete data
+   */
+  async delete(id: string): Promise<void> {
+    await this.ensureInitialized();
+
+    const promises: Promise<void | null>[] = [];
+
+    if (this.localAdapter) {
+      promises.push(
+        this.executeLocal(() =>
+          this.localAdapter!.delete(this.storeName, id, this.idKey),
+        ),
+      );
+    }
+
+    if (this.remoteAdapter) {
+      promises.push(this.remoteAdapter.delete(this.storeName, id, this.idKey));
+    }
+
+    await Promise.all(promises);
+    this.triggerChange();
+  }
+
+  /**
+   * Get data by ID
+   */
+  async getData(id: string): Promise<T | null> {
+    await this.ensureInitialized();
+
+    // Prioritize getting from local
+    if (this.localAdapter) {
+      try {
+        const localResult = await this.executeLocal(() =>
+          this.localAdapter!.getData(this.storeName, id, this.idKey),
+        );
+        if (localResult) {
+          return localResult as T;
+        }
+      } catch (error) {
+        if (!this.notThrowLocalError) {
+          throw error;
+        }
+      }
+    }
+
+    // Get from remote
+    if (this.remoteAdapter) {
+      return await this.remoteAdapter.getData(this.storeName, id, this.idKey);
+    }
+
+    return null;
+  }
+
+  /**
+   * Get list data
+   */
+  async getList(options: QueryOptions<T> = {}): Promise<T[]> {
+    await this.ensureInitialized();
+
+    const source = options.source;
+
+    // If source is specified
+    if (source === "local" && this.localAdapter) {
+      return await this.localAdapter.getList<T>(
+        this.storeName,
+        options,
+        this.idKey,
+      );
+    }
+
+    if (source === "remote" && this.remoteAdapter) {
+      const result = await this.remoteAdapter.getList<T>(
+        this.storeName,
+        options,
+        this.idKey,
+      );
+      return result.data;
+    }
+
+    // Default to getting from remote
+    if (this.remoteAdapter) {
+      try {
+        const result = await this.remoteAdapter.getList<T>(
+          this.storeName,
+          options,
+          this.idKey,
+        );
+
+        // Cache to local
+        if (this.localAdapter && result.data.length > 0) {
+          await Promise.all(
+            result.data.map((item) =>
+              this.executeLocal(() =>
+                this.localAdapter!.add(this.storeName, item, this.idKey),
+              ),
+            ),
+          );
+
+        // Check local storage entries limit
+          await this.enforceMaxLocalEntries();
+        }
+
+        return result.data;
+      } catch (error) {
+        // If remote fails, try to get from local
+        if (this.localAdapter) {
+          return await this.localAdapter.getList<T>(
+            this.storeName,
+            options,
+            this.idKey,
+          );
+        }
+        throw error;
+      }
+    }
+
+    // Only local adapter
+    if (this.localAdapter) {
+      return await this.localAdapter.getList<T>(
+        this.storeName,
+        options,
+        this.idKey,
+      );
+    }
+
+    return [];
+  }
+
+  /**
+   * Get query object for list data
+   */
+  async getListQuery(options: QueryOptions<T> = {}): Promise<QueryResult<T[]>> {
+    await this.ensureInitialized();
+
+    const source = options.source;
+
+    // Build query key
+    const queryKey = ["store", this.storeName, source || "default", options];
+
+    // Build query function
+    const queryFn = async (): Promise<T[]> => {
+      return this.getList(options);
+    };
+
+    // Build initial data fetch function
+    const getInitialData = async (): Promise<T[]> => {
+      if (this.localAdapter) {
+        try {
+          return await this.localAdapter.getList<T>(
+            this.storeName,
+            options,
+            this.idKey,
+          );
+        } catch (error) {
+          // If local fetch fails, return empty array
+          return [];
+        }
+      }
+      return [];
+    };
+
+    return {
+      queryKey,
+      queryFn,
+      getInitialData,
+    };
+  }
+
+  /**
+   * Clear store
+   */
+  async clear(): Promise<void> {
+    await this.ensureInitialized();
+
+    const promises: Promise<void>[] = [];
+
+    if (this.localAdapter) {
+      await this.executeLocal(() => this.localAdapter!.clear(this.storeName));
+    }
+
+    if (this.remoteAdapter) {
+      promises.push(this.remoteAdapter.clear(this.storeName));
+    }
+
+    await Promise.all(promises);
+    this.triggerChange();
+  }
+}

package/src/sync-manager.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createSyncManager, SyncManager } from './sync-manager.js';
+import { AdapterType, type QueryResult, type QueryOptions } from './types.js';
+import type { LocalAdapter, RemoteAdapter } from './types.js';
+
+// Mock adapters
+class MockLocalAdapter implements LocalAdapter {
+  readonly type = AdapterType.Local;
+  readonly name = 'MockLocalAdapter';
+  
+  async add<T extends Record<string, unknown>>(storeName: string, data: T, idKey?: string): Promise<T> {
+    return data;
+  }
+  
+  async update<T extends Record<string, unknown>>(storeName: string, id: string, data: Partial<T>, idKey?: string): Promise<T> {
+    return { ...data, id } as unknown as T;
+  }
+  
+  async delete(storeName: string, id: string, idKey?: string): Promise<void> {
+    // Mock implementation
+  }
+  
+  async getData<T extends Record<string, unknown>>(storeName: string, id: string, idKey?: string): Promise<T | null> {
+    return null;
+  }
+  
+  async getList<T extends Record<string, unknown>>(storeName: string, options?: unknown, idKey?: string): Promise<T[]> {
+    return [];
+  }
+
+
+  
+  async clear(storeName: string): Promise<void> {
+    // Mock implementation
+  }
+  
+  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) {
+    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('SyncManager', () => {
+  let localAdapter: LocalAdapter;
+  let remoteAdapter: RemoteAdapter;
+
+  beforeEach(() => {
+    localAdapter = new MockLocalAdapter();
+    remoteAdapter = new MockRemoteAdapter();
+  });
+
+  describe('createSyncManager', () => {
+    it('应该能够创建 SyncManager 实例', () => {
+      const manager = createSyncManager({
+        localAdapter,
+        remoteAdapter,
+      });
+
+      expect(manager).toBeInstanceOf(SyncManager);
+    });
+
+    it('应该支持可选参数', () => {
+      const manager = createSyncManager({});
+      expect(manager).toBeInstanceOf(SyncManager);
+    });
+
+    it('应该支持 notThrowLocalError 选项', () => {
+      const manager = createSyncManager({
+        notThrowLocalError: true,
+      });
+      expect(manager).toBeInstanceOf(SyncManager);
+    });
+  });
+
+  describe('setLocalAdapter', () => {
+    it('应该能够设置本地适配器', () => {
+      const manager = createSyncManager({});
+      manager.setLocalAdapter(localAdapter);
+      expect(manager).toBeDefined();
+    });
+  });
+
+  describe('setRemoteAdapter', () => {
+    it('应该能够设置远程适配器', () => {
+      const manager = createSyncManager({});
+      manager.setRemoteAdapter(remoteAdapter);
+      expect(manager).toBeDefined();
+    });
+  });
+
+  describe('createStore', () => {
+    it('应该能够创建 Store', () => {
+      const manager = createSyncManager({
+        localAdapter,
+        remoteAdapter,
+      });
+
+      const store = manager.createStore<{ id: string; name: string }>('test-store', {
+        idKey: 'id',
+        indexes: ['name'],
+      });
+
+      expect(store).toBeDefined();
+    });
+
+    it('应该支持可选配置', () => {
+      const manager = createSyncManager({
+        localAdapter,
+        remoteAdapter,
+      });
+
+      const store = manager.createStore<{ id: string }>('test-store');
+      expect(store).toBeDefined();
+    });
+
+    it('应该支持 onChange 回调', () => {
+      const onChange = vi.fn();
+      const manager = createSyncManager({
+        localAdapter,
+        remoteAdapter,
+      });
+
+      const store = manager.createStore<{ id: string }>('test-store', {
+        onChange,
+      });
+
+      expect(store).toBeDefined();
+    });
+  });
+});
+
+