@smess/networking 1.0.23 → 1.0.24

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

@@ -0,0 +1,93 @@
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(LogLevel || (LogLevel = {}));
+export class LoggerService {
+    constructor() {
+        this.currentLevel = LogLevel.DEBUG;
+        this.logs = [];
+        this.maxLogs = 1000;
+    }
+    setLogLevel(level) {
+        this.currentLevel = level;
+    }
+    shouldLog(level) {
+        return level >= this.currentLevel;
+    }
+    formatMessage(level, message, context) {
+        const emoji = this.getEmojiForLevel(level);
+        const levelName = LogLevel[level];
+        const contextStr = context ? ` [${context}]` : "";
+        return `${emoji} ${levelName}${contextStr}: ${message}`;
+    }
+    getEmojiForLevel(level) {
+        switch (level) {
+            case LogLevel.DEBUG:
+                return "🔍";
+            case LogLevel.INFO:
+                return "ℹ️";
+            case LogLevel.WARN:
+                return "⚠️";
+            case LogLevel.ERROR:
+                return "❌";
+            default:
+                return "📝";
+        }
+    }
+    log(level, message, data, context) {
+        if (!this.shouldLog(level))
+            return;
+        const logEntry = {
+            level,
+            message,
+            data,
+            timestamp: Date.now(),
+            context,
+        };
+        // Store log entry
+        this.logs.push(logEntry);
+        if (this.logs.length > this.maxLogs) {
+            this.logs.shift();
+        }
+        // Console output
+        const formattedMessage = this.formatMessage(level, message, context);
+        switch (level) {
+            case LogLevel.DEBUG:
+                console.debug(formattedMessage, data || "");
+                break;
+            case LogLevel.INFO:
+                console.info(formattedMessage, data || "");
+                break;
+            case LogLevel.WARN:
+                console.warn(formattedMessage, data || "");
+                break;
+            case LogLevel.ERROR:
+                console.error(formattedMessage, data || "");
+                break;
+        }
+    }
+    debug(message, data, context) {
+        this.log(LogLevel.DEBUG, message, data, context);
+    }
+    info(message, data, context) {
+        this.log(LogLevel.INFO, message, data, context);
+    }
+    warn(message, data, context) {
+        this.log(LogLevel.WARN, message, data, context);
+    }
+    error(message, data, context) {
+        this.log(LogLevel.ERROR, message, data, context);
+    }
+    getLogs() {
+        return [...this.logs];
+    }
+    clearLogs() {
+        this.logs = [];
+    }
+}
+// Export singleton instance
+export const $logger = new LoggerService();

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

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

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

@@ -0,0 +1,31 @@
+import { $logger, LogLevel } from "./logger.service";
+describe("LoggerService", () => {
+    beforeEach(() => {
+        $logger.clearLogs();
+        $logger.setLogLevel(LogLevel.DEBUG);
+    });
+    it("should log info", () => {
+        $logger.info("info message", { foo: 1 }, "test");
+        const logs = $logger.getLogs();
+        expect(logs[0].level).toBe(LogLevel.INFO);
+        expect(logs[0].message).toBe("info message");
+        expect(logs[0].data).toEqual({ foo: 1 });
+        expect(logs[0].context).toBe("test");
+    });
+    it("should log warn and error", () => {
+        $logger.warn("warn message");
+        $logger.error("error message", { bar: 2 });
+        const logs = $logger.getLogs();
+        expect(logs[0].level).toBe(LogLevel.WARN);
+        expect(logs[1].level).toBe(LogLevel.ERROR);
+        expect(logs[1].data).toEqual({ bar: 2 });
+    });
+    it("should respect log level", () => {
+        $logger.setLogLevel(LogLevel.ERROR);
+        $logger.info("should not log");
+        $logger.error("should log");
+        const logs = $logger.getLogs();
+        expect(logs.length).toBe(1);
+        expect(logs[0].level).toBe(LogLevel.ERROR);
+    });
+});

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

@@ -0,0 +1,73 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type OrderTarget = "order-list" | "order-create" | "order-delete" | "order-get-draft" | "order-update" | "order-get" | "order-collection";
+export interface CreateOrderRequest extends UpdateOrderRequest {
+}
+export interface UpdateOrderRequest {
+    external_id?: string;
+    order_date: string;
+    type?: string;
+    status?: string;
+    payment_status?: string;
+    delivery_note?: string;
+    delivery_fee?: number;
+    delivery_address?: string;
+    payment_method?: string;
+    payment_period?: string;
+    discount_in_percent?: number;
+    due_payment_amount?: number;
+    total_gst?: number;
+    total_exclude_gst?: number;
+    total_include_gst?: number;
+    order_items: OrderItemRequest[];
+}
+export interface OrderItemRequest {
+    product_name: string;
+    product_category: string;
+    supplier?: string;
+    supplier_code?: string;
+    supplier_item_name?: string;
+    unit: string;
+    quantity: number;
+    price_include_taxes: number;
+    vat_in_percent: number;
+    discount_in_percent?: number;
+    page_number?: number;
+    item_row_in_page?: number;
+}
+export interface OrderCollectionRequest {
+    page?: number;
+    per_page?: number;
+    search?: string;
+    status?: string;
+    payment_status?: string;
+    order_date_from?: string;
+    order_date_to?: string;
+    sort_by?: string;
+    sort_order?: 'asc' | 'desc';
+}
+export declare class OrderProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: OrderTarget, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export declare class OrderService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: OrderTarget): SmessService<OrderProvider>;
+    list(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    create(payload: CreateOrderRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    delete(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getDraft(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    update(id: string, payload: UpdateOrderRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    get(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    collection(payload: OrderCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

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

@@ -0,0 +1,97 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+export class OrderProvider {
+    constructor(config, target, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "order-list":
+                return "/order/list";
+            case "order-create":
+                return "/order/create";
+            case "order-delete":
+                return "/order/${id}";
+            case "order-get-draft":
+                return "/order/get-draft";
+            case "order-collection":
+                return "/order/collection";
+            case "order-update":
+            case "order-get":
+            default:
+                return "/order/${id}";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "order-list":
+            case "order-get":
+            case "order-get-draft":
+            case "order-collection":
+                return "GET";
+            case "order-create":
+                return "POST";
+            case "order-update":
+                return "PUT";
+            case "order-delete":
+                return "DELETE";
+            default:
+                return "GET";
+        }
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        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 OrderService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new OrderProvider(this.config, target, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    list() {
+        return this.provider("order-list").request();
+    }
+    create(payload) {
+        return this.provider("order-create").request(payload);
+    }
+    delete(id) {
+        return this.provider("order-delete").request(null, undefined, id);
+    }
+    getDraft() {
+        return this.provider("order-get-draft").request();
+    }
+    update(id, payload) {
+        return this.provider("order-update").request(payload, undefined, id);
+    }
+    get(id) {
+        return this.provider("order-get").request(null, undefined, id);
+    }
+    collection(payload) {
+        return this.provider("order-collection").request(payload, undefined, undefined);
+    }
+}

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

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

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

@@ -0,0 +1,163 @@
+import { OrderService, } from "./order.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("OrderService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        service = new OrderService(config, $authToken);
+    });
+    it("list success", async () => {
+        const response = { data: [{ id: "1", status: "draft" }] };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        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())),
+        });
+        const result = await service.list().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("create success", async () => {
+        const payload = {
+            order_date: "2024-01-01",
+            order_items: [],
+        };
+        const response = { data: { id: "1", status: "created" } };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.create(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("create error", async () => {
+        const payload = {
+            order_date: "2024-01-01",
+            order_items: [],
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.create(payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("delete success", async () => {
+        const response = { data: { id: "1", status: "deleted" } };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.delete("1").toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("delete error", async () => {
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.delete("1").toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("getDraft success", async () => {
+        const response = { data: { id: "draft", status: "draft" } };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.getDraft().toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("getDraft error", async () => {
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.getDraft().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("update success", async () => {
+        const payload = {
+            order_date: "2024-01-01",
+            order_items: [],
+        };
+        const response = { data: { id: "1", status: "updated" } };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.update("1", payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("update error", async () => {
+        const payload = {
+            order_date: "2024-01-01",
+            order_items: [],
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.update("1", payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("get success", async () => {
+        const response = { data: { id: "1", status: "fetched" } };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        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())),
+        });
+        const result = await service.get("1").toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("collection success", async () => {
+        const payload = {
+            page: 1,
+            per_page: 10,
+            search: "test order",
+            status: "pending",
+            payment_status: "paid",
+        };
+        const response = { data: { orders: [], total: 0 } };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.collection(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("collection error", async () => {
+        const payload = {
+            page: 1,
+            per_page: 10,
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.collection(payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+});

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

@@ -0,0 +1,21 @@
+import { BaseProvider } from "../core/base.provider";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+import { NetworkingConfig } from "../types/types";
+export interface Product {
+    id: number;
+    name: string;
+    price: number;
+}
+export declare class ProductProvider extends BaseProvider {
+    constructor(config: NetworkingConfig, { productId, method }?: {
+        productId?: number;
+        method?: string;
+    });
+}
+export declare class ProductService extends BaseServiceWrapper<ProductProvider> {
+    private config;
+    constructor(config: NetworkingConfig, productId?: number, method?: string);
+    fetchProductById(id: number): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
+    fetchAllProducts(): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product[]>>;
+    createProduct(product: Omit<Product, "id">): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
+}

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

@@ -0,0 +1,42 @@
+import { BaseProvider } from "../core/base.provider";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+// ProductProvider implements ProviderType for product endpoints
+export class ProductProvider extends BaseProvider {
+    constructor(config, { productId, method } = {}) {
+        super({
+            config,
+            path: productId ? `/products/${productId}` : "/products",
+            method: method || "GET",
+            headers: { "Content-Type": "application/json" },
+            getPath: () => (productId ? `/products/${productId}` : "/products"),
+        });
+    }
+}
+// ProductService provides high-level methods for product API
+export class ProductService extends BaseServiceWrapper {
+    constructor(config, productId, method) {
+        super(new ProductProvider(config, { productId, method }));
+        this.config = config;
+    }
+    // Fetch a product by ID
+    fetchProductById(id) {
+        this.provider = new ProductProvider(this.config, { productId: id });
+        return this.request();
+    }
+    // Fetch all products
+    fetchAllProducts() {
+        this.provider = new ProductProvider(this.config);
+        return this.request();
+    }
+    // Create a new product (POST)
+    createProduct(product) {
+        this.provider = new ProductProvider(this.config, { method: "POST" });
+        return this.request(product);
+    }
+}
+// Example usage:
+// setNetworkingConfig({ baseUrl: 'https://fakestoreapi.com', isProd: false });
+// const productService = new ProductService();
+// productService.fetchProductById(1).subscribe(result => console.log(result));
+// productService.fetchAllProducts().subscribe(result => console.log(result));
+// productService.createProduct({ name: 'New Product', price: 99.99 }).subscribe(result => console.log(result));

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

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

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

@@ -0,0 +1,61 @@
+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",
+        isProd: false,
+        clientId: "test-client",
+        apiKey: "test-key",
+    };
+    const product = { id: 1, name: "Product", price: 10 };
+    let requestSpy;
+    beforeEach(() => {
+        requestSpy = jest
+            .spyOn(BaseServiceWrapper.prototype, "request")
+            .mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(product)));
+    });
+    afterEach(() => {
+        requestSpy.mockRestore();
+    });
+    it("should fetch product by id", (done) => {
+        const service = new ProductService(config, 1);
+        service
+            .fetchProductById(1)
+            .subscribe((result) => {
+            expect(result.response).toEqual(product);
+            done();
+        });
+    });
+    it("should fetch all products", (done) => {
+        const service = new ProductService(config);
+        service
+            .fetchAllProducts()
+            .subscribe((result) => {
+            expect(result.response).toEqual(product);
+            done();
+        });
+    });
+    it("should create a product", (done) => {
+        const service = new ProductService(config);
+        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")));
+        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");
+                done();
+            },
+        });
+    });
+});

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

@@ -0,0 +1,36 @@
+import { HeaderType, NetworkingUIEventWrapped, ProviderType } from "../types/types";
+import { Observable } from "../utils/rxjs-import";
+export declare enum SMESSHeader {
+    ContentType = "Content-Type",
+    Authorization = "Authorization",
+    Accept = "Accept",
+    ApiKey = "X-Api-Key",
+    ClientId = "X-Client-Id"
+}
+export declare enum ContentType {
+    Json = "application/json",
+    FormURLEncoded = "application/x-www-form-urlencoded"
+}
+export declare enum Accept {
+    V1 = "application/json",
+    V2 = "application/vnd.smess.v2+json",
+    V3 = "application/vnd.smess.v3+json",
+    V4 = "application/vnd.smess.v4+json",
+    V5 = "application/vnd.smess.v5+json",
+    V6 = "application/vnd.smess.v6+json",
+    V7 = "application/vnd.smess.v7+json",
+    V8 = "application/vnd.smess.v8+json",
+    V9 = "application/vnd.smess.v9+json",
+    V10 = "application/vnd.smess.v10+json"
+}
+export declare class SmessService<T extends ProviderType> {
+    private httpService;
+    private target;
+    constructor(target: T);
+    static getHeaders(version: Accept, authorization?: string | null, options?: HeaderType): Partial<Record<SMESSHeader, string | undefined>>;
+    static filterHeaders(headers: Partial<Record<SMESSHeader, string | undefined>>): Record<string, string>;
+    private static commonHeaders;
+    request<R = unknown>(request?: unknown, mockResponse?: R, ...queryParams: unknown[]): Observable<NetworkingUIEventWrapped<R>>;
+    private transformAxiosError;
+    private transformAxiosResponse;
+}