@smess/networking 1.0.7 → 1.0.9

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 export * from './services/user.service';
 export * from './services/product.service';
 export * from './services/auth.service';
+export * from './services/store.service';
+export * from './services/customer.service';
+export * from './services/order.service';
+export * from './services/cache.service';
 export * from './services/smess.service';
 export * from './core/base.provider';
 export * from './core/base.service.wrapper';

package/dist/index.js

@@ -1,6 +1,10 @@
 export * from './services/user.service';
 export * from './services/product.service';
 export * from './services/auth.service';
+export * from './services/store.service';
+export * from './services/customer.service';
+export * from './services/order.service';
+export * from './services/cache.service';
 export * from './services/smess.service';
 export * from './core/base.provider';
 export * from './core/base.service.wrapper';

package/dist/services/cache.service.d.ts

@@ -0,0 +1,31 @@
+import { Dexie, Table } from '../utils/cache-import';
+export interface CacheMetadata {
+    key: string;
+    cachedAt: number;
+    expiresAt: number;
+    version: string;
+}
+export declare class GenericDB<T> extends Dexie {
+    data: Table<T>;
+    cache: Table<CacheMetadata>;
+    constructor(name: string, dataStoreSchema: string);
+}
+export declare class GenericIndexedDBService<T, TCached> {
+    private toCached;
+    private fromCached;
+    private readonly CACHE_DURATION;
+    readonly db: GenericDB<TCached>;
+    constructor(dbName: string, storeSchema: string, toCached: (raw: T) => TCached, fromCached: (cached: TCached) => T);
+    saveAll(items: T[], cacheKey: string): Promise<void>;
+    getAll(cacheKey: string): Promise<T[] | null>;
+    saveOne(item: T): Promise<void>;
+    getOne(id: string): Promise<T | null>;
+    delete(id: string): Promise<void>;
+    clearAll(): Promise<void>;
+    getCacheInfo(key: string): Promise<{
+        count: number;
+        lastUpdated?: Date;
+    }>;
+    setStats(key: string, stats: unknown): Promise<void>;
+    getStats(key: string): Promise<unknown | null>;
+}

package/dist/services/cache.service.js

@@ -0,0 +1,77 @@
+import { Dexie } from '../utils/cache-import';
+export class GenericDB extends Dexie {
+    constructor(name, dataStoreSchema) {
+        super(name);
+        this.version(1).stores({
+            data: dataStoreSchema,
+            cache: 'key, cachedAt, expiresAt'
+        });
+    }
+}
+export class GenericIndexedDBService {
+    constructor(dbName, storeSchema, toCached, fromCached) {
+        this.toCached = toCached;
+        this.fromCached = fromCached;
+        this.CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours
+        this.db = new GenericDB(dbName, storeSchema);
+    }
+    async saveAll(items, cacheKey) {
+        const cachedItems = items.map(this.toCached);
+        await this.db.transaction('rw', this.db.data, this.db.cache, async () => {
+            await this.db.data.clear();
+            await this.db.data.bulkAdd(cachedItems);
+            await this.db.cache.put({
+                key: cacheKey,
+                cachedAt: Date.now(),
+                expiresAt: Date.now() + this.CACHE_DURATION,
+                version: '1.0'
+            });
+        });
+    }
+    async getAll(cacheKey) {
+        const cacheInfo = await this.db.cache.get(cacheKey);
+        if (!cacheInfo || Date.now() > cacheInfo.expiresAt)
+            return null;
+        const cachedItems = await this.db.data.toArray();
+        return cachedItems.map(this.fromCached);
+    }
+    async saveOne(item) {
+        const cached = this.toCached(item);
+        await this.db.data.put(cached);
+    }
+    async getOne(id) {
+        const cached = await this.db.data.get(id);
+        return cached ? this.fromCached(cached) : null;
+    }
+    async delete(id) {
+        await this.db.data.delete(id);
+    }
+    async clearAll() {
+        await this.db.transaction('rw', this.db.data, this.db.cache, async () => {
+            await this.db.data.clear();
+            await this.db.cache.clear();
+        });
+    }
+    async getCacheInfo(key) {
+        const count = await this.db.data.count();
+        const cacheInfo = await this.db.cache.get(key);
+        return {
+            count,
+            lastUpdated: cacheInfo ? new Date(cacheInfo.cachedAt) : undefined
+        };
+    }
+    async setStats(key, stats) {
+        await this.db.cache.put({
+            key,
+            cachedAt: Date.now(),
+            expiresAt: Date.now() + this.CACHE_DURATION,
+            version: JSON.stringify(stats)
+        });
+    }
+    async getStats(key) {
+        const cacheInfo = await this.db.cache.get(key);
+        if (!cacheInfo || Date.now() > cacheInfo.expiresAt)
+            return null;
+        return JSON.parse(cacheInfo.version);
+    }
+}

