@futdevpro/nts-dynamo 1.15.2 → 1.15.5

package/src/_services/base/singleton.service.spec.ts

@@ -0,0 +1,114 @@
+
+import { DyNTS_SingletonService } from './singleton.service';
+import { DyFM_Error, DyFM_Error_Settings } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+class TestSingletonService extends DyNTS_SingletonService {
+  static getInstance(): TestSingletonService {
+    return TestSingletonService.getSingletonInstance();
+  }
+}
+
+describe('| DyNTS_SingletonService', () => {
+  let service: TestSingletonService;
+
+  beforeEach(() => {
+    service = TestSingletonService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = TestSingletonService.getInstance();
+    const instance2 = TestSingletonService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestSingletonService);
+  });
+
+  it('| should have default error user message', () => {
+    expect(service.defaultErrorUserMsg).toBeDefined();
+    expect(service.defaultErrorUserMsg).toContain('Control Service Error');
+  });
+
+  describe('| getDefaultErrorSettings', () => {
+    it('| should return error settings with default values', () => {
+      const error = new Error('Test error');
+      const issuer = 'issuer-123';
+
+      const result = (service as any).getDefaultErrorSettings('testFunction', error, issuer);
+
+      expect(result).toBeDefined();
+      expect(result.message).toBe('Test error');
+      // useMessageAsUserMessage defaults to true, so userMessage will be error.message
+      expect(result.userMessage).toBe('Test error');
+      expect(result.issuer).toBe(issuer);
+      expect(result.issuerService).toBe('TestSingletonService');
+      expect(result.systemVersion).toBe(DyNTS_global_settings.systemVersion);
+      expect(result.error).toBe(error);
+    });
+
+    it('| should use DyFM_Error status when available', () => {
+      const error = new DyFM_Error({
+        status: 404,
+        message: 'Not found',
+      });
+      const issuer = 'issuer-123';
+
+      const result = (service as any).getDefaultErrorSettings('testFunction', error, issuer);
+
+      expect(result.status).toBe(404);
+    });
+
+    it('| should use default status when error is not DyFM_Error', () => {
+      const error = new Error('Test error');
+      const issuer = 'issuer-123';
+
+      const result = (service as any).getDefaultErrorSettings('testFunction', error, issuer);
+
+      expect(result.status).toBe(500);
+    });
+
+    it('| should use error message when available', () => {
+      const error = new Error('Test error message');
+      const issuer = 'issuer-123';
+
+      const result = (service as any).getDefaultErrorSettings('testFunction', error, issuer);
+
+      expect(result.message).toBe('Test error message');
+    });
+
+    it('| should use default message when error message is not available', () => {
+      const error = {} as Error;
+      const issuer = 'issuer-123';
+
+      const result = (service as any).getDefaultErrorSettings('testFunction', error, issuer);
+
+      expect(result.message).toContain('testFunction was UNSUCCESSFUL');
+    });
+
+    it('| should use DyFM_Error user message when available', () => {
+      const error = new DyFM_Error({
+        message: 'Test error',
+        userMessage: 'Custom user message',
+      });
+      const issuer = 'issuer-123';
+
+      const result = (service as any).getDefaultErrorSettings('testFunction', error, issuer);
+
+      expect(result.userMessage).toBe('Custom user message');
+      expect(result.addECToUserMsg).toBe(false);
+    });
+
+    it('| should use default user message when DyFM_Error user message is not available', () => {
+      const error = new DyFM_Error({
+        message: 'Test error',
+      });
+      const issuer = 'issuer-123';
+
+      const result = (service as any).getDefaultErrorSettings('testFunction', error, issuer, false);
+
+      expect(result.userMessage).toBe(service.defaultErrorUserMsg);
+      expect(result.addECToUserMsg).toBe(true);
+    });
+  });
+});
+

package/src/_services/core/api.service.ts

@@ -266,6 +266,7 @@ export class DyNTS_ApiService {
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE1`,
         message: 
           `API call "${callParams.name}" failed on the other end!`+
+          `\nurl: ${url}` +
           `\nerror response found: ${errorMsg}`,
         error: dyfmErrorInAxiosResponse,
         additionalContent: {

package/src/_services/core/auth.service.spec.ts

@@ -0,0 +1,159 @@
+
+import { DyNTS_AuthService } from './auth.service';
+import { Request } from 'express';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+class TestAuthService extends DyNTS_AuthService {
+  static getInstance(): TestAuthService {
+    return TestAuthService.getSingletonInstance();
+  }
+
+  authenticate_token = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  authenticate_tokenSelf = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  authenticate_tokenPerm_accUsageData = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  getIssuerFromRequest(req: Request): string {
+    return 'test-issuer';
+  }
+
+  getUsernameFromRequest(req: Request): string {
+    return 'test-user';
+  }
+}
+
+describe('| DyNTS_AuthService', () => {
+  let service: TestAuthService;
+
+  beforeEach(() => {
+    service = TestAuthService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = TestAuthService.getInstance();
+    const instance2 = TestAuthService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestAuthService);
+  });
+
+  it('| should have default service name', () => {
+    expect(service.serviceName).toBe('AuthService');
+  });
+
+  it('| should have default error user message', () => {
+    expect(service.defaultErrorUserMsg).toBeDefined();
+    expect(service.defaultErrorUserMsg).toContain('Auth Error');
+  });
+
+  describe('| getTokenFromRequest', () => {
+    it('| should extract token from authorization header', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer test-token-123',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('test-token-123');
+    });
+
+    it('| should throw error when authorization header is missing', () => {
+      const req = {
+        headers: {},
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when authorization header is null', () => {
+      const req = {
+        headers: {
+          authorization: null,
+        },
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when token is missing from header', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer ',
+        },
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when authorization header does not contain Bearer', () => {
+      const req = {
+        headers: {
+          authorization: 'InvalidFormat token',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('token');
+    });
+
+    it('| should handle token with spaces correctly', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer token-with-spaces',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('token-with-spaces');
+    });
+
+    it('| should include error code in thrown error', () => {
+      const req = {
+        headers: {},
+      } as any as Request;
+
+      try {
+        service.getTokenFromRequest(req);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-AS0-GT0');
+      }
+    });
+
+    it('| should include confidential content in error when header missing', () => {
+      const req = {
+        headers: {
+          'x-custom-header': 'value',
+        },
+      } as any as Request;
+
+      try {
+        service.getTokenFromRequest(req);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error).confidentialContent).toBeDefined();
+      }
+    });
+  });
+});
+

package/src/_services/core/auth.service.ts

@@ -12,7 +12,7 @@ import { DyNTS_global_settings } from '../../_collections/global-settings.const'
  * You should use singleton instance getting function by implementing a
  * static getInstance() function
  * @example
- * export class AuthService extends DynamoBEAuthService {
+ * export class AuthService extends DyNTS_AuthService {
  *
  *   static getInstance(): AuthService {
  *     return AuthService.getSingletonInstance();
@@ -150,7 +150,7 @@ export abstract class DyNTS_AuthService extends DyNTS_SingletonService {
   abstract authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
 
   /**
-   * The DynamoBE System is using this to get issuer, that will be set on DBServices
+   * The DynamoNTS System is using this to get issuer, that will be set on DBServices
    * Don't throw error in this function, since it will be used in every request
    * @param req 
    * 

package/src/_services/core/email.service.spec.ts

@@ -1,6 +1,7 @@
 
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
 import { DyNTS_EmailService, DyNTS_EmailService_Settings, DyNTS_EmailTemplateComponent, DyNTS_SendEmail_Settings } from './email.service';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 
 describe('| DyNTS_EmailService', () => {
   let emailService: DyNTS_EmailService;
@@ -21,7 +22,19 @@ describe('| DyNTS_EmailService', () => {
     ],
   };
 
+  beforeAll(() => {
+    if (!DyNTS_global_settings.systemShortCodeName) (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
+    if (!DyNTS_global_settings.env_settings) (DyNTS_global_settings as { env_settings?: unknown }).env_settings = { environment: DyFM_EnvironmentFlag.local };
+  });
+
   beforeEach(() => {
+    (DyNTS_global_settings as { env_settings: unknown }).env_settings = {
+      environment: DyFM_EnvironmentFlag.local,
+      mongoUri: 'mongodb://localhost:27017/test',
+      discord: undefined,
+      openAi: undefined,
+    };
+
     emailService = new DyNTS_EmailService(settings);
   });
 
@@ -37,17 +50,6 @@ describe('| DyNTS_EmailService', () => {
     expect(emailService['componentsBySelector']['test-selector']).toBeDefined();
   });
 
-  xit('should send email with direct content', async () => {
-    const sendEmailSettings: DyNTS_SendEmail_Settings = {
-      to: 'recipient@example.com',
-      subject: 'Test Subject',
-      content: '<p>Test Content</p>',
-    };
-
-    await emailService.sendEmail(sendEmailSettings, 'testIssuer');
-    // No error should be thrown
-  });
-
   it('| should throw error if no template component name is provided', async () => {
     const sendEmailSettings: DyNTS_SendEmail_Settings = {
       to: 'recipient@example.com',
@@ -69,16 +71,6 @@ describe('| DyNTS_EmailService', () => {
       .toBeRejectedWith(jasmine.any(DyFM_Error));
   });
 
-  xit('should compile template component correctly', async () => {
-    const compiledTemplate = await emailService['compileTemplateComponent'](
-      'testComponent',
-      { property: 'value' },
-      'testIssuer'
-    );
-
-    expect(compiledTemplate).toContain('<div>value</div>');
-  });
-
   it('| should throw error if template property is missing', async () => {
     const component = new DyNTS_EmailTemplateComponent({
       name: 'testComponent',

package/src/_services/core/email.service.ts

@@ -664,7 +664,7 @@ export class DyNTS_EmailService /* extends DyNTS_SingletonService */ {
       while (propertyOpenTagIndex >= 0) {
         if (propertyCloseTagIndex === -1) {
           DyFM_Log.error(
-            `\nDynamoBEEmailService ERROR, missing closing tag from email template! ` +
+            `\nDyNTS_EmailService ERROR, missing closing tag from email template! ` +
             `(${propertyOpenTagIndex} -)`, 
             propertyKeys
           );

package/src/_services/core/global.service.spec.ts

@@ -0,0 +1,275 @@
+
+import { DyNTS_GlobalService } from './global.service';
+import { DyNTS_AuthService } from './auth.service';
+import { DyNTS_EmailService } from './email.service';
+import { DyNTS_DBService } from '../base/db.service';
+import { DyNTS_Service_Collection } from './service-collection.service';
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import { DyFM_DataModel_Params, DyFM_Error, DyFM_Metadata, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+import { DyNTS_GlobalService_Settings } from '../../_models/interfaces/global-service-settings.interface';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+class TestMetadata extends DyFM_Metadata {
+  name: string;
+}
+
+class TestAuthService extends DyNTS_AuthService {
+  static getInstance(): TestAuthService {
+    return TestAuthService.getSingletonInstance();
+  }
+
+  authenticate_token = async (req: any, res: any): Promise<void> => {};
+  authenticate_tokenSelf = async (req: any, res: any): Promise<void> => {};
+  authenticate_tokenPerm_accUsageData = async (req: any, res: any): Promise<void> => {};
+  getIssuerFromRequest(req: any): string { return 'test'; }
+  getUsernameFromRequest(req: any): string { return 'test'; }
+}
+
+describe('| DyNTS_GlobalService', () => {
+  // Ensure env_settings exists before tests
+  beforeAll(() => {
+    if (!DyNTS_global_settings.env_settings) {
+      (DyNTS_global_settings as any).env_settings = {
+        environment: DyFM_EnvironmentFlag.local,
+        discord: {},
+        mongoUri: undefined,
+        openAi: {},
+      };
+    } else if (!DyNTS_global_settings.env_settings.environment) {
+      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.local;
+    }
+  });
+
+  beforeEach(() => {
+    // Reset singleton instance
+    (DyNTS_GlobalService as any).instance = undefined;
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = DyNTS_GlobalService.getInstance();
+    const instance2 = DyNTS_GlobalService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(DyNTS_GlobalService);
+  });
+
+  describe('| params', () => {
+    it('| should return undefined when not set', () => {
+      // Reset params before test
+      (DyNTS_GlobalService as any)._params = undefined;
+      expect(DyNTS_GlobalService.params).toBeUndefined();
+    });
+
+    it('| should return set params', () => {
+      const params = new DyNTS_App_Params({
+        name: 'Test App',
+        version: '1.0.0',
+        dbName: 'test_db',
+      });
+
+      DyNTS_GlobalService.setParams(params);
+
+      expect(DyNTS_GlobalService.params).toBe(params);
+      expect(DyNTS_GlobalService.params.name).toBe('Test App');
+    });
+  });
+
+  describe('| upSince', () => {
+    it('| should return a Date object', () => {
+      expect(DyNTS_GlobalService.upSince).toBeInstanceOf(Date);
+    });
+
+    it('| should return the same date on multiple calls', () => {
+      const date1 = DyNTS_GlobalService.upSince;
+      const date2 = DyNTS_GlobalService.upSince;
+
+      expect(date1).toBe(date2);
+    });
+  });
+
+  describe('| upTime', () => {
+    it('| should return a number', () => {
+      expect(typeof DyNTS_GlobalService.upTime).toBe('number');
+    });
+
+    it('| should return positive value', () => {
+      expect(DyNTS_GlobalService.upTime).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('| setParams', () => {
+    it('| should set params', () => {
+      const params = new DyNTS_App_Params({
+        name: 'Test App',
+        version: '1.0.0',
+        dbName: 'test_db',
+      });
+
+      DyNTS_GlobalService.setParams(params);
+
+      expect(DyNTS_GlobalService.params).toBe(params);
+    });
+  });
+
+  describe('| getAuthService', () => {
+    it('| should throw error when auth service not set', () => {
+      expect(() => {
+        DyNTS_GlobalService.getAuthService();
+      }).toThrow();
+    });
+
+    it('| should return auth service when set', async () => {
+      const authService = TestAuthService.getInstance();
+      await DyNTS_GlobalService.setServices({
+        authService: authService,
+      });
+
+      const result = DyNTS_GlobalService.getAuthService();
+
+      expect(result).toBe(authService);
+    });
+  });
+
+  describe('| getDBServiceCollection', () => {
+    it('| should throw error when db service collection not set', () => {
+      expect(() => {
+        DyNTS_GlobalService.getDBServiceCollection();
+      }).toThrow();
+    });
+
+    it('| should return db service collection when set', async () => {
+      const dbModel = new DyFM_DataModel_Params<TestMetadata>({
+        dataName: 'test_data',
+        properties: { name: { key: 'name', type: 'string' } },
+      });
+
+      await DyNTS_GlobalService.setServices({
+        dbModels: [dbModel],
+      });
+
+      const result = DyNTS_GlobalService.getDBServiceCollection();
+
+      expect(result).toBeDefined();
+      expect(result['test_data']).toBeDefined();
+    });
+  });
+
+  describe('| getDBService', () => {
+    it('| should return db service by data params', async () => {
+      const dbModel = new DyFM_DataModel_Params<TestMetadata>({
+        dataName: 'test_data',
+        properties: { name: { key: 'name', type: 'string' } },
+      });
+
+      await DyNTS_GlobalService.setServices({
+        dbModels: [dbModel],
+      });
+
+      const result = DyNTS_GlobalService.getDBService(dbModel);
+
+      expect(result).toBeDefined();
+      expect(result).toBeInstanceOf(DyNTS_DBService);
+    });
+
+    it('| should throw error when db service not found', async () => {
+      const dbModel = new DyFM_DataModel_Params<TestMetadata>({
+        dataName: 'non_existent',
+        properties: { name: { key: 'name', type: 'string' } },
+      });
+
+      await DyNTS_GlobalService.setServices({
+        dbModels: [],
+      });
+
+      expect(() => {
+        DyNTS_GlobalService.getDBService(dbModel);
+      }).toThrow();
+    });
+  });
+
+  describe('| getDBServiceByKey', () => {
+    it('| should return db service by key', async () => {
+      const dbModel = new DyFM_DataModel_Params<TestMetadata>({
+        dataName: 'test_data',
+        properties: { name: { key: 'name', type: 'string' } },
+      });
+
+      await DyNTS_GlobalService.setServices({
+        dbModels: [dbModel],
+      });
+
+      const result = DyNTS_GlobalService.getDBServiceByKey<TestMetadata>('test_data');
+
+      expect(result).toBeDefined();
+      expect(result).toBeInstanceOf(DyNTS_DBService);
+    });
+
+    it('| should throw error when key not found', async () => {
+      await DyNTS_GlobalService.setServices({
+        dbModels: [],
+      });
+
+      expect(() => {
+        DyNTS_GlobalService.getDBServiceByKey('non_existent');
+      }).toThrow();
+    });
+  });
+
+  describe('| getEmailServiceCollection', () => {
+    it('| should throw error when email service collection not set', () => {
+      expect(() => {
+        DyNTS_GlobalService.getEmailServiceCollection();
+      }).toThrow();
+    });
+
+    it('| should return email service collection when set', async () => {
+      const emailServiceCollection = {} as DyNTS_Service_Collection<DyNTS_EmailService>;
+
+      await DyNTS_GlobalService.setServices({
+        emailServiceCollection: emailServiceCollection,
+      });
+
+      const result = DyNTS_GlobalService.getEmailServiceCollection();
+
+      expect(result).toBe(emailServiceCollection);
+    });
+  });
+
+  describe('| setServices', () => {
+    it('| should setup all services', async () => {
+      const authService = TestAuthService.getInstance();
+      const dbModel = new DyFM_DataModel_Params<TestMetadata>({
+        dataName: 'test_data',
+        properties: { name: { key: 'name', type: 'string' } },
+      });
+      const emailServiceCollection = {} as DyNTS_Service_Collection<DyNTS_EmailService>;
+
+      await DyNTS_GlobalService.setServices({
+        authService: authService,
+        dbModels: [dbModel],
+        emailServiceCollection: emailServiceCollection,
+      });
+
+      expect(DyNTS_GlobalService.getAuthService()).toBe(authService);
+      expect(DyNTS_GlobalService.getDBServiceCollection()).toBeDefined();
+      expect(DyNTS_GlobalService.getEmailServiceCollection()).toBe(emailServiceCollection);
+    });
+
+    it('| should handle empty settings', async () => {
+      await expectAsync(
+        DyNTS_GlobalService.setServices({})
+      ).toBeResolved();
+    });
+
+    it('| should throw error on setup failure', async () => {
+      const invalidDbModel = null as any;
+
+      await expectAsync(
+        DyNTS_GlobalService.setServices({
+          dbModels: [invalidDbModel],
+        })
+      ).toBeRejected();
+    });
+  });
+});
+

package/src/_services/core/global.service.ts

@@ -30,7 +30,7 @@ import { DyNTS_SingletonService } from '../base/singleton.service';
 import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
 
 /**
- * This is the main Global/Core Service Collection used by DynamoBE, 
+ * This is the main Global/Core Service Collection used by DynamoNTS, 
  * you also can use this to access main services as 
  * dbServices, emailServices, or authService
  */
@@ -373,7 +373,7 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
       throw new Error(
         `\n  Unique Email Service Collection missing!` + 
         `\n    Please create a Unique Email Service Collection extending ` +
-          `DynamoBEEmailServiceCollection, ` + 
+          `DyNTS_EmailServiceCollection, ` + 
         '\n    (If you set the globalErrorHandler, ' +
           'please check if it is using the same node_modules as the app)' +
         `\n      and Setup with DyNTS_GlobalServiceC.setServices(...)\n` +