feat: add IsStrongPassword decorator (#1025)

Author: jhonatanhulse

README.md

@@ -899,6 +899,7 @@ isBoolean(value);
 | `@IsISSN(options?: IsISSNOptions)`              | Checks if the string is a ISSN. |
 | `@IsISRC()`                                     | Checks if the string is a [ISRC](https://en.wikipedia.org/wiki/International_Standard_Recording_Code). |
 | `@IsRFC3339()`                                  | Checks if the string is a valid [RFC 3339](https://tools.ietf.org/html/rfc3339) date. |
+| `@IsStrongPassword(options?: IsStrongPasswordOptions)` | Checks if the string is a strong password. |
 | **Array validation decorators**                 | |
 | `@ArrayContains(values: any[])`                 | Checks if array contains all values from the given array of values. |
 | `@ArrayNotContains(values: any[])`              | Checks if array does not contain any of the given values. |

src/decorator/decorators.ts

@@ -111,6 +111,7 @@ export * from './string/IsPostalCode';
 export * from './string/IsRFC3339';
 export * from './string/IsRgbColor';
 export * from './string/IsSemVer';
+export * from './string/IsStrongPassword';
 export * from './string/IsTimeZone';
 
 // -------------------------------------------------------------------------

src/decorator/string/IsStrongPassword.ts

@@ -0,0 +1,42 @@
+import validator from 'validator';
+import { ValidationOptions } from '../ValidationOptions';
+import { buildMessage, ValidateBy } from '../common/ValidateBy';
+
+export const IS_STRONG_PASSWORD = 'isStrongPassword';
+
+/**
+ * Options to be passed to IsStrongPassword decorator.
+ */
+export type IsStrongPasswordOptions = Pick<
+  validator.StrongPasswordOptions,
+  'minLength' | 'minLowercase' | 'minUppercase' | 'minNumbers' | 'minSymbols'
+>;
+
+/**
+ * Checks if the string is a strong password.
+ * If given value is not a string, then it returns false.
+ */
+export function isStrongPassword(value: unknown, options?: IsStrongPasswordOptions): boolean {
+  return typeof value === 'string' && validator.isStrongPassword(value, options);
+}
+
+/**
+ * Checks if the string is a strong password.
+ * If given value is not a string, then it returns false.
+ */
+export function IsStrongPassword(
+  options?: IsStrongPasswordOptions,
+  validationOptions?: ValidationOptions
+): PropertyDecorator {
+  return ValidateBy(
+    {
+      name: IS_STRONG_PASSWORD,
+      constraints: [options],
+      validator: {
+        validate: (value, args): boolean => isStrongPassword(value, args.constraints[0]),
+        defaultMessage: buildMessage(eachPrefix => eachPrefix + '$property is not strong enough', validationOptions),
+      },
+    },
+    validationOptions
+  );
+}

test/functional/validation-functions-and-decorators.spec.ts

@@ -184,6 +184,9 @@ import {
   isPostalCode,
   IsSemVer,
   isSemVer,
+  IsStrongPassword,
+  isStrongPassword,
+  IsStrongPasswordOptions,
   IsTimeZone,
 } from '../../src/decorator/decorators';
 import { Validator } from '../../src/validation/Validator';
@@ -4577,3 +4580,83 @@ describe('isInstance', () => {
     return checkReturnedError(new MyClass(), invalidValues, validationType, message);
   });
 });
+
+describe('IsStrongPassword', () => {
+  class MyClass {
+    @IsStrongPassword()
+    someProperty: string;
+  }
+
+  const validValues = ['Abcdef1!'];
+  const invalidValues = [null, undefined, 'Abcde1!', 'abcdef1!', 'ABCDEF1!', 'Abcdefg!', 'Abcdefg1'];
+
+  it('should not fail if validator.validate said that its valid', () => {
+    return checkValidValues(new MyClass(), validValues);
+  });
+
+  it('should fail if validator.validate said that its invalid', () => {
+    return checkInvalidValues(new MyClass(), invalidValues);
+  });
+
+  it('should not fail if method in validator said that its valid', () => {
+    validValues.forEach(value => expect(isStrongPassword(value)).toBeTruthy());
+  });
+
+  it('should fail if method in validator said that its invalid', () => {
+    invalidValues.forEach(value => expect(isStrongPassword(value)).toBeFalsy());
+  });
+
+  it('should return error object with proper data', () => {
+    const validationType = 'isStrongPassword';
+    const message = 'someProperty is not strong enough';
+    return checkReturnedError(new MyClass(), invalidValues, validationType, message);
+  });
+});
+
+describe('IsStrongPassword with options', () => {
+  const options: IsStrongPasswordOptions = {
+    minLength: 12,
+    minLowercase: 2,
+    minUppercase: 2,
+    minNumbers: 2,
+    minSymbols: 2,
+  };
+
+  class MyClass {
+    @IsStrongPassword(options)
+    someProperty: string;
+  }
+
+  const validValues = ['ABcdefgh12!#'];
+  const invalidValues = [
+    null,
+    undefined,
+    'ABcdefg12!#',
+    'Abcdefgh12!#',
+    'ABcDEFGH12!#',
+    'ABcdefghi1!#',
+    'ABcdefghi12!',
+  ];
+
+  it('should not fail if validator.validate said that its valid', () => {
+    return checkValidValues(new MyClass(), validValues);
+  });
+
+  it('should fail if validator.validate said that its invalid', () => {
+    return checkInvalidValues(new MyClass(), invalidValues);
+  });
+
+  it('should not fail if method in validator said that its valid', () => {
+    validValues.forEach(value => expect(isStrongPassword(value, options)).toBeTruthy());
+  });
+
+  it('should fail if method in validator said that its invalid', () => {
+    invalidValues.forEach(value => expect(isStrongPassword(value, options)).toBeFalsy());
+  });
+
+  it('should return error object with proper data', () => {
+    const validationType = 'isStrongPassword';
+    const message = 'someProperty is not strong enough';
+    return checkReturnedError(new MyClass(), invalidValues, validationType, message);
+  });
+});