belongs-to.js
3.86 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
var Utils = require("./../utils")
, DataTypes = require('./../data-types')
, Helpers = require('./helpers')
, Transaction = require('../transaction')
, _ = require('lodash')
module.exports = (function() {
var BelongsTo = function(source, target, options) {
this.associationType = 'BelongsTo'
this.source = source
this.target = target
this.options = options
this.isSingleAssociation = true
this.isSelfAssociation = (this.source == this.target)
this.as = this.options.as
if (this.as) {
this.isAliased = true
} else {
this.as = Utils.singularize(this.target.name, this.target.options.language)
}
if (!this.options.foreignKey) {
this.options.foreignKey = Utils._.camelizeIf(
[this.as, this.target.primaryKeyAttribute].join("_"),
!this.source.options.underscored
)
}
this.identifier = this.options.foreignKey
this.targetIdentifier = this.target.primaryKeyAttribute
this.associationAccessor = this.as
this.options.useHooks = options.useHooks
this.accessors = {
get: Utils._.camelize('get_' + this.as),
set: Utils._.camelize('set_' + this.as),
create: Utils._.camelize('create_' + this.as)
}
}
// the id is in the source table
BelongsTo.prototype.injectAttributes = function() {
var newAttributes = {}
newAttributes[this.identifier] = { type: this.options.keyType || this.target.rawAttributes[this.targetIdentifier].type }
Helpers.addForeignKeyConstraints(newAttributes[this.identifier], this.target, this.source, this.options)
Utils._.defaults(this.source.rawAttributes, newAttributes)
// Sync attributes and setters/getters to DAO prototype
this.source.refreshAttributes()
return this
}
// Add getAssociation method to the prototype of the model instance
BelongsTo.prototype.injectGetter = function(instancePrototype) {
var association = this
instancePrototype[this.accessors.get] = function(params) {
var where = {}
params = params || {}
params.where = [params.where] || []
where[association.targetIdentifier] = this.get(association.identifier)
params.where.push(where)
params.where = new Utils.and(params.where)
return association.target.find(params)
}
return this
}
// Add setAssociaton method to the prototype of the model instance
BelongsTo.prototype.injectSetter = function(instancePrototype) {
var association = this
instancePrototype[this.accessors.set] = function(associatedInstance, options) {
this.set(association.identifier, associatedInstance ? associatedInstance[association.targetIdentifier] : null)
options = Utils._.extend({
fields: [ association.identifier ],
allowNull: [association.identifier ],
association: true
}, options)
// passes the changed field to save, so only that field get updated.
return this.save(options)
}
return this
}
// Add createAssociation method to the prototype of the model instance
BelongsTo.prototype.injectCreator = function(instancePrototype) {
var association = this
instancePrototype[this.accessors.create] = function(values, fieldsOrOptions) {
var instance = this
, options = {}
if ((fieldsOrOptions || {}).transaction instanceof Transaction) {
options.transaction = fieldsOrOptions.transaction
}
return new Utils.CustomEventEmitter(function(emitter) {
association.target
.create(values, fieldsOrOptions)
.proxy(emitter, { events: ['error', 'sql'] })
.success(function(newAssociatedObject) {
instance[association.accessors.set](newAssociatedObject, options)
.proxy(emitter)
})
}).run()
}
return this
}
return BelongsTo
})()