@nest-yalc-2/utils 1.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@nest-yalc-2/utils",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./src/index.js",
+  "exports": {
+    "./": "./src/"
+  },
+  "author": "",
+  "license": "AGPL-3.0-or-later",
+  "types": "./src/index.d.ts",
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nek97/nestjs-yalc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Nek97/nestjs-yalc/issues"
+  },
+  "homepage": "https://github.com/Nek97/nestjs-yalc#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "tslib": "^2.8.1"
+  }
+}

package/src/__mocks__/enum.mock.ts

@@ -0,0 +1,9 @@
+export enum TestEnum1 {
+  TEST1 = 'test1',
+  TEST2 = 'test2',
+}
+
+export enum TestEnum2 {
+  TEST2 = 'test2',
+  TEST3 = 'test3',
+}

package/src/__tests__/class.helper.spec.ts

@@ -0,0 +1,32 @@
+import { isClass, isES6Class } from '../class.helper.js';
+import { describe, expect, it } from '@jest/globals';
+import { DefaultError } from '@nest-yalc-2/errors/default.error.js';
+
+describe('Test Class Helpers', () => {
+  it('should test a class correctly', () => {
+    expect(isClass(class {})).toBeTruthy();
+  });
+
+  it('should test a class correctly', () => {
+    expect(
+      isClass(function (nothing: any) {
+        nothing;
+      }),
+    ).toBeTruthy();
+    expect(isClass(Error)).toBeTruthy();
+    expect(isES6Class(Error)).toBeFalsy();
+    expect(isClass(() => {})).toBeFalsy();
+  });
+
+  it('expect an instance of a class to not be a class', () => {
+    expect(isClass(new (class {})())).toBeFalsy();
+  });
+
+  it('should test a class against a name', () => {
+    const defaultError = DefaultError;
+    expect(isClass(class Test {}, 'Test')).toBeTruthy();
+    expect(isClass(class Test {}, 'Test2')).toBeFalsy();
+    expect(isES6Class(class Test {}, 'Test2')).toBeFalsy();
+    expect(isClass(defaultError, DefaultError.name)).toBeTruthy();
+  });
+});

package/src/__tests__/command.helper.spec.ts

@@ -0,0 +1,35 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+
+import { commandWithErrors } from '../command.helper.js';
+
+describe('test shared functions', () => {
+  it('should run cliWithErrors without errors', async () => {
+    const fn = jest.fn();
+    const cliWithErrorsResult = commandWithErrors(fn);
+    await cliWithErrorsResult(1);
+
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenLastCalledWith(1);
+  });
+
+  it('should run cliWithErrors and call the process exit', async () => {
+    const spiedProcessExit = jest.spyOn(process, 'exit');
+
+    spiedProcessExit.mockImplementation((() => {}) as any);
+
+    await commandWithErrors(async () => {
+      throw new Error('Test');
+    })('Test');
+    expect(spiedProcessExit).toHaveBeenCalledWith(1);
+
+    spiedProcessExit.mockRestore();
+  });
+});

