feat(validation): Remove deprecated async magic ✨

You now must explicitely use the asyncValidators or validators as they should be used

BREAKING CHANGE: If you were not heeding the deprecation warning before, you're going to need to
move any async validation you have going on to the  object

Author: Kent C. Dodds

other/ERRORS_AND_WARNINGS.md

@@ -127,13 +127,6 @@ of the expression, the scope you're passed wont have all the properties you may
 See documentation [here](http://docs.angular-formly.com/docs/field-configuration-object#hideexpression-string--function)
 and an example [here](http://angular-formly.com/#/example/field-options/hide-fields)
 
-# Validators returning promises should use asyncValidators
-
-Due to some issues with treating all function validators as async validators, the functionality has been split into
-simply `validators` and `asyncValidators`. The ability to return a promise from a validator has been deprecated and you
-should use `asyncValidators` for those now. For more info, see
-[#369](https://github.com/formly-js/angular-formly/issues/369).
-
 # apiCheck as an object deprecated
 
 As a performance optimization, the `apiCheck` property has been changed to a function. This is good because when

src/directives/formly-custom-validation.js

@@ -2,13 +2,12 @@ import angular from 'angular-fix';
 export default formlyCustomValidation;
 
 // @ngInject
-function formlyCustomValidation(formlyConfig, formlyUtil, $q, formlyWarn) {
+function formlyCustomValidation(formlyUtil) {
   return {
     restrict: 'A',
     require: 'ngModel',
     link: function formlyCustomValidationLink(scope, el, attrs, ctrl) {
       const opts = scope.options;
-      const warnedValidators = [];
       opts.validation.messages = opts.validation.messages || {};
       angular.forEach(opts.validation.messages, (message, key) => {
         opts.validation.messages[key] = () => {
@@ -41,45 +40,18 @@ function formlyCustomValidation(formlyConfig, formlyUtil, $q, formlyWarn) {
       }
 
       function setupWithValidators(validator, name, isAsync) {
-        const isPossiblyAsync = !angular.isString(validator);
-        let validatorCollection = (isPossiblyAsync || isAsync) ? '$asyncValidators' : '$validators';
-
-        // UPDATE IN 7.0.0
-        // this is temporary until we can have a breaking change. Allow people to get the wins of the explicitAsync api
-        if (formlyConfig.extras.explicitAsync && !isAsync) {
-          validatorCollection = '$validators';
-        }
+        const validatorCollection = isAsync ? '$asyncValidators' : '$validators';
 
         ctrl[validatorCollection][name] = function evalValidity(modelValue, viewValue) {
-          const value = formlyUtil.formlyEval(scope, validator, modelValue, viewValue);
-          // UPDATE IN 7.0.0
-          // In the next breaking change, this code should simply return the value
-          if (isAsync) {
-            return value;
-          } else if (isPossiblyAsync && !formlyConfig.extras.explicitAsync) {
-            if (isPromiseLike(value)) {
-              logAsyncValidatorsDeprecationNotice(validator, opts);
-              return value;
-            } else {
-              return value ? $q.when(value) : $q.reject(value);
-            }
-          } else {
-            return value;
-          }
+          return formlyUtil.formlyEval(scope, validator, modelValue, viewValue);
         };
       }
 
       function setupWithParsers(validator, name, isAsync) {
         let inFlightValidator;
         ctrl.$parsers.unshift(function evalValidityOfParser(viewValue) {
           const isValid = formlyUtil.formlyEval(scope, validator, ctrl.$modelValue, viewValue);
-          // UPDATE IN 7.0.0
-          // In the next breaking change, rather than checking for isPromiseLike, it should just check for isAsync.
-
-          if (isAsync || isPromiseLike(isValid)) {
-            if (!isAsync) {
-              logAsyncValidatorsDeprecationNotice(validator, opts);
-            }
+          if (isAsync) {
             ctrl.$pending = ctrl.$pending || {};
             ctrl.$pending[name] = true;
             inFlightValidator = isValid;
@@ -105,24 +77,6 @@ function formlyCustomValidation(formlyConfig, formlyUtil, $q, formlyWarn) {
           return viewValue;
         });
       }
-
-      function logAsyncValidatorsDeprecationNotice(validator, options) {
-        if (warnedValidators.indexOf(validator) !== -1) {
-          // we've warned about this one before. No spam necessary...
-          return;
-        }
-        warnedValidators.push(validator);
-        formlyWarn(
-          'validators-returning-promises-should-use-asyncvalidators',
-          'Validators returning promises should use asyncValidators instead of validators.',
-          options
-        );
-      }
     }
   };
-
-
-  function isPromiseLike(obj) {
-    return obj && angular.isFunction(obj.then);
-  }
 }

src/directives/formly-custom-validation.test.js

@@ -30,37 +30,6 @@ describe(`formly-custom-validation`, function() {
     checkApi(formTemplate.replace(
       `TEMPLATE`, `<input ng-model="input" name="field" formly-custom-validation />`
     ));
-
-    describe(`validators that are functions placement`, () => {
-      it(`should be placed in $asyncValidators because it can return a promise`, () => {
-        scope.options.validators.isHello = viewValue => viewValue === 'hello';
-        $compile(
-          `<form name="myForm"><input ng-model="input" name="field" formly-custom-validation /></form>`
-        )(scope);
-        scope.$digest();
-        const field = scope.myForm.field;
-        expect(field.$validators.isHello).to.not.exist;
-        expect(field.$asyncValidators.isHello).to.exist;
-      });
-
-      it(`should be placed in $validators if formlyConfig.extras.explicitAsync`, () => {
-        formlyConfig.extras.explicitAsync = true;
-        scope.options.validators.isHello = viewValue => viewValue === 'hello';
-        $compile(
-          `<form name="myForm"><input ng-model="input" name="field" formly-custom-validation /></form>`
-        )(scope);
-        scope.$digest();
-        const field = scope.myForm.field;
-        expect(field.$validators.isHello).to.exist;
-        expect(field.$asyncValidators.isHello).to.not.exist;
-      });
-
-      it(`should validate properly when explicitAsync is true`, () => {
-        formlyConfig.extras.explicitAsync = true;
-        const template = `<form name="myForm"><input ng-model="input" name="field" formly-custom-validation /></form>`;
-        doValidation(template, 'hello', false, viewValue => viewValue !== 'hello', false);
-      });
-    });
   });
 
   describe(`options.validation.messages`, () => {
@@ -100,18 +69,6 @@ describe(`formly-custom-validation`, function() {
       it(`should fail if it's a function that fails`, () => {
         validate(viewValue => viewValue !== value, false);
       });
-
-      it(`should warn if it's a function that returns a promise for a regular validator (should use asyncValidators instead)`, () => {
-        const logArgs = [
-          'Formly Warning:',
-          'Validators returning promises should use asyncValidators instead of validators.',
-          scope.options,
-          /validators-returning-promises-should-use-asyncvalidators/
-        ];
-        shouldWarnWithLog($log, logArgs, () => {
-          validate(() => $q.when(), true);
-        });
-      });
     });
 
     describe(`asyncValidators`, () => {