package/dist/services/cache.service.test.d.ts

@@ -0,0 +1 @@
+import 'fake-indexeddb/auto';

package/dist/services/cache.service.test.js

@@ -0,0 +1,88 @@
+import 'fake-indexeddb/auto';
+import { GenericIndexedDBService } from './cache.service';
+const toCached = (entity) => ({
+    id: entity.id,
+    name: entity.name,
+    createdAt: entity.createdAt.toISOString(),
+    cachedAt: Date.now()
+});
+const fromCached = (cached) => ({
+    id: cached.id,
+    name: cached.name,
+    createdAt: new Date(cached.createdAt)
+});
+describe('GenericIndexedDBService', () => {
+    let service;
+    beforeEach(() => {
+        service = new GenericIndexedDBService('TestDB', 'id, name', toCached, fromCached);
+    });
+    afterEach(async () => {
+        await service.db.delete();
+    });
+    it('should save and retrieve one item', async () => {
+        const item = {
+            id: '1',
+            name: 'Test Item',
+            createdAt: new Date()
+        };
+        await service.saveOne(item);
+        const result = await service.getOne('1');
+        expect(result).not.toBeNull();
+        expect(result?.id).toBe('1');
+    });
+    it('should save and retrieve all items', async () => {
+        const now = new Date();
+        const items = [
+            { id: '1', name: 'One', createdAt: now },
+            { id: '2', name: 'Two', createdAt: now }
+        ];
+        await service.saveAll(items, 'all');
+        const results = await service.getAll('all');
+        expect(results).not.toBeNull();
+        expect(results.length).toBe(2);
+    });
+    it('should return null when cache is expired', async () => {
+        const cacheTable = service.db.cache;
+        await cacheTable.put({
+            key: 'expired',
+            cachedAt: Date.now() - 10000,
+            expiresAt: Date.now() - 5000,
+            version: '1.0'
+        });
+        const result = await service.getAll('expired');
+        expect(result).toBeNull();
+    });
+    it('should delete one item', async () => {
+        const item = {
+            id: '1',
+            name: 'Delete Me',
+            createdAt: new Date()
+        };
+        await service.saveOne(item);
+        await service.delete('1');
+        const result = await service.getOne('1');
+        expect(result).toBeNull();
+    });
+    it('should set and retrieve stats', async () => {
+        const stats = { total: 99 };
+        await service.setStats('mystats', stats);
+        const result = await service.getStats('mystats');
+        expect(result).toEqual(stats);
+    });
+    it('should get cache info', async () => {
+        await service.saveOne({
+            id: '123',
+            name: 'Info Item',
+            createdAt: new Date()
+        });
+        await service.db.cache.put({
+            key: 'info',
+            cachedAt: Date.now(),
+            expiresAt: Date.now() + 10000,
+            version: '1.0'
+        });
+        const info = await service.getCacheInfo('info');
+        expect(info.count).toBeGreaterThanOrEqual(1);
+        expect(info.lastUpdated).toBeInstanceOf(Date);
+    });
+});

package/dist/services/store.service.d.ts

@@ -26,9 +26,38 @@ export declare class StoreProvider implements ProviderType {
     get headers(): Record<string, string>;
     getPath(...queryParams: unknown[]): string;
 }
