forked from typeorm/typeorm
-
Notifications
You must be signed in to change notification settings - Fork 0
/
RelationLoader.ts
230 lines (205 loc) · 11.7 KB
/
RelationLoader.ts
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
import {Connection, ObjectLiteral, QueryRunner} from "../";
import {RelationMetadata} from "../metadata/RelationMetadata";
/**
* Wraps entities and creates getters/setters for their relations
* to be able to lazily load relations when accessing these relations.
*/
export class RelationLoader {
// -------------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------------
constructor(private connection: Connection) {
}
// -------------------------------------------------------------------------
// Public Methods
// -------------------------------------------------------------------------
/**
* Loads relation data for the given entity and its relation.
*/
load(relation: RelationMetadata, entityOrEntities: ObjectLiteral|ObjectLiteral[], queryRunner?: QueryRunner): Promise<any[]> { // todo: check all places where it uses non array
if (queryRunner && queryRunner.isReleased) queryRunner = undefined; // get new one if already closed
if (relation.isManyToOne || relation.isOneToOneOwner) {
return this.loadManyToOneOrOneToOneOwner(relation, entityOrEntities, queryRunner);
} else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
return this.loadOneToManyOrOneToOneNotOwner(relation, entityOrEntities, queryRunner);
} else if (relation.isManyToManyOwner) {
return this.loadManyToManyOwner(relation, entityOrEntities, queryRunner);
} else { // many-to-many non owner
return this.loadManyToManyNotOwner(relation, entityOrEntities, queryRunner);
}
}
/**
* Loads data for many-to-one and one-to-one owner relations.
*
* (ow) post.category<=>category.post
* loaded: category from post
* example: SELECT category.id AS category_id, category.name AS category_name FROM category category
* INNER JOIN post Post ON Post.category=category.id WHERE Post.id=1
*/
loadManyToOneOrOneToOneOwner(relation: RelationMetadata, entityOrEntities: ObjectLiteral|ObjectLiteral[], queryRunner?: QueryRunner): Promise<any> {
const entities = entityOrEntities instanceof Array ? entityOrEntities : [entityOrEntities];
const columns = relation.entityMetadata.primaryColumns;
const joinColumns = relation.isOwning ? relation.joinColumns : relation.inverseRelation!.joinColumns;
const conditions = joinColumns.map(joinColumn => {
return `${relation.entityMetadata.name}.${joinColumn.propertyName} = ${relation.propertyName}.${joinColumn.referencedColumn!.propertyName}`;
}).join(" AND ");
const joinAliasName = relation.entityMetadata.name;
const qb = this.connection
.createQueryBuilder(queryRunner)
.select(relation.propertyName) // category
.from(relation.type, relation.propertyName) // Category, category
.innerJoin(relation.entityMetadata.target as Function, joinAliasName, conditions);
if (columns.length === 1) {
qb.where(`${joinAliasName}.${columns[0].propertyPath} IN (:...${joinAliasName + "_" + columns[0].propertyName})`);
qb.setParameter(joinAliasName + "_" + columns[0].propertyName, entities.map(entity => columns[0].getEntityValue(entity)));
} else {
const condition = entities.map((entity, entityIndex) => {
return columns.map((column, columnIndex) => {
const paramName = joinAliasName + "_entity_" + entityIndex + "_" + columnIndex;
qb.setParameter(paramName, column.getEntityValue(entity));
return joinAliasName + "." + column.propertyPath + " = :" + paramName;
}).join(" AND ");
}).map(condition => "(" + condition + ")").join(" OR ");
qb.where(condition);
}
return qb.getMany();
// return qb.getOne(); todo: fix all usages
}
/**
* Loads data for one-to-many and one-to-one not owner relations.
*
* SELECT post
* FROM post post
* WHERE post.[joinColumn.name] = entity[joinColumn.referencedColumn]
*/
loadOneToManyOrOneToOneNotOwner(relation: RelationMetadata, entityOrEntities: ObjectLiteral|ObjectLiteral[], queryRunner?: QueryRunner): Promise<any> {
const entities = entityOrEntities instanceof Array ? entityOrEntities : [entityOrEntities];
const aliasName = relation.propertyName;
const columns = relation.inverseRelation!.joinColumns;
const qb = this.connection
.createQueryBuilder(queryRunner)
.select(aliasName)
.from(relation.inverseRelation!.entityMetadata.target, aliasName);
if (columns.length === 1) {
qb.where(`${aliasName}.${columns[0].propertyPath} IN (:...${aliasName + "_" + columns[0].propertyName})`);
qb.setParameter(aliasName + "_" + columns[0].propertyName, entities.map(entity => columns[0].referencedColumn!.getEntityValue(entity)));
} else {
const condition = entities.map((entity, entityIndex) => {
return columns.map((column, columnIndex) => {
const paramName = aliasName + "_entity_" + entityIndex + "_" + columnIndex;
qb.setParameter(paramName, column.referencedColumn!.getEntityValue(entity));
return aliasName + "." + column.propertyPath + " = :" + paramName;
}).join(" AND ");
}).map(condition => "(" + condition + ")").join(" OR ");
qb.where(condition);
}
return qb.getMany();
// return relation.isOneToMany ? qb.getMany() : qb.getOne(); todo: fix all usages
}
/**
* Loads data for many-to-many owner relations.
*
* SELECT category
* FROM category category
* INNER JOIN post_categories post_categories
* ON post_categories.postId = :postId
* AND post_categories.categoryId = category.id
*/
loadManyToManyOwner(relation: RelationMetadata, entityOrEntities: ObjectLiteral|ObjectLiteral[], queryRunner?: QueryRunner): Promise<any> {
const entities = entityOrEntities instanceof Array ? entityOrEntities : [entityOrEntities];
const mainAlias = relation.propertyName;
const joinAlias = relation.junctionEntityMetadata!.tableName;
const joinColumnConditions = relation.joinColumns.map(joinColumn => {
return `${joinAlias}.${joinColumn.propertyName} IN (:...${joinColumn.propertyName})`;
});
const inverseJoinColumnConditions = relation.inverseJoinColumns.map(inverseJoinColumn => {
return `${joinAlias}.${inverseJoinColumn.propertyName}=${mainAlias}.${inverseJoinColumn.referencedColumn!.propertyName}`;
});
const parameters = relation.joinColumns.reduce((parameters, joinColumn) => {
parameters[joinColumn.propertyName] = entities.map(entity => joinColumn.referencedColumn!.getEntityValue(entity));
return parameters;
}, {} as ObjectLiteral);
return this.connection
.createQueryBuilder(queryRunner)
.select(mainAlias)
.from(relation.type, mainAlias)
.innerJoin(joinAlias, joinAlias, [...joinColumnConditions, ...inverseJoinColumnConditions].join(" AND "))
.setParameters(parameters)
.getMany();
}
/**
* Loads data for many-to-many not owner relations.
*
* SELECT post
* FROM post post
* INNER JOIN post_categories post_categories
* ON post_categories.postId = post.id
* AND post_categories.categoryId = post_categories.categoryId
*/
loadManyToManyNotOwner(relation: RelationMetadata, entityOrEntities: ObjectLiteral|ObjectLiteral[], queryRunner?: QueryRunner): Promise<any> {
const entities = entityOrEntities instanceof Array ? entityOrEntities : [entityOrEntities];
const mainAlias = relation.propertyName;
const joinAlias = relation.junctionEntityMetadata!.tableName;
const joinColumnConditions = relation.inverseRelation!.joinColumns.map(joinColumn => {
return `${joinAlias}.${joinColumn.propertyName} = ${mainAlias}.${joinColumn.referencedColumn!.propertyName}`;
});
const inverseJoinColumnConditions = relation.inverseRelation!.inverseJoinColumns.map(inverseJoinColumn => {
return `${joinAlias}.${inverseJoinColumn.propertyName} IN (:...${inverseJoinColumn.propertyName})`;
});
const parameters = relation.inverseRelation!.inverseJoinColumns.reduce((parameters, joinColumn) => {
parameters[joinColumn.propertyName] = entities.map(entity => joinColumn.referencedColumn!.getEntityValue(entity));
return parameters;
}, {} as ObjectLiteral);
return this.connection
.createQueryBuilder(queryRunner)
.select(mainAlias)
.from(relation.type, mainAlias)
.innerJoin(joinAlias, joinAlias, [...joinColumnConditions, ...inverseJoinColumnConditions].join(" AND "))
.setParameters(parameters)
.getMany();
}
/**
* Wraps given entity and creates getters/setters for its given relation
* to be able to lazily load data when accessing this relation.
*/
enableLazyLoad(relation: RelationMetadata, entity: ObjectLiteral, queryRunner?: QueryRunner) {
const relationLoader = this;
const dataIndex = "__" + relation.propertyName + "__"; // in what property of the entity loaded data will be stored
const promiseIndex = "__promise_" + relation.propertyName + "__"; // in what property of the entity loading promise will be stored
const resolveIndex = "__has_" + relation.propertyName + "__"; // indicates if relation data already was loaded or not, we need this flag if loaded data is empty
const dirtyIndex = "__dirty_" + relation.propertyName + "__"; // indicates if relation Promise is "dirty" - ie a user-supplied promise set via the property setter
Object.defineProperty(entity, relation.propertyName, {
get: function() {
if (this[resolveIndex] === true) // if related data already was loaded then simply return it
return Promise.resolve(this[dataIndex]);
if (this[promiseIndex]) // if related data is loading then return a promise relationLoader loads it
return this[promiseIndex];
// nothing is loaded yet, load relation data and save it in the model once they are loaded
this[promiseIndex] = relationLoader.load(relation, this, queryRunner).then(result => {
if (relation.isOneToOne || relation.isManyToOne) result = result[0];
this[dataIndex] = result;
this[resolveIndex] = true;
delete this[promiseIndex];
return this[dataIndex];
});
return this[promiseIndex];
},
set: function(value: any|Promise<any>) {
if (value instanceof Promise) { // if set data is a promise then wait for its resolve and save in the object
this[dirtyIndex] = true;
this[promiseIndex] = value.then(result => {
this[dataIndex] = result;
this[resolveIndex] = true;
delete this[promiseIndex];
delete this[dirtyIndex];
return this[dataIndex];
});
} else { // if its direct data set (non promise, probably not safe-typed)
this[dataIndex] = value;
this[resolveIndex] = true;
}
},
configurable: true
});
}
}