1 | "use strict";
|
2 | Object.defineProperty(exports, "__esModule", { value: true });
|
3 | var tslib_1 = require("tslib");
|
4 | var RelationMetadata_1 = require("../metadata/RelationMetadata");
|
5 |
|
6 |
|
7 |
|
8 | var RelationIdLoader = (function () {
|
9 |
|
10 |
|
11 |
|
12 | function RelationIdLoader(connection) {
|
13 | this.connection = connection;
|
14 | }
|
15 | |
16 |
|
17 |
|
18 | RelationIdLoader.prototype.load = function (relationOrTarget, relationNameOrEntities, entitiesOrRelatedEntities, maybeRelatedEntities) {
|
19 | return tslib_1.__awaiter(this, void 0, void 0, function () {
|
20 | var relation, entities, relatedEntities, entityMetadata;
|
21 | return tslib_1.__generator(this, function (_a) {
|
22 | if (relationOrTarget instanceof RelationMetadata_1.RelationMetadata) {
|
23 | relation = relationOrTarget;
|
24 | entities = relationNameOrEntities instanceof Array ? relationNameOrEntities : [relationNameOrEntities];
|
25 | relatedEntities = entitiesOrRelatedEntities instanceof Array ? entitiesOrRelatedEntities : (entitiesOrRelatedEntities ? [entitiesOrRelatedEntities] : undefined);
|
26 | }
|
27 | else {
|
28 | entityMetadata = this.connection.getMetadata(relationOrTarget);
|
29 | relation = entityMetadata.findRelationWithPropertyPath(relationNameOrEntities);
|
30 | if (!relation)
|
31 | throw new Error("Relation \"" + relation + "\" was not found in \"" + entityMetadata.name + "\".");
|
32 | entities = entitiesOrRelatedEntities instanceof Array ? entitiesOrRelatedEntities : [entitiesOrRelatedEntities];
|
33 | relatedEntities = maybeRelatedEntities instanceof Array ? maybeRelatedEntities : (maybeRelatedEntities ? [maybeRelatedEntities] : undefined);
|
34 | }
|
35 |
|
36 | if (relation.isManyToMany) {
|
37 | return [2 , this.loadForManyToMany(relation, entities, relatedEntities)];
|
38 | }
|
39 | else if (relation.isManyToOne || relation.isOneToOneOwner) {
|
40 | return [2 , this.loadForManyToOneAndOneToOneOwner(relation, entities, relatedEntities)];
|
41 | }
|
42 | else {
|
43 | return [2 , this.loadForOneToManyAndOneToOneNotOwner(relation, entities, relatedEntities)];
|
44 | }
|
45 | return [2 ];
|
46 | });
|
47 | });
|
48 | };
|
49 | |
50 |
|
51 |
|
52 |
|
53 |
|
54 | RelationIdLoader.prototype.loadManyToManyRelationIdsAndGroup = function (relation, entitiesOrEntities, relatedEntityOrEntities) {
|
55 | return tslib_1.__awaiter(this, void 0, void 0, function () {
|
56 | var isMany, entities, relationIds, relatedEntities, columns, inverseColumns;
|
57 | return tslib_1.__generator(this, function (_a) {
|
58 | switch (_a.label) {
|
59 | case 0:
|
60 | isMany = relation.isManyToMany || relation.isOneToMany;
|
61 | entities = entitiesOrEntities instanceof Array ? entitiesOrEntities : [entitiesOrEntities];
|
62 | if (!!relatedEntityOrEntities) return [3 , 2];
|
63 | return [4 , this.connection.relationLoader.load(relation, entitiesOrEntities)];
|
64 | case 1:
|
65 | relatedEntityOrEntities = _a.sent();
|
66 | if (!relatedEntityOrEntities.length)
|
67 | return [2 , entities.map(function (entity) { return ({ entity: entity, related: isMany ? [] : undefined }); })];
|
68 | _a.label = 2;
|
69 | case 2: return [4 , this.load(relation, entitiesOrEntities, relatedEntityOrEntities)];
|
70 | case 3:
|
71 | relationIds = _a.sent();
|
72 | relatedEntities = relatedEntityOrEntities instanceof Array ? relatedEntityOrEntities : [relatedEntityOrEntities];
|
73 | if (relation.isManyToManyOwner) {
|
74 | columns = relation.junctionEntityMetadata.inverseColumns.map(function (column) { return column.referencedColumn; });
|
75 | inverseColumns = relation.junctionEntityMetadata.ownerColumns.map(function (column) { return column.referencedColumn; });
|
76 | }
|
77 | else if (relation.isManyToManyNotOwner) {
|
78 | columns = relation.junctionEntityMetadata.ownerColumns.map(function (column) { return column.referencedColumn; });
|
79 | inverseColumns = relation.junctionEntityMetadata.inverseColumns.map(function (column) { return column.referencedColumn; });
|
80 | }
|
81 | else if (relation.isManyToOne || relation.isOneToOneOwner) {
|
82 | columns = relation.joinColumns.map(function (column) { return column.referencedColumn; });
|
83 | inverseColumns = relation.entityMetadata.primaryColumns;
|
84 | }
|
85 | else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
|
86 | columns = relation.inverseRelation.entityMetadata.primaryColumns;
|
87 | inverseColumns = relation.inverseRelation.joinColumns.map(function (column) { return column.referencedColumn; });
|
88 | }
|
89 | else {
|
90 | }
|
91 | return [2 , entities.map(function (entity) {
|
92 | var group = { entity: entity, related: isMany ? [] : undefined };
|
93 | relationIds.forEach(function (relationId) {
|
94 | var entityMatched = inverseColumns.every(function (column) {
|
95 | return column.getEntityValue(entity) === relationId[column.entityMetadata.name + "_" + column.propertyPath.replace(".", "_")];
|
96 | });
|
97 | if (entityMatched) {
|
98 | relatedEntities.forEach(function (relatedEntity) {
|
99 | var relatedEntityMatched = columns.every(function (column) {
|
100 | return column.getEntityValue(relatedEntity) === relationId[column.entityMetadata.name + "_" + relation.propertyPath.replace(".", "_") + "_" + column.propertyPath.replace(".", "_")];
|
101 | });
|
102 | if (relatedEntityMatched) {
|
103 | if (isMany) {
|
104 | group.related.push(relatedEntity);
|
105 | }
|
106 | else {
|
107 | group.related = relatedEntity;
|
108 | }
|
109 | }
|
110 | });
|
111 | }
|
112 | });
|
113 | return group;
|
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 | RelationIdLoader.prototype.loadForManyToMany = function (relation, entities, relatedEntities) {
|
164 | var junctionMetadata = relation.junctionEntityMetadata;
|
165 | var mainAlias = junctionMetadata.name;
|
166 | var columns = relation.isOwning ? junctionMetadata.ownerColumns : junctionMetadata.inverseColumns;
|
167 | var inverseColumns = relation.isOwning ? junctionMetadata.inverseColumns : junctionMetadata.ownerColumns;
|
168 | var qb = this.connection.createQueryBuilder();
|
169 |
|
170 | junctionMetadata.ownerColumns.forEach(function (column) {
|
171 | var columnName = column.referencedColumn.entityMetadata.name + "_" + column.referencedColumn.propertyPath.replace(".", "_");
|
172 | qb.addSelect(mainAlias + "." + column.propertyPath, columnName);
|
173 | });
|
174 | junctionMetadata.inverseColumns.forEach(function (column) {
|
175 | var columnName = column.referencedColumn.entityMetadata.name + "_" + relation.propertyPath.replace(".", "_") + "_" + column.referencedColumn.propertyPath.replace(".", "_");
|
176 | qb.addSelect(mainAlias + "." + column.propertyPath, columnName);
|
177 | });
|
178 |
|
179 | var condition1 = "";
|
180 | if (columns.length === 1) {
|
181 | qb.setParameter("values1", entities.map(function (entity) { return columns[0].referencedColumn.getEntityValue(entity); }));
|
182 | condition1 = mainAlias + "." + columns[0].propertyPath + " IN (:...values1)";
|
183 | }
|
184 | else {
|
185 | condition1 = "(" + entities.map(function (entity, entityIndex) {
|
186 | return columns.map(function (column) {
|
187 | var paramName = "entity1_" + entityIndex + "_" + column.propertyName;
|
188 | qb.setParameter(paramName, column.referencedColumn.getEntityValue(entity));
|
189 | return mainAlias + "." + column.propertyPath + " = :" + paramName;
|
190 | }).join(" AND ");
|
191 | }).map(function (condition) { return "(" + condition + ")"; }).join(" OR ") + ")";
|
192 | }
|
193 |
|
194 | var condition2 = "";
|
195 | if (relatedEntities) {
|
196 | if (inverseColumns.length === 1) {
|
197 | qb.setParameter("values2", relatedEntities.map(function (entity) { return inverseColumns[0].referencedColumn.getEntityValue(entity); }));
|
198 | condition2 = mainAlias + "." + inverseColumns[0].propertyPath + " IN (:...values2)";
|
199 | }
|
200 | else {
|
201 | condition2 = "(" + relatedEntities.map(function (entity, entityIndex) {
|
202 | return inverseColumns.map(function (column) {
|
203 | var paramName = "entity2_" + entityIndex + "_" + column.propertyName;
|
204 | qb.setParameter(paramName, column.referencedColumn.getEntityValue(entity));
|
205 | return mainAlias + "." + column.propertyPath + " = :" + paramName;
|
206 | }).join(" AND ");
|
207 | }).map(function (condition) { return "(" + condition + ")"; }).join(" OR ") + ")";
|
208 | }
|
209 | }
|
210 |
|
211 | return qb
|
212 | .from(junctionMetadata.target, mainAlias)
|
213 | .where(condition1 + (condition2 ? " AND " + condition2 : ""))
|
214 | .getRawMany();
|
215 | };
|
216 | |
217 |
|
218 |
|
219 | RelationIdLoader.prototype.loadForManyToOneAndOneToOneOwner = function (relation, entities, relatedEntities) {
|
220 | var mainAlias = relation.entityMetadata.targetName;
|
221 |
|
222 | var qb = this.connection.createQueryBuilder();
|
223 | relation.entityMetadata.primaryColumns.forEach(function (primaryColumn) {
|
224 | var columnName = primaryColumn.entityMetadata.name + "_" + primaryColumn.propertyPath.replace(".", "_");
|
225 | qb.addSelect(mainAlias + "." + primaryColumn.propertyPath, columnName);
|
226 | });
|
227 | relation.joinColumns.forEach(function (column) {
|
228 | var columnName = column.referencedColumn.entityMetadata.name + "_" + relation.propertyPath.replace(".", "_") + "_" + column.referencedColumn.propertyPath.replace(".", "_");
|
229 | qb.addSelect(mainAlias + "." + column.propertyPath, columnName);
|
230 | });
|
231 |
|
232 | var condition = "";
|
233 | if (relation.entityMetadata.primaryColumns.length === 1) {
|
234 | qb.setParameter("values", entities.map(function (entity) { return relation.entityMetadata.primaryColumns[0].getEntityValue(entity); }));
|
235 | condition = mainAlias + "." + relation.entityMetadata.primaryColumns[0].propertyPath + " IN (:...values)";
|
236 | }
|
237 | else {
|
238 | condition = entities.map(function (entity, entityIndex) {
|
239 | return relation.entityMetadata.primaryColumns.map(function (column, columnIndex) {
|
240 | var paramName = "entity" + entityIndex + "_" + columnIndex;
|
241 | qb.setParameter(paramName, column.getEntityValue(entity));
|
242 | return mainAlias + "." + column.propertyPath + " = :" + paramName;
|
243 | }).join(" AND ");
|
244 | }).map(function (condition) { return "(" + condition + ")"; }).join(" OR ");
|
245 | }
|
246 |
|
247 | return qb.from(relation.entityMetadata.target, mainAlias)
|
248 | .where(condition)
|
249 | .getRawMany();
|
250 | };
|
251 | |
252 |
|
253 |
|
254 | RelationIdLoader.prototype.loadForOneToManyAndOneToOneNotOwner = function (relation, entities, relatedEntities) {
|
255 | relation = relation.inverseRelation;
|
256 | var mainAlias = relation.entityMetadata.targetName;
|
257 |
|
258 | var qb = this.connection.createQueryBuilder();
|
259 | relation.entityMetadata.primaryColumns.forEach(function (primaryColumn) {
|
260 | var columnName = primaryColumn.entityMetadata.name + "_" + relation.inverseRelation.propertyPath.replace(".", "_") + "_" + primaryColumn.propertyPath.replace(".", "_");
|
261 | qb.addSelect(mainAlias + "." + primaryColumn.propertyPath, columnName);
|
262 | });
|
263 | relation.joinColumns.forEach(function (column) {
|
264 | var columnName = column.referencedColumn.entityMetadata.name + "_" + column.referencedColumn.propertyPath.replace(".", "_");
|
265 | qb.addSelect(mainAlias + "." + column.propertyPath, columnName);
|
266 | });
|
267 |
|
268 | var condition = "";
|
269 | if (relation.joinColumns.length === 1) {
|
270 | qb.setParameter("values", entities.map(function (entity) { return relation.joinColumns[0].referencedColumn.getEntityValue(entity); }));
|
271 | condition = mainAlias + "." + relation.joinColumns[0].propertyPath + " IN (:...values)";
|
272 | }
|
273 | else {
|
274 | condition = entities.map(function (entity, entityIndex) {
|
275 | return relation.joinColumns.map(function (joinColumn, joinColumnIndex) {
|
276 | var paramName = "entity" + entityIndex + "_" + joinColumnIndex;
|
277 | qb.setParameter(paramName, joinColumn.referencedColumn.getEntityValue(entity));
|
278 | return mainAlias + "." + joinColumn.propertyPath + " = :" + paramName;
|
279 | }).join(" AND ");
|
280 | }).map(function (condition) { return "(" + condition + ")"; }).join(" OR ");
|
281 | }
|
282 |
|
283 | return qb.from(relation.entityMetadata.target, mainAlias)
|
284 | .where(condition)
|
285 | .getRawMany();
|
286 | };
|
287 | return RelationIdLoader;
|
288 | }());
|
289 | exports.RelationIdLoader = RelationIdLoader;
|
290 |
|
291 |
|