+export interface StoreData {
+    id: string;
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface StoreListData {
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface ProductCollectionData {
+    storeId: string;
+    request: ProductCollectionRequest;
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface ProductCategoryData {
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface FeaturedProductData {
+    storeId: string;
+    data: HttpResponse;
+    timestamp: number;
+}
 export declare class StoreService {
     private readonly config;
     private readonly $authToken;
+    private readonly cacheService;
+    private readonly storeListCache;
+    private readonly productCollectionCache;
+    private readonly productCategoryCache;
+    private readonly featuredProductCache;
     constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
     provider(target: StoreTarget): SmessService<StoreProvider>;
     get(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
@@ -36,4 +65,8 @@ export declare class StoreService {
     productCategoryList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
     productCollection(id: string, payload: ProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
     featuredProductList(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    clearCache(): Promise<void>;
+    clearStoreCache(id: string): Promise<void>;
+    clearProductCollectionCache(id: string): Promise<void>;
+    private isCacheValid;
 }

package/dist/services/store.service.js

@@ -1,4 +1,8 @@
+import { NetworkingUIEventWrapped } from '../types/types';
 import { Accept, SMESSHeader, SmessService } from './smess.service';
+import { from, of } from 'rxjs';
+import { map, switchMap, catchError } from 'rxjs/operators';
+import { GenericIndexedDBService } from './cache.service';
 export class StoreProvider {
     constructor(config, target, $authToken) {
         this.config = config;
@@ -50,24 +54,151 @@ export class StoreService {
     constructor(config, $authToken) {
         this.config = config;
         this.$authToken = $authToken;
+        // Initialize cache services for different data types
+        this.cacheService = new GenericIndexedDBService('StoreCache', 'id, timestamp', (data) => data, (data) => data);
+        this.storeListCache = new GenericIndexedDBService('StoreListCache', 'timestamp', (data) => data, (data) => data);
+        this.productCollectionCache = new GenericIndexedDBService('ProductCollectionCache', 'storeId, timestamp', (data) => data, (data) => data);
+        this.productCategoryCache = new GenericIndexedDBService('ProductCategoryCache', 'timestamp', (data) => data, (data) => data);
+        this.featuredProductCache = new GenericIndexedDBService('FeaturedProductCache', 'storeId, timestamp', (data) => data, (data) => data);
     }
     provider(target) {
         const targetWrapper = new StoreProvider(this.config, target, this.$authToken);
         return new SmessService(targetWrapper);
     }
     get(id) {
-        return this.provider('store-get').request(null, undefined, id);
+        return from(this.cacheService.getOne(id)).pipe(switchMap(cachedData => {
+            if (cachedData && this.isCacheValid(cachedData.timestamp)) {
+                // Return cached data if valid
+                return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+            }
+            // Fetch from network if no cache or expired
+            return this.provider('store-get').request(null, undefined, id).pipe(map(response => {
+                // Cache the successful response
+                if (response.response) {
+                    this.cacheService.saveOne({
+                        id,
+                        data: response.response,
+                        timestamp: Date.now()
+                    });
+                }
+                return response;
+            }), catchError(error => {
+                // If network fails and we have stale cache, return it
+                if (cachedData) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+                }
+                throw error;
+            }));
+        }));
     }
     list() {
-        return this.provider('store-list').request();
+        return from(this.storeListCache.getAll('store-list')).pipe(switchMap(cachedData => {
+            if (cachedData && cachedData.length > 0 && this.isCacheValid(cachedData[0].timestamp)) {
+                return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
+            }
+            return this.provider('store-list').request().pipe(map(response => {
+                if (response.response) {
+                    this.storeListCache.saveAll([{
+                            data: response.response,
+                            timestamp: Date.now()
+                        }], 'store-list');
+                }
+                return response;
+            }), catchError(error => {
+                if (cachedData && cachedData.length > 0) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
+                }
+                throw error;
+            }));
+        }));
     }
     productCategoryList() {
-        return this.provider('store-product-category-list').request();
+        return from(this.productCategoryCache.getAll('product-category-list')).pipe(switchMap(cachedData => {
+            if (cachedData && cachedData.length > 0 && this.isCacheValid(cachedData[0].timestamp)) {
+                return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
+            }
+            return this.provider('store-product-category-list').request().pipe(map(response => {
+                if (response.response) {
+                    this.productCategoryCache.saveAll([{
+                            data: response.response,
+                            timestamp: Date.now()
+                        }], 'product-category-list');
+                }
+                return response;
+            }), catchError(error => {
+                if (cachedData && cachedData.length > 0) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
+                }
+                throw error;
+            }));
+        }));
     }
     productCollection(id, payload) {
-        return this.provider('store-product-collection').request(payload, undefined, id);
+        const cacheKey = `${id}-${JSON.stringify(payload)}`;
+        return from(this.productCollectionCache.getOne(cacheKey)).pipe(switchMap(cachedData => {
+            if (cachedData && this.isCacheValid(cachedData.timestamp)) {
+                return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+            }
+            return this.provider('store-product-collection').request(payload, undefined, id).pipe(map(response => {
+                if (response.response) {
+                    this.productCollectionCache.saveOne({
+                        storeId: cacheKey,
+                        request: payload,
+                        data: response.response,
+                        timestamp: Date.now()
+                    });
+                }
+                return response;
+            }), catchError(error => {
+                if (cachedData) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+                }
+                throw error;
+            }));
+        }));
     }
     featuredProductList(id) {
-        return this.provider('store-featured-product-list').request(null, undefined, id);
+        return from(this.featuredProductCache.getOne(id)).pipe(switchMap(cachedData => {
+            if (cachedData && this.isCacheValid(cachedData.timestamp)) {
+                return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+            }
+            return this.provider('store-featured-product-list').request(null, undefined, id).pipe(map(response => {
+                if (response.response) {
+                    this.featuredProductCache.saveOne({
+                        storeId: id,
+                        data: response.response,
+                        timestamp: Date.now()
+                    });
+                }
+                return response;
+            }), catchError(error => {
+                if (cachedData) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+                }
+                throw error;
+            }));
+        }));
+    }
+    // Cache management methods
+    clearCache() {
+        return Promise.all([
+            this.cacheService.clearAll(),
+            this.storeListCache.clearAll(),
+            this.productCollectionCache.clearAll(),
+            this.productCategoryCache.clearAll(),
+            this.featuredProductCache.clearAll()
+        ]).then(() => { });
+    }
+    clearStoreCache(id) {
+        return this.cacheService.delete(id);
+    }
+    clearProductCollectionCache(id) {
+        // This would need to be implemented with a more sophisticated approach
+        // to clear all product collection cache entries for a specific store
+        return Promise.resolve();
+    }
+    isCacheValid(timestamp) {
+        const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours for testing
+        return Date.now() - timestamp < CACHE_DURATION;
     }
 }

package/dist/services/store.service.test.d.ts

@@ -1 +1 @@
-export {};
+import 'fake-indexeddb/auto';

package/dist/services/store.service.test.js

@@ -1,3 +1,4 @@
+import 'fake-indexeddb/auto';
 import { StoreService } from './store.service';
 import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
 import { of, BehaviorSubject } from 'rxjs';
@@ -14,91 +15,186 @@ describe('StoreService', () => {
         $authToken = new BehaviorSubject(null);
         service = new StoreService(config, $authToken);
     });
-    it('get success', async () => {
+    afterEach(async () => {
+        await service.clearCache();
+    });
+    it('should create service instance', () => {
+        expect(service).toBeDefined();
+    });
+    it('should get store from network when no cache', async () => {
         const response = { data: { id: '1', name: 'Store' } };
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
+        const mockProvider = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
         const result = await service.get('1').toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('get error', async () => {
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
+    it('should get store from cache when available', async () => {
+        const response = { data: { id: '1', name: 'Store' } };
+        // First call to populate cache
+        const mockProvider1 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
+        await service.get('1').toPromise();
+        // Second call should use cache (even if network fails)
+        const mockProvider2 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
+        const result = await service.get('1').toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('should handle network error when no cache', async () => {
+        const mockProvider = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
         const result = await service.get('1').toPromise();
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
-    it('list success', async () => {
+    it('should get store list from network when no cache', async () => {
         const response = { data: [{ id: '1', name: 'Store' }] };
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
+        const mockProvider = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
         const result = await service.list().toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('list error', async () => {
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
+    it('should get store list from cache when available', async () => {
+        const response = { data: [{ id: '1', name: 'Store' }] };
+        // First call to populate cache
+        const mockProvider1 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
+        await service.list().toPromise();
+        // Second call should use cache
+        const mockProvider2 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
         const result = await service.list().toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
     });
-    it('productCategoryList success', async () => {
+    it('should get product category list from network when no cache', async () => {
         const response = { data: [{ id: 'cat1', name: 'Category' }] };
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
+        const mockProvider = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
         const result = await service.productCategoryList().toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('productCategoryList error', async () => {
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
+    it('should get product category list from cache when available', async () => {
+        const response = { data: [{ id: 'cat1', name: 'Category' }] };
+        // First call to populate cache
+        const mockProvider1 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
+        await service.productCategoryList().toPromise();
+        // Second call should use cache
+        const mockProvider2 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
         const result = await service.productCategoryList().toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
     });
-    it('productCollection success', async () => {
+    it('should get product collection from network when no cache', async () => {
         const response = { data: [{ id: 'prod1', name: 'Product' }] };
         const payload = { page: 1, per_page: 10 };
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: (payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
+        const mockProvider = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
         const result = await service.productCollection('1', payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('productCollection error', async () => {
+    it('should get product collection from cache when available', async () => {
+        const response = { data: [{ id: 'prod1', name: 'Product' }] };
         const payload = { page: 1, per_page: 10 };
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: (payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
+        // First call to populate cache
+        const mockProvider1 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
+        await service.productCollection('1', payload).toPromise();
+        // Second call should use cache
+        const mockProvider2 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
         const result = await service.productCollection('1', payload).toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
     });
-    it('featuredProductList success', async () => {
+    it('should get featured product list from network when no cache', async () => {
         const response = { data: [{ id: 'feat1', name: 'Featured' }] };
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: (_payload, _mockResponse, storeId) => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
+        const mockProvider = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
         const result = await service.featuredProductList('1').toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('featuredProductList error', async () => {
-        jest.spyOn(service, 'provider').mockReturnValue({
-            request: (_payload, _mockResponse, storeId) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
+    it('should get featured product list from cache when available', async () => {
+        const response = { data: [{ id: 'feat1', name: 'Featured' }] };
+        // First call to populate cache
+        const mockProvider1 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
+        await service.featuredProductList('1').toPromise();
+        // Second call should use cache
+        const mockProvider2 = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
         const result = await service.featuredProductList('1').toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('should clear cache successfully', async () => {
+        const response = { data: { id: '1', name: 'Store' } };
+        const mockProvider = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
+        // Populate cache
+        await service.get('1').toPromise();
+        // Clear cache
+        await service.clearCache();
+        // Should call network again after cache clear
+        const result = await service.get('1').toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(mockProvider.request).toHaveBeenCalledTimes(2); // Once before clear, once after
+    });
+    it('should clear specific store cache', async () => {
+        const response = { data: { id: '1', name: 'Store' } };
+        const mockProvider = {
+            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+        };
+        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
+        // Populate cache for store '1'
+        await service.get('1').toPromise();
+        // Clear specific store cache
+        await service.clearStoreCache('1');
+        // Should call network again after cache clear
+        const result = await service.get('1').toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(mockProvider.request).toHaveBeenCalledTimes(2);
     });
 });

package/dist/utils/cache-import.d.ts

@@ -0,0 +1,3 @@
+import Dexie from 'dexie';
+export { Dexie };
+export type Table<T> = Dexie.Table<T, string>;

package/dist/utils/cache-import.js

@@ -0,0 +1,2 @@
+import Dexie from 'dexie';
+export { Dexie };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smess/networking",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Networking utilities and services for SMESS platform.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,6 +34,8 @@
   },
   "dependencies": {
     "axios": "^1.10.0",
+    "dexie": "^4.0.11",
+    "fake-indexeddb": "^6.0.1",
     "rxjs": "^7.8.2"
   }
 }