@futdevpro/nts-dynamo 1.15.15 → 1.15.16

package/src/_services/base/api.service-base.ts

@@ -1,75 +1,75 @@
-import {
-  DyFM_Error, DyFM_HttpCallType,
-  DyFM_Log, 
-} from '@futdevpro/fsm-dynamo';
-import { DyNTS_AuthService } from '../core/auth.service';
-import { DyNTS_SingletonService } from './singleton.service';
-import { DyNTS_ApiService } from '../core/api.service';
-import { DyNTS_ApiCall_Params, DyNTS_global_settings } from '../..';
-
-export abstract class DyNTS_ApiService_Base extends DyNTS_SingletonService {
-
-  /* protected abstract readonly auth_CS: DyNTS_AuthService */
-
-  /* abstract get token(): string; */
-
-  /* abstract get env(): { baseUrl: string, test: string }; */
-  abstract get baseUrl(): string;
-  abstract get testEndpoint(): string;
-  abstract get connectingSystemName(): string;
-
-  async runApiCallWithAvailabilityCheck<T>(
-    apiCall: () => Promise<T>,
-    issuer: string
-  ): Promise<T> {
-    try {
-      return await apiCall();
-    } catch (error) {
-      await this.checkServerAvailability(issuer);
-
-      throw error;
-    }
-  }
-
-  async checkServerAvailability(issuer: string): Promise<void> {
-    try {
-      await this.testGet(issuer);      
-    } catch (error) {      
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings(
-          'checkServerAvailability',
-          new Error(
-            `${this.connectingSystemName} server is not available` +
-            `\n    baseUrl: ${this.baseUrl}`
-          ),
-          issuer
-        ),
-        userMessage: `${this.connectingSystemName} server is not available`,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ASB-CSA0`,
-      });
-    }
-  }
-
-  async testGet(issuer: string): Promise<void> {
-    if (!this.testEndpoint) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings(
-          'testGet',
-          new Error(`testEndpoint is not set for ${this.connectingSystemName}`),
-          issuer
-        ),
-      });
-    }
-
-    await DyNTS_ApiService.startApiCall<void>(
-      new DyNTS_ApiCall_Params({
-        name: `${this.connectingSystemName} testGet`,
-        type: DyFM_HttpCallType.get,
-        baseUrl: this.baseUrl,
-        endpoint: this.testEndpoint,
-      }),
-    );
-
-    DyFM_Log.success(`${this.connectingSystemName} is available`);
-  }
+import {
+  DyFM_Error, DyFM_HttpCallType,
+  DyFM_Log, 
+} from '@futdevpro/fsm-dynamo';
+import { DyNTS_AuthService } from '../core/auth.service';
+import { DyNTS_SingletonService } from './singleton.service';
+import { DyNTS_ApiService } from '../core/api.service';
+import { DyNTS_ApiCall_Params, DyNTS_global_settings } from '../..';
+
+export abstract class DyNTS_ApiService_Base extends DyNTS_SingletonService {
+
+  /* protected abstract readonly auth_CS: DyNTS_AuthService */
+
+  /* abstract get token(): string; */
+
+  /* abstract get env(): { baseUrl: string, test: string }; */
+  abstract get baseUrl(): string;
+  abstract get testEndpoint(): string;
+  abstract get connectingSystemName(): string;
+
+  async runApiCallWithAvailabilityCheck<T>(
+    apiCall: () => Promise<T>,
+    issuer: string
+  ): Promise<T> {
+    try {
+      return await apiCall();
+    } catch (error) {
+      await this.checkServerAvailability(issuer);
+
+      throw error;
+    }
+  }
+
+  async checkServerAvailability(issuer: string): Promise<void> {
+    try {
+      await this.testGet(issuer);      
+    } catch (error) {      
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'checkServerAvailability',
+          new Error(
+            `${this.connectingSystemName} server is not available` +
+            `\n    baseUrl: ${this.baseUrl}`
+          ),
+          issuer
+        ),
+        userMessage: `${this.connectingSystemName} server is not available`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ASB-CSA0`,
+      });
+    }
+  }
+
+  async testGet(issuer: string): Promise<void> {
+    if (!this.testEndpoint) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'testGet',
+          new Error(`testEndpoint is not set for ${this.connectingSystemName}`),
+          issuer
+        ),
+      });
+    }
+
+    await DyNTS_ApiService.startApiCall<void>(
+      new DyNTS_ApiCall_Params({
+        name: `${this.connectingSystemName} testGet`,
+        type: DyFM_HttpCallType.get,
+        baseUrl: this.baseUrl,
+        endpoint: this.testEndpoint,
+      }),
+    );
+
+    DyFM_Log.success(`${this.connectingSystemName} is available`);
+  }
 }

package/src/_services/base/archive-data.service.spec.ts

@@ -1,196 +1,196 @@
-
-import { DyNTS_ArchiveDataService } from './archive-data.service';
-import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyNTS_GlobalService } from '../core/global.service';
-import { DyNTS_DBService } from './db.service';
-import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
-
-class TestMetadata extends DyFM_Metadata {
-  name: string;
-}
-
-describe('| DyNTS_ArchiveDataService', () => {
-  let mockDataParams: DyFM_DataModel_Params<TestMetadata>;
-  let mockOriginalDBService: jasmine.SpyObj<DyNTS_DBService<TestMetadata>>;
-  let mockArchivedDBService: jasmine.SpyObj<DyNTS_DBService<TestMetadata>>;
-
-  beforeEach(() => {
-    mockDataParams = {
-      dataName: 'test_data',
-      addArchive: true,
-      constructed: () => true,
-      properties: {},
-    } as any;
-
-    mockOriginalDBService = jasmine.createSpyObj<DyNTS_DBService<TestMetadata>>('OriginalDBService', [
-      'getDataById',
-      'trueDeleteDataById',
-    ]);
-
-    mockArchivedDBService = jasmine.createSpyObj<DyNTS_DBService<TestMetadata>>('ArchivedDBService', [
-      'createData',
-      'getDataById',
-    ]);
-
-    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockOriginalDBService);
-  });
-
-  it('| should throw error when addArchive is missing from dataParams', () => {
-    const dataParamsWithoutArchive = {
-      ...mockDataParams,
-      addArchive: false,
-    } as any;
-
-    const data = new TestMetadata();
-
-    expect(() => {
-      new DyNTS_ArchiveDataService(data, dataParamsWithoutArchive, 'issuer-123');
-    }).toThrowError('addArchive is missing from dataParams!');
-  });
-
-  it('| should create service with archived data name', () => {
-    const data = new TestMetadata();
-
-    const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-
-    expect(service).toBeInstanceOf(DyNTS_ArchiveDataService);
-    expect(service.originalDBService).toBe(mockOriginalDBService);
-    expect(service.dataParams.dataName).toBe('test_data_archived');
-  });
-
-  describe('| archiveDataById', () => {
-    it('| should throw error when id is missing', async () => {
-      const data = new TestMetadata();
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-
-      await expectAsync(
-        service.archiveDataById('')
-      ).toBeRejected();
-    });
-
-    it('| should throw error when data not found', async () => {
-      const data = new TestMetadata();
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-      mockOriginalDBService.getDataById.and.returnValue(Promise.resolve(null));
-
-      await expectAsync(
-        service.archiveDataById('non-existent-id')
-      ).toBeRejected();
-    });
-
-    it('| should archive data when found', async () => {
-      const data = new TestMetadata({ _id: 'test-id' });
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-      mockOriginalDBService.getDataById.and.returnValue(Promise.resolve(data));
-      mockOriginalDBService.trueDeleteDataById.and.returnValue(Promise.resolve());
-      spyOn(service, 'archiveData').and.returnValue(Promise.resolve(data));
-
-      const result = await service.archiveDataById('test-id');
-
-      expect(mockOriginalDBService.getDataById).toHaveBeenCalledWith('test-id');
-      expect(service.archiveData).toHaveBeenCalledWith(data);
-      expect(result).toBe(data);
-    });
-  });
-
-  describe('| getDataByOriginalId', () => {
-    it('| should find data by original id', async () => {
-      const data = new TestMetadata();
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-      const archivedData = new TestMetadata({ _originalId: 'original-id' });
-      spyOn(service, 'findData').and.returnValue(Promise.resolve(archivedData));
-
-      const result = await service.getDataByOriginalId('original-id');
-
-      expect(service.findData).toHaveBeenCalled();
-      expect(result).toBe(archivedData);
-    });
-
-    it('| should throw error on find failure', async () => {
-      const data = new TestMetadata();
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-      spyOn(service, 'findData').and.returnValue(Promise.reject(new Error('Find failed')));
-
-      await expectAsync(
-        service.getDataByOriginalId('original-id')
-      ).toBeRejected();
-    });
-  });
-
-  describe('| archiveData', () => {
-    it('| should throw error when originalId already exists', async () => {
-      const data = new TestMetadata({ _id: 'test-id', _originalId: 'existing-original-id' } as TestMetadata);
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-
-      await expectAsync(
-        service.archiveData(data)
-      ).toBeRejected();
-    });
-
-    it('| should throw error when data is already archived', async () => {
-      const data = new TestMetadata({ _id: 'test-id', _archived: new Date() } as TestMetadata);
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-
-      await expectAsync(
-        service.archiveData(data)
-      ).toBeRejected();
-    });
-
-    it('| should throw error when id is missing', async () => {
-      const data = new TestMetadata();
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-
-      await expectAsync(
-        service.archiveData(data)
-      ).toBeRejected();
-    });
-
-    it('| should archive data successfully', async () => {
-      const data = new TestMetadata({ _id: 'test-id' });
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-      mockOriginalDBService.trueDeleteDataById.and.returnValue(Promise.resolve());
-      spyOn(service, 'saveData').and.returnValue(Promise.resolve(data));
-
-      const result = await service.archiveData(data);
-
-      expect(mockOriginalDBService.trueDeleteDataById).toHaveBeenCalledWith('test-id');
-      expect(data._originalId).toBe('test-id');
-      expect(data._archived).toBeInstanceOf(Date);
-      expect(data._id).toBeUndefined();
-      expect(service.saveData).toHaveBeenCalled();
-      expect(result).toBe(data);
-    });
-  });
-
-  describe('| saveData', () => {
-    it('| should throw error when originalId is missing', async () => {
-      const data = new TestMetadata();
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-
-      await expectAsync(
-        service.saveData(data)
-      ).toBeRejected();
-    });
-
-    it('| should throw error when data is not archived', async () => {
-      const data = new TestMetadata({ _originalId: 'original-id' } as TestMetadata);
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-
-      await expectAsync(
-        service.saveData(data)
-      ).toBeRejected();
-    });
-
-    it('| should save archived data successfully', async () => {
-      const data = new TestMetadata({ _originalId: 'original-id', _archived: new Date() } as TestMetadata);
-      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
-      const parentSaveDataSpy = spyOn(Object.getPrototypeOf(DyNTS_ArchiveDataService.prototype), 'saveData').and.returnValue(Promise.resolve(data));
-
-      const result = await service.saveData(data);
-
-      expect(parentSaveDataSpy).toHaveBeenCalled();
-      expect(result).toBe(data);
-    });
-  });
-});
-
+
+import { DyNTS_ArchiveDataService } from './archive-data.service';
+import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_DBService } from './db.service';
+import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
+
+class TestMetadata extends DyFM_Metadata {
+  name: string;
+}
+
+describe('| DyNTS_ArchiveDataService', () => {
+  let mockDataParams: DyFM_DataModel_Params<TestMetadata>;
+  let mockOriginalDBService: jasmine.SpyObj<DyNTS_DBService<TestMetadata>>;
+  let mockArchivedDBService: jasmine.SpyObj<DyNTS_DBService<TestMetadata>>;
+
+  beforeEach(() => {
+    mockDataParams = {
+      dataName: 'test_data',
+      addArchive: true,
+      constructed: () => true,
+      properties: {},
+    } as any;
+
+    mockOriginalDBService = jasmine.createSpyObj<DyNTS_DBService<TestMetadata>>('OriginalDBService', [
+      'getDataById',
+      'trueDeleteDataById',
+    ]);
+
+    mockArchivedDBService = jasmine.createSpyObj<DyNTS_DBService<TestMetadata>>('ArchivedDBService', [
+      'createData',
+      'getDataById',
+    ]);
+
+    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockOriginalDBService);
+  });
+
+  it('| should throw error when addArchive is missing from dataParams', () => {
+    const dataParamsWithoutArchive = {
+      ...mockDataParams,
+      addArchive: false,
+    } as any;
+
+    const data = new TestMetadata();
+
+    expect(() => {
+      new DyNTS_ArchiveDataService(data, dataParamsWithoutArchive, 'issuer-123');
+    }).toThrowError('addArchive is missing from dataParams!');
+  });
+
+  it('| should create service with archived data name', () => {
+    const data = new TestMetadata();
+
+    const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+    expect(service).toBeInstanceOf(DyNTS_ArchiveDataService);
+    expect(service.originalDBService).toBe(mockOriginalDBService);
+    expect(service.dataParams.dataName).toBe('test_data_archived');
+  });
+
+  describe('| archiveDataById', () => {
+    it('| should throw error when id is missing', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.archiveDataById('')
+      ).toBeRejected();
+    });
+
+    it('| should throw error when data not found', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      mockOriginalDBService.getDataById.and.returnValue(Promise.resolve(null));
+
+      await expectAsync(
+        service.archiveDataById('non-existent-id')
+      ).toBeRejected();
+    });
+
+    it('| should archive data when found', async () => {
+      const data = new TestMetadata({ _id: 'test-id' });
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      mockOriginalDBService.getDataById.and.returnValue(Promise.resolve(data));
+      mockOriginalDBService.trueDeleteDataById.and.returnValue(Promise.resolve());
+      spyOn(service, 'archiveData').and.returnValue(Promise.resolve(data));
+
+      const result = await service.archiveDataById('test-id');
+
+      expect(mockOriginalDBService.getDataById).toHaveBeenCalledWith('test-id');
+      expect(service.archiveData).toHaveBeenCalledWith(data);
+      expect(result).toBe(data);
+    });
+  });
+
+  describe('| getDataByOriginalId', () => {
+    it('| should find data by original id', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      const archivedData = new TestMetadata({ _originalId: 'original-id' });
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(archivedData));
+
+      const result = await service.getDataByOriginalId('original-id');
+
+      expect(service.findData).toHaveBeenCalled();
+      expect(result).toBe(archivedData);
+    });
+
+    it('| should throw error on find failure', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      spyOn(service, 'findData').and.returnValue(Promise.reject(new Error('Find failed')));
+
+      await expectAsync(
+        service.getDataByOriginalId('original-id')
+      ).toBeRejected();
+    });
+  });
+
+  describe('| archiveData', () => {
+    it('| should throw error when originalId already exists', async () => {
+      const data = new TestMetadata({ _id: 'test-id', _originalId: 'existing-original-id' } as TestMetadata);
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.archiveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should throw error when data is already archived', async () => {
+      const data = new TestMetadata({ _id: 'test-id', _archived: new Date() } as TestMetadata);
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.archiveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should throw error when id is missing', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.archiveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should archive data successfully', async () => {
+      const data = new TestMetadata({ _id: 'test-id' });
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      mockOriginalDBService.trueDeleteDataById.and.returnValue(Promise.resolve());
+      spyOn(service, 'saveData').and.returnValue(Promise.resolve(data));
+
+      const result = await service.archiveData(data);
+
+      expect(mockOriginalDBService.trueDeleteDataById).toHaveBeenCalledWith('test-id');
+      expect(data._originalId).toBe('test-id');
+      expect(data._archived).toBeInstanceOf(Date);
+      expect(data._id).toBeUndefined();
+      expect(service.saveData).toHaveBeenCalled();
+      expect(result).toBe(data);
+    });
+  });
+
+  describe('| saveData', () => {
+    it('| should throw error when originalId is missing', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.saveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should throw error when data is not archived', async () => {
+      const data = new TestMetadata({ _originalId: 'original-id' } as TestMetadata);
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.saveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should save archived data successfully', async () => {
+      const data = new TestMetadata({ _originalId: 'original-id', _archived: new Date() } as TestMetadata);
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      const parentSaveDataSpy = spyOn(Object.getPrototypeOf(DyNTS_ArchiveDataService.prototype), 'saveData').and.returnValue(Promise.resolve(data));
+
+      const result = await service.saveData(data);
+
+      expect(parentSaveDataSpy).toHaveBeenCalled();
+      expect(result).toBe(data);
+    });
+  });
+});
+