@nest-yalc-2/field-middleware 1.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@nest-yalc-2/field-middleware",
+  "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/__tests__/class-transformer.helper.spec.ts

@@ -0,0 +1,337 @@
+import { describe, it, expect } from '@jest/globals';
+import {
+  ParseArray,
+  parseArray,
+  ParseBoolean,
+  ParseInt,
+  ParseNumber,
+  parseBoolean,
+  parseInt,
+  parseNumber,
+} from '../class-transformer.helper.js'; // change this to your actual file name
+import { plainToClass } from 'class-transformer';
+
+describe('ParseArray', () => {
+  it('should transform a comma separated string to an array', () => {
+    class TestClass {
+      @ParseArray()
+      field: string[];
+    }
+
+    const payload = {
+      field: 'a,b,c',
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should transform a semi colon separated string to an array', () => {
+    class TestClass {
+      @ParseArray({ separator: ';' })
+      field: string[];
+    }
+
+    const payload = {
+      field: 'a;b;c',
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should ignore empty string', () => {
+    class TestClass {
+      @ParseArray()
+      field: string[];
+    }
+
+    const payload = {
+      field: 'a,b,,c',
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(['a', 'b', 'c']);
+  });
+});
+
+describe('parseArray', () => {
+  it('should split a string into array by a comma', () => {
+    const result = parseArray('a,b,c');
+    expect(result).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should split a string into array by a semi colon', () => {
+    const result = parseArray('a;b;c', ';');
+    expect(result).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should ignore empty string', () => {
+    const result = parseArray('a,b,,c');
+    expect(result).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should return empty array for empty string', () => {
+    const result = parseArray('');
+    expect(result).toEqual([]);
+  });
+
+  it('should return empty array for undefined', () => {
+    const result = parseArray(undefined);
+    expect(result).toEqual([]);
+  });
+
+  it('should return empty array for null', () => {
+    const result = parseArray(null);
+    expect(result).toEqual([]);
+  });
+
+  it('should return empty array for number', () => {
+    const result = parseArray(123);
+    expect(result).toEqual([123]);
+  });
+
+  it('should return array for array', () => {
+    const result = parseArray(['a', 'b', 'c']);
+    expect(result).toEqual(['a', 'b', 'c']);
+  });
+});
+
+describe('ParseBoolean', () => {
+  it('should transform a string to boolean', () => {
+    class TestClass {
+      @ParseBoolean()
+      field: boolean;
+    }
+
+    const payload = {
+      field: 'true',
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(true);
+  });
+
+  it('should transform a boolean to boolean', () => {
+    class TestClass {
+      @ParseBoolean()
+      field: boolean;
+    }
+
+    const payload = {
+      field: true,
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(true);
+  });
+
+  it('should transform a string to boolean', () => {
+    class TestClass {
+      @ParseBoolean()
+      field: boolean;
+    }
+
+    const payload = {
+      field: 'false',
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(false);
+  });
+
+  it('should transform a boolean to boolean', () => {
+    class TestClass {
+      @ParseBoolean()
+      field: boolean;
+    }
+
+    const payload = {
+      field: false,
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(false);
+  });
+});
+
+describe('parseBoolean', () => {
+  it('should transform a string to boolean', () => {
+    const result = parseBoolean('true');
+    expect(result).toEqual(true);
+  });
+
+  it('should transform a boolean to boolean', () => {
+    const result = parseBoolean(true);
+    expect(result).toEqual(true);
+  });
+
+  it('should transform a string to boolean', () => {
+    const result = parseBoolean('false');
+    expect(result).toEqual(false);
+  });
+
+  it('should transform a boolean to boolean', () => {
+    const result = parseBoolean(false);
+    expect(result).toEqual(false);
+  });
+
+  it('should return false for undefined', () => {
+    const result = parseBoolean(undefined);
+    expect(result).toEqual(false);
+  });
+
+  it('should return false for null', () => {
+    const result = parseBoolean(null);
+    expect(result).toEqual(false);
+  });
+
+  it('should return false for number', () => {
+    const result = parseBoolean(123);
+    expect(result).toEqual(false);
+  });
+
+  it('should return false for empty string', () => {
+    const result = parseBoolean('');
+    expect(result).toEqual(false);
+  });
+});
+
+describe('ParseNumber', () => {
+  it('should transform a string to number', () => {
+    class TestClass {
+      @ParseNumber()
+      field: number;
+    }
+
+    const payload = {
+      field: '123',
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(123);
+  });
+
+  it('should transform a number to number', () => {
+    class TestClass {
+      @ParseNumber()
+      field: number;
+    }
+
+    const payload = {
+      field: 123,
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(123);
+  });
+});
+
+describe('parseNumber', () => {
+  it('should transform a string to number', () => {
+    const result = parseNumber('123');
+    expect(result).toEqual(123);
+  });
+
+  it('should transform a number to number', () => {
+    const result = parseNumber(123);
+    expect(result).toEqual(123);
+  });
+
+  it('should transform a float to float', () => {
+    const result = parseNumber(123.123);
+    expect(result).toEqual(123.123);
+  });
+
+  it('should transform a string to float', () => {
+    const result = parseNumber('123.123');
+    expect(result).toEqual(123.123);
+  });
+
+  it('should return NaN for undefined', () => {
+    const result = parseNumber(undefined);
+    expect(result).toEqual(NaN);
+  });
+
+  it('should return NaN for null', () => {
+    const result = parseNumber(null);
+    expect(result).toEqual(NaN);
+  });
+
+  it('should return NaN for boolean', () => {
+    const result = parseNumber(true);
+    expect(result).toEqual(NaN);
+  });
+
+  it('should return NaN for empty string', () => {
+    const result = parseNumber('');
+    expect(result).toEqual(NaN);
+  });
+});
+
+describe('ParseInt', () => {
+  it('should transform a string to number', () => {
+    class TestClass {
+      @ParseInt()
+      field: number;
+    }
+
+    const payload = {
+      field: '123',
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(123);
+  });
+
+  it('should transform a number to number', () => {
+    class TestClass {
+      @ParseInt()
+      field: number;
+    }
+
+    const payload = {
+      field: 123,
+    };
+
+    const transformed = plainToClass(TestClass, payload);
+    expect(transformed.field).toEqual(123);
+  });
+});
+
+describe('parseInt', () => {
+  it('should transform a string to number', () => {
+    const result = parseInt('123');
+    expect(result).toEqual(123);
+  });
+
+  it('should transform a number to number', () => {
+    const result = parseInt(123);
+    expect(result).toEqual(123);
+  });
+
+  it('should return NaN for undefined', () => {
+    const result = parseInt(undefined);
+    expect(result).toEqual(NaN);
+  });
+
+  it('should return NaN for null', () => {
+    const result = parseInt(null);
+    expect(result).toEqual(NaN);
+  });
+
+  it('should return NaN for boolean', () => {
+    const result = parseInt(true);
+    expect(result).toEqual(NaN);
+  });
+
+  it('should return NaN for empty string', () => {
+    const result = parseInt('');
+    expect(result).toEqual(NaN);
+  });
+
+  it('should return NaN for float', () => {
+    const result = parseInt('123.123');
+    expect(result).toEqual(NaN);
+  });
+});

package/src/__tests__/decimal-middleware.helper.spec.ts

@@ -0,0 +1,35 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+
+import { createMock } from '@golevelup/ts-jest';
+import { MiddlewareContext } from '@nestjs/graphql';
+import { decimalMiddleware } from '../decimal-middleware.helper.js';
+
+describe('Decimal middleware helper test', () => {
+  // it('should return the value as float', async () => {
+  //   const ctx = createMock<MiddlewareContext>();
+  //   const next = jest.fn().mockResolvedValue('500.2');
+  //   const float = await decimalMiddleware(ctx, next);
+
+  //   expect(float).not.toEqual(expect.any(String));
+  //   expect(float).toEqual(expect.any(Number));
+  //   expect(float).toEqual(500.2);
+  // });
+
+  it('should return the value a', async () => {
+    const ctx = createMock<MiddlewareContext>();
+    const next = jest.fn().mockResolvedValue('500.2');
+    const float = await decimalMiddleware(ctx, next);
+
+    expect(float).toEqual(expect.any(String));
+    expect(float).toEqual('500.2');
+  });
+});

package/src/__tests__/field-error.enum.spec.ts

@@ -0,0 +1,7 @@
+import { FieldErrorsEnum } from '../field-error.enum';
+
+describe('Shared enum test', () => {
+  it('Gender enum definition', async () => {
+    expect(FieldErrorsEnum).toBeDefined();
+  });
+});

package/src/__tests__/fields-error.enum.spec.ts

@@ -0,0 +1,17 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { FieldErrorsEnum } from '../fields-error.enum.js';
+
+describe('Shared enum test', () => {
+  it('Gender enum definition', async () => {
+    expect(FieldErrorsEnum).toBeDefined();
+  });
+});

package/src/__tests__/nullable-timestamp-middleware.helper.spec.ts

@@ -0,0 +1,36 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+
+import { createMock } from '@golevelup/ts-jest';
+import { MiddlewareContext } from '@nestjs/graphql';
+import { nullableTimestampMiddleware } from '../nullable-timestamp-middleware.helper.js';
+
+describe('Date middleware helper test', () => {
+  it('should return the value as null', async () => {
+    const ctx = createMock<MiddlewareContext>();
+    let next = jest.fn().mockResolvedValue('0000-00-00 00:00:00');
+    const date = await nullableTimestampMiddleware(ctx, next);
+    expect(date).toEqual(null);
+
+    next = jest.fn().mockResolvedValue('');
+    const date2 = await nullableTimestampMiddleware(ctx, next);
+    expect(date2).toEqual(null);
+  });
+
+  it('should return the date correctly', async () => {
+    const testingDate = '2021-06-21 11:43:54';
+    const ctx = createMock<MiddlewareContext>();
+    const next = jest.fn().mockResolvedValue(testingDate);
+    const date = await nullableTimestampMiddleware(ctx, next);
+
+    expect(date).toEqual(testingDate);
+  });
+});

package/src/__tests__/string-format.enum.spec.ts

@@ -0,0 +1,17 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { StringFormatEnum } from '../string-format.enum.js';
+
+describe('Shared enum test', () => {
+  it('Gender enum definition', async () => {
+    expect(StringFormatEnum).toBeDefined();
+  });
+});

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

@@ -0,0 +1,38 @@
+import { defaultDateTransformer, enumTransformer } from '../transformer.helper';
+
+enum TestEnum {
+  TEST = 'test',
+}
+
+const testString = 'test';
+
+describe('Transformer helper', () => {
+  it('should not transform enum value to null if it belongs to a specific enumObj', () => {
+    const transformer = enumTransformer(TestEnum);
+
+    expect(transformer.to).toBeDefined();
+    expect(transformer.from).toBeDefined();
+
+    expect(transformer.to(testString)).toBe(testString);
+    expect(transformer.from(testString)).toBe(testString);
+  });
+
+  it('should transform enum value to null if it not belongs to a specific enumObj', () => {
+    const transformer = enumTransformer(TestEnum);
+
+    expect(transformer.to).toBeDefined();
+    expect(transformer.from).toBeDefined();
+
+    expect(transformer.from('')).toBeNull();
+  });
+
+  it('defaultDateTransformer work', () => {
+    const transformer = defaultDateTransformer();
+
+    expect(transformer.from(new Date())).toBeDefined();
+    expect(transformer.to(undefined)).toBeDefined();
+
+    const fixedDate = new Date('01 01 01');
+    expect(transformer.to(fixedDate)).toEqual(fixedDate);
+  });
+});

package/src/__tests__/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../tsconfig.test.json"
+}

package/src/__tests__/typeorm-transformer.helper.spec.ts

@@ -0,0 +1,51 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import {
+  defaultDateTransformer,
+  enumTransformer,
+} from '../typeorm-transformer.helper.js';
+
+enum TestEnum {
+  TEST = 'test',
+}
+
+const testString = 'test';
+
+describe('Transformer helper', () => {
+  it('should not transform enum value to null if it belongs to a specific enumObj', () => {
+    const transformer = enumTransformer(TestEnum);
+
+    expect(transformer.to).toBeDefined();
+    expect(transformer.from).toBeDefined();
+
+    expect(transformer.to(testString)).toBe(testString);
+    expect(transformer.from(testString)).toBe(testString);
+  });
+
+  it('should transform enum value to null if it not belongs to a specific enumObj', () => {
+    const transformer = enumTransformer(TestEnum);
+
+    expect(transformer.to).toBeDefined();
+    expect(transformer.from).toBeDefined();
+
+    expect(transformer.from('')).toBeNull();
+  });
+
+  it('defaultDateTransformer work', () => {
+    const transformer = defaultDateTransformer();
+
+    expect(transformer.from(new Date())).toBeDefined();
+    expect(transformer.to(undefined)).toBeDefined();
+
+    const fixedDate = new Date('01 01 01');
+    expect(transformer.to(fixedDate)).toEqual(fixedDate);
+  });
+});

package/src/__tests__/validator.decorator.spec.ts

@@ -0,0 +1,57 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+
+import * as Validator from '../validator.decorator.js';
+
+import { StringFormatEnum } from '../string-format.enum.js';
+
+describe('validator decorator test', () => {
+  it('StringFormatMatchValidation is defined', async () => {
+    let testData = Validator.StringFormatMatchValidation();
+    expect(testData('', '')).not.toBeDefined(); //This is only for the coverage
+
+    testData = Validator.StringFormatMatchValidation({});
+    expect(testData).toBeDefined();
+  });
+
+  it('DateValidation is defined', async () => {
+    let testData = Validator.DateValidation();
+    expect(testData('', '')).not.toBeDefined(); //This is only for the coverage
+
+    testData = Validator.DateValidation({});
+    expect(testData).toBeDefined();
+  });
+
+  it('stringFormatMatchValidatorFactory return the correct result', async () => {
+    const testDataFunctionMatch = Validator.stringFormatMatchValidatorFactory({
+      toMatch: true,
+      pattern: '^valid$',
+    });
+    const testDataFunctionDontMatch =
+      Validator.stringFormatMatchValidatorFactory({
+        toMatch: false,
+        pattern: '^valid$',
+      });
+
+    expect(testDataFunctionMatch.validate('valid')).toEqual(true);
+    expect(testDataFunctionDontMatch.validate('valid')).toEqual(false);
+
+    expect(testDataFunctionMatch.validate('invalid')).toEqual(false);
+    expect(testDataFunctionDontMatch.validate('invalid')).toEqual(true);
+  });
+
+  it("dateValidatorFactory return validateDate's result", async () => {
+    const testDataFunction = Validator.dateValidatorFactory();
+
+    expect(testDataFunction.validate('2023-01-01')).toEqual(true);
+    expect(testDataFunction.validate('not-a-date')).toEqual(false);
+  });
+});