@smess/networking 1.0.10 → 1.0.13

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

@@ -1,12 +1,12 @@
-import { CustomerService } from './customer.service';
-import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
-import { of, BehaviorSubject } from 'rxjs';
-describe('CustomerService', () => {
+import { CustomerService, } from "./customer.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("CustomerService", () => {
     const config = {
-        baseUrl: 'https://api.example.com',
+        baseUrl: "https://api.example.com",
         isProd: false,
-        clientId: 'test-client-id',
-        apiKey: 'test-api-key',
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
     };
     let service;
     let $authToken;
@@ -14,79 +14,83 @@ describe('CustomerService', () => {
         $authToken = new BehaviorSubject(null);
         service = new CustomerService(config, $authToken);
     });
-    it('register success', async () => {
+    it("register success", async () => {
         const payload = {
-            email: 'test@example.com',
-            password: 'pass',
+            email: "test@example.com",
+            password: "pass",
         };
-        const response = { data: { id: 1, email: 'test@example.com' } };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        const response = {
+            data: { id: 1, email: "test@example.com" },
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(response)),
         });
         const result = await service.register(payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('register error', async () => {
+    it("register error", async () => {
         const payload = {
-            email: 'test@example.com',
-            password: 'pass',
+            email: "test@example.com",
+            password: "pass",
         };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
         const result = await service.register(payload).toPromise();
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
-    it('getProfile success', async () => {
-        const response = { data: { id: 1, email: 'test@example.com' } };
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("getProfile success", async () => {
+        const response = {
+            data: { id: 1, email: "test@example.com" },
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(response)),
         });
         const result = await service.getProfile().toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('getProfile error', async () => {
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("getProfile error", async () => {
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
         const result = await service.getProfile().toPromise();
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
-    it('updateProfile success', async () => {
+    it("updateProfile success", async () => {
         const payload = {
-            name: 'Test',
-            address: '123 Main St',
-            postal_code: '12345',
-            city: 'City',
+            name: "Test",
+            address: "123 Main St",
+            postal_code: "12345",
+            city: "City",
             state: null,
             country: null,
             contact_email: null,
             phone_number: null,
         };
-        const response = { data: { id: 1, name: 'Test' } };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        const response = { data: { id: 1, name: "Test" } };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(response)),
         });
         const result = await service.updateProfile(payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('updateProfile error', async () => {
+    it("updateProfile error", async () => {
         const payload = {
-            name: 'Test',
-            address: '123 Main St',
-            postal_code: '12345',
-            city: 'City',
+            name: "Test",
+            address: "123 Main St",
+            postal_code: "12345",
+            city: "City",
             state: null,
             country: null,
             contact_email: null,
             phone_number: null,
         };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
         const result = await service.updateProfile(payload).toPromise();

package/dist/services/logger.service.js

@@ -21,21 +21,21 @@ export class LoggerService {
     formatMessage(level, message, context) {
         const emoji = this.getEmojiForLevel(level);
         const levelName = LogLevel[level];
-        const contextStr = context ? ` [${context}]` : '';
+        const contextStr = context ? ` [${context}]` : "";
         return `${emoji} ${levelName}${contextStr}: ${message}`;
     }
     getEmojiForLevel(level) {
         switch (level) {
             case LogLevel.DEBUG:
-                return '🔍';
+                return "🔍";
             case LogLevel.INFO:
-                return 'ℹ️';
+                return "ℹ️";
             case LogLevel.WARN:
-                return '⚠️';
+                return "⚠️";
             case LogLevel.ERROR:
-                return '❌';
+                return "❌";
             default:
-                return '📝';
+                return "📝";
         }
     }
     log(level, message, data, context) {
@@ -46,7 +46,7 @@ export class LoggerService {
             message,
             data,
             timestamp: Date.now(),
-            context
+            context,
         };
         // Store log entry
         this.logs.push(logEntry);
@@ -57,16 +57,16 @@ export class LoggerService {
         const formattedMessage = this.formatMessage(level, message, context);
         switch (level) {
             case LogLevel.DEBUG:
-                console.debug(formattedMessage, data || '');
+                console.debug(formattedMessage, data || "");
                 break;
             case LogLevel.INFO:
-                console.info(formattedMessage, data || '');
+                console.info(formattedMessage, data || "");
                 break;
             case LogLevel.WARN:
-                console.warn(formattedMessage, data || '');
+                console.warn(formattedMessage, data || "");
                 break;
             case LogLevel.ERROR:
-                console.error(formattedMessage, data || '');
+                console.error(formattedMessage, data || "");
                 break;
         }
     }

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

@@ -1,29 +1,29 @@
-import { $logger, LogLevel } from './logger.service';
-describe('LoggerService', () => {
+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');
+    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].message).toBe("info message");
         expect(logs[0].data).toEqual({ foo: 1 });
-        expect(logs[0].context).toBe('test');
+        expect(logs[0].context).toBe("test");
     });
-    it('should log warn and error', () => {
-        $logger.warn('warn message');
-        $logger.error('error message', { bar: 2 });
+    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', () => {
+    it("should respect log level", () => {
         $logger.setLogLevel(LogLevel.ERROR);
-        $logger.info('should not log');
-        $logger.error('should log');
+        $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/services/order.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 OrderTarget = 'order-list' | 'order-create' | 'order-delete' | 'order-get-draft' | 'order-update' | 'order-get';
+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 {
@@ -36,6 +36,17 @@ export interface OrderItemRequest {
     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;
@@ -58,4 +69,5 @@ export declare class OrderService {
     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/services/order.service.js

@@ -1,4 +1,4 @@
-import { Accept, SMESSHeader, SmessService } from './smess.service';
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
 export class OrderProvider {
     constructor(config, target, $authToken) {
         this.config = config;
@@ -6,38 +6,43 @@ export class OrderProvider {
         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 '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-update':
-            case 'order-get':
+            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}';
+                return "/order/${id}";
         }
     }
     get method() {
         switch (this.target) {
-            case 'order-list':
-            case 'order-get':
-            case 'order-get-draft':
-                return 'GET';
-            case 'order-create':
-                return 'POST';
-            case 'order-update':
-                return 'PUT';
-            case 'order-delete':
-                return 'DELETE';
+            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';
+                return "GET";
         }
     }
     get headers() {
@@ -69,21 +74,24 @@ export class OrderService {
         return new SmessService(targetWrapper);
     }
     list() {
-        return this.provider('order-list').request();
+        return this.provider("order-list").request();
     }
     create(payload) {
-        return this.provider('order-create').request(payload);
+        return this.provider("order-create").request(payload);
     }
     delete(id) {
-        return this.provider('order-delete').request(null, undefined, id);
+        return this.provider("order-delete").request(null, undefined, id);
     }
     getDraft() {
-        return this.provider('order-get-draft').request();
+        return this.provider("order-get-draft").request();
     }
     update(id, payload) {
-        return this.provider('order-update').request(payload, undefined, id);
+        return this.provider("order-update").request(payload, undefined, id);
     }
     get(id) {
-        return this.provider('order-get').request(null, undefined, id);
+        return this.provider("order-get").request(null, undefined, id);
+    }
+    collection(payload) {
+        return this.provider("order-collection").request(null, undefined, undefined, payload);
     }
 }

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

@@ -1,12 +1,12 @@
-import { OrderService } from './order.service';
-import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
-import { of, BehaviorSubject } from 'rxjs';
-describe('OrderService', () => {
+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',
+        baseUrl: "https://api.example.com",
         isProd: false,
-        clientId: 'test-client-id',
-        apiKey: 'test-api-key',
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
     };
     let service;
     let $authToken;
@@ -14,121 +14,149 @@ describe('OrderService', () => {
         $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({
+    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({
+    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 () => {
+    it("create success", async () => {
         const payload = {
-            order_date: '2024-01-01',
+            order_date: "2024-01-01",
             order_items: [],
         };
-        const response = { data: { id: '1', status: 'created' } };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        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 () => {
+    it("create error", async () => {
         const payload = {
-            order_date: '2024-01-01',
+            order_date: "2024-01-01",
             order_items: [],
         };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        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({
+    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();
+        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({
+    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();
+        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({
+    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({
+    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 () => {
+    it("update success", async () => {
         const payload = {
-            order_date: '2024-01-01',
+            order_date: "2024-01-01",
             order_items: [],
         };
-        const response = { data: { id: '1', status: 'updated' } };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        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();
+        const result = await service.update("1", payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('update error', async () => {
+    it("update error", async () => {
         const payload = {
-            order_date: '2024-01-01',
+            order_date: "2024-01-01",
             order_items: [],
         };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        jest.spyOn(service, "provider").mockReturnValue({
             request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
-        const result = await service.update('1', payload).toPromise();
+        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({
+    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();
+        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({
+    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();
+        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/services/product.service.d.ts

@@ -1,6 +1,6 @@
-import { BaseProvider } from '../core/base.provider';
-import { BaseServiceWrapper } from '../core/base.service.wrapper';
-import { NetworkingConfig } from '../types/types';
+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;
@@ -17,5 +17,5 @@ export declare class ProductService extends BaseServiceWrapper<ProductProvider>
     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>>;
+    createProduct(product: Omit<Product, "id">): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
 }

package/dist/services/product.service.js

@@ -1,14 +1,14 @@
-import { BaseProvider } from '../core/base.provider';
-import { BaseServiceWrapper } from '../core/base.service.wrapper';
+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'),
+            path: productId ? `/products/${productId}` : "/products",
+            method: method || "GET",
+            headers: { "Content-Type": "application/json" },
+            getPath: () => (productId ? `/products/${productId}` : "/products"),
         });
     }
 }
@@ -30,7 +30,7 @@ export class ProductService extends BaseServiceWrapper {
     }
     // Create a new product (POST)
     createProduct(product) {
-        this.provider = new ProductProvider(this.config, { method: 'POST' });
+        this.provider = new ProductProvider(this.config, { method: "POST" });
         return this.request(product);
     }
 }
@@ -39,4 +39,4 @@ export class ProductService extends BaseServiceWrapper {
 // 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)); 
+// productService.createProduct({ name: 'New Product', price: 99.99 }).subscribe(result => console.log(result));