title: Meteor: autoform not displaying validation errors
body: <p>I use Autoform and SimpleSchema for account creation with a custom <code>emailAvailable</code> validation method to protect against dupes. This works great and I get a nice <code>Email must be unique</code> message as expected. However, I have issues when using the same setup (minus a password field) to allow users to change their email address.</p>
  
  <p>My first issue is that even though the <code>emailAvailable</code> method works as expected and prevents the user from changing their email address to one that is already in use, it fails silently and the errors do not appear in the form. I know that the validation errors are caught by SimpleSchema because thanks to <code>SimpleSchema.debug = true</code>, I see a <code>SimpleSchema invalid keys for "account" context</code> message containing the <code>name: email, type: notUnique</code> error being logged.</p>
  
  <p>My second issue is that the server method to update the account is called despite the validation clearly failing. This results in a <code>Exception while invoking method 'updateAccount' MongoError: E11000 duplicate key error index: meteor.users.$emails.address_1</code> message. I understand that the documentation for SimpleSchema explains that this may happen since the validation is run on the client and not the server, but I'm confused as to why the same error doesn't occur when validation fails for account creation.</p>
  
  <p>Thanks! Relevant code is below:</p>
  
  <p>My account creation schema:</p>
  
  <pre><code>// create account
      Schema.users= new SimpleSchema({
          email: {
              type: String,
              unique: true,
              regEx: SimpleSchema.RegEx.Email,
              // check for duplicate email address
              custom: function () {
                  if (Meteor.isClient &amp;&amp; this.isSet) {
                      Meteor.call('emailAvailable', this.value, function (error, result) {
                          if (!result) {
                              Schema.users.namedContext('register').addInvalidKeys([{name: 'email', type: 'notUnique'}]);
                          }
                      });
                  }
              }
          },
          password: {
              type: String
          },
          name: {
              type: String
          }
      });
  </code></pre>
  
  <p>My account update schema:</p>
  
  <pre><code>    // update account
      Schema.profile = new SimpleSchema({
          email: {
              type: String,
              unique: true,
              regEx: SimpleSchema.RegEx.Email,
              // check for duplicate email address
              custom: function () {
                  if (Meteor.isClient &amp;&amp; this.isSet) {
                      Meteor.call('emailAvailable', this.value, function (error, result) {
                          if (!result) {
                              Schema.users.namedContext('account').addInvalidKeys([{name: 'email', type: 'notUnique'}]);
                          }
                      });
                  }
              }
          },
          name: {
              type: String
          }
      });
  </code></pre>
  
  <p>My check email method:</p>
  
  <pre><code>    emailAvailable: function(email) {
          var currentId = "";
          if (Meteor.user()) {
              var currentId = Meteor.user()._id;
          }
          var findEmail = Meteor.users.find(
              {_id:
                  {
                      $ne: currentId
                  }
                  ,emails:
                  {
                      $elemMatch:{
                          address:email
                      }
                  }
              }
          );
          var findEmailCount = findEmail.count();
          if (findEmailCount == 0) {
              return true;
          }
          return false;
      }
  </code></pre>
  
  <p>My server methods:</p>
  
  <pre><code>    Meteor.methods({
          registerAccount: function(doc) {
              check(doc, Schema.users;
              Accounts.createUser({
                  email: doc.email,
                  profile: {
                      name: doc.name
                  },
                  password : doc.password
              });
          },
          updateAccount: function(doc) {
              check(doc, Schema.profile);
              Meteor.users.update(
                  {_id:Meteor.user()._id},
                  {$set:
                      {
                          "profile.name": doc.name,
                          "emails": [ {address:doc.email} ]
                      }
              });
          },
          emailAvailable: function(email) {
              var currentId = "";
              if (Meteor.user()) {
                  var currentId = Meteor.user()._id;
              }
              var findEmail = Meteor.users.find(
                  {_id:
                      {
                          $ne: currentId
                      }
                      ,emails:
                      {
                          $elemMatch:{
                              address:email
                          }
                      }
                  }
              );
              var findEmailCount = findEmail.count();
              if (findEmailCount == 0) {
                  return true;
              }
              return false;
          }
      });
  </code></pre>