@smess/networking 1.0.28 → 1.0.30

package/dist/src/services/storefront.store.service.js

@@ -0,0 +1,140 @@
+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 StorefrontStoreProvider {
+    constructor(config, target) {
+        this.config = config;
+        this.target = target;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "store-list":
+                return "/storefront/stores/list";
+            case "store-information":
+                return "/storefront/stores/${id}/information";
+            default:
+                return "/storefront/stores/list";
+        }
+    }
+    get method() {
+        return "GET";
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, null);
+        if (this.config.clientId) {
+            headers[SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            headers[SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        return SmessService.filterHeaders(headers);
+    }
+    getPath(...queryParams) {
+        let definedPath = this.path;
+        const params = definedPath.match(/\$\{(.+?)\}/g);
+        params?.forEach((value, index) => {
+            definedPath = definedPath.replace(value, String(queryParams[index]));
+        });
+        return definedPath;
+    }
+}
+export class StorefrontStoreService {
+    constructor(config) {
+        this.config = config;
+        // Initialize cache services for different data types
+        this.cacheService = new GenericIndexedDBService("StorefrontStoreCache", "id, timestamp", (data) => data, (data) => data);
+        this.storeListCache = new GenericIndexedDBService("StorefrontStoreListCache", "timestamp", (data) => data, (data) => data);
+    }
+    provider(target) {
+        const targetWrapper = new StorefrontStoreProvider(this.config, target);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * List all accessible stores with shipping rules
+     * GET /storefront/stores/list
+     */
+    listStores() {
+        return from(this.storeListCache.getAll("storefront-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(),
+                        },
+                    ], "storefront-store-list");
+                }
+                return response;
+            }), catchError((error) => {
+                if (cachedData && cachedData.length > 0) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
+                }
+                throw error;
+            }));
+        }));
+    }
+    /**
+     * Get detailed store information by ID including shipping rules
+     * GET /storefront/stores/{id}/information
+     */
+    getStoreInformation(id) {
+        return from(this.cacheService.getOne(String(id))).pipe(switchMap((cachedData) => {
+            if (cachedData && this.isCacheValid(cachedData.timestamp)) {
+                return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+            }
+            return this.provider("store-information")
+                .request(null, undefined, id)
+                .pipe(map((response) => {
+                if (response.response) {
+                    this.cacheService.saveOne({
+                        id,
+                        data: response.response,
+                        timestamp: Date.now(),
+                    });
+                }
+                return response;
+            }), catchError((error) => {
+                if (cachedData) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+                }
+                throw error;
+            }));
+        }));
+    }
+    /**
+     * Clear all cache
+     */
+    clearCache() {
+        return Promise.all([
+            this.cacheService.clearAll(),
+            this.storeListCache.clearAll(),
+        ]).then(() => { });
+    }
+    /**
+     * Clear cache for a specific store
+     */
+    clearStoreCache(id) {
+        return this.cacheService.delete(String(id));
+    }
+    /**
+     * Check if cache is still valid (24 hours)
+     */
+    isCacheValid(timestamp) {
+        const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours
+        return Date.now() - timestamp < CACHE_DURATION;
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,90 @@
+import { StorefrontStoreService, StorefrontStoreProvider, } from "./storefront.store.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of } from "rxjs";
+describe("StorefrontStoreService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        version: "api/v1",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    beforeEach(() => {
+        service = new StorefrontStoreService(config);
+    });
+    describe("StorefrontStoreProvider", () => {
+        it("should generate correct path for store-list", () => {
+            const provider = new StorefrontStoreProvider(config, "store-list");
+            expect(provider.path).toBe("/storefront/stores/list");
+            expect(provider.method).toBe("GET");
+        });
+        it("should generate correct path for store-information", () => {
+            const provider = new StorefrontStoreProvider(config, "store-information");
+            expect(provider.path).toBe("/storefront/stores/${id}/information");
+            expect(provider.method).toBe("GET");
+            expect(provider.getPath(1)).toBe("/storefront/stores/1/information");
+        });
+        it("should include correct headers", () => {
+            const provider = new StorefrontStoreProvider(config, "store-list");
+            const headers = provider.headers;
+            expect(headers["X-Client-Id"]).toBe("test-client-id");
+            expect(headers["X-Api-Key"]).toBe("test-api-key");
+            expect(headers["Accept"]).toBe("application/json");
+        });
+        it("should generate correct baseURL with version", () => {
+            const provider = new StorefrontStoreProvider(config, "store-list");
+            expect(provider.baseURL).toBe("https://api.example.com/api/v1");
+        });
+    });
+    describe("listStores", () => {
+        it("should list stores successfully", async () => {
+            const response = {
+                data: { stores: [], total: 0 },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.listStores().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle list stores error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.listStores().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("getStoreInformation", () => {
+        it("should get store information successfully", async () => {
+            const response = {
+                data: { id: 1, name: "Test Store" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getStoreInformation(1).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle get store information error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.getStoreInformation(1).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("cache management", () => {
+        it("should clear all cache", async () => {
+            await expect(service.clearCache()).resolves.toBeUndefined();
+        });
+        it("should clear specific store cache", async () => {
+            await expect(service.clearStoreCache(1)).resolves.toBeUndefined();
+        });
+    });
+});

package/dist/src/services/user.service.d.ts

@@ -0,0 +1,16 @@
+import { BaseProvider } from "../core/base.provider";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+import { NetworkingConfig } from "../types/types";
+export interface User {
+    id: number;
+    name: string;
+    email: string;
+}
+export declare class UserProvider extends BaseProvider {
+    constructor(config: NetworkingConfig, userId?: number);
+}
+export declare class UserService extends BaseServiceWrapper<UserProvider> {
+    constructor(config: NetworkingConfig, userId?: number);
+    fetchUserById(id: number): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<User>>;
+    fetchAllUsers(): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<User[]>>;
+}

package/dist/src/services/user.service.js

@@ -0,0 +1,37 @@
+import { BaseProvider } from "../core/base.provider";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+// UserProvider implements ProviderType for user endpoints
+export class UserProvider extends BaseProvider {
+    constructor(config, userId) {
+        super({
+            config,
+            path: userId ? `/users/${userId}` : "/users",
+            method: "GET",
+            headers: {},
+            getPath: () => (userId ? `/users/${userId}` : "/users"),
+        });
+    }
+}
+// UserService provides high-level methods for user API
+export class UserService extends BaseServiceWrapper {
+    constructor(config, userId) {
+        super(new UserProvider(config, userId));
+    }
+    // Fetch a user by ID
+    fetchUserById(id) {
+        this.provider = new UserProvider({ baseUrl: "https://jsonplaceholder.typicode.com", isProd: false }, id);
+        return this.request();
+    }
+    // Fetch all users
+    fetchAllUsers() {
+        this.provider = new UserProvider({
+            baseUrl: "https://jsonplaceholder.typicode.com",
+            isProd: false,
+        });
+        return this.request();
+    }
+}
+// Example usage:
+// setNetworkingConfig({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false });
+// const userService = new UserService();
+// userService.fetchUserById(1).subscribe(result => console.log(result));

package/dist/src/services/user.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/user.service.test.js

@@ -0,0 +1,52 @@
+import { UserService } from "./user.service";
+import { NetworkingUIEventWrapped } from "../types/types";
+import { of, throwError } from "rxjs";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+describe("UserService", () => {
+    const config = {
+        baseUrl: "https://jsonplaceholder.typicode.com",
+        isProd: false,
+        clientId: "test-client",
+        apiKey: "test-key",
+    };
+    const user = { id: 1, name: "Test", email: "test@example.com" };
+    let requestSpy;
+    beforeEach(() => {
+        requestSpy = jest
+            .spyOn(BaseServiceWrapper.prototype, "request")
+            .mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(user)));
+    });
+    afterEach(() => {
+        requestSpy.mockRestore();
+    });
+    it("fetchUserById should return user (success)", (done) => {
+        const service = new UserService(config);
+        service
+            .fetchUserById(1)
+            .subscribe((result) => {
+            expect(result.response).toEqual(user);
+            done();
+        });
+    });
+    it("fetchAllUsers should return users (success)", (done) => {
+        const service = new UserService(config);
+        service
+            .fetchAllUsers()
+            .subscribe((result) => {
+            expect(result.response).toEqual(user);
+            done();
+        });
+    });
+    it("request should handle error", (done) => {
+        requestSpy.mockImplementationOnce(() => throwError(() => new Error("Test error")));
+        const service = new UserService(config);
+        // Simulate error by calling a method that uses request
+        service.fetchUserById(1).subscribe({
+            error: (err) => {
+                expect(err).toBeInstanceOf(Error);
+                expect(err.message).toBe("Test error");
+                done();
+            },
+        });
+    });
+});

package/dist/src/services/utils/withAuthReset.d.ts

@@ -0,0 +1,3 @@
+import { BehaviorSubject, Observable } from "rxjs";
+import { NetworkingUIEventWrapped } from "../../types/types";
+export declare const withAuthReset: <T>(source$: Observable<NetworkingUIEventWrapped<T>>, $authToken: BehaviorSubject<string | null>) => Observable<NetworkingUIEventWrapped<T>>;

package/dist/src/services/utils/withAuthReset.js

@@ -0,0 +1,8 @@
+import { tap } from "rxjs/operators";
+export const withAuthReset = (source$, $authToken) => {
+    return source$.pipe(tap((event) => {
+        if (event.isUnauthenticated) {
+            $authToken.next(null);
+        }
+    }));
+};

package/dist/src/types/types.d.ts

@@ -0,0 +1,93 @@
+export type CallbackHandler = () => void;
+interface AlertModelable {
+    isUnauthenticated: boolean;
+    isNetworkingError: boolean;
+}
+interface AlertButtonModelable {
+    title: string;
+    handler?: CallbackHandler;
+}
+export declare class AlertButtonModel implements AlertButtonModelable {
+    title: string;
+    handler?: CallbackHandler | undefined;
+    constructor(title: string, handler?: CallbackHandler | undefined);
+    static buttonYes(handler?: CallbackHandler): AlertButtonModelable;
+    static buttonNo(handler?: CallbackHandler): AlertButtonModelable;
+}
+export declare class AlertModel implements AlertModelable {
+    message: string;
+    httpErrorCode: number;
+    isDisplayable: boolean;
+    title?: string | undefined;
+    data?: unknown | undefined;
+    buttons?: AlertButtonModelable[] | undefined;
+    constructor(message: string, httpErrorCode: number, isDisplayable?: boolean, title?: string | undefined, data?: unknown | undefined, buttons?: AlertButtonModelable[] | undefined);
+    get isUnauthenticated(): boolean;
+    get isNetworkingError(): boolean;
+    static default(): AlertModel;
+}
+export declare class ValidationErrorMessage {
+    message: string;
+    constructor(message: string);
+}
+export type NetworkingFailed = {
+    alertModel: AlertModel;
+};
+export type NetworkingSucceeded<ResponseType> = {
+    responseBody: ResponseType;
+};
+export declare enum NetworkingUIEvent {
+    waiting = "waiting",
+    succeeded = "succeeded",
+    failed = "failed"
+}
+export declare class NetworkingUIEventWrapped<JSONResponse> {
+    private event;
+    private succeeded?;
+    private failed?;
+    constructor(event: NetworkingUIEvent, succeeded?: NetworkingSucceeded<JSONResponse> | undefined, failed?: NetworkingFailed | undefined);
+    get response(): JSONResponse | null;
+    get alertModel(): AlertModel | null;
+    get isWaiting(): boolean;
+    get hasSuccess(): boolean;
+    get hasFailed(): boolean;
+    get isUnauthenticated(): boolean;
+    static waiting<JSONResponse>(): NetworkingUIEventWrapped<JSONResponse>;
+    static succeeded<JSONResponse>(data: JSONResponse): NetworkingUIEventWrapped<JSONResponse>;
+    static failed<JSONResponse>(alertModel: AlertModel): NetworkingUIEventWrapped<JSONResponse>;
+}
+export interface ProviderType {
+    baseURL: string;
+    path: string;
+    method: string;
+    headers: Record<string, string | undefined>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface HeaderType {
+    shouldAddEncryptionHeader?: boolean;
+    shouldAddClientIdHeader?: boolean;
+}
+export interface HttpResponse {
+    data: unknown;
+}
+export interface ServerValidationErrorMessage {
+    message: string;
+    parameters?: {
+        error_code?: string;
+        field?: string;
+        [key: string]: unknown;
+    };
+}
+export interface ServerErrorResponse {
+    errors?: {
+        [field: string]: ServerValidationErrorMessage[];
+    };
+}
+export interface NetworkingConfig {
+    baseUrl: string;
+    version?: string;
+    isProd: boolean;
+    clientId?: string;
+    apiKey?: string;
+}
+export {};

package/dist/src/types/types.js

@@ -0,0 +1,82 @@
+export class AlertButtonModel {
+    constructor(title, handler) {
+        this.title = title;
+        this.handler = handler;
+    }
+    static buttonYes(handler) {
+        return new AlertButtonModel("Yes", handler);
+    }
+    static buttonNo(handler) {
+        return new AlertButtonModel("No", handler);
+    }
+}
+export class AlertModel {
+    constructor(message, httpErrorCode, isDisplayable = false, title, data, buttons) {
+        this.message = message;
+        this.httpErrorCode = httpErrorCode;
+        this.isDisplayable = isDisplayable;
+        this.title = title;
+        this.data = data;
+        this.buttons = buttons;
+    }
+    get isUnauthenticated() {
+        return this.httpErrorCode == 401;
+    }
+    get isNetworkingError() {
+        return this.httpErrorCode == 0;
+    }
+    static default() {
+        return new AlertModel("Generic Error", 0, true, "", null, [
+            AlertButtonModel.buttonYes(),
+        ]);
+    }
+}
+export class ValidationErrorMessage {
+    constructor(message) {
+        this.message = message;
+    }
+}
+export var NetworkingUIEvent;
+(function (NetworkingUIEvent) {
+    NetworkingUIEvent["waiting"] = "waiting";
+    NetworkingUIEvent["succeeded"] = "succeeded";
+    NetworkingUIEvent["failed"] = "failed";
+})(NetworkingUIEvent || (NetworkingUIEvent = {}));
+export class NetworkingUIEventWrapped {
+    constructor(event, succeeded, failed) {
+        this.event = event;
+        this.succeeded = succeeded;
+        this.failed = failed;
+    }
+    get response() {
+        return this.succeeded ? this.succeeded.responseBody : null;
+    }
+    get alertModel() {
+        return this.failed ? this.failed.alertModel : null;
+    }
+    get isWaiting() {
+        return this.event == NetworkingUIEvent.waiting;
+    }
+    get hasSuccess() {
+        return this.event == NetworkingUIEvent.succeeded;
+    }
+    get hasFailed() {
+        return this.event == NetworkingUIEvent.failed;
+    }
+    get isUnauthenticated() {
+        return this.alertModel ? this.alertModel.isUnauthenticated : false;
+    }
+    static waiting() {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.waiting);
+    }
+    static succeeded(data) {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.succeeded, {
+            responseBody: data,
+        });
+    }
+    static failed(alertModel) {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.failed, undefined, {
+            alertModel: alertModel,
+        });
+    }
+}

package/dist/src/types/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/types/types.test.js

@@ -0,0 +1,25 @@
+import { NetworkingUIEventWrapped, AlertModel } from "./types";
+describe("NetworkingUIEventWrapped", () => {
+    it("should wrap succeeded response", () => {
+        const wrap = NetworkingUIEventWrapped.succeeded({ foo: "bar" });
+        expect(wrap.response).toEqual({ foo: "bar" });
+        expect(wrap.hasSuccess).toBe(true);
+        expect(wrap.hasFailed).toBe(false);
+        expect(wrap.isWaiting).toBe(false);
+    });
+    it("should wrap failed response and set alertModel", () => {
+        const alert = new AlertModel("err", 500, true, "Error", { detail: "fail" });
+        const wrap = NetworkingUIEventWrapped.failed(alert);
+        expect(wrap.response).toBeNull();
+        expect(wrap.hasSuccess).toBe(false);
+        expect(wrap.hasFailed).toBe(true);
+        expect(wrap.isWaiting).toBe(false);
+        expect(wrap.alertModel).toBe(alert);
+    });
+    it("should wrap waiting state", () => {
+        const wrap = NetworkingUIEventWrapped.waiting();
+        expect(wrap.isWaiting).toBe(true);
+        expect(wrap.hasSuccess).toBe(false);
+        expect(wrap.hasFailed).toBe(false);
+    });
+});

package/dist/src/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/src/utils/cache-import.js

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

package/dist/src/utils/networking-import.d.ts

@@ -0,0 +1,4 @@
+export * from "axios";
+import axios, { HttpStatusCode } from "axios";
+export { axios, HttpStatusCode };
+export type { AxiosInstance, AxiosResponse, AxiosError, InternalAxiosRequestConfig, AxiosRequestConfig, } from "axios";

package/dist/src/utils/networking-import.js

@@ -0,0 +1,3 @@
+export * from "axios";
+import axios, { HttpStatusCode } from "axios";
+export { axios, HttpStatusCode };

package/dist/src/utils/rxjs-import.d.ts

@@ -0,0 +1,5 @@
+import { BehaviorSubject, Observable, Subject, Subscription, Subscriber, catchError, combineLatest, concatMap, distinctUntilChanged, filter, firstValueFrom, from, fromEvent, merge, NEVER, interval, map, mergeMap, of, pipe, shareReplay, startWith, tap, timeout, retry, throwError, combineLatestWith, debounceTime, delay, takeUntil } from "rxjs";
+export { Observable, Subject, BehaviorSubject, Subscription, Subscriber };
+export { startWith, firstValueFrom, from, fromEvent, tap, pipe, distinctUntilChanged, of, mergeMap, interval, map, concatMap, combineLatest, merge, combineLatestWith, debounceTime, delay, timeout, retry, takeUntil, NEVER, };
+export { shareReplay, filter };
+export { catchError, throwError };

package/dist/src/utils/rxjs-import.js

@@ -0,0 +1,5 @@
+import { BehaviorSubject, Observable, Subject, Subscription, Subscriber, catchError, combineLatest, concatMap, distinctUntilChanged, filter, firstValueFrom, from, fromEvent, merge, NEVER, interval, map, mergeMap, of, pipe, shareReplay, startWith, tap, timeout, retry, throwError, combineLatestWith, debounceTime, delay, takeUntil, } from "rxjs";
+export { Observable, Subject, BehaviorSubject, Subscription, Subscriber };
+export { startWith, firstValueFrom, from, fromEvent, tap, pipe, distinctUntilChanged, of, mergeMap, interval, map, concatMap, combineLatest, merge, combineLatestWith, debounceTime, delay, timeout, retry, takeUntil, NEVER, };
+export { shareReplay, filter };
+export { catchError, throwError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smess/networking",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "Networking utilities and services for SMESS platform.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",