@nmxjs/types 1.0.21 → 1.1.0

package/__mocks__/@nmxjs/constants.ts

@@ -0,0 +1 @@
+export const paginationLimit = 25;

package/__mocks__/@nmxjs/validation.ts

@@ -0,0 +1,19 @@
+const fieldMetadata = new Map<string, Map<string, any>>();
+
+export const getFieldMetadata = (target: string, property: string) => {
+  return fieldMetadata.get(target)?.get(property);
+};
+
+export const getAllFieldMetadata = (target: string) => {
+  return fieldMetadata.get(target);
+};
+
+export const Field = (options: any): PropertyDecorator => {
+  return (target: any, propertyKey: string | symbol) => {
+    const className = target.constructor.name;
+    if (!fieldMetadata.has(className)) {
+      fieldMetadata.set(className, new Map());
+    }
+    fieldMetadata.get(className)!.set(String(propertyKey), options);
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nmxjs/types",
-  "version": "1.0.21",
+  "version": "1.1.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,6 +22,9 @@
   },
   "homepage": "https://github.com/n1ghtm6r9/nm-types#readme",
   "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.1.6"
   },
   "dependencies": {

package/tests/dto/EntityDto.spec.ts

@@ -0,0 +1,28 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { EntityDto } from '../../src/dto/EntityDto';
+
+describe('EntityDto', () => {
+  beforeAll(() => {
+    new (EntityDto as any)();
+  });
+
+  it('id should have type String', () => {
+    const meta = getAllFieldMetadata('EntityDto');
+    expect(meta?.get('id')).toEqual({ type: String });
+  });
+
+  it('createdAt should have type Number', () => {
+    const meta = getAllFieldMetadata('EntityDto');
+    expect(meta?.get('createdAt')).toEqual({ type: Number });
+  });
+
+  it('updatedAt should have type Number', () => {
+    const meta = getAllFieldMetadata('EntityDto');
+    expect(meta?.get('updatedAt')).toEqual({ type: Number });
+  });
+
+  it('should have exactly 3 fields', () => {
+    const meta = getAllFieldMetadata('EntityDto');
+    expect(meta?.size).toBe(3);
+  });
+});

package/tests/dto/GetOneRequestDto.spec.ts

@@ -0,0 +1,34 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { GetOneRequestDto } from '../../src/dto/GetOneRequestDto';
+
+describe('GetOneRequestDto', () => {
+  beforeAll(() => {
+    new (GetOneRequestDto as any)();
+  });
+
+  it('id should have type String', () => {
+    const meta = getAllFieldMetadata('GetOneRequestDto');
+    expect(meta?.get('id')).toEqual({
+      type: String,
+    });
+  });
+
+  it('select should be nullable array of String without GraphQL', () => {
+    const meta = getAllFieldMetadata('GetOneRequestDto');
+    expect(meta?.get('select')).toEqual({
+      type: String,
+      array: true,
+      nullable: true,
+      withoutGraphQl: true,
+    });
+  });
+
+  it('reject should be nullable Boolean without GraphQL', () => {
+    const meta = getAllFieldMetadata('GetOneRequestDto');
+    expect(meta?.get('reject')).toEqual({
+      type: Boolean,
+      nullable: true,
+      withoutGraphQl: true,
+    });
+  });
+});

package/tests/dto/GetOneResponseDto.spec.ts

@@ -0,0 +1,19 @@
+import { GetOneResponseDto } from '../../src/dto/GetOneResponseDto';
+
+describe('GetOneResponseDto', () => {
+  it('should be abstract class with field item', () => {
+    class TestResponse extends GetOneResponseDto<{ name: string }> {
+      item? = { name: 'test' };
+    }
+    const instance = new TestResponse();
+    expect(instance.item).toEqual({ name: 'test' });
+  });
+
+  it('item can be undefined', () => {
+    class TestResponse extends GetOneResponseDto<{ name: string }> {
+      item? = undefined;
+    }
+    const instance = new TestResponse();
+    expect(instance.item).toBeUndefined();
+  });
+});

package/tests/dto/ListRequestDto.spec.ts

@@ -0,0 +1,47 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { ListRequestDto } from '../../src/dto/ListRequestDto';
+import { ListRequestFilterDto } from '../../src/dto/ListRequestFilterDto';
+import { ListRequestSortDto } from '../../src/dto/ListRequestSortDto';
+import { ListRequestPaginationDto } from '../../src/dto/ListRequestPaginationDto';
+
+describe('ListRequestDto', () => {
+  beforeAll(() => {
+    new (ListRequestDto as any)();
+  });
+
+  it('filters should be nullable array of ListRequestFilterDto', () => {
+    const meta = getAllFieldMetadata('ListRequestDto');
+    expect(meta?.get('filters')).toEqual({
+      type: ListRequestFilterDto,
+      array: true,
+      nullable: true,
+    });
+  });
+
+  it('sorts should be nullable array of ListRequestSortDto', () => {
+    const meta = getAllFieldMetadata('ListRequestDto');
+    expect(meta?.get('sorts')).toEqual({
+      type: ListRequestSortDto,
+      array: true,
+      nullable: true,
+    });
+  });
+
+  it('pagination should be nullable ListRequestPaginationDto', () => {
+    const meta = getAllFieldMetadata('ListRequestDto');
+    expect(meta?.get('pagination')).toEqual({
+      type: ListRequestPaginationDto,
+      nullable: true,
+    });
+  });
+
+  it('select should be nullable array of String without GraphQL', () => {
+    const meta = getAllFieldMetadata('ListRequestDto');
+    expect(meta?.get('select')).toEqual({
+      type: String,
+      array: true,
+      nullable: true,
+      withoutGraphQl: true,
+    });
+  });
+});

package/tests/dto/ListRequestFilterDto.spec.ts

@@ -0,0 +1,101 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { FilterOperatorEnum } from '../../src/interfaces';
+import { ListRequestFilterDto } from '../../src/dto/ListRequestFilterDto';
+
+describe('ListRequestFilterDto', () => {
+  beforeAll(() => {
+    new (ListRequestFilterDto as any)();
+  });
+
+  it('field should have type String', () => {
+    const meta = getAllFieldMetadata('ListRequestFilterDto');
+    expect(meta?.get('field')).toEqual({ type: String });
+  });
+
+  it('value should have type JSON (not String)', () => {
+    const meta = getAllFieldMetadata('ListRequestFilterDto');
+    expect(meta?.get('value')).toEqual({ type: JSON });
+  });
+
+  it('value should NOT have type String', () => {
+    const meta = getAllFieldMetadata('ListRequestFilterDto');
+    expect(meta?.get('value')?.type).not.toBe(String);
+  });
+
+  it('operator should be enum FilterOperatorEnum', () => {
+    const meta = getAllFieldMetadata('ListRequestFilterDto');
+    expect(meta?.get('operator')).toEqual({
+      type: { FilterOperatorEnum },
+      enum: true,
+    });
+  });
+
+  it('not should be nullable Boolean', () => {
+    const meta = getAllFieldMetadata('ListRequestFilterDto');
+    expect(meta?.get('not')).toEqual({
+      type: Boolean,
+      nullable: true,
+    });
+  });
+
+  describe('value accepts different data types', () => {
+    it('string "test"', () => {
+      class TestFilter extends ListRequestFilterDto {
+        field = 'name';
+        value: any = 'test';
+        operator = FilterOperatorEnum.EQ;
+      }
+      const instance = new TestFilter();
+      expect(instance.value).toBe('test');
+      expect(typeof instance.value).toBe('string');
+    });
+
+    it('array ["a", "b"]', () => {
+      class TestFilter extends ListRequestFilterDto {
+        field = 'id';
+        value: any = ['a', 'b'];
+        operator = FilterOperatorEnum.IN;
+      }
+      const instance = new TestFilter();
+      expect(instance.value).toEqual(['a', 'b']);
+      expect(Array.isArray(instance.value)).toBe(true);
+    });
+
+    it('number 123', () => {
+      class TestFilter extends ListRequestFilterDto {
+        field = 'age';
+        value: any = 123;
+        operator = FilterOperatorEnum.EQ;
+      }
+      const instance = new TestFilter();
+      expect(instance.value).toBe(123);
+      expect(typeof instance.value).toBe('number');
+    });
+
+    it('object { key: "val" }', () => {
+      class TestFilter extends ListRequestFilterDto {
+        field = 'data';
+        value: any = { key: 'val' };
+        operator = FilterOperatorEnum.EQ;
+      }
+      const instance = new TestFilter();
+      expect(instance.value).toEqual({ key: 'val' });
+      expect(typeof instance.value).toBe('object');
+      expect(Array.isArray(instance.value)).toBe(false);
+    });
+
+    it('UUID array for IN operator', () => {
+      const uuids = ['550e8400-e29b-41d4-a716-446655440000', '6ba7b810-9dad-11d1-80b4-00c04fd430c8'];
+
+      class TestFilter extends ListRequestFilterDto {
+        field = 'id';
+        value: any = uuids;
+        operator = FilterOperatorEnum.IN;
+      }
+      const instance = new TestFilter();
+      expect(instance.value).toEqual(uuids);
+      expect(Array.isArray(instance.value)).toBe(true);
+      expect(instance.value).not.toBe(uuids.join(','));
+    });
+  });
+});

package/tests/dto/ListRequestPaginationDto.spec.ts

@@ -0,0 +1,35 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { paginationLimit } from '../../__mocks__/@nmxjs/constants';
+import { ListRequestPaginationDto } from '../../src/dto/ListRequestPaginationDto';
+
+describe('ListRequestPaginationDto', () => {
+  let instance: any;
+
+  beforeAll(() => {
+    instance = new (ListRequestPaginationDto as any)();
+  });
+
+  it('page should have type Number with default 1', () => {
+    const meta = getAllFieldMetadata('ListRequestPaginationDto');
+    expect(meta?.get('page')).toEqual({
+      type: Number,
+      default: 1,
+    });
+  });
+
+  it('limit should have type Number with default paginationLimit', () => {
+    const meta = getAllFieldMetadata('ListRequestPaginationDto');
+    expect(meta?.get('limit')).toEqual({
+      type: Number,
+      default: paginationLimit,
+    });
+  });
+
+  it('page defaults to 1', () => {
+    expect(instance.page).toBe(1);
+  });
+
+  it('limit defaults to paginationLimit', () => {
+    expect(instance.limit).toBe(paginationLimit);
+  });
+});

package/tests/dto/ListRequestSortDto.spec.ts

@@ -0,0 +1,22 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { SortOrderByEnum } from '../../src/interfaces';
+import { ListRequestSortDto } from '../../src/dto/ListRequestSortDto';
+
+describe('ListRequestSortDto', () => {
+  beforeAll(() => {
+    new (ListRequestSortDto as any)();
+  });
+
+  it('field should have type String', () => {
+    const meta = getAllFieldMetadata('ListRequestSortDto');
+    expect(meta?.get('field')).toEqual({ type: String });
+  });
+
+  it('type should be enum SortOrderByEnum', () => {
+    const meta = getAllFieldMetadata('ListRequestSortDto');
+    expect(meta?.get('type')).toEqual({
+      type: { SortOrderByEnum },
+      enum: true,
+    });
+  });
+});

package/tests/dto/ListResponseCursorDto.spec.ts

@@ -0,0 +1,26 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { ListResponseCursorDto } from '../../src/dto/ListResponseCursorDto';
+
+describe('ListResponseCursorDto', () => {
+  beforeAll(() => {
+    new (ListResponseCursorDto as any)();
+  });
+
+  it('totalCount should have type Number', () => {
+    const meta = getAllFieldMetadata('ListResponseCursorDto');
+    expect(meta?.get('totalCount')).toEqual({ type: Number });
+  });
+
+  it('totalPages should have type Number', () => {
+    const meta = getAllFieldMetadata('ListResponseCursorDto');
+    expect(meta?.get('totalPages')).toEqual({ type: Number });
+  });
+
+  it('nextPage should be nullable Number', () => {
+    const meta = getAllFieldMetadata('ListResponseCursorDto');
+    expect(meta?.get('nextPage')).toEqual({
+      type: Number,
+      nullable: true,
+    });
+  });
+});

package/tests/dto/ListResponseDto.spec.ts

@@ -0,0 +1,24 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { ListResponseDto } from '../../src/dto/ListResponseDto';
+import { ListResponseCursorDto } from '../../src/dto/ListResponseCursorDto';
+
+describe('ListResponseDto', () => {
+  beforeAll(() => {
+    new (ListResponseDto as any)();
+  });
+
+  it('cursor should have type ListResponseCursorDto', () => {
+    const meta = getAllFieldMetadata('ListResponseDto');
+    expect(meta?.get('cursor')).toEqual({
+      type: ListResponseCursorDto,
+    });
+  });
+
+  it('should support abstract field items', () => {
+    class TestListResponse extends ListResponseDto<{ id: string }> {
+      items = [{ id: '1' }];
+    }
+    const instance = new TestListResponse();
+    expect(instance.items).toEqual([{ id: '1' }]);
+  });
+});

package/tests/dto/ProxyDto.spec.ts

@@ -0,0 +1,43 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { ProxyTypeEnum } from '../../src/interfaces';
+import { ProxyDto } from '../../src/dto/ProxyDto';
+
+describe('ProxyDto', () => {
+  beforeAll(() => {
+    new ProxyDto();
+  });
+
+  it('ip should have type String', () => {
+    const meta = getAllFieldMetadata('ProxyDto');
+    expect(meta?.get('ip')).toEqual({ type: String });
+  });
+
+  it('port should have type Number', () => {
+    const meta = getAllFieldMetadata('ProxyDto');
+    expect(meta?.get('port')).toEqual({ type: Number });
+  });
+
+  it('type should be enum ProxyTypeEnum', () => {
+    const meta = getAllFieldMetadata('ProxyDto');
+    expect(meta?.get('type')).toEqual({
+      type: { ProxyTypeEnum },
+      enum: true,
+    });
+  });
+
+  it('username should be nullable String', () => {
+    const meta = getAllFieldMetadata('ProxyDto');
+    expect(meta?.get('username')).toEqual({
+      type: String,
+      nullable: true,
+    });
+  });
+
+  it('password should be nullable String', () => {
+    const meta = getAllFieldMetadata('ProxyDto');
+    expect(meta?.get('password')).toEqual({
+      type: String,
+      nullable: true,
+    });
+  });
+});

package/tests/dto/UpdateRequestDto.spec.ts

@@ -0,0 +1,21 @@
+import { getAllFieldMetadata } from '../../__mocks__/@nmxjs/validation';
+import { UpdateRequestDto } from '../../src/dto/UpdateRequestDto';
+
+describe('UpdateRequestDto', () => {
+  beforeAll(() => {
+    new (UpdateRequestDto as any)();
+  });
+
+  it('id should have type String', () => {
+    const meta = getAllFieldMetadata('UpdateRequestDto');
+    expect(meta?.get('id')).toEqual({ type: String });
+  });
+
+  it('should support abstract field payload', () => {
+    class TestUpdate extends UpdateRequestDto<{ name: string }> {
+      payload = { name: 'test' };
+    }
+    const instance = new TestUpdate();
+    expect(instance.payload).toEqual({ name: 'test' });
+  });
+});

package/tests/interfaces/EnvironmentEnum.spec.ts

@@ -0,0 +1,20 @@
+import { EnvironmentEnum } from '../../src/interfaces/EnvironmentEnum';
+
+describe('EnvironmentEnum', () => {
+  it('should contain DEVELOPMENT', () => {
+    expect(EnvironmentEnum.DEVELOPMENT).toBe('development');
+  });
+
+  it('should contain PRODUCTION', () => {
+    expect(EnvironmentEnum.PRODUCTION).toBe('production');
+  });
+
+  it('should contain TEST', () => {
+    expect(EnvironmentEnum.TEST).toBe('test');
+  });
+
+  it('should contain exactly 3 values', () => {
+    const values = Object.values(EnvironmentEnum);
+    expect(values).toHaveLength(3);
+  });
+});

package/tests/interfaces/FilterOperatorEnum.spec.ts

@@ -0,0 +1,36 @@
+import { FilterOperatorEnum } from '../../src/interfaces/FilterOperatorEnum';
+
+describe('FilterOperatorEnum', () => {
+  it('should contain EQ', () => {
+    expect(FilterOperatorEnum.EQ).toBe('EQ');
+  });
+
+  it('should contain IN', () => {
+    expect(FilterOperatorEnum.IN).toBe('IN');
+  });
+
+  it('should contain SEARCH', () => {
+    expect(FilterOperatorEnum.SEARCH).toBe('SEARCH');
+  });
+
+  it('should contain LESS', () => {
+    expect(FilterOperatorEnum.LESS).toBe('LESS');
+  });
+
+  it('should contain LESS_OR_EQ', () => {
+    expect(FilterOperatorEnum.LESS_OR_EQ).toBe('LESS_OR_EQ');
+  });
+
+  it('should contain MORE', () => {
+    expect(FilterOperatorEnum.MORE).toBe('MORE');
+  });
+
+  it('should contain MORE_OR_EQ', () => {
+    expect(FilterOperatorEnum.MORE_OR_EQ).toBe('MORE_OR_EQ');
+  });
+
+  it('should contain exactly 7 values', () => {
+    const values = Object.values(FilterOperatorEnum);
+    expect(values).toHaveLength(7);
+  });
+});

package/tests/interfaces/ProxyTypeEnum.spec.ts

@@ -0,0 +1,24 @@
+import { ProxyTypeEnum } from '../../src/interfaces/ProxyTypeEnum';
+
+describe('ProxyTypeEnum', () => {
+  it('should contain HTTP', () => {
+    expect(ProxyTypeEnum.HTTP).toBe('HTTP');
+  });
+
+  it('should contain HTTPS', () => {
+    expect(ProxyTypeEnum.HTTPS).toBe('HTTPS');
+  });
+
+  it('should contain SOCKS4', () => {
+    expect(ProxyTypeEnum.SOCKS4).toBe('SOCKS4');
+  });
+
+  it('should contain SOCKS5', () => {
+    expect(ProxyTypeEnum.SOCKS5).toBe('SOCKS5');
+  });
+
+  it('should contain exactly 4 values', () => {
+    const values = Object.values(ProxyTypeEnum);
+    expect(values).toHaveLength(4);
+  });
+});

package/tests/interfaces/SortOrderByEnum.spec.ts

@@ -0,0 +1,16 @@
+import { SortOrderByEnum } from '../../src/interfaces/SortOrderByEnum';
+
+describe('SortOrderByEnum', () => {
+  it('should contain ASC', () => {
+    expect(SortOrderByEnum.ASC).toBe('ASC');
+  });
+
+  it('should contain DESC', () => {
+    expect(SortOrderByEnum.DESC).toBe('DESC');
+  });
+
+  it('should contain exactly 2 values', () => {
+    const values = Object.values(SortOrderByEnum);
+    expect(values).toHaveLength(2);
+  });
+});

package/tests/interfaces/StartModeEnum.spec.ts

@@ -0,0 +1,20 @@
+import { StartModeEnum } from '../../src/interfaces/StartModeEnum';
+
+describe('StartModeEnum', () => {
+  it('should contain DEV', () => {
+    expect(StartModeEnum.DEV).toBe('DEV');
+  });
+
+  it('should contain NATIVE', () => {
+    expect(StartModeEnum.NATIVE).toBe('NATIVE');
+  });
+
+  it('should contain WATCH', () => {
+    expect(StartModeEnum.WATCH).toBe('WATCH');
+  });
+
+  it('should contain exactly 3 values', () => {
+    const values = Object.values(StartModeEnum);
+    expect(values).toHaveLength(3);
+  });
+});