Merge pull request #41 from AndreyWV/issue-40/type-validator

Issue 40 Added property type validator
AndreyWV · May 3, 2024 · 8d650bb · 8d650bb
2 parents 3022a7b + 4943ade
commit 8d650bb
Show file tree

Hide file tree

Showing 7 changed files with 248 additions and 4 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.2.0 (2024-05-03)
+
+- Feature: Issue 40 - Added property type validator
+
 ## 1.1.0 (2024-04-25)
 
 - Feature: Issue 38 - Serializable validation errors

diff --git a/README.md b/README.md
@@ -1,7 +1,8 @@
 # typescript-object-serializer
 Typescript library to convert javascript object to typescript class and vice versa
 
-[CHANGELOG](CHANGELOG.md)
+[CHANGELOG](CHANGELOG.md)<br>
+[Useful snippets](https://github.com/AndreyWV/typescript-object-serializer/wiki)
 
 ## Installation and configuration
 ```sh

diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "typescript-object-serializer",
-    "version": "1.1.0",
+    "version": "1.2.0",
     "description": "Powerful Scalable Typescript object serializer",
     "scripts": {
         "build": "TS_NODE_PROJECT=\"webpack.tsconfig.json\" webpack",
@@ -44,5 +44,13 @@
         "webpack-cli": "~5.1.4",
         "webpack-dev-server": "~4.15.1"
     },
+    "peerDependencies": {
+        "reflect-metadata": ">0.1.12 && <1.0.0"
+    },
+    "peerDependenciesMeta": {
+        "reflect-metadata": {
+            "optional": true
+        }
+    },
     "source": "src/index.ts"
 }
diff --git a/src/validators/index.ts b/src/validators/index.ts
@@ -6,3 +6,4 @@ export * from './validators/number-value';
 export * from './validators/regexp';
 export * from './validators/required';
 export * from './validators/string-length';
+export * from './validators/type';
diff --git a/src/validators/validators/type.ts b/src/validators/validators/type.ts
@@ -0,0 +1,88 @@
+import { Constructor } from '../../base-types/constructor';
+import { ValidationError } from '../types/validation-error';
+import { Validator } from '../types/validator';
+
+/**
+ * @class TypeValidator Validates that the value is of the specified type.
+ * @example
+ * class SomeClass extends SerializableObject {
+ *
+ *   @property()
+ *   @propertyValidators([TypeValidator.Number()])
+ *   public numberProperty: number;
+ *
+ *   @property()
+ *   @propertyValidators([TypeValidator.String()])
+ *   public stringProperty: string;
+ *
+ *   @property()
+ *   @propertyValidators([TypeValidator.Boolean()])
+ *   public booleanProperty: boolean;
+ *
+ *   @property()
+ *   @propertyValidators([TypeValidator.Object()])
+ *   public someObjectProperty: any;
+ *
+ * }
+ *
+ * This Validator doesn't return validation error if value is empty or null.
+ */
+export abstract class TypeValidator extends Validator {
+
+  protected isEmpty(value: unknown): boolean {
+    return value === undefined || value === null;
+  }
+
+  public static String(): Constructor<Validator> {
+    return class extends TypeValidator {
+      public validate(value: any, path: string): ValidationError | undefined {
+        if (this.isEmpty(value)) {
+          return;
+        }
+        if (typeof value !== 'string') {
+          return new ValidationError('Value must be of type String', path);
+        }
+      }
+    }
+  }
+
+  public static Number(): Constructor<Validator> {
+    return class extends TypeValidator {
+      public validate(value: any, path: string): ValidationError | undefined {
+        if (this.isEmpty(value)) {
+          return;
+        }
+        if (typeof value !== 'number') {
+          return new ValidationError('Value must be of type Number', path);
+        }
+      }
+    }
+  }
+
+  public static Boolean(): Constructor<Validator> {
+    return class extends TypeValidator {
+      public validate(value: any, path: string): ValidationError | undefined {
+        if (this.isEmpty(value)) {
+          return;
+        }
+        if (typeof value !== 'boolean') {
+          return new ValidationError('Value must be of type Boolean', path);
+        }
+      }
+    }
+  }
+
+  public static Object(): Constructor<Validator> {
+    return class extends TypeValidator {
+      public validate(value: any, path: string): ValidationError | undefined {
+        if (this.isEmpty(value)) {
+          return;
+        }
+        if (typeof value !== 'object') {
+          return new ValidationError('Value must be of type Object', path);
+        }
+      }
+    }
+  }
+
+}
diff --git a/tests/validators/validators.spec.ts b/tests/validators/validators.spec.ts
@@ -2,6 +2,7 @@ import { NumberValueValidator } from '../../src/validators/validators/number-val
 import { StringRegexpValidator } from '../../src/validators/validators/regexp';
 import { RequiredValidator } from '../../src/validators/validators/required';
 import { StringLengthValidator } from '../../src/validators/validators/string-length';
+import { TypeValidator } from '../../src/validators/validators/type';
 
 describe('RequiredValidator', () => {
 
@@ -114,3 +115,136 @@ describe('NumberValueValidator', () => {
   });
 
 });
+
+describe('TypeValidator', () => {
+
+  describe('String type', () => {
+
+    it('should return validation error if value is not string', () => {
+      const result = (new (TypeValidator.String())).validate(123, 'test');
+      expect(result).toEqual({
+        message: 'Value must be of type String',
+        path: 'test',
+      });
+    });
+
+    it('should not return validation error if value is string', () => {
+      const result = (new (TypeValidator.String())).validate('string value', 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is null', () => {
+      const result = (new (TypeValidator.String())).validate(null, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is undefined', () => {
+      const result = (new (TypeValidator.String())).validate(undefined, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is empty string', () => {
+      const result = (new (TypeValidator.String())).validate('', 'test');
+      expect(result).toBeUndefined();
+    });
+
+  });
+
+  describe('Number type', () => {
+
+    it('should return validation error if value is not number', () => {
+      const result = (new (TypeValidator.Number())).validate('123', 'test');
+      expect(result).toEqual({
+        message: 'Value must be of type Number',
+        path: 'test',
+      });
+    });
+
+    it('should not return validation error if value is number', () => {
+      const result = (new (TypeValidator.Number())).validate(123, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is null', () => {
+      const result = (new (TypeValidator.Number())).validate(null, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is undefined', () => {
+      const result = (new (TypeValidator.Number())).validate(undefined, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is 0', () => {
+      const result = (new (TypeValidator.Number())).validate(0, 'test');
+      expect(result).toBeUndefined();
+    });
+
+  });
+
+  describe('Boolean type', () => {
+
+    it('should return validation error if value is not boolean', () => {
+      const result = (new (TypeValidator.Boolean())).validate('123', 'test');
+      expect(result).toEqual({
+        message: 'Value must be of type Boolean',
+        path: 'test',
+      });
+    });
+
+    it('should not return validation error if value is boolean', () => {
+      const result = (new (TypeValidator.Boolean())).validate(true, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is null', () => {
+      const result = (new (TypeValidator.Boolean())).validate(null, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is undefined', () => {
+      const result = (new (TypeValidator.Boolean())).validate(undefined, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is false', () => {
+      const result = (new (TypeValidator.Boolean())).validate(false, 'test');
+      expect(result).toBeUndefined();
+    });
+
+  });
+
+  describe('Object type', () => {
+
+    it('should return validation error if value is not object', () => {
+      const result = (new (TypeValidator.Object())).validate('123', 'test');
+      expect(result).toEqual({
+        message: 'Value must be of type Object',
+        path: 'test',
+      });
+    });
+
+    it('should not return validation error if value is object', () => {
+      const result = (new (TypeValidator.Object())).validate({ test: true }, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is null', () => {
+      const result = (new (TypeValidator.Object())).validate(null, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is undefined', () => {
+      const result = (new (TypeValidator.Object())).validate(undefined, 'test');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not return validation error if value is empty object', () => {
+      const result = (new (TypeValidator.Object())).validate({}, 'test');
+      expect(result).toBeUndefined();
+    });
+
+  });
+
+
+});