@smess/networking 1.0.9 → 1.0.12

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

@@ -1,51 +1,59 @@
-import { ProductService } from './product.service';
-import { NetworkingUIEventWrapped } from '../types/types';
-import { of, throwError } from 'rxjs';
-import { BaseServiceWrapper } from '../core/base.service.wrapper';
-describe('ProductService', () => {
+import { ProductService } from "./product.service";
+import { NetworkingUIEventWrapped } from "../types/types";
+import { of, throwError } from "rxjs";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+describe("ProductService", () => {
     const config = {
-        baseUrl: 'https://jsonplaceholder.typicode.com',
+        baseUrl: "https://jsonplaceholder.typicode.com",
         isProd: false,
-        clientId: 'test-client',
-        apiKey: 'test-key',
+        clientId: "test-client",
+        apiKey: "test-key",
     };
-    const product = { id: 1, name: 'Product', price: 10 };
+    const product = { id: 1, name: "Product", price: 10 };
     let requestSpy;
     beforeEach(() => {
-        requestSpy = jest.spyOn(BaseServiceWrapper.prototype, 'request').mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(product)));
+        requestSpy = jest
+            .spyOn(BaseServiceWrapper.prototype, "request")
+            .mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(product)));
     });
     afterEach(() => {
         requestSpy.mockRestore();
     });
-    it('should fetch product by id', (done) => {
+    it("should fetch product by id", (done) => {
         const service = new ProductService(config, 1);
-        service.fetchProductById(1).subscribe((result) => {
+        service
+            .fetchProductById(1)
+            .subscribe((result) => {
             expect(result.response).toEqual(product);
             done();
         });
     });
-    it('should fetch all products', (done) => {
+    it("should fetch all products", (done) => {
         const service = new ProductService(config);
-        service.fetchAllProducts().subscribe((result) => {
+        service
+            .fetchAllProducts()
+            .subscribe((result) => {
             expect(result.response).toEqual(product);
             done();
         });
     });
-    it('should create a product', (done) => {
+    it("should create a product", (done) => {
         const service = new ProductService(config);
-        service.createProduct({ name: 'New Product', price: 99.99 }).subscribe((result) => {
+        service
+            .createProduct({ name: "New Product", price: 99.99 })
+            .subscribe((result) => {
             expect(result.response).toEqual(product);
             done();
         });
     });
-    it('request should handle error', (done) => {
-        requestSpy.mockImplementationOnce(() => throwError(() => new Error('Test error')));
+    it("request should handle error", (done) => {
+        requestSpy.mockImplementationOnce(() => throwError(() => new Error("Test error")));
         const service = new ProductService(config);
         // Simulate error by calling a method that uses request
         service.fetchProductById(1).subscribe({
             error: (err) => {
                 expect(err).toBeInstanceOf(Error);
-                expect(err.message).toBe('Test error');
+                expect(err.message).toBe("Test error");
                 done();
             },
         });

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

@@ -1,5 +1,5 @@
-import { HeaderType, NetworkingUIEventWrapped, ProviderType } from '../types/types';
-import { Observable } from '../utils/rxjs-import';
+import { HeaderType, NetworkingUIEventWrapped, ProviderType } from "../types/types";
+import { Observable } from "../utils/rxjs-import";
 export declare enum SMESSHeader {
     ContentType = "Content-Type",
     Authorization = "Authorization",

package/dist/services/smess.service.js

@@ -1,7 +1,7 @@
-import { AlertButtonModel, AlertModel, NetworkingUIEventWrapped, } from '../types/types';
-import { catchError, mergeMap, of, startWith, } from '../utils/rxjs-import';
-import HttpService from '../core/rx.http.service';
-import { $logger } from '../services/logger.service';
+import { AlertButtonModel, AlertModel, NetworkingUIEventWrapped, } from "../types/types";
+import { catchError, mergeMap, of, startWith, } from "../utils/rxjs-import";
+import HttpService from "../core/rx.http.service";
+import { $logger } from "../services/logger.service";
 export var SMESSHeader;
 (function (SMESSHeader) {
     SMESSHeader["ContentType"] = "Content-Type";
@@ -32,12 +32,12 @@ export class SmessService {
     constructor(target) {
         this.target = target;
         // Set default headers
-        $logger.info('SmessService initialized', {
+        $logger.info("SmessService initialized", {
             target: this.target,
             baseURL: this.target.baseURL,
             method: this.target.method,
             headers: this.target.headers,
-        }, 'SmessService');
+        }, "SmessService");
         this.httpService = HttpService.create({
             baseURL: this.target.baseURL,
             headers: this.target.headers,
@@ -47,7 +47,7 @@ export class SmessService {
             const originalRequest = error.config;
             if (error.response?.status === 401 && !originalRequest._retry) {
                 originalRequest._retry = true;
-                $logger.info('SmessService constructor - 401 retry', originalRequest, 'SmessService');
+                $logger.info("SmessService constructor - 401 retry", originalRequest, "SmessService");
                 // Implement token refresh logic here
                 // Then retry the original request
                 // return httpService.request(originalRequest);
@@ -58,21 +58,21 @@ export class SmessService {
     static getHeaders(version, authorization = null, options) {
         const headers = this.commonHeaders(version, options);
         if (authorization) {
-            headers['Authorization'] = authorization;
+            headers["Authorization"] = authorization;
         }
         return headers;
     }
     static filterHeaders(headers) {
-        const filteredHeaders = Object.fromEntries(Object.entries(headers).filter(([_, value]) => value !== undefined && value !== null && value !== ''));
+        const filteredHeaders = Object.fromEntries(Object.entries(headers).filter(([_, value]) => value !== undefined && value !== null && value !== ""));
         return filteredHeaders;
     }
     static commonHeaders(version, options) {
-        const { shouldAddClientIdHeader = true, } = options ?? {};
+        const { shouldAddClientIdHeader = true } = options ?? {};
         const headers = {
             Accept: version,
-            Authorization: '',
-            'Content-Type': ContentType.Json,
-            'X-Api-Key': ''
+            Authorization: "",
+            "Content-Type": ContentType.Json,
+            "X-Api-Key": "",
         };
         return headers;
     }
@@ -83,20 +83,20 @@ export class SmessService {
             : this.target.path;
         const config = { url };
         let observable;
-        if (this.target.method === 'GET') {
+        if (this.target.method === "GET") {
             if (request) {
                 config.data = request;
                 config.params = request;
             }
             observable = this.httpService.get(url, config);
         }
-        else if (this.target.method === 'POST') {
+        else if (this.target.method === "POST") {
             observable = this.httpService.post(url, request, config);
         }
-        else if (this.target.method === 'PATCH') {
+        else if (this.target.method === "PATCH") {
             observable = this.httpService.patch(url, request, config);
         }
-        else if (this.target.method === 'PUT') {
+        else if (this.target.method === "PUT") {
             observable = this.httpService.put(url, request, config);
         }
         else {
@@ -106,7 +106,7 @@ export class SmessService {
     }
     // MARK: - Private
     transformAxiosError(error, mockResponse) {
-        $logger.error('transformAxiosError', error, 'SmessService');
+        $logger.error("transformAxiosError", error, "SmessService");
         const message = error instanceof Error ? error.message : String(error);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for axios compatibility
         const response = error.response;
@@ -119,7 +119,7 @@ export class SmessService {
         return of(NetworkingUIEventWrapped.failed(alertModel));
     }
     transformAxiosResponse(response) {
-        $logger.info('transformAxiosResponse', response, 'SmessService');
+        $logger.info("transformAxiosResponse", response, "SmessService");
         if (response instanceof NetworkingUIEventWrapped) {
             return of(response);
         }

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

@@ -1,25 +1,25 @@
 /* eslint-disable @typescript-eslint/no-explicit-any -- Required for test mocks */
-import { SmessService } from './smess.service';
-import { NetworkingUIEventWrapped } from '../types/types';
-import { of, throwError } from 'rxjs';
-describe('SmessService', () => {
+import { SmessService } from "./smess.service";
+import { NetworkingUIEventWrapped, } from "../types/types";
+import { of, throwError } from "rxjs";
+describe("SmessService", () => {
     const config = {
-        baseUrl: 'https://api.example.com',
+        baseUrl: "https://api.example.com",
         isProd: false,
-        clientId: 'test-client',
-        apiKey: 'test-key',
+        clientId: "test-client",
+        apiKey: "test-key",
     };
     const provider = {
         baseURL: config.baseUrl,
-        path: '/resource',
-        method: 'GET',
+        path: "/resource",
+        method: "GET",
         headers: {},
-        getPath: () => '/resource',
+        getPath: () => "/resource",
     };
-    it('should return succeeded for GET', done => {
+    it("should return succeeded for GET", (done) => {
         const service = new SmessService(provider);
-        service['httpService'] = {
-            get: jest.fn(() => of({ data: { foo: 'bar' } })),
+        service["httpService"] = {
+            get: jest.fn(() => of({ data: { foo: "bar" } })),
             post: jest.fn(),
             patch: jest.fn(),
             put: jest.fn(),
@@ -28,33 +28,35 @@ describe('SmessService', () => {
         };
         service.request().subscribe((result) => {
             if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: 'bar' });
+                expect(result.response).toEqual({ foo: "bar" });
                 done();
             }
         });
     });
-    it('should return succeeded for POST', done => {
-        const postProvider = { ...provider, method: 'POST' };
+    it("should return succeeded for POST", (done) => {
+        const postProvider = { ...provider, method: "POST" };
         const service = new SmessService(postProvider);
-        service['httpService'] = {
+        service["httpService"] = {
             get: jest.fn(),
-            post: jest.fn(() => of({ data: { foo: 'baz' } })),
+            post: jest.fn(() => of({ data: { foo: "baz" } })),
             patch: jest.fn(),
             put: jest.fn(),
             request: jest.fn(),
             interceptors: { response: { use: jest.fn() } },
         };
-        service.request({ some: 'data' }).subscribe((result) => {
+        service
+            .request({ some: "data" })
+            .subscribe((result) => {
             if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: 'baz' });
+                expect(result.response).toEqual({ foo: "baz" });
                 done();
             }
         });
     });
-    it('should handle error', done => {
+    it("should handle error", (done) => {
         const service = new SmessService(provider);
-        service['httpService'] = {
-            get: jest.fn(() => throwError(() => new Error('Test error'))),
+        service["httpService"] = {
+            get: jest.fn(() => throwError(() => new Error("Test error"))),
             post: jest.fn(),
             patch: jest.fn(),
             put: jest.fn(),
@@ -66,32 +68,34 @@ describe('SmessService', () => {
                 expect(result).toBeInstanceOf(NetworkingUIEventWrapped);
                 expect(result.hasFailed).toBe(true);
                 expect(result.alertModel).toBeTruthy();
-                expect(result.alertModel?.message).toBe('Test error');
+                expect(result.alertModel?.message).toBe("Test error");
                 done();
             }
         });
     });
-    it('should return mock response if provided', done => {
+    it("should return mock response if provided", (done) => {
         const service = new SmessService(provider);
-        service['httpService'] = {
-            get: jest.fn(() => throwError(() => new Error('Test error'))),
+        service["httpService"] = {
+            get: jest.fn(() => throwError(() => new Error("Test error"))),
             post: jest.fn(),
             patch: jest.fn(),
             put: jest.fn(),
             request: jest.fn((payload, mockResponse) => {
-                if (payload === 'error') {
-                    return throwError(() => new Error('Test error'));
+                if (payload === "error") {
+                    return throwError(() => new Error("Test error"));
                 }
                 if (mockResponse !== undefined) {
                     return of(NetworkingUIEventWrapped.succeeded(mockResponse));
                 }
-                return of({ data: { foo: 'mock' } });
+                return of({ data: { foo: "mock" } });
             }),
             interceptors: { response: { use: jest.fn() } },
         };
-        service.request(undefined, { foo: 'mock' }).subscribe((result) => {
+        service
+            .request(undefined, { foo: "mock" })
+            .subscribe((result) => {
             if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: 'mock' });
+                expect(result.response).toEqual({ foo: "mock" });
                 done();
             }
         });

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

@@ -1,7 +1,7 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types';
-import { SmessService } from './smess.service';
-import { BehaviorSubject, Observable } from 'rxjs';
-export type StoreTarget = 'store-get' | 'store-list' | 'store-product-category-list' | 'store-product-collection' | 'store-featured-product-list';
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type StoreTarget = "store-get" | "store-list" | "store-product-category-list" | "store-product-collection" | "store-featured-product-list";
 export interface ProductCollectionRequest {
     page?: number;
     per_page?: number;

package/dist/services/store.service.js

@@ -1,8 +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';
+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;
@@ -10,26 +10,28 @@ export class StoreProvider {
         this.$authToken = $authToken;
     }
     get baseURL() {
-        return this.config.version ? `${this.config.baseUrl}/${this.config.version}` : this.config.baseUrl;
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
     }
     get path() {
         switch (this.target) {
-            case 'store-get':
-                return '/store/${id}/information';
-            case 'store-list':
-                return '/store/list';
-            case 'store-product-category-list':
-                return '/store/product-category-list';
-            case 'store-product-collection':
-                return '/store/${id}/product-collection';
-            case 'store-featured-product-list':
-                return '/store/${id}/featured-product-list';
+            case "store-get":
+                return "/store/${id}/information";
+            case "store-list":
+                return "/store/list";
+            case "store-product-category-list":
+                return "/store/product-category-list";
+            case "store-product-collection":
+                return "/store/${id}/product-collection";
+            case "store-featured-product-list":
+                return "/store/${id}/featured-product-list";
             default:
-                return '/store/${id}';
+                return "/store/${id}";
         }
     }
     get method() {
-        return 'GET';
+        return "GET";
     }
     get headers() {
         let headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
@@ -55,34 +57,36 @@ export class StoreService {
         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);
+        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 from(this.cacheService.getOne(id)).pipe(switchMap(cachedData => {
+        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 => {
+            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()
+                        timestamp: Date.now(),
                     });
                 }
                 return response;
-            }), catchError(error => {
+            }), catchError((error) => {
                 // If network fails and we have stale cache, return it
                 if (cachedData) {
                     return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
@@ -92,19 +96,25 @@ export class StoreService {
         }));
     }
     list() {
-        return from(this.storeListCache.getAll('store-list')).pipe(switchMap(cachedData => {
-            if (cachedData && cachedData.length > 0 && this.isCacheValid(cachedData[0].timestamp)) {
+        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 => {
+            return this.provider("store-list")
+                .request()
+                .pipe(map((response) => {
                 if (response.response) {
-                    this.storeListCache.saveAll([{
+                    this.storeListCache.saveAll([
+                        {
                             data: response.response,
-                            timestamp: Date.now()
-                        }], 'store-list');
+                            timestamp: Date.now(),
+                        },
+                    ], "store-list");
                 }
                 return response;
-            }), catchError(error => {
+            }), catchError((error) => {
                 if (cachedData && cachedData.length > 0) {
                     return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
                 }
@@ -113,19 +123,25 @@ export class StoreService {
         }));
     }
     productCategoryList() {
-        return from(this.productCategoryCache.getAll('product-category-list')).pipe(switchMap(cachedData => {
-            if (cachedData && cachedData.length > 0 && this.isCacheValid(cachedData[0].timestamp)) {
+        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 => {
+            return this.provider("store-product-category-list")
+                .request()
+                .pipe(map((response) => {
                 if (response.response) {
-                    this.productCategoryCache.saveAll([{
+                    this.productCategoryCache.saveAll([
+                        {
                             data: response.response,
-                            timestamp: Date.now()
-                        }], 'product-category-list');
+                            timestamp: Date.now(),
+                        },
+                    ], "product-category-list");
                 }
                 return response;
-            }), catchError(error => {
+            }), catchError((error) => {
                 if (cachedData && cachedData.length > 0) {
                     return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
                 }
@@ -135,21 +151,23 @@ export class StoreService {
     }
     productCollection(id, payload) {
         const cacheKey = `${id}-${JSON.stringify(payload)}`;
-        return from(this.productCollectionCache.getOne(cacheKey)).pipe(switchMap(cachedData => {
+        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 => {
+            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()
+                        timestamp: Date.now(),
                     });
                 }
                 return response;
-            }), catchError(error => {
+            }), catchError((error) => {
                 if (cachedData) {
                     return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
                 }
@@ -158,20 +176,22 @@ export class StoreService {
         }));
     }
     featuredProductList(id) {
-        return from(this.featuredProductCache.getOne(id)).pipe(switchMap(cachedData => {
+        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 => {
+            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()
+                        timestamp: Date.now(),
                     });
                 }
                 return response;
-            }), catchError(error => {
+            }), catchError((error) => {
                 if (cachedData) {
                     return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
                 }
@@ -186,7 +206,7 @@ export class StoreService {
             this.storeListCache.clearAll(),
             this.productCollectionCache.clearAll(),
             this.productCategoryCache.clearAll(),
-            this.featuredProductCache.clearAll()
+            this.featuredProductCache.clearAll(),
         ]).then(() => { });
     }
     clearStoreCache(id) {

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

@@ -1 +1 @@
-import 'fake-indexeddb/auto';
+import "fake-indexeddb/auto";