Where do I need a closure for this one?

I have this constructor:

var EditableItem = (function() {

    function EditableItem(schema, item) {
        this.schema = _.clone(schema);
        this.item = _.clone(item);
        this.propertyTypes = [
            'stringProperties',
            'booleanProperties'];
    }

    EditableItem.prototype = {
        createItem: function() {
            var self = this;
            self.propertyTypes.forEach(function(type) {
                var properties = self.schema[type];
                properties.forEach(function(property, i) {
                    var itemProperty = self.item[type][property.id];
                    if (itemProperty) {
                        properties[i].value = itemProperty;
                    }
                });
            });

            self.schema.itemId = self.item._id;

            return self.schema;
        }
    };

    return EditableItem;

})();

and each time I use it, like this...

async.parallel({
    schema: function(callback) {
        schemas().findOne({
            _id: 'default'
        }, callback);
    },
    items: function(callback) {
        items().find().toArray(callback);
    }
},

function(err, result) {
    if (err) return callback(err);

    var all = result.items.map(function(item) {
        return new EditableItem(result.schema, item).createItem();
    });

    callback(null, all);
});

...I end up with an array result where the last item is repeated while the others are omitted.

My guess is that I need to add a closure somewhere, and as you can see I've tried, but still it yields the same result. Any ideas?

EDIT: I've found a solution. It's not pretty, but maybe someone here can explain why it works and offer a better solution...

In the constructor, where I had: this.schema = _.clone(schema);

I changed to: this.schema = JSON.parse(JSON.stringify(schema));

This seems to allocate new memory for the object, while _.clone still keeps some references to the original object (I guess).