Promise chain using q and Mongoose models. Passing result from previous promise to another

collection.js

// The route
var  Q = require('q');

module.exports = function(app) {
    var promise = require('./path/to/promise'),
        promise.init(app);

    app.post('someurl/add', function(req, res, next) {
        Q.fcall(promise.createModel1, req.body)
         .then(promise.createModel2)
         .then(promise.updateModel1)
         .fail(function(err) {
            res.send(500, {err: err});
         })
         .done(function(id) {
            res.json({id: id});
         });
    });
};

promise.js

// promise.js
var Q = require('q'),
    Model1,
    Model2,
    Model3;

var getDefaultModel3Type = function() {
    return Q.ninvoke(Model3, 'findOne', {type: 'video'});
};

module.exports = {
    init: function(app) {
        Model1 = app.get('models').Model1;
        Model2 = app.get('models').Model2;
        Model3 = app.get('models').Model3;
    },

    createModel1: function(data) {
        var deferred = Q.defer();

        (function() {
            Model1.create(data, function(err, model1) {
                if (err) {
                    deferred.reject(err);
                } else {
                    deferred.resolve({'model1_id': model1._id, 'extra_data': 'extra_data'});
                }
            });
        })();

        return deferred.promise;
    },

    createModel2: function(result) {
        var deferred = Q.defer();

        (function() {
            getDefaultModel3Type()
            .then(function(model3Type) {
                // Could not retrieve a valid default model3 type, fail the promise chain
                if (model3Type === null) {
                    return deferred.reject(new Error('Invalid model3 type'));
                }

                Model2.create({type: model3Type._id}, function(err, model2) {
                    if (err) {
                        deferred.reject(err);
                    } else {
                        deferred.resolve({'model2': model2, 'model1_id': result.model1_id});
                    }
                });
            });
        })();

        return deferred.promise;
    },

    updateModel1: function(result) {
        var deferred = Q.defer();

        (function() {
            var id = result.model1_id,
                query = {}; // your query here

            Model1.findByIdAndUpdate(id, query, function(err, res) {
                if (err) {
                    deferred.reject(err);
                } else {
                    deferred.resolve(res);
                }
            });
        })();

        return deferred.promise;
    }
};

schema.js

// Schemas

// model1.js
var Model1 = new Schema({
    title: {
        type: String,
        required: true
    },
    model2: [{
        type:Schema.Types.ObjectId,
        ref: 'Model2'
    }],
    ...
});

// model2.js
var Model2 = new Schema({
    title: String,
    type: {
        type: Schema.Types.ObjectId,
        ref: 'Model3'
    },
    ...
});

// model3.js
var Model3 = new Schema({
    type: {
        type: String,
        unique: true
    },
    ...
});