@smess/networking 1.0.10 → 1.0.12

package/dist/services/auth.service.js

@@ -1,4 +1,6 @@
-import { Accept, SMESSHeader, SmessService } from './smess.service';
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { BehaviorSubject } from "rxjs";
+import { tap } from "rxjs/operators";
 export class AuthProvider {
     constructor(config, target, $authToken) {
         this.config = config;
@@ -6,39 +8,41 @@ export class AuthProvider {
         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 'login':
-                return '/authentication/login_check';
-            case 'password-forgot':
-                return '/authentication/forgot-password';
-            case 'reset-password':
-                return '/authentication/reset-password';
-            case 'verify-reset-password-token':
-                return '/authentication/verify-reset-password-token';
-            case 'logout':
-                return '/authentication/logout';
-            case 'change-password':
-                return '/authentication/change-password';
+            case "login":
+                return "/authentication/login_check";
+            case "password-forgot":
+                return "/authentication/forgot-password";
+            case "reset-password":
+                return "/authentication/reset-password";
+            case "verify-reset-password-token":
+                return "/authentication/verify-reset-password-token";
+            case "logout":
+                return "/authentication/logout";
+            case "change-password":
+                return "/authentication/change-password";
             default:
-                return '/authentication';
+                return "/authentication";
         }
     }
     get method() {
         switch (this.target) {
             default:
-                return 'POST';
+                return "POST";
         }
     }
     get headers() {
         let authHeaders = {};
         switch (this.target) {
-            case 'login':
-            case 'password-forgot':
-            case 'reset-password':
-            case 'verify-reset-password-token':
+            case "login":
+            case "password-forgot":
+            case "reset-password":
+            case "verify-reset-password-token":
                 authHeaders = SmessService.getHeaders(Accept.V1);
                 break;
             default:
@@ -62,30 +66,48 @@ export class AuthProvider {
     }
 }
 export class AuthService {
-    constructor(config, $authToken) {
+    constructor(config) {
         this.config = config;
-        this.$authToken = $authToken;
+        this.$authToken = new BehaviorSubject(null);
+    }
+    // Get current auth token value
+    get currentAuthToken() {
+        return this.$authToken.value;
     }
     provider(target) {
         const targetWrapper = new AuthProvider(this.config, target, this.$authToken);
         return new SmessService(targetWrapper);
     }
     login(payload) {
-        return this.provider('login').request(payload);
+        return this.provider("login")
+            .request(payload)
+            .pipe(tap((result) => {
+            if (result.hasSuccess && result.response?.token) {
+                // Set the auth token when login is successful
+                this.$authToken.next(String(result.response.token));
+            }
+        }));
     }
     logout() {
-        return this.provider('logout').request();
+        return this.provider("logout")
+            .request()
+            .pipe(tap((result) => {
+            if (result.hasSuccess) {
+                // Clear the auth token when logout is successful
+                this.$authToken.next(null);
+            }
+        }));
     }
     forgotPassword(payload) {
-        return this.provider('password-forgot').request(payload);
+        return this.provider("password-forgot").request(payload);
     }
     changePassword(payload) {
-        return this.provider('change-password').request(payload);
+        return this.provider("change-password").request(payload);
     }
     resetPassword(payload) {
-        return this.provider('reset-password').request(payload);
+        return this.provider("reset-password").request(payload);
     }
     verifyResetPasswordToken(token) {
-        return this.provider('verify-reset-password-token').request({ token });
+        return this.provider("verify-reset-password-token").request({ token });
     }
 }

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

@@ -1,125 +1,141 @@
-import { AuthService } from './auth.service';
-import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
-import { of, BehaviorSubject } from 'rxjs';
-describe('AuthService', () => {
+import { AuthService, } from "./auth.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of } from "rxjs";
+describe("AuthService", () => {
     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;
     beforeEach(() => {
-        $authToken = new BehaviorSubject(null);
-        service = new AuthService(config, $authToken);
+        service = new AuthService(config);
     });
-    it('login success', async () => {
-        const payload = { identifier: 'user', password: 'pass' };
+    it("login success", async () => {
+        const payload = { identifier: "user", password: "pass" };
         const response = {
-            token_type: 'Bearer',
+            token_type: "Bearer",
             expires_in: 3600,
-            token: 'token',
-            refresh_token: 'refresh',
+            token: "token",
+            refresh_token: "refresh",
         };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(response)),
         });
         const result = await service.login(payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
+        // Verify that auth token is set after successful login
+        expect(service.currentAuthToken).toBe("token");
+        expect(service.$authToken.value).toBe("token");
     });
-    it('login error', async () => {
-        const payload = { identifier: 'user', password: 'wrong' };
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("login error", async () => {
+        const payload = { identifier: "user", password: "wrong" };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
         const result = await service.login(payload).toPromise();
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
-    it('logout success', async () => {
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("logout success", async () => {
+        // First set a token to test clearing it
+        service.$authToken.next("test-token");
+        expect(service.currentAuthToken).toBe("test-token");
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(undefined)),
         });
         const result = await service.logout().toPromise();
         expect(result?.hasSuccess).toBe(true);
+        // Verify that auth token is cleared after successful logout
+        expect(service.currentAuthToken).toBe(null);
+        expect(service.$authToken.value).toBe(null);
     });
-    it('forgotPassword success', async () => {
-        const payload = { identifier: 'user' };
-        const response = { data: 'ok' };
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("forgotPassword success", async () => {
+        const payload = { identifier: "user" };
+        const response = { data: "ok" };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(response)),
         });
         const result = await service.forgotPassword(payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('changePassword success', async () => {
-        const payload = { old_password: 'old', password: 'new' };
-        const response = { data: 'changed' };
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("changePassword success", async () => {
+        const payload = {
+            old_password: "old",
+            password: "new",
+        };
+        const response = { data: "changed" };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(response)),
         });
         const result = await service.changePassword(payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('resetPassword success', async () => {
-        const payload = { token: 'token', password: 'newpass' };
-        const response = { data: 'reset' };
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("resetPassword success", async () => {
+        const payload = {
+            token: "token",
+            password: "newpass",
+        };
+        const response = { data: "reset" };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(response)),
         });
         const result = await service.resetPassword(payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('verifyResetPasswordToken success', async () => {
-        const token = 'token';
+    it("verifyResetPasswordToken success", async () => {
+        const token = "token";
         const response = {
-            token_type: 'Bearer',
+            token_type: "Bearer",
             expires_in: 3600,
-            token: 'token',
-            refresh_token: 'refresh',
+            token: "token",
+            refresh_token: "refresh",
         };
-        jest.spyOn(service, 'provider').mockReturnValue({
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.succeeded(response)),
         });
         const result = await service.verifyResetPasswordToken(token).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('forgotPassword error', async () => {
-        const payload = { identifier: 'user' };
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("forgotPassword error", async () => {
+        const payload = { identifier: "user" };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
         const result = await service.forgotPassword(payload).toPromise();
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
-    it('changePassword error', async () => {
-        const payload = { old_password: 'old', password: 'bad' };
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("changePassword error", async () => {
+        const payload = {
+            old_password: "old",
+            password: "bad",
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
         const result = await service.changePassword(payload).toPromise();
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
-    it('resetPassword error', async () => {
-        const payload = { token: 'bad', password: 'bad' };
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("resetPassword error", async () => {
+        const payload = { token: "bad", password: "bad" };
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
         const result = await service.resetPassword(payload).toPromise();
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
-    it('verifyResetPasswordToken error', async () => {
-        const token = 'bad';
-        jest.spyOn(service, 'provider').mockReturnValue({
+    it("verifyResetPasswordToken error", async () => {
+        const token = "bad";
+        jest.spyOn(service, "provider").mockReturnValue({
             request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
         });
         const result = await service.verifyResetPasswordToken(token).toPromise();

package/dist/services/cache.service.d.ts

@@ -1,4 +1,4 @@
-import { Dexie, Table } from '../utils/cache-import';
+import { Dexie, Table } from "../utils/cache-import";
 export interface CacheMetadata {
     key: string;
     cachedAt: number;

package/dist/services/cache.service.js

@@ -1,10 +1,10 @@
-import { Dexie } from '../utils/cache-import';
+import { Dexie } from "../utils/cache-import";
 export class GenericDB extends Dexie {
     constructor(name, dataStoreSchema) {
         super(name);
         this.version(1).stores({
             data: dataStoreSchema,
-            cache: 'key, cachedAt, expiresAt'
+            cache: "key, cachedAt, expiresAt",
         });
     }
 }
@@ -17,14 +17,14 @@ export class GenericIndexedDBService {
     }
     async saveAll(items, cacheKey) {
         const cachedItems = items.map(this.toCached);
-        await this.db.transaction('rw', this.db.data, this.db.cache, async () => {
+        await this.db.transaction("rw", this.db.data, this.db.cache, async () => {
             await this.db.data.clear();
             await this.db.data.bulkAdd(cachedItems);
             await this.db.cache.put({
                 key: cacheKey,
                 cachedAt: Date.now(),
                 expiresAt: Date.now() + this.CACHE_DURATION,
-                version: '1.0'
+                version: "1.0",
             });
         });
     }
@@ -47,7 +47,7 @@ export class GenericIndexedDBService {
         await this.db.data.delete(id);
     }
     async clearAll() {
-        await this.db.transaction('rw', this.db.data, this.db.cache, async () => {
+        await this.db.transaction("rw", this.db.data, this.db.cache, async () => {
             await this.db.data.clear();
             await this.db.cache.clear();
         });
@@ -57,7 +57,7 @@ export class GenericIndexedDBService {
         const cacheInfo = await this.db.cache.get(key);
         return {
             count,
-            lastUpdated: cacheInfo ? new Date(cacheInfo.cachedAt) : undefined
+            lastUpdated: cacheInfo ? new Date(cacheInfo.cachedAt) : undefined,
         };
     }
     async setStats(key, stats) {
@@ -65,7 +65,7 @@ export class GenericIndexedDBService {
             key,
             cachedAt: Date.now(),
             expiresAt: Date.now() + this.CACHE_DURATION,
-            version: JSON.stringify(stats)
+            version: JSON.stringify(stats),
         });
     }
     async getStats(key) {

package/dist/services/cache.service.test.d.ts

@@ -1 +1 @@
-import 'fake-indexeddb/auto';
+import "fake-indexeddb/auto";

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

@@ -1,87 +1,87 @@
-import 'fake-indexeddb/auto';
-import { GenericIndexedDBService } from './cache.service';
+import "fake-indexeddb/auto";
+import { GenericIndexedDBService } from "./cache.service";
 const toCached = (entity) => ({
     id: entity.id,
     name: entity.name,
     createdAt: entity.createdAt.toISOString(),
-    cachedAt: Date.now()
+    cachedAt: Date.now(),
 });
 const fromCached = (cached) => ({
     id: cached.id,
     name: cached.name,
-    createdAt: new Date(cached.createdAt)
+    createdAt: new Date(cached.createdAt),
 });
-describe('GenericIndexedDBService', () => {
+describe("GenericIndexedDBService", () => {
     let service;
     beforeEach(() => {
-        service = new GenericIndexedDBService('TestDB', 'id, name', toCached, fromCached);
+        service = new GenericIndexedDBService("TestDB", "id, name", toCached, fromCached);
     });
     afterEach(async () => {
         await service.db.delete();
     });
-    it('should save and retrieve one item', async () => {
+    it("should save and retrieve one item", async () => {
         const item = {
-            id: '1',
-            name: 'Test Item',
-            createdAt: new Date()
+            id: "1",
+            name: "Test Item",
+            createdAt: new Date(),
         };
         await service.saveOne(item);
-        const result = await service.getOne('1');
+        const result = await service.getOne("1");
         expect(result).not.toBeNull();
-        expect(result?.id).toBe('1');
+        expect(result?.id).toBe("1");
     });
-    it('should save and retrieve all items', async () => {
+    it("should save and retrieve all items", async () => {
         const now = new Date();
         const items = [
-            { id: '1', name: 'One', createdAt: now },
-            { id: '2', name: 'Two', createdAt: now }
+            { id: "1", name: "One", createdAt: now },
+            { id: "2", name: "Two", createdAt: now },
         ];
-        await service.saveAll(items, 'all');
-        const results = await service.getAll('all');
+        await service.saveAll(items, "all");
+        const results = await service.getAll("all");
         expect(results).not.toBeNull();
         expect(results.length).toBe(2);
     });
-    it('should return null when cache is expired', async () => {
+    it("should return null when cache is expired", async () => {
         const cacheTable = service.db.cache;
         await cacheTable.put({
-            key: 'expired',
+            key: "expired",
             cachedAt: Date.now() - 10000,
             expiresAt: Date.now() - 5000,
-            version: '1.0'
+            version: "1.0",
         });
-        const result = await service.getAll('expired');
+        const result = await service.getAll("expired");
         expect(result).toBeNull();
     });
-    it('should delete one item', async () => {
+    it("should delete one item", async () => {
         const item = {
-            id: '1',
-            name: 'Delete Me',
-            createdAt: new Date()
+            id: "1",
+            name: "Delete Me",
+            createdAt: new Date(),
         };
         await service.saveOne(item);
-        await service.delete('1');
-        const result = await service.getOne('1');
+        await service.delete("1");
+        const result = await service.getOne("1");
         expect(result).toBeNull();
     });
-    it('should set and retrieve stats', async () => {
+    it("should set and retrieve stats", async () => {
         const stats = { total: 99 };
-        await service.setStats('mystats', stats);
-        const result = await service.getStats('mystats');
+        await service.setStats("mystats", stats);
+        const result = await service.getStats("mystats");
         expect(result).toEqual(stats);
     });
-    it('should get cache info', async () => {
+    it("should get cache info", async () => {
         await service.saveOne({
-            id: '123',
-            name: 'Info Item',
-            createdAt: new Date()
+            id: "123",
+            name: "Info Item",
+            createdAt: new Date(),
         });
         await service.db.cache.put({
-            key: 'info',
+            key: "info",
             cachedAt: Date.now(),
             expiresAt: Date.now() + 10000,
-            version: '1.0'
+            version: "1.0",
         });
-        const info = await service.getCacheInfo('info');
+        const info = await service.getCacheInfo("info");
         expect(info.count).toBeGreaterThanOrEqual(1);
         expect(info.lastUpdated).toBeInstanceOf(Date);
     });

package/dist/services/customer.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 CustomerTarget = 'register' | 'get-profile' | 'update-profile';
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type CustomerTarget = "register" | "get-profile" | "update-profile";
 export interface CustomerRegisterRequest {
     client_id?: string;
     email: string;

package/dist/services/customer.service.js

@@ -1,4 +1,4 @@
-import { Accept, SMESSHeader, SmessService } from './smess.service';
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
 export class CustomerProvider {
     constructor(config, target, $authToken) {
         this.config = config;
@@ -6,28 +6,30 @@ export class CustomerProvider {
         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 'register':
-                return '/authentication/customer/register';
-            case 'get-profile':
-                return '/authentication/customer/get-profile';
-            case 'update-profile':
-                return '/authentication/customer/update';
+            case "register":
+                return "/authentication/customer/register";
+            case "get-profile":
+                return "/authentication/customer/get-profile";
+            case "update-profile":
+                return "/authentication/customer/update";
             default:
-                return '/authentication/customer';
+                return "/authentication/customer";
         }
     }
     get method() {
         switch (this.target) {
-            case 'get-profile':
-                return 'GET';
-            case 'update-profile':
-                return 'PUT';
+            case "get-profile":
+                return "GET";
+            case "update-profile":
+                return "PUT";
             default:
-                return 'POST';
+                return "POST";
         }
     }
     get headers() {
@@ -59,12 +61,12 @@ export class CustomerService {
         return new SmessService(targetWrapper);
     }
     register(payload) {
-        return this.provider('register').request(payload);
+        return this.provider("register").request(payload);
     }
     getProfile() {
-        return this.provider('get-profile').request();
+        return this.provider("get-profile").request();
     }
     updateProfile(payload) {
-        return this.provider('update-profile').request(payload);
+        return this.provider("update-profile").request(payload);
     }
 }