@smess/networking 1.0.25 → 1.0.28

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

@@ -1,274 +0,0 @@
-import "fake-indexeddb/auto";
-import { StoreService, } from "./store.service";
-import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
-import { of } from "rxjs";
-describe("StoreService", () => {
-    const config = {
-        baseUrl: "https://api.example.com",
-        isProd: false,
-        clientId: "test-client-id",
-        apiKey: "test-api-key",
-    };
-    let service;
-    beforeEach(() => {
-        service = new StoreService(config);
-    });
-    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" } };
-        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("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("should get store list from network when no 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);
-        const result = await service.list().toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    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?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get product category list from network when no cache", async () => {
-        const response = { data: [{ id: "cat1", name: "Category" }] };
-        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("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?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    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 };
-        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("should get product collection from cache when available", async () => {
-        const response = { data: [{ id: "prod1", name: "Product" }] };
-        const payload = { page: 1, per_page: 10 };
-        // 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?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get featured product list from network when no cache", async () => {
-        const response = {
-            data: [{ id: "feat1", name: "Featured" }],
-        };
-        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("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?.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/src/services/user.service.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

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

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

@@ -1,52 +0,0 @@
-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/types/types.d.ts

@@ -1,93 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

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

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

@@ -1,25 +0,0 @@
-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

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

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

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

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

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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 };