package/src/__tests__/config-manager.helper.spec.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from '@jest/globals';
+import { ConfigValueManager, checkForDuplicateKeys } from '../config-manager.helper.js'; // Adjust the import path accordingly
+
+describe('ConfigValueManager and Utilities', () => {
+
+  describe('checkForDuplicateKeys', () => {
+    it('should not throw an error for unique keys', () => {
+      const execute = () => checkForDuplicateKeys(['key1', 'key2', 'key3']);
+      expect(execute).not.toThrow();
+    });
+
+    it('should throw an error for duplicate keys', () => {
+      const execute = () => checkForDuplicateKeys(['key1', 'key1']);
+      expect(execute).toThrow(/Duplicate key found in configuration: key1/);
+    });
+  });
+
+  describe('ConfigValueManager.value', () => {
+    it('returns the correct value for a matching key', () => {
+      const result = ConfigValueManager.value('myKey', {k: 'myKey', v: 'myValue'});
+      expect(result).toBe('myValue');
+    });
+
+    it('returns the default value when key does not match', () => {
+      const result = ConfigValueManager.value('otherKey', { k: 'myKey', v: 'myValue' }, 'default');
+      expect(result).toBe('default');
+    });
+
+    it('returns the value from a function when key matches', () => {
+      const result = ConfigValueManager.value('myKey', { k: 'myKey', v: () => 'dynamicValue' });
+      expect(result).toBe('dynamicValue');
+    });
+
+    it('returns the default value from a function when key does not match', () => {
+      const result = ConfigValueManager.value('otherKey', { k: 'myKey', v: 'myValue' }, () => 'dynamicDefault');
+      expect(result).toBe('dynamicDefault');
+    });
+
+    it('handles multiple configurations and returns the first matching value', () => {
+      const configs = [{ k: 'myKey1', v: 'value1' }, { k: 'myKey2', v: 'value2' }];
+      const result = ConfigValueManager.value('myKey2', configs);
+      expect(result).toBe('value2');
+    });
+
+    it('throws an error for duplicate keys in configurations', () => {
+      const configs = [{ k: 'myKey', v:'value1'}, { k: 'myKey', v: 'value2'}];
+      const execute = () => ConfigValueManager.value('myKey', configs);
+      expect(execute).toThrow(/Duplicate key found in configuration: myKey/);
+    });
+  });
+
+  describe('ConfigValueManager.is', () => {
+    it('returns true when the key matches', () => {
+      const result = ConfigValueManager.is('myKey', 'myKey');
+      expect(result).toBe(true);
+    });
+
+    it('returns false when the key does not match', () => {
+      const result = ConfigValueManager.is('otherKey', 'myKey');
+      expect(result).toBe(false);
+    });
+
+    it('returns false when using negation and the key matches', () => {
+      const result = ConfigValueManager.is('myKey', 'myKey', true);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('ConfigValueManager.only', () => {
+    it('returns the value for a matching key', () => {
+      const result = ConfigValueManager.only('myKey', 'myKey', 'returnValue');
+      expect(result).toBe('returnValue');
+    });
+
+    it('returns undefined for a non-matching key', () => {
+      const result = ConfigValueManager.only('otherKey', 'myKey', 'returnValue');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('ConfigValueManager.skip', () => {
+    it('returns undefined for a matching key', () => {
+      const result = ConfigValueManager.skip('myKey', 'myKey', 'returnValue');
+      expect(result).toBeUndefined();
+    });
+
+    it('returns the value for a non-matching key', () => {
+      const result = ConfigValueManager.skip('otherKey', 'myKey', 'returnValue');
+      expect(result).toBe('returnValue');
+    });
+  });
+
+});

package/src/__tests__/custom-validator.spec.ts

@@ -0,0 +1,34 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+import { stringIsInEnumValidatorFactory } from '../custom-validator.js';
+
+describe('stringIsInEnumValidatorFactory', () => {
+  enum TestEnum {
+    Value1 = 'Value1',
+    Value2 = 'Value2',
+  }
+
+  it('should validate if a string is in the enum', () => {
+    const validator = stringIsInEnumValidatorFactory(TestEnum);
+
+    const validString = 'Value1';
+    const invalidString = 'Invalid';
+
+    expect(validator.validate(validString)).toBe(true);
+    expect(validator.validate(invalidString)).toBe(false);
+  });
+
+  it('should call stringIsInEnum with the right arguments', () => {
+    const validator = stringIsInEnumValidatorFactory(TestEnum);
+
+    const validString = 'Value1';
+    expect(validator.validate(validString)).toBe(true);
+  });
+});

package/src/__tests__/data-structure.helper.spec.ts

@@ -0,0 +1,30 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+
+import { arrayGroupByField } from '../data-structure.helper.js';
+
+const testArray = [
+  {
+    key: 'xx',
+    data: 'firstData',
+  },
+  {
+    key: 'xx',
+    data: 'seconData',
+  },
+];
+describe('Test Data Structure Helpers', () => {
+  it('should groupby an array with a field', () => {
+    const groupedArray = arrayGroupByField(testArray, (item) => item.key);
+    expect(groupedArray['xx']).toEqual(
+      expect.arrayContaining([testArray[0], testArray[1]]),
+    );
+  });
+});

package/src/__tests__/date.helper.spec.ts

@@ -0,0 +1,78 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+} from '@jest/globals';
+
+import { DateHelper } from '../date.helper.js';
+
+describe('Date helper test suite', () => {
+  it('getDateQuery - returns proper query', () => {
+    jest
+      .spyOn(global.Date, 'now')
+      .mockImplementation(() => Date.parse('01-30-2022'));
+
+    const result = DateHelper.getWeekEdgeDates();
+
+    expect(result).toEqual({ endDate: '2022-01-30', startDate: '2022-01-23' });
+  });
+
+  it('getDateQuery - gets months with single number code', () => {
+    jest
+      .spyOn(global.Date, 'now')
+      .mockImplementation(() => Date.parse('09-09-2022'));
+
+    const result = DateHelper.getWeekEdgeDates();
+
+    expect(result).toEqual({ endDate: '2022-09-09', startDate: '2022-09-02' });
+  });
+
+  it('getDateQuery - gets month with double number code', () => {
+    jest
+      .spyOn(global.Date, 'now')
+      .mockImplementation(() => Date.parse('12-09-2022'));
+
+    const result = DateHelper.getWeekEdgeDates();
+
+    expect(result).toEqual({ endDate: '2022-12-09', startDate: '2022-12-02' });
+  });
+
+  it('getDateQuery - returns query with week overlapping on two months', () => {
+    jest
+      .spyOn(global.Date, 'now')
+      .mockImplementation(() => Date.parse('12-04-2022'));
+
+    const result = DateHelper.getWeekEdgeDates();
+
+    expect(result).toEqual({ endDate: '2022-12-04', startDate: '2022-11-27' });
+  });
+
+  it('should be able add minutes to a Date', () => {
+    const date = new Date('2021-10-13T13:13:00.000Z');
+    const result = DateHelper.addMinutes(date, 5);
+    expect(result).toBeInstanceOf(Date);
+    expect(result.toISOString()).toBe('2021-10-13T13:18:00.000Z');
+  });
+
+  it('should be able substract minutes from a Date', () => {
+    const date = new Date('2003-01-05T20:00:00.000Z');
+    const result = DateHelper.subsMinutes(date, 5);
+    expect(result).toBeInstanceOf(Date);
+    expect(result.toISOString()).toBe('2003-01-05T19:55:00.000Z');
+  });
+
+  it('should be able to convert to SQL format', () => {
+    const date = new Date('2003-01-05T20:00:00.000Z');
+    const result = DateHelper.dateToSQLDateTime(date);
+    expect(result).toBe('2003-01-05 20:00:00');
+  });
+  
+  it('dateToPlainISO - converts date to plain ISO format', () => {
+    const date = new Date('2003-01-05T20:00:00.000Z');
+    const result = DateHelper.dateToPlainISO(date);
+    expect(result).toBe('20030105T200000000Z');
+  });
+});

package/src/__tests__/encryption.helper.spec.ts

@@ -0,0 +1,45 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+
+import { encryptAes, decryptAes } from '../encryption.helper.js';
+import crypto from 'crypto';
+
+// Please let me know if you know how to solve this as unknown as void.
+jest
+  .spyOn(crypto, 'randomBytes')
+  .mockReturnValue(
+    Buffer.from('173606b5fe22770c890b48c41866abc3', 'hex') as unknown as void,
+  );
+
+describe('Utils encryption helper test', () => {
+  const key =
+    '60f810732e3c8d1eb5ba227143d46aabce1bb1ae0aa7081ef0b0c3bbaaed76a6';
+  const decrypted = 'should be able to encrypt a simple message with a key';
+  it('should be defined', () => {
+    expect(encryptAes).toBeDefined();
+  });
+
+  it('should be defined', () => {
+    expect(decryptAes).toBeDefined();
+  });
+
+  it('should be able to encrypt a simple message with a key', () => {
+    expect(encryptAes(decrypted, key)).toBeDefined();
+  });
+
+  it('should be able to decrypt a simple message with a key', () => {
+    const encrypted = encryptAes(decrypted, key);
+    expect(decryptAes(encrypted, key)).toEqual(decrypted);
+  });
+
+  it('should return an empty string if the input is empty as well', () => {
+    expect(decryptAes('', key)).toEqual('');
+  });
+});

package/src/__tests__/enum.helper.spec.ts

@@ -0,0 +1,53 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+
+import {
+  belongsToEnum,
+  mergeEnums,
+  getEnumValueByEnumKey,
+} from '../enum.helper.js';
+import { TestEnum1, TestEnum2 } from '../__mocks__/enum.mock.js';
+
+test('belongsToEnum should check if a value belongs to a specific Enum', () => {
+  enum TestEnum {
+    TEST = 'test',
+  }
+
+  let result = belongsToEnum(TestEnum, 'test');
+  expect(result).toBeTruthy();
+
+  result = belongsToEnum(TestEnum, 'TEST');
+  expect(result).toBeFalsy();
+});
+
+test('mergeEnums should merge 2 enums', () => {
+  const result = mergeEnums(TestEnum1, TestEnum2);
+  const compareWith = {
+    ...TestEnum1,
+    ...TestEnum2,
+  };
+
+  expect(result).toMatchObject(compareWith);
+});
+
+test('getEnumValueByEnumKey should return value of enum 1 by key of enum 2', () => {
+  const result = getEnumValueByEnumKey(TestEnum1, Object.keys(TestEnum2)[0]);
+  expect(result).toBe('test2');
+});
+
+test('getEnumValueByEnumKey should return value of enum 1 by key of enum 2', () => {
+  const result = getEnumValueByEnumKey(TestEnum1, Object.keys(TestEnum2)[1]);
+  expect(result).toBeUndefined();
+});
+
+test('getEnumValueByEnumKey should return null when no undefined key is provided ', () => {
+  const result = getEnumValueByEnumKey(TestEnum1, undefined);
+  expect(result).toBeUndefined();
+});

package/src/__tests__/env.helper.spec.ts

@@ -0,0 +1,68 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+
+import { envIsTrue, envToArray, isProduction } from '../env.helper.js';
+import { envTestHelper } from '@nest-yalc-2/jest';
+
+describe('environment helper test', () => {
+  it('should convert a comma separated list to an array', () => {
+    process.env.Test = 'apple,pear,pineapple,cherry';
+    const res = envToArray('Test');
+    expect(res).toEqual(['apple', 'pear', 'pineapple', 'cherry']);
+  });
+
+  it('should return an empty array when the var is an empty string', () => {
+    process.env.Test = '';
+    const res = envToArray('Test');
+    expect(res).toEqual([]);
+  });
+
+  it('should return an empty array when the var is missing', () => {
+    delete process.env.Test;
+    const res = envToArray('Test');
+    expect(res).toEqual([]);
+  });
+
+  it('should return false for "undefined"', () => {
+    expect(envIsTrue(undefined)).toEqual(false);
+  });
+
+  it('should return true for "true"', () => {
+    expect(envIsTrue('true')).toEqual(true);
+  });
+
+  it('should return true for "1"', () => {
+    expect(envIsTrue('1')).toEqual(true);
+  });
+
+  it('should return true for "on"', () => {
+    expect(envIsTrue('on')).toEqual(true);
+  });
+
+  it('should return true if is production"', () => {
+    const env = envTestHelper(process.env);
+    env.setEnv('NODE_ENV', 'production');
+    expect(isProduction(false)).toBeTruthy();
+
+    env.setEnv('NODE_ENV', 'somethingelse');
+    expect(isProduction(true)).toBeTruthy();
+    env.reset();
+  });
+
+  it('should return false if is not production"', () => {
+    const env = envTestHelper(process.env);
+    env.setEnv('NODE_ENV', 'pipeline');
+    expect(isProduction()).toBeFalsy();
+
+    env.setEnv('NODE_ENV', 'somethingelse');
+    expect(isProduction(false)).toBeFalsy();
+    env.reset();
+  });
+});

package/src/__tests__/error.helper.spec.ts

@@ -0,0 +1,20 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+import { throwWrap } from '../error.helper.js';
+
+describe('Test errors helpers', () => {
+  it('should throw an error without wraping it', () => {
+    const fixedErrorMessage = `i'm an error`;
+    const fixedError = new Error(fixedErrorMessage);
+
+    expect(() => throwWrap(fixedErrorMessage)).toThrow(fixedErrorMessage);
+    expect(() => throwWrap(fixedError)).toThrow(fixedErrorMessage);
+  });
+});