newportsite 1.1.3

package/src/lib/services/cache.service.spec.ts

@@ -0,0 +1,143 @@
+import { TestBed } from '@angular/core/testing';
+import { CacheService } from './cache.service';
+
+describe('CacheService', () => {
+  let svc: CacheService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    svc = TestBed.inject(CacheService);
+  });
+
+  // ── getData / setData / removeData ────────────────────────────────────────
+
+  describe('getData / setData / removeData', () => {
+    it('returns undefined for an unknown key', () => {
+      expect(svc.getData('UNKNOWN')).toBeUndefined();
+    });
+
+    it('stores and retrieves entity data by key', () => {
+      const data = { entities: [] } as any;
+      svc.setData('APP.ENT.2024', data);
+      expect(svc.getData('APP.ENT.2024')).toBe(data);
+    });
+
+    it('overwrites an existing entry on a second setData call', () => {
+      const first = { entities: [{ name: 'a' }] } as any;
+      const second = { entities: [{ name: 'b' }] } as any;
+      svc.setData('KEY', first);
+      svc.setData('KEY', second);
+      expect(svc.getData('KEY')).toBe(second);
+    });
+
+    it('removes the entry for the given key', () => {
+      svc.setData('APP.ENT.2024', { entities: [] } as any);
+      svc.removeData('APP.ENT.2024');
+      expect(svc.getData('APP.ENT.2024')).toBeUndefined();
+    });
+
+    it('removing one key does not affect other keys', () => {
+      svc.setData('A', { entities: [] } as any);
+      svc.setData('B', { entities: [] } as any);
+      svc.removeData('A');
+      expect(svc.getData('B')).toBeDefined();
+    });
+
+    it('removeData on a non-existing key does not throw', () => {
+      expect(() => svc.removeData('NOT_THERE')).not.toThrow();
+    });
+  });
+
+  // ── getFields / setFields ─────────────────────────────────────────────────
+
+  describe('getFields / setFields', () => {
+    it('returns undefined for an unknown key', () => {
+      expect(svc.getFields('NONE')).toBeUndefined();
+    });
+
+    it('stores and retrieves a Member array', () => {
+      const fields = [{ id: 'field1' }] as any[];
+      svc.setFields('KEY', fields);
+      expect(svc.getFields('KEY')).toBe(fields);
+    });
+
+    it('overwrites fields when setFields is called twice for the same key', () => {
+      svc.setFields('KEY', [{ id: 'old' }] as any[]);
+      const updated = [{ id: 'new' }] as any[];
+      svc.setFields('KEY', updated);
+      expect(svc.getFields('KEY')).toBe(updated);
+    });
+  });
+
+  // ── getProjectItems / setProjectItems / clearProjectItems ─────────────────
+
+  describe('getProjectItems / setProjectItems / clearProjectItems', () => {
+    it('returns undefined for an unknown key', () => {
+      expect(svc.getProjectItems('NONE')).toBeUndefined();
+    });
+
+    it('stores and retrieves a project items array', () => {
+      const items = [{ id: 'item1' }] as any[];
+      svc.setProjectItems('PRJ.2024', items);
+      expect(svc.getProjectItems('PRJ.2024')).toBe(items);
+    });
+
+    it('clearProjectItems removes all project entries', () => {
+      svc.setProjectItems('PRJ.2024', [] as any[]);
+      svc.setProjectItems('PRJ.2025', [] as any[]);
+      svc.clearProjectItems();
+      expect(svc.getProjectItems('PRJ.2024')).toBeUndefined();
+      expect(svc.getProjectItems('PRJ.2025')).toBeUndefined();
+    });
+  });
+
+  // ── getDataJson / setDataJson ─────────────────────────────────────────────
+
+  describe('getDataJson / setDataJson', () => {
+    it('returns undefined for an unknown key', () => {
+      expect(svc.getDataJson('NONE')).toBeUndefined();
+    });
+
+    it('stores and retrieves JSON entity data', () => {
+      const data = { entities: [] } as any;
+      svc.setDataJson('PRJ.2024', data);
+      expect(svc.getDataJson('PRJ.2024')).toBe(data);
+    });
+  });
+
+  // ── getSchemaJson / setSchemaJson ─────────────────────────────────────────
+
+  describe('getSchemaJson / setSchemaJson', () => {
+    it('returns undefined for an unknown key', () => {
+      expect(svc.getSchemaJson('NONE')).toBeUndefined();
+    });
+
+    it('stores and retrieves schema (Entities)', () => {
+      const schema = { entities: [] } as any;
+      svc.setSchemaJson('PRJ.2024', schema);
+      expect(svc.getSchemaJson('PRJ.2024')).toBe(schema);
+    });
+  });
+
+  // ── Key isolation ─────────────────────────────────────────────────────────
+
+  describe('key isolation', () => {
+    it('similar keys do not collide in the data map', () => {
+      const d1 = { entities: [{ name: '2024' }] } as any;
+      const d2 = { entities: [{ name: '2025' }] } as any;
+      svc.setData('APP.ENT.2024', d1);
+      svc.setData('APP.ENT.2025', d2);
+      expect(svc.getData('APP.ENT.2024')).toBe(d1);
+      expect(svc.getData('APP.ENT.2025')).toBe(d2);
+    });
+
+    it('similar keys do not collide in the schema map', () => {
+      const s1 = { entities: [{ name: 'a' }] } as any;
+      const s2 = { entities: [{ name: 'b' }] } as any;
+      svc.setSchemaJson('PRJ.2024', s1);
+      svc.setSchemaJson('PRJ.2025', s2);
+      expect(svc.getSchemaJson('PRJ.2024')).toBe(s1);
+      expect(svc.getSchemaJson('PRJ.2025')).toBe(s2);
+    });
+  });
+});

package/src/lib/services/cache.service.ts

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import { EntitiesData, Entities, Member, ItemInterface } from '../interfaces/index';
+
+@Injectable({ providedIn: 'root' })
+export class CacheService {
+  private datas = new Map<string, EntitiesData>();
+  private fields: Record<string, Member[]> = {};
+  private projectItems: Record<string, ItemInterface[]> = {};
+  private dataJson: Record<string, EntitiesData> = {};
+  private schemaJson: Record<string, Entities> = {};
+
+  /** Returns the cached EntitiesData for the given key, or undefined if not present. */
+  public getData(id: string): EntitiesData | undefined {
+    return this.datas.get(id);
+  }
+
+  /** Stores EntitiesData under the given key. */
+  public setData(id: string, data: EntitiesData): void {
+    this.datas.set(id, data);
+  }
+
+  /** Removes the EntitiesData entry for the given key. */
+  public removeData(id: string): void {
+    this.datas.delete(id);
+  }
+
+  /** Returns the cached Member array for the given key. */
+  public getFields(id: string): Member[] {
+    return this.fields[id];
+  }
+
+  /** Stores a Member array under the given key. */
+  public setFields(id: string, fields: Member[]): void {
+    this.fields[id] = fields;
+  }
+
+  /** Returns the cached ItemInterface array for the given project key. */
+  public getProjectItems(id: string): ItemInterface[] {
+    return this.projectItems[id];
+  }
+
+  /** Stores an ItemInterface array under the given project key. */
+  public setProjectItems(id: string, items: ItemInterface[]): void {
+    this.projectItems[id] = items;
+  }
+
+  /** Clears all cached project items. */
+  public clearProjectItems(): void {
+    this.projectItems = {};
+  }
+
+  /** Returns the cached JSON entity data for the given key. */
+  public getDataJson(id: string): EntitiesData {
+    return this.dataJson[id];
+  }
+
+  /** Stores JSON entity data under the given key. */
+  public setDataJson(id: string, data: EntitiesData): void {
+    this.dataJson[id] = data;
+  }
+
+  /** Returns the cached schema (Entities) for the given key. */
+  public getSchemaJson(id: string): Entities {
+    return this.schemaJson[id];
+  }
+
+  /** Stores a schema (Entities) under the given key. */
+  public setSchemaJson(id: string, schema: Entities): void {
+    this.schemaJson[id] = schema;
+  }
+}

package/src/lib/services/global-error-handler.spec.ts

@@ -0,0 +1,39 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpErrorResponse } from '@angular/common/http';
+import { GlobalErrorHandler } from './global-error-handler';
+
+describe('GlobalErrorHandler', () => {
+  let handler: GlobalErrorHandler;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    handler = TestBed.inject(GlobalErrorHandler);
+  });
+
+  it('sets lastError with the message of an Error instance', () => {
+    handler.handleError(new Error('something broke'));
+    expect(handler.lastError()).toBe('something broke');
+  });
+
+  it('sets lastError to string representation for non-Error values', () => {
+    handler.handleError('raw string error');
+    expect(handler.lastError()).toBe('raw string error');
+  });
+
+  it('ignores HttpErrorResponse (handled by the auth interceptor)', () => {
+    handler.handleError(new HttpErrorResponse({ status: 500 }));
+    expect(handler.lastError()).toBeNull();
+  });
+
+  it('clearError resets lastError to null', () => {
+    handler.handleError(new Error('test'));
+    handler.clearError();
+    expect(handler.lastError()).toBeNull();
+  });
+
+  it('overwrites a previous error with a newer one', () => {
+    handler.handleError(new Error('first'));
+    handler.handleError(new Error('second'));
+    expect(handler.lastError()).toBe('second');
+  });
+});

package/src/lib/services/global-error-handler.ts

@@ -0,0 +1,28 @@
+import { ErrorHandler, Injectable, isDevMode, signal } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+
+@Injectable({ providedIn: 'root' })
+export class GlobalErrorHandler implements ErrorHandler {
+  readonly lastError = signal<string | null>(null);
+
+  /** Captures unhandled errors; ignores HTTP errors already handled by the interceptor. */
+  handleError(error: unknown): void {
+    // HTTP errors are already handled by the auth interceptor
+    if (error instanceof HttpErrorResponse) {
+      return;
+    }
+
+    const message = error instanceof Error ? error.message : String(error);
+
+    if (isDevMode()) {
+      console.error('[GlobalErrorHandler]', error);
+    }
+
+    this.lastError.set(message);
+  }
+
+  /** Clears the last captured error signal. */
+  clearError(): void {
+    this.lastError.set(null);
+  }
+}