@smess/networking 1.0.23 → 1.0.24

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

@@ -0,0 +1,114 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+export class CustomerProvider {
+    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 "register":
+                return "/authentication/customer/register";
+            case "get-profile":
+                return "/authentication/customer/get-profile";
+            case "update-profile":
+                return "/authentication/customer/update";
+            case "cart-collection":
+                return "/store/cart/collection";
+            case "customer-product-collection":
+                return "/store/customer-product/collection";
+            case "customer-product-create":
+                return "/store/customer-product";
+            case "customer-product-remove":
+                return "/store/customer-product/remove";
+            case "customer-product-update-notes":
+                return "/store/customer-product/notes";
+            default:
+                return "/authentication/customer";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "get-profile":
+                return "GET";
+            case "cart-collection":
+                return "GET";
+            case "customer-product-collection":
+                return "GET";
+            case "customer-product-create":
+                return "POST";
+            case "customer-product-remove":
+                return "DELETE";
+            case "customer-product-update-notes":
+                return "PATCH";
+            case "update-profile":
+                return "PUT";
+            default:
+                return "POST";
+        }
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        switch (this.target) {
+            case "register":
+                headers = SmessService.getHeaders(Accept.V1);
+                break;
+            default:
+                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 CustomerService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new CustomerProvider(this.config, target, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    register(payload) {
+        return this.provider("register").request(payload);
+    }
+    getProfile() {
+        return this.provider("get-profile").request();
+    }
+    updateProfile(payload) {
+        return this.provider("update-profile").request(payload);
+    }
+    getCartCollection(query) {
+        return this.provider("cart-collection").request(query);
+    }
+    getCustomerProductCollection(query) {
+        return this.provider("customer-product-collection").request(query);
+    }
+    createCustomerProduct(payload) {
+        return this.provider("customer-product-create").request(payload);
+    }
+    removeCustomerProduct(payload) {
+        return this.provider("customer-product-remove").request(payload);
+    }
+    updateCustomerProductNotes(payload) {
+        return this.provider("customer-product-update-notes").request(payload);
+    }
+}

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

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

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

@@ -0,0 +1,274 @@
+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",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        service = new CustomerService(config, $authToken);
+    });
+    it("register success", async () => {
+        const payload = {
+            email: "test@example.com",
+            password: "pass",
+        };
+        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 () => {
+        const payload = {
+            email: "test@example.com",
+            password: "pass",
+        };
+        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({
+            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({
+            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 () => {
+        const payload = {
+            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({
+            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 () => {
+        const payload = {
+            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({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.updateProfile(payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("getCartCollection success", async () => {
+        const response = {
+            data: { items: [], page: 1, perPage: 24, total: 0 },
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+            status: "confirmed",
+        };
+        const result = await service.getCartCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("getCartCollection error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+        };
+        const result = await service.getCartCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("getCustomerProductCollection success", async () => {
+        const response = {
+            data: { items: [], page: 1, perPage: 24, total: 0 },
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+        };
+        const result = await service.getCustomerProductCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("getCustomerProductCollection error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+        };
+        const result = await service.getCustomerProductCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("createCustomerProduct success", async () => {
+        const response = {
+            data: { id: "favorite-id", productId: "product-123" },
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+            notes: "Customer note for this favorite product",
+        };
+        const result = await service.createCustomerProduct(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("createCustomerProduct error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+            notes: "Customer note for this favorite product",
+        };
+        const result = await service.createCustomerProduct(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("removeCustomerProduct success", async () => {
+        const response = { data: { success: true } };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+        };
+        const result = await service.removeCustomerProduct(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("removeCustomerProduct error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+        };
+        const result = await service.removeCustomerProduct(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("updateCustomerProductNotes success", async () => {
+        const response = { data: { success: true } };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+            notes: "Updated note for this favorite product",
+        };
+        const result = await service
+            .updateCustomerProductNotes(payload)
+            .toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("updateCustomerProductNotes error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+            notes: "Updated note for this favorite product",
+        };
+        const result = await service
+            .updateCustomerProductNotes(payload)
+            .toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+});

package/dist/src/services/employee.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 EmployeeTarget = "get-profile" | "cart-client-collection" | "cart-bulk-action";
+export interface EmployeeCartCollectionQuery {
+    page?: number;
+    per_page?: number;
+    status?: string;
+    search?: string;
+    sort_by?: string;
+    sort_order?: "asc" | "desc";
+}
+export interface EmployeeCartBulkActionRequest {
+    create?: Array<{
+        cart_id?: string;
+        status?: string;
+        customer_note?: string;
+        customer_id?: string;
+        payment_method?: string;
+        delivery_type?: string;
+        items?: Array<{
+            product_id: string;
+            quantity: number;
+            custom_price?: number;
+            [key: string]: unknown;
+        }>;
+        billing_information?: Record<string, unknown>;
+        shipping_information?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>;
+    update?: Array<{
+        cart_id: string;
+        status?: string;
+        customer_note?: string;
+        customer_id?: string;
+        payment_method?: string;
+        delivery_type?: string;
+        items?: Array<{
+            product_id: string;
+            quantity: number;
+            custom_price?: number;
+            [key: string]: unknown;
+        }>;
+        billing_information?: Record<string, unknown>;
+        shipping_information?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>;
+    delete?: Array<{
+        cart_id: string;
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+export declare class EmployeeProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: EmployeeTarget, $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 EmployeeService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: EmployeeTarget): SmessService<EmployeeProvider>;
+    getProfile(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getCartCollection(query?: EmployeeCartCollectionQuery): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    bulkCartAction(payload: EmployeeCartBulkActionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

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

@@ -0,0 +1,73 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+export class EmployeeProvider {
+    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 "get-profile":
+                return "/authentication/get-profile";
+            case "cart-client-collection":
+                return "/store/cart/client/collection";
+            case "cart-bulk-action":
+                return "/store/cart/bulk-action";
+            default:
+                return "/authentication/not-found";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "get-profile":
+            case "cart-client-collection":
+                return "GET";
+            case "cart-bulk-action":
+                return "POST";
+            default:
+                return "GET";
+        }
+    }
+    get headers() {
+        const 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 EmployeeService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new EmployeeProvider(this.config, target, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    getProfile() {
+        return this.provider("get-profile").request();
+    }
+    getCartCollection(query) {
+        return this.provider("cart-client-collection").request(query);
+    }
+    bulkCartAction(payload) {
+        return this.provider("cart-bulk-action").request(payload);
+    }
+}

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

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

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

@@ -0,0 +1,120 @@
+import { EmployeeService, } from "./employee.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { BehaviorSubject, of } from "rxjs";
+describe("EmployeeService", () => {
+    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 EmployeeService(config, $authToken);
+    });
+    it("getProfile success", async () => {
+        const response = {
+            data: { id: "employee-123", email: "employee@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({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.getProfile().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("getCartCollection success", async () => {
+        const response = {
+            data: { items: [], page: 1, perPage: 24, total: 0 },
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+            status: "submitted",
+        };
+        const result = await service.getCartCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("getCartCollection error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 2,
+            per_page: 10,
+        };
+        const result = await service.getCartCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("bulkCartAction success", async () => {
+        const response = {
+            data: { updated: 1 },
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            update: [
+                {
+                    cart_id: "cart-123",
+                    status: "submitted",
+                    items: [
+                        {
+                            product_id: "product-1",
+                            quantity: 2,
+                        },
+                    ],
+                },
+            ],
+        };
+        const result = await service.bulkCartAction(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("bulkCartAction error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            update: [
+                {
+                    cart_id: "cart-456",
+                },
+            ],
+        };
+        const result = await service.bulkCartAction(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+});

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

@@ -0,0 +1,31 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+}
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    data?: unknown;
+    timestamp: number;
+    context?: string;
+}
+export declare class LoggerService {
+    private currentLevel;
+    private logs;
+    private maxLogs;
+    setLogLevel(level: LogLevel): void;
+    private shouldLog;
+    private formatMessage;
+    private getEmojiForLevel;
+    private log;
+    debug(message: string, data?: unknown, context?: string): void;
+    info(message: string, data?: unknown, context?: string): void;
+    warn(message: string, data?: unknown, context?: string): void;
+    error(message: string, data?: unknown, context?: string): void;
+    getLogs(): LogEntry[];
+    clearLogs(): void;
+}
+export declare const $logger: LoggerService;