水线/帆Js防止模型的嵌套（关系）保存

Question

I have a model "User" that has a Many-to-One relationship with a "Subject".

User.js

attributes: {
    subject: { model: 'subject' },
}

Subject.js

attributes: {
    name: { type: 'string', unique: true, required: true },
}

When I call the blueprint create function for a User "/user" and pass in the data:

{
    "name":"Test",
    "subject":{"name":"Do Not Allow"}
}

It creates the user and also creates the Subject. However I do not want to allow the subject to be created, I only want to be able to attach an existing one. For example I would like it to reject the subject being created using the above data but allow the subject to be attached by using the below data.

{
    "name":"Test",
    "subject":1
}

I tried adding a policy (shown below) but this only stops the subject from being created using the URL "/subject" and not the nested create shown above.

'SubjectController':{
    'create':false
}

Edit To help understand what is going on here this is the lifecycle process it is going through:

Before Validation of Subject
After Validation of Subject
Before Creating Subject
After Creating Subject
Before Validation of User
After Validation of User
Before Creating User
Before Validation of User
After Validation of User
After Creating User

As you can see it is validating and creating the subject before it even gets to validating or creating the user.

Answer 1

You want to avoid the creation of an associated object when calling the blueprint creation route.

Create a policy (I've named it checkSubjectAndHydrate ) and add it into the policies.js file:

// checkSubjectAndHydrate.js
module.exports = function (req, res, next) {

  // We can create a user without a subject
  if (_.isUndefined(req.body.subject)) {
    return next();
  }

  // Check that the subject exists
  Subject
    .findOne(req.body.subject)
    .exec(function (err, subject) {
      if (err) return next(err);

      // The subject does not exist, send an error message
      if (!subject) return res.forbidden('You are not allowed to do that');

      // The subject does exist, replace the body param with its id
      req.body.subject = subject.id;

      return next();
  });

};

// policies.js
module.exports.policies = {

  UserController: {
    create: 'checkSubjectAndHydrate',
    update: 'checkSubjectAndHydrate',
  }

};

Answer 2

You can create custom type for subject, and add your logic inside model. I'm not 100% sure I understood the attach sometimes part but maybe this could help:

models/User.js

module.exports = {

    schema: true,

    attributes: {
        name: {
            type: 'string'
        },

        subject: {
            type: 'json',
            myValidation: true
        }
    },

    types: {
        myValidation: function(value) {
            // add here any kind of logic...

            // for example... reject if someone passed name key
            return !value.name;
        }
    }
};

You can find more info here http://sailsjs.org/documentation/concepts/models-and-orm/validations at the bottom of the page.

If I totally missed the point... The second option would be to add beforeCreate and beforeUpdate lifecycle callback to your model like this:

models/User.js

 module.exports = {

    schema: true,

    attributes: {
        name: {
            type: 'string'
        },

        subject: {
            type: 'json'
        }
    },

    beforeCreate: function (values, cb) {

        // for example... reject creating of subject if anything else then value of 1
        if (values.subject && values.subject !== 1) return cb('make error obj...');

        cb();
    },


    beforeUpdate: function (values, cb) {
        // here you can add any kind of logic to check existing user or current update values that are going to be updated
        // and allow it or not

        return cb();
    }
};

By using this you can use one logic for creating and another one for updating... etc...

You can find more info here: http://sailsjs.org/documentation/concepts/models-and-orm/lifecycle-callbacks

EDIT

Realized you have trouble with relation, and in above examples I thought you are handling type json...

module.exports = {

    schema: true,

    attributes: {
        name: {
            type: 'string'
        },

        subject: {
            model: 'subject'
        }
    },

    beforeValidate: function (values, cb) {

        // subject is not sent at all, so we just go to next lifecycle
        if (!values.subject) return cb();

        // before we update or create... we will check if subject by id exists...
        Subject.findOne(values.subject).exec(function (err, subject) {
            // subject is not existing, return an error
            if (err || !subject) return cb(err || 'no subject');

            //

            // you can also remove subject key instead of sending error like this:
            // delete values.subject;

            //

            // subject is existing... continue with update
            cb();
        });
    }
};

Answer 3

You should be passing the subject id (eg 1 ) instead of an object (eg { name: 'Hello, World!' } ) containing the name of the subject as it's not necessarily unique.

If it is unique, you should replace the object by its id inside a beforeValidate for example.

// User.js

module.exports = {

  ...

  beforeValidate: function (users, callback) {
    // users = [{
    //   "name":"Test",
    //   "subject":{"name":"Do Not Allow"}
    // }]

    async.each(users, function replaceSubject(user, next) {
      var where = {};
      if (_.isObject(user.subject) && _.isString(user.subject.name)) {
        where.name = user.subject.name;
      } else if(_.isInteger(user.subject)) {
        where.id = user.subject;
      } else {
        return next();
      }

      // Check the existence of the subject
      Subject
        .findOne(where)
        .exec(function (err, subject) {
          if (err) return next(err);

          // Create a user without a subject if it does not exist
          user.subject = subject? subject.id : null;
          next();
      });
    }, callback);

    // users = [{
    //   "name":"Test",
    //   "subject":1
    // }]
  }

};