archive-gh-me/typeorm
1
0
Fork 0
mirror of https://github.com/typeorm/typeorm.git synced 2025-12-08 21:26:23 +00:00
Code Issues Projects Releases Wiki Activity

implementing multiple primary key functionality in to RelationId;

Browse Source 
fixes and refactoring;
This commit is contained in:
Zotov Dmitry 2017-05-13 17:29:59 +05:00
parent 50d350434b
commit b0873656d4
29 changed files with 495 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/metadata/ColumnMetadata.ts
View File

@ -427,10 +427,25 @@ export class ColumnMetadata {
// once we get nested embed object we get its column, e.g. post[data][information][counters][this.propertyName]
const embeddedObject = extractEmbeddedColumnValue(propertyNames, entity);
return embeddedObject ? embeddedObject[this.propertyName] : undefined;
if (embeddedObject) {
if (this.relationMetadata && this.referencedColumn) {
const relatedEntity = this.relationMetadata.getEntityValue(embeddedObject);
return relatedEntity ? this.referencedColumn.getEntityValue(relatedEntity) : undefined;
} else {
return embeddedObject[this.propertyName];
}
}
return undefined;
// return embeddedObject ? embeddedObject[this.propertyName] : undefined;
} else { // no embeds - no problems. Simply return column name by property name of the entity
return entity[this.propertyName];
if (this.relationMetadata && this.referencedColumn) {
const relatedEntity = this.relationMetadata.getEntityValue(entity);
return relatedEntity ? this.referencedColumn.getEntityValue(relatedEntity) : undefined;
} else {
return entity[this.propertyName];
}
// return entity[this.propertyName];
}
}

6
src/persistence/SubjectBuilder.ts
View File

@ -786,7 +786,7 @@ export class SubjectBuilder<Entity extends ObjectLiteral> {
.map(subRelationValue => {
const joinColumns = relation.isOwning ? relation.inverseJoinColumns : relation.inverseRelation.joinColumns;
return joinColumns.reduce((ids, joinColumn) => {
return OrmUtils.mergeDeep(ids, joinColumn.createValueMap(joinColumn.referencedColumn!.getEntityValue(subRelationValue))); // todo: duplicate. relation.createJoinColumnsIdMap(entity) ?
return OrmUtils.mergeDeep(ids, joinColumn.referencedColumn!.createValueMap(joinColumn.referencedColumn!.getEntityValue(subRelationValue))); // todo: duplicate. relation.createJoinColumnsIdMap(entity) ?
}, {} as ObjectLiteral);
})
.filter(subRelationValue => subRelationValue !== undefined && subRelationValue !== null);
@ -802,11 +802,13 @@ export class SubjectBuilder<Entity extends ObjectLiteral> {
// now from all entities in the persisted entity find only those which aren't found in the db
const newJunctionEntities = relatedValue.filter(subRelatedValue => {
// console.log(subRelatedValue);
const joinColumns = relation.isOwning ? relation.inverseJoinColumns : relation.inverseRelation.joinColumns;
const ids = joinColumns.reduce((ids, joinColumn) => {
return OrmUtils.mergeDeep(ids, joinColumn.createValueMap(joinColumn.referencedColumn!.getEntityValue(subRelatedValue))); // todo: duplicate. relation.createJoinColumnsIdMap(entity) ?
return OrmUtils.mergeDeep(ids, joinColumn.referencedColumn!.createValueMap(joinColumn.referencedColumn!.getEntityValue(subRelatedValue))); // todo: duplicate. relation.createJoinColumnsIdMap(entity) ?
}, {} as ObjectLiteral);
// console.log("ids:", ids);
return !existInverseEntityRelationIds.find(relationId => {
return relation.inverseEntityMetadata.compareIds(relationId, ids);
});

2
src/query-builder/QueryBuilder.ts
View File

@ -1149,7 +1149,7 @@ export class QueryBuilder<Entity> {
*/
enableAutoRelationIdsLoad(): this {
this.expressionMap.mainAlias!.metadata.relations.forEach(relation => {
this.loadRelationIdAndMap(this.expressionMap.mainAlias!.name + "." + relation.propertyName, this.expressionMap.mainAlias!.name + "." + relation.propertyName);
this.loadRelationIdAndMap(this.expressionMap.mainAlias!.name + "." + relation.propertyPath, this.expressionMap.mainAlias!.name + "." + relation.propertyPath);
});
return this;
}

18
src/query-builder/relation-id/RelationIdLoader.ts
View File

@ -34,10 +34,15 @@ export class RelationIdLoader {
throw new Error(""); // todo: fix
const results = rawEntities.map(rawEntity => {
return {
id: rawEntity[relationIdAttr.parentAlias + "_" + relationIdAttr.relation.name],
parentId: this.createIdMap(relationIdAttr.relation.entityMetadata.primaryColumns, relationIdAttr.parentAlias, rawEntity)
};
const result: ObjectLiteral = {};
relationIdAttr.relation.joinColumns.forEach(joinColumn => {
result[joinColumn.databaseName] = rawEntity[relationIdAttr.parentAlias + "_" + joinColumn.databaseName];
});
relationIdAttr.relation.entityMetadata.primaryColumns.forEach(primaryColumn => {
result[primaryColumn.databaseName] = rawEntity[relationIdAttr.parentAlias + "_" + primaryColumn.databaseName];
});
return result;
});
return {
@ -51,8 +56,7 @@ export class RelationIdLoader {
// we expect it to load array of category ids
const relation = relationIdAttr.relation; // "post.categories"
const inverseRelation = relation.inverseRelation; // "category.post"
const joinColumns = relation.isOwning ? relation.joinColumns : inverseRelation.joinColumns;
const joinColumns = relation.isOwning ? relation.joinColumns : relation.inverseRelation.joinColumns;
const table = relation.inverseEntityMetadata.target; // category
const tableName = relation.inverseEntityMetadata.tableName; // category
const tableAlias = relationIdAttr.alias || tableName; // if condition (custom query builder factory) is set then relationIdAttr.alias defined
@ -80,7 +84,7 @@ export class RelationIdLoader {
qb.addSelect(tableAlias + "." + joinColumn.databaseName, joinColumn.databaseName);
});
inverseRelation.entityMetadata.primaryColumns.forEach(primaryColumn => {
relation.inverseRelation.entityMetadata.primaryColumns.forEach(primaryColumn => {
qb.addSelect(tableAlias + "." + primaryColumn.databaseName, primaryColumn.databaseName);
});

105
src/query-builder/transformer/RawSqlResultsToEntityTransformer.ts
View File

@ -143,60 +143,39 @@ export class RawSqlResultsToEntityTransformer {
return;
const relation = rawRelationIdResult.relationIdAttribute.relation;
let idMap: any;
let valueMap: ObjectLiteral;
if (relation.isManyToOne || relation.isOneToOneOwner) {
idMap = relation.entityMetadata.primaryColumns.reduce((idMap, primaryColumn) => {
idMap[primaryColumn.propertyName] = rawSqlResults[0][alias.name + "_" + primaryColumn.databaseName];
return idMap;
}, {} as ObjectLiteral);
} else {
if (relation.isOneToMany || relation.isOneToOneNotOwner) {
valueMap = this.createValueMapFromJoinColumns(relation, entity);
} else {
valueMap = this.createValueMapFromJoinColumns(relation, entity);
}
/* referenceColumnValue = rawSqlResults[0][alias.name + "_" + referenceColumnName];
if (referenceColumnValue === undefined || referenceColumnValue === null)
return;*/
if (valueMap === undefined || valueMap === null)
return;
}
const referencedColumnResults = rawRelationIdResult.results.map(result => {
/* if (result.parentId && !alias.metadata.compareIds(result.parentId, idMap))
return;
if (result.manyToManyId && result.manyToManyId !== referenceColumnValue)
return;*/
const valueMap = this.createValueMapFromJoinColumns(relation, rawRelationIdResult.relationIdAttribute.parentAlias, rawSqlResults);
if (valueMap === undefined || valueMap === null)
return;
const idMaps = rawRelationIdResult.results.map(result => {
const entityPrimaryIds = this.extractEntityPrimaryIds(relation, result);
if (!alias.metadata.compareIds(entityPrimaryIds, valueMap))
return;
let joinColumns: ColumnMetadata[];
if (relation.isOneToMany || relation.isOneToOneNotOwner) {
joinColumns = relation.inverseEntityMetadata.primaryColumns.map(joinColumn => joinColumn);
} else {
if (relation.isManyToManyOwner) {
joinColumns = relation.inverseJoinColumns.map(joinColumn => joinColumn);
let columns: ColumnMetadata[];
if (relation.isManyToOne || relation.isOneToOneOwner) {
columns = relation.joinColumns.map(joinColumn => joinColumn);
} else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
columns = relation.inverseEntityMetadata.primaryColumns.map(joinColumn => joinColumn);
} else { // ManyToMany
if (relation.isOwning) {
columns = relation.inverseJoinColumns.map(joinColumn => joinColumn);
} else {
joinColumns = relation.inverseRelation.joinColumns.map(joinColumn => joinColumn);
columns = relation.inverseRelation.joinColumns.map(joinColumn => joinColumn);
}
}
return joinColumns.reduce((referencedColumnResult, joinColumn) => {
if (joinColumns.length > 1) {
return columns.reduce((idMap, joinColumn) => {
if (columns.length > 1) {
if (relation.isOneToMany || relation.isOneToOneNotOwner) {
referencedColumnResult[joinColumn.propertyName] = result[joinColumn.databaseName];
idMap[joinColumn.propertyName] = result[joinColumn.databaseName];
} else {
referencedColumnResult[joinColumn.referencedColumn!.propertyName] = result[joinColumn.databaseName];
idMap[joinColumn.referencedColumn!.propertyName] = result[joinColumn.databaseName];
}
} else {
referencedColumnResult = result[joinColumn.databaseName];
idMap = result[joinColumn.databaseName];
}
return referencedColumnResult;
return idMap;
}, {} as ObjectLiteral);
}).filter(result => result);
@ -213,7 +192,11 @@ export class RawSqlResultsToEntityTransformer {
return map;
}
};
mapToProperty(properties, entity, referencedColumnResults);
if (relation.isOneToOne || relation.isManyToOne) {
mapToProperty(properties, entity, idMaps[0]);
} else {
mapToProperty(properties, entity, idMaps);
}
hasData = true;
});
return hasData;
@ -249,37 +232,47 @@ export class RawSqlResultsToEntityTransformer {
return hasData;
}
private createValueMapFromJoinColumns(relation: RelationMetadata, entity: ObjectLiteral): ObjectLiteral {
let joinColumns: ColumnMetadata[];
if (relation.isOneToMany || relation.isOneToOneNotOwner) {
joinColumns = relation.inverseRelation.joinColumns.map(joinColumn => joinColumn);
private createValueMapFromJoinColumns(relation: RelationMetadata, parentAlias: string, rawSqlResults: any[]): ObjectLiteral {
let columns: ColumnMetadata[];
if (relation.isManyToOne || relation.isOneToOneOwner) {
columns = relation.entityMetadata.primaryColumns.map(joinColumn => joinColumn);
} else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
columns = relation.inverseRelation.joinColumns.map(joinColumn => joinColumn);
} else {
if (relation.isOwning) {
joinColumns = relation.joinColumns.map(joinColumn => joinColumn);
columns = relation.joinColumns.map(joinColumn => joinColumn);
} else {
joinColumns = relation.inverseRelation.inverseJoinColumns.map(joinColumn => joinColumn);
columns = relation.inverseRelation.inverseJoinColumns.map(joinColumn => joinColumn);
}
}
return joinColumns.reduce((valueMap, joinColumn) => {
valueMap[joinColumn.databaseName] = joinColumn.referencedColumn!.getEntityValue(entity);
return columns.reduce((valueMap, column) => {
rawSqlResults.forEach(rawSqlResult => {
if (relation.isManyToOne || relation.isOneToOneOwner) {
valueMap[column.databaseName] = rawSqlResult[parentAlias + "_" + column.databaseName];
} else {
valueMap[column.databaseName] = rawSqlResult[parentAlias + "_" + column.referencedColumn!.databaseName];
}
});
return valueMap;
}, {} as ObjectLiteral);
}
private extractEntityPrimaryIds(relation: RelationMetadata, relationIdRawResult: any) {
let joinColumns: ColumnMetadata[];
if (relation.isOneToMany || relation.isOneToOneNotOwner) {
joinColumns = relation.inverseRelation.joinColumns.map(joinColumn => joinColumn);
let columns: ColumnMetadata[];
if (relation.isManyToOne || relation.isOneToOneOwner) {
columns = relation.entityMetadata.primaryColumns.map(joinColumn => joinColumn);
} else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
columns = relation.inverseRelation.joinColumns.map(joinColumn => joinColumn);
} else {
if (relation.isOwning) {
joinColumns = relation.joinColumns.map(joinColumn => joinColumn);
columns = relation.joinColumns.map(joinColumn => joinColumn);
} else {
joinColumns = relation.inverseRelation.inverseJoinColumns.map(joinColumn => joinColumn);
columns = relation.inverseRelation.inverseJoinColumns.map(joinColumn => joinColumn);
}
}
return joinColumns.reduce((data, joinColumn) => {
data[joinColumn.databaseName] = relationIdRawResult[joinColumn.databaseName];
return columns.reduce((data, column) => {
data[column.databaseName] = relationIdRawResult[column.databaseName];
return data;
}, {} as ObjectLiteral);
}

3
src/repository/SpecificRepository.ts
View File

@ -419,7 +419,6 @@ export class SpecificRepository<Entity extends ObjectLiteral> {
const relation = this.convertMixedRelationToMetadata(relationOrName);
if (!(entityOrEntities instanceof Array)) entityOrEntities = [entityOrEntities];
// todo fix joinColumns[0]
const entityReferencedColumns = relation.isOwning ? relation.joinColumns.map(joinColumn => joinColumn.referencedColumn!) : relation.inverseRelation.inverseJoinColumns.map(joinColumn => joinColumn.referencedColumn!);
const ownerEntityColumns = relation.isOwning ? relation.joinColumns : relation.inverseRelation.inverseJoinColumns;
const inverseEntityColumns = relation.isOwning ? relation.inverseJoinColumns : relation.inverseRelation.joinColumns;
@ -440,7 +439,7 @@ export class SpecificRepository<Entity extends ObjectLiteral> {
const ec = (column: string) => this.connection.driver.escapeColumnName(column);
let ids: any[] = [];
console.log("entityOrEntities:", entityOrEntities);
// console.log("entityOrEntities:", entityOrEntities);
// console.log("entityIds:", entityIds);
const promises = (entityIds as any[]).map((entityId: any) => {
const qb = new QueryBuilder(this.connection, this.queryRunnerProvider);

2
test/benchmark/bulk-save/bulk-save.ts
View File

@ -22,7 +22,7 @@ describe.skip("benchmark > bulk-save", () => {
const posts: Post[] = [];
for(let i = 1; i <= 100; i++) {
for (let i = 1; i <= 100; i++) {
const post = new Post();
post.title = `Post #${i}`;
post.text = `Post #${i} text`;

2
test/functional/decorators/relation-count/relation-count-many-to-many/relation-count-decorator-many-to-many.ts
View File

@ -9,7 +9,7 @@ import {Image} from "./entity/Image";
const should = chai.should();
describe.skip("query builder > relation-count-decorator-many-to-many > many-to-many", () => {
describe("query builder > relation-count-decorator-many-to-many > many-to-many", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({

10
test/functional/query-builder/relation-id/relation-id-many-to-one/load-relation-id-and-map-many-to-one.ts → test/functional/query-builder/relation-id/many-to-one/basic-functionality/basic-functionality.ts
View File

@ -1,8 +1,12 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {Connection} from "../../../../../src/connection/Connection";
import {
closeTestingConnections,
createTestingConnections,
reloadTestingDatabases
} from "../../../../../utils/test-utils";
import {Connection} from "../../../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
import {Image} from "./entity/Image";
@ -10,7 +14,7 @@ import {PostCategory} from "./entity/PostCategory";
const should = chai.should();
describe("query builder > load-relation-id-and-map > many-to-one", () => {
describe("query builder > relation-id > many-to-one > basic-functionality", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({

19
test/functional/query-builder/relation-id/many-to-one/basic-functionality/entity/Category.ts Normal file
View File

@ -0,0 +1,19 @@
import {Entity} from "../../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../../src/decorator/columns/Column";
import {OneToMany} from "../../../../../../../src/decorator/relations/OneToMany";
import {PostCategory} from "./PostCategory";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column({ unique: true })
name: string;
@OneToMany(type => PostCategory, postCategory => postCategory.category)
posts: PostCategory[];
}

14
test/functional/query-builder/relation-id/many-to-one/basic-functionality/entity/Image.ts Normal file
View File

@ -0,0 +1,14 @@
import {Entity} from "../../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../../src/decorator/columns/Column";
@Entity()
export class Image {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
}

12
test/functional/query-builder/relation-id/relation-id-many-to-one/entity/Post.ts → test/functional/query-builder/relation-id/many-to-one/basic-functionality/entity/Post.ts
View File

@ -1,9 +1,9 @@
import {Entity} from "../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../src/decorator/columns/Column";
import {ManyToOne} from "../../../../../../src/decorator/relations/ManyToOne";
import {JoinColumn} from "../../../../../../src/decorator/relations/JoinColumn";
import {OneToMany} from "../../../../../../src/decorator/relations/OneToMany";
import {Entity} from "../../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../../src/decorator/columns/Column";
import {ManyToOne} from "../../../../../../../src/decorator/relations/ManyToOne";
import {JoinColumn} from "../../../../../../../src/decorator/relations/JoinColumn";
import {OneToMany} from "../../../../../../../src/decorator/relations/OneToMany";
import {Category} from "./Category";
import {PostCategory} from "./PostCategory";

4
test/functional/query-builder/relation-id/relation-id-many-to-one/entity/PostCategory.ts → test/functional/query-builder/relation-id/many-to-one/basic-functionality/entity/PostCategory.ts
View File

@ -1,5 +1,5 @@
import {Entity} from "../../../../../../src/decorator/entity/Entity";
import {ManyToOne} from "../../../../../../src/decorator/relations/ManyToOne";
import {Entity} from "../../../../../../../src/decorator/entity/Entity";
import {ManyToOne} from "../../../../../../../src/decorator/relations/ManyToOne";
import {Post} from "./Post";
import {Category} from "./Category";
import {Image} from "./Image";

2
test/functional/query-builder/relation-id/one-to-many/basic-functionality/basic-functionality.ts
View File

@ -13,7 +13,7 @@ import {Image} from "./entity/Image";
const should = chai.should();
describe.only("query builder > load-relation-id-and-map > one-to-many", () => {
describe("query builder > relation-id > one-to-many > basic-functionality", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({

11
test/functional/query-builder/relation-id/relation-id-one-to-one/load-relation-id-and-map-one-to-one.ts → test/functional/query-builder/relation-id/one-to-one/basic-functionality/basic-functionality.ts
View File

@ -1,14 +1,18 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {Connection} from "../../../../../src/connection/Connection";
import {
closeTestingConnections,
createTestingConnections,
reloadTestingDatabases
} from "../../../../../utils/test-utils";
import {Connection} from "../../../../../../src/connection/Connection";
import {Category} from "./entity/Category";
import {Post} from "./entity/Post";
const should = chai.should();
describe("query builder > load-relation-id-and-map > one-to-one", () => {
describe("query builder > relation-id > one-to-one > basic-functionality", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
@ -19,7 +23,6 @@ describe("query builder > load-relation-id-and-map > one-to-one", () => {
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
it("should load ids when loadRelationIdAndMap used with OneToOne owner side relation", () => Promise.all(connections.map(async connection => {
const category = new Category();

21
test/functional/query-builder/relation-id/one-to-one/basic-functionality/entity/Category.ts Normal file
View File

@ -0,0 +1,21 @@
import {Entity} from "../../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../../src/decorator/columns/Column";
import {OneToOne} from "../../../../../../../src/decorator/relations/OneToOne";
import {Post} from "./Post";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@OneToOne(type => Post, post => post.category2)
post: Post;
postId: number;
}

27
test/functional/query-builder/relation-id/one-to-one/basic-functionality/entity/Post.ts Normal file
View File

@ -0,0 +1,27 @@
import {Entity} from "../../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../../src/decorator/columns/Column";
import {OneToOne} from "../../../../../../../src/decorator/relations/OneToOne";
import {JoinColumn} from "../../../../../../../src/decorator/relations/JoinColumn";
import {Category} from "./Category";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@OneToOne(type => Category)
@JoinColumn()
category: Category;
@OneToOne(type => Category, category => category.post)
@JoinColumn()
category2: Category;
categoryId: number;
}

19
test/functional/query-builder/relation-id/relation-id-many-to-one/entity/Category.ts
View File

@ -1,19 +0,0 @@
import {Entity} from "../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../src/decorator/columns/Column";
import {OneToMany} from "../../../../../../src/decorator/relations/OneToMany";
import {PostCategory} from "./PostCategory";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column({ unique: true })
name: string;
@OneToMany(type => PostCategory, postCategory => postCategory.category)
posts: PostCategory[];
}

14
test/functional/query-builder/relation-id/relation-id-many-to-one/entity/Image.ts
View File

@ -1,14 +0,0 @@
import {Entity} from "../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../src/decorator/columns/Column";
@Entity()
export class Image {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
}

21
test/functional/query-builder/relation-id/relation-id-one-to-one/entity/Category.ts
View File

@ -1,21 +0,0 @@
import {Entity} from "../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../src/decorator/columns/Column";
import {OneToOne} from "../../../../../../src/decorator/relations/OneToOne";
import {Post} from "./Post";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@OneToOne(type => Post, post => post.category2)
post: Post;
postId: number;
}

27
test/functional/query-builder/relation-id/relation-id-one-to-one/entity/Post.ts
View File

@ -1,27 +0,0 @@
import {Entity} from "../../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../../src/decorator/columns/Column";
import {OneToOne} from "../../../../../../src/decorator/relations/OneToOne";
import {JoinColumn} from "../../../../../../src/decorator/relations/JoinColumn";
import {Category} from "./Category";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@OneToOne(type => Category)
@JoinColumn()
category: Category;
@OneToOne(type => Category, category => category.post)
@JoinColumn()
category2: Category;
categoryId: number;
}

150
test/functional/relations/custom-referenced-column-name/custom-referenced-column-name.ts
View File

@ -1,7 +1,7 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
@ -26,23 +26,23 @@ describe("relations > custom-referenced-column-name", () => {
const category1 = new Category();
category1.name = "cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.category = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.category = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.getMany();
@ -51,7 +51,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![1].categoryName).to.not.be.empty;
expect(loadedPosts![1].categoryName).to.be.equal("airplanes");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.where("post.id = :id", { id: 1 })
.getOne();
@ -65,23 +65,23 @@ describe("relations > custom-referenced-column-name", () => {
const category1 = new Category();
category1.name = "cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.categoryWithEmptyJoinCol = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoryWithEmptyJoinCol = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithEmptyJoinCol", "categoryWithEmptyJoinCol")
.getMany();
@ -89,7 +89,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![0].categoryWithEmptyJoinCol.id).to.be.equal(1);
expect(loadedPosts![1].categoryWithEmptyJoinCol.id).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.where("post.id = :id", { id: 1 })
.leftJoinAndSelect("post.categoryWithEmptyJoinCol", "categoryWithEmptyJoinCol")
@ -103,30 +103,30 @@ describe("relations > custom-referenced-column-name", () => {
const category1 = new Category();
category1.name = "cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.categoryWithoutRefColName = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoryWithoutRefColName = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.getMany();
expect(loadedPosts![0].categoryId).to.be.equal(1);
expect(loadedPosts![1].categoryId).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.where("post.id = :id", { id: 1 })
.getOne();
@ -139,23 +139,23 @@ describe("relations > custom-referenced-column-name", () => {
const category1 = new Category();
category1.name = "cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.categoryWithoutColName = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoryWithoutColName = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithoutColName", "categoryWithoutColName")
.getMany();
@ -163,7 +163,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![0].categoryWithoutColName.id).to.be.equal(1);
expect(loadedPosts![1].categoryWithoutColName.id).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithoutColName", "categoryWithoutColName")
.where("post.id = :id", { id: 1 })
@ -177,23 +177,23 @@ describe("relations > custom-referenced-column-name", () => {
const category1 = new Category();
category1.name = "cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.categoryWithoutRefColName2 = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoryWithoutRefColName2 = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithoutRefColName2", "categoryWithoutRefColName2")
.getMany();
@ -203,7 +203,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![1].categoryWithoutRefColName2).to.not.be.empty;
expect(loadedPosts![1].categoryWithoutRefColName2.id).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithoutRefColName2", "categoryWithoutRefColName2")
.where("post.id = :id", { id: 1 })
@ -214,27 +214,27 @@ describe("relations > custom-referenced-column-name", () => {
})));
it("should persist relation when relation sets via join column", () => Promise.all(connections.map(async connection => {
it.skip("should persist relation when relation sets via join column", () => Promise.all(connections.map(async connection => {
const category1 = new Category();
category1.name = "cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.categoryName = "cars";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoryName = "airplanes";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.category", "category")
.getMany();
@ -244,7 +244,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![1].category).to.not.be.empty;
expect(loadedPosts![1].category.id).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.category", "category")
.where("post.id = :id", { id: 1 })
@ -262,23 +262,23 @@ describe("relations > custom-referenced-column-name", () => {
const tag1 = new Tag();
tag1.name = "tag #1";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.name = "tag #2";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const post1 = new Post();
post1.title = "Post #1";
post1.tag = tag1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "Post #2";
post2.tag = tag2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.getMany();
@ -287,7 +287,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![1].tagName).to.not.be.empty;
expect(loadedPosts![1].tagName).to.be.equal("tag #2");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.where("post.id = :id", { id: 1 })
.getOne();
@ -301,23 +301,23 @@ describe("relations > custom-referenced-column-name", () => {
const tag1 = new Tag();
tag1.name = "tag #1";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.name = "tag #2";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const post1 = new Post();
post1.title = "About BMW";
post1.tagWithEmptyJoinCol = tag1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.tagWithEmptyJoinCol = tag2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.tagWithEmptyJoinCol", "tagWithEmptyJoinCol")
.getMany();
@ -325,7 +325,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![0].tagWithEmptyJoinCol.id).to.be.equal(1);
expect(loadedPosts![1].tagWithEmptyJoinCol.id).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.tagWithEmptyJoinCol", "tagWithEmptyJoinCol")
.where("post.id = :id", { id: 1 })
@ -339,30 +339,30 @@ describe("relations > custom-referenced-column-name", () => {
const tag1 = new Tag();
tag1.name = "tag #1";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.name = "tag #2";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const post1 = new Post();
post1.title = "About BMW";
post1.tagWithoutRefColName = tag1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.tagWithoutRefColName = tag2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.getMany();
expect(loadedPosts![0].tagId).to.be.equal(1);
expect(loadedPosts![1].tagId).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.where("post.id = :id", { id: 1 })
.getOne();
@ -375,23 +375,23 @@ describe("relations > custom-referenced-column-name", () => {
const tag1 = new Tag();
tag1.name = "tag #1";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.name = "tag #2";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const post1 = new Post();
post1.title = "About BMW";
post1.tagWithoutColName = tag1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.tagWithoutColName = tag2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.tagWithoutColName", "tagWithoutColName")
.getMany();
@ -399,7 +399,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![0].tagWithoutColName.id).to.be.equal(1);
expect(loadedPosts![1].tagWithoutColName.id).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.tagWithoutColName", "tagWithoutColName")
.where("post.id = :id", { id: 1 })
@ -413,23 +413,23 @@ describe("relations > custom-referenced-column-name", () => {
const tag1 = new Tag();
tag1.name = "tag #1";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.name = "tag #2";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const post1 = new Post();
post1.title = "About BMW";
post1.tagWithoutRefColName2 = tag1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.tagWithoutRefColName2 = tag2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.tagWithoutRefColName2", "tagWithoutRefColName2")
.getMany();
@ -439,7 +439,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![1].tagWithoutRefColName2).to.not.be.empty;
expect(loadedPosts![1].tagWithoutRefColName2.id).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.tagWithoutRefColName2", "tagWithoutRefColName2")
.where("post.id = :id", { id: 1 })
@ -450,27 +450,27 @@ describe("relations > custom-referenced-column-name", () => {
})));
it("should persist relation when relation sets via join column", () => Promise.all(connections.map(async connection => {
it.skip("should persist relation when relation sets via join column", () => Promise.all(connections.map(async connection => {
const tag1 = new Tag();
tag1.name = "tag #1";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.name = "tag #2";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const post1 = new Post();
post1.title = "Post #1";
post1.tagName = "tag #1";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "Post #2";
post2.tagName = "tag #2";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.tag", "tag")
.getMany();
@ -480,7 +480,7 @@ describe("relations > custom-referenced-column-name", () => {
expect(loadedPosts![1].tag).to.not.be.empty;
expect(loadedPosts![1].tag.id).to.be.equal(2);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.tag", "category")
.where("post.id = :id", { id: 1 })

170
test/functional/relations/multiple-primary-keys/multiple-primary-keys-many-to-many/multiple-primary-keys-many-to-many.ts
View File

@ -1,7 +1,7 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {Connection} from "../../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
@ -29,33 +29,33 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "BMW";
category2.type = "cars-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const category3 = new Category();
category3.name = "airplanes";
category3.type = "common-category";
category3.code = 3;
category3.version = 1;
await connection.entityManager.persist(category3);
await connection.manager.persist(category3);
const post1 = new Post();
post1.title = "About BMW";
post1.categories = [category1, category2];
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categories = [category3];
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categories", "categories")
.orderBy("post.id, categories.code")
@ -70,7 +70,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedPosts[1].categories[0].name).to.be.equal("airplanes");
expect(loadedPosts[1].categories[0].type).to.be.equal("common-category");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categories", "categories")
.orderBy("categories.code")
@ -90,33 +90,33 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "BMW";
category2.type = "cars-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const category3 = new Category();
category3.name = "airplanes";
category3.type = "common-category";
category3.code = 3;
category3.version = 1;
await connection.entityManager.persist(category3);
await connection.manager.persist(category3);
const post1 = new Post();
post1.title = "About BMW";
post1.categoriesWithOptions = [category1, category2];
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoriesWithOptions = [category3];
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoriesWithOptions", "categories")
.orderBy("post.id, categories.code")
@ -131,7 +131,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedPosts[1].categoriesWithOptions[0].name).to.be.equal("airplanes");
expect(loadedPosts[1].categoriesWithOptions[0].type).to.be.equal("common-category");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoriesWithOptions", "categories")
.orderBy("categories.code")
@ -152,7 +152,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.code = 1;
category1.version = 1;
category1.description = "category of cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "BMW";
@ -160,7 +160,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category2.code = 2;
category2.version = 1;
category2.description = "category of BMW";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const category3 = new Category();
category3.name = "airplanes";
@ -168,19 +168,19 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category3.code = 3;
category3.version = 1;
category3.description = "category of airplanes";
await connection.entityManager.persist(category3);
await connection.manager.persist(category3);
const post1 = new Post();
post1.title = "About BMW";
post1.categoriesWithNonPrimaryColumns = [category1, category2];
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoriesWithNonPrimaryColumns = [category3];
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoriesWithNonPrimaryColumns", "categories")
.orderBy("post.id, categories.code")
@ -198,7 +198,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedPosts[1].categoriesWithNonPrimaryColumns[0].version).to.be.equal(1);
expect(loadedPosts[1].categoriesWithNonPrimaryColumns[0].description).to.be.equal("category of airplanes");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoriesWithNonPrimaryColumns", "categories")
.orderBy("categories.code")
@ -219,37 +219,37 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "BMW";
category2.type = "cars-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const category3 = new Category();
category3.name = "airplanes";
category3.type = "common-category";
category3.code = 3;
category3.version = 1;
await connection.entityManager.persist(category3);
await connection.manager.persist(category3);
const tag1 = new Tag();
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
tag1.categories = [category1, category2];
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 2;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
tag2.categories = [category3];
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const loadedTags = await connection.entityManager
const loadedTags = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categories", "categories")
.orderBy("tag.code, categories.code")
@ -264,7 +264,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedTags[1].categories[0].name).to.be.equal("airplanes");
expect(loadedTags[1].categories[0].type).to.be.equal("common-category");
const loadedTag = await connection.entityManager
const loadedTag = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categories", "categories")
.orderBy("categories.code")
@ -284,37 +284,37 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "BMW";
category2.type = "cars-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const category3 = new Category();
category3.name = "airplanes";
category3.type = "common-category";
category3.code = 3;
category3.version = 1;
await connection.entityManager.persist(category3);
await connection.manager.persist(category3);
const tag1 = new Tag();
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
tag1.categoriesWithOptions = [category1, category2];
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 2;
tag2.title = "About Boeing";
tag2.description = "Tag about Boeing";
tag2.categoriesWithOptions = [category3];
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const loadedTags = await connection.entityManager
const loadedTags = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categoriesWithOptions", "categories")
.orderBy("tag.code, categories.code")
@ -329,7 +329,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedTags[1].categoriesWithOptions[0].name).to.be.equal("airplanes");
expect(loadedTags[1].categoriesWithOptions[0].type).to.be.equal("common-category");
const loadedTag = await connection.entityManager
const loadedTag = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categoriesWithOptions", "categories")
.orderBy("categories.code")
@ -350,7 +350,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.code = 1;
category1.version = 1;
category1.description = "category of cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "BMW";
@ -358,7 +358,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category2.code = 2;
category2.version = 1;
category2.description = "category of BMW";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const category3 = new Category();
category3.name = "airplanes";
@ -366,23 +366,23 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category3.code = 3;
category3.version = 1;
category3.description = "category of airplanes";
await connection.entityManager.persist(category3);
await connection.manager.persist(category3);
const tag1 = new Tag();
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
tag1.categoriesWithNonPrimaryColumns = [category1, category2];
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 2;
tag2.title = "About Boeing";
tag2.description = "Tag about Boeing";
tag2.categoriesWithNonPrimaryColumns = [category3];
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const loadedTags = await connection.entityManager
const loadedTags = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categoriesWithNonPrimaryColumns", "categories")
.orderBy("tag.code, categories.code")
@ -400,7 +400,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedTags[1].categoriesWithNonPrimaryColumns[0].version).to.be.equal(1);
expect(loadedTags[1].categoriesWithNonPrimaryColumns[0].description).to.be.equal("category of airplanes");
const loadedTag = await connection.entityManager
const loadedTag = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categoriesWithNonPrimaryColumns", "categories")
.orderBy("categories.code")
@ -422,15 +422,15 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
const post1 = new Post();
post1.title = "About BMW";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Audi";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const post3 = new Post();
post3.title = "About Boeing";
await connection.entityManager.persist(post3);
await connection.manager.persist(post3);
const category1 = new Category();
category1.name = "cars";
@ -438,7 +438,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.code = 1;
category1.version = 1;
category1.posts = [post1, post2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -446,9 +446,9 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category2.code = 2;
category2.version = 1;
category2.posts = [post3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.posts", "posts")
.orderBy("category.code, posts.id")
@ -460,7 +460,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedCategories[1].posts).to.not.be.empty;
expect(loadedCategories[1].posts[0].id).to.be.equal(3);
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.posts", "posts")
.orderBy("posts.id")
@ -477,15 +477,15 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
const post1 = new Post();
post1.title = "About BMW";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Audi";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const post3 = new Post();
post3.title = "About Boeing";
await connection.entityManager.persist(post3);
await connection.manager.persist(post3);
const category1 = new Category();
category1.name = "cars";
@ -493,7 +493,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.code = 1;
category1.version = 1;
category1.postsWithOptions = [post1, post2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -501,9 +501,9 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category2.code = 2;
category2.version = 1;
category2.postsWithOptions = [post3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithOptions", "posts")
.orderBy("category.code, posts.id")
@ -515,7 +515,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedCategories[1].postsWithOptions).to.not.be.empty;
expect(loadedCategories[1].postsWithOptions[0].id).to.be.equal(3);
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithOptions", "posts")
.orderBy("posts.id")
@ -532,15 +532,15 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
const post1 = new Post();
post1.title = "About BMW";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Audi";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const post3 = new Post();
post3.title = "About Boeing";
await connection.entityManager.persist(post3);
await connection.manager.persist(post3);
const category1 = new Category();
category1.name = "cars";
@ -549,7 +549,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.version = 1;
category1.description = "category of cars";
category1.postsWithNonPrimaryColumns = [post1, post2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -558,9 +558,9 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category2.version = 1;
category2.description = "category of airplanes";
category2.postsWithNonPrimaryColumns = [post3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithNonPrimaryColumns", "posts")
.orderBy("category.code, posts.id")
@ -572,7 +572,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedCategories[1].postsWithNonPrimaryColumns).to.not.be.empty;
expect(loadedCategories[1].postsWithNonPrimaryColumns[0].id).to.be.equal(3);
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithNonPrimaryColumns", "posts")
.orderBy("posts.id")
@ -591,19 +591,19 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 2;
tag2.title = "About Audi";
tag2.description = "Tag about Audi";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const tag3 = new Tag();
tag3.code = 3;
tag3.title = "About Boeing";
tag3.description = "tag about Boeing";
await connection.entityManager.persist(tag3);
await connection.manager.persist(tag3);
const category1 = new Category();
category1.name = "cars";
@ -611,7 +611,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.code = 1;
category1.version = 1;
category1.tags = [tag1, tag2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -619,9 +619,9 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category2.code = 2;
category2.version = 1;
category2.tags = [tag3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tags", "tags")
.orderBy("category.code, tags.code")
@ -636,7 +636,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedCategories[1].tags[0].title).to.be.equal("About Boeing");
expect(loadedCategories[1].tags[0].description).to.be.equal("tag about Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tags", "tags")
.orderBy("tags.code")
@ -655,19 +655,19 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 2;
tag2.title = "About Audi";
tag2.description = "Tag about Audi";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const tag3 = new Tag();
tag3.code = 3;
tag3.title = "About Boeing";
tag3.description = "tag about Boeing";
await connection.entityManager.persist(tag3);
await connection.manager.persist(tag3);
const category1 = new Category();
category1.name = "cars";
@ -675,7 +675,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.code = 1;
category1.version = 1;
category1.tagsWithOptions = [tag1, tag2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -683,9 +683,9 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category2.code = 2;
category2.version = 1;
category2.tagsWithOptions = [tag3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagsWithOptions", "tags")
.orderBy("category.code, tags.code")
@ -700,7 +700,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedCategories[1].tagsWithOptions[0].title).to.be.equal("About Boeing");
expect(loadedCategories[1].tagsWithOptions[0].description).to.be.equal("tag about Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagsWithOptions", "tags")
.orderBy("tags.code")
@ -719,19 +719,19 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 2;
tag2.title = "About Audi";
tag2.description = "Tag about Audi";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const tag3 = new Tag();
tag3.code = 3;
tag3.title = "About Boeing";
tag3.description = "tag about Boeing";
await connection.entityManager.persist(tag3);
await connection.manager.persist(tag3);
const category1 = new Category();
category1.name = "cars";
@ -740,7 +740,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category1.version = 1;
category1.description = "category of cars";
category1.tagsWithNonPrimaryColumns = [tag1, tag2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -749,9 +749,9 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
category2.version = 1;
category2.description = "category of airplanes";
category2.tagsWithNonPrimaryColumns = [tag3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagsWithNonPrimaryColumns", "tags")
.orderBy("category.code, tags.code")
@ -766,7 +766,7 @@ describe("relations > multiple-primary-keys > many-to-many", () => {
expect(loadedCategories[1].tagsWithNonPrimaryColumns[0].title).to.be.equal("About Boeing");
expect(loadedCategories[1].tagsWithNonPrimaryColumns[0].description).to.be.equal("tag about Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagsWithNonPrimaryColumns", "tags")
.orderBy("tags.code")

106
test/functional/relations/multiple-primary-keys/multiple-primary-keys-many-to-one/multiple-primary-keys-many-to-one.ts
View File

@ -1,7 +1,7 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {Connection} from "../../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
@ -28,26 +28,26 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
category2.type = "common-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.category = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.category = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.category", "category")
.orderBy("post.id")
@ -60,7 +60,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
expect(loadedPosts[1].category.name).to.be.equal("airplanes");
expect(loadedPosts[1].category.type).to.be.equal("common-category");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.category", "category")
.where("post.id = :id", {id: 1})
@ -79,26 +79,26 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
category2.type = "common-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.categoryWithEmptyJoinColumn = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoryWithEmptyJoinColumn = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithEmptyJoinColumn", "category")
.orderBy("post.id")
@ -111,7 +111,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
expect(loadedPosts[1].categoryWithEmptyJoinColumn.name).to.be.equal("airplanes");
expect(loadedPosts[1].categoryWithEmptyJoinColumn.type).to.be.equal("common-category");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithEmptyJoinColumn", "category")
.where("post.id = :id", {id: 1})
@ -130,26 +130,26 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
category2.type = "common-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.categoryWithOptions = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoryWithOptions = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithOptions", "category")
.orderBy("post.id")
@ -162,7 +162,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
expect(loadedPosts[1].categoryWithOptions.name).to.be.equal("airplanes");
expect(loadedPosts[1].categoryWithOptions.type).to.be.equal("common-category");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithOptions", "category")
.where("post.id = :id", {id: 1})
@ -182,7 +182,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.description = "category about cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -190,19 +190,19 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.description = "category about airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About BMW";
post1.categoryWithNonPrimaryColumns = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
post2.categoryWithNonPrimaryColumns = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithNonPrimaryColumns", "category")
.orderBy("post.id")
@ -216,7 +216,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
expect(loadedPosts[1].categoryWithNonPrimaryColumns.code).to.be.equal(2);
expect(loadedPosts[1].categoryWithNonPrimaryColumns.version).to.be.equal(1);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithNonPrimaryColumns", "category")
.where("post.id = :id", {id: 1})
@ -236,15 +236,15 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
const post1 = new Post();
post1.title = "About BMW";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Audi";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const post3 = new Post();
post3.title = "About Boeing";
await connection.entityManager.persist(post3);
await connection.manager.persist(post3);
const category1 = new Category();
category1.name = "cars";
@ -252,7 +252,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.posts = [post1, post2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -260,9 +260,9 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.posts = [post3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.posts", "posts")
.orderBy("category.code, posts.id")
@ -277,7 +277,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
expect(loadedCategories[1].posts[0].id).to.be.equal(3);
expect(loadedCategories[1].posts[0].title).to.be.equal("About Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.posts", "posts")
.orderBy("posts.id")
@ -296,15 +296,15 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
const post1 = new Post();
post1.title = "About BMW";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Audi";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const post3 = new Post();
post3.title = "About Boeing";
await connection.entityManager.persist(post3);
await connection.manager.persist(post3);
const category1 = new Category();
category1.name = "cars";
@ -312,7 +312,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.postsWithEmptyJoinColumn = [post1, post2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -320,9 +320,9 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.postsWithEmptyJoinColumn = [post3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithEmptyJoinColumn", "posts")
.orderBy("category.code, posts.id")
@ -337,7 +337,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
expect(loadedCategories[1].postsWithEmptyJoinColumn[0].id).to.be.equal(3);
expect(loadedCategories[1].postsWithEmptyJoinColumn[0].title).to.be.equal("About Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithEmptyJoinColumn", "posts")
.orderBy("posts.id")
@ -356,15 +356,15 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
const post1 = new Post();
post1.title = "About BMW";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Audi";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const post3 = new Post();
post3.title = "About Boeing";
await connection.entityManager.persist(post3);
await connection.manager.persist(post3);
const category1 = new Category();
category1.name = "cars";
@ -372,7 +372,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.postsWithOptions = [post1, post2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -380,9 +380,9 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.postsWithOptions = [post3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithOptions", "posts")
.orderBy("category.code, posts.id")
@ -397,7 +397,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
expect(loadedCategories[1].postsWithOptions[0].id).to.be.equal(3);
expect(loadedCategories[1].postsWithOptions[0].title).to.be.equal("About Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithOptions", "posts")
.orderBy("posts.id")
@ -416,15 +416,15 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
const post1 = new Post();
post1.title = "About BMW";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Audi";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const post3 = new Post();
post3.title = "About Boeing";
await connection.entityManager.persist(post3);
await connection.manager.persist(post3);
const category1 = new Category();
category1.name = "cars";
@ -433,7 +433,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category1.version = 1;
category1.description = "category of cars";
category1.postsWithNonPrimaryColumns = [post1, post2];
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -442,9 +442,9 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
category2.version = 1;
category2.description = "category of airplanes";
category2.postsWithNonPrimaryColumns = [post3];
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithNonPrimaryColumns", "posts")
.orderBy("category.code, posts.id")
@ -459,7 +459,7 @@ describe("relations > multiple-primary-keys > many-to-one", () => {
expect(loadedCategories[1].postsWithNonPrimaryColumns[0].id).to.be.equal(3);
expect(loadedCategories[1].postsWithNonPrimaryColumns[0].title).to.be.equal("About Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.postsWithNonPrimaryColumns", "posts")
.orderBy("posts.id")

146
test/functional/relations/multiple-primary-keys/multiple-primary-keys-one-to-one/multiple-primary-keys-one-to-one.ts
View File

@ -1,7 +1,7 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {Connection} from "../../../../../src/connection/Connection";
import {Category} from "./entity/Category";
import {Post} from "./entity/Post";
@ -29,26 +29,26 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
category2.type = "common-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About cars #1";
post1.category = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About cars #2";
post2.category = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.category", "category")
.orderBy("post.id")
@ -61,7 +61,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedPosts[1].category.name).to.be.equal("airplanes");
expect(loadedPosts[1].category.type).to.be.equal("common-category");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.category", "category")
.where("post.id = :id", {id: 1})
@ -80,26 +80,26 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
category2.type = "common-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About cars #1";
post1.categoryWithOptions = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About cars #2";
post2.categoryWithOptions = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithOptions", "category")
.orderBy("post.id")
@ -112,7 +112,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedPosts[1].categoryWithOptions.name).to.be.equal("airplanes");
expect(loadedPosts[1].categoryWithOptions.type).to.be.equal("common-category");
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithOptions", "category")
.where("post.id = :id", { id: 1 })
@ -132,7 +132,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.description = "category about cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -140,19 +140,19 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.description = "category about airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const post1 = new Post();
post1.title = "About cars #1";
post1.categoryWithNonPrimaryColumns = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About cars #2";
post2.categoryWithNonPrimaryColumns = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const loadedPosts = await connection.entityManager
const loadedPosts = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithNonPrimaryColumns", "category")
.orderBy("post.id")
@ -166,7 +166,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedPosts[1].categoryWithNonPrimaryColumns.code).to.be.equal(2);
expect(loadedPosts[1].categoryWithNonPrimaryColumns.version).to.be.equal(1);
const loadedPost = await connection.entityManager
const loadedPost = await connection.manager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.categoryWithNonPrimaryColumns", "category")
.where("post.id = :id", { id: 1 })
@ -186,30 +186,30 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
category2.type = "common-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const tag1 = new Tag();
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
tag1.category = category1;
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 3;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
tag2.category = category2;
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const loadedTags = await connection.entityManager
const loadedTags = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.category", "category")
.orderBy("tag.code, category.code")
@ -222,7 +222,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedTags[1].category.name).to.be.equal("airplanes");
expect(loadedTags[1].category.type).to.be.equal("common-category");
const loadedTag = await connection.entityManager
const loadedTag = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.category", "category")
.orderBy("category.code")
@ -242,30 +242,30 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.type = "common-category";
category1.code = 1;
category1.version = 1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
category2.type = "common-category";
category2.code = 2;
category2.version = 1;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const tag1 = new Tag();
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
tag1.categoryWithOptions = category1;
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 3;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
tag2.categoryWithOptions = category2;
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const loadedTags = await connection.entityManager
const loadedTags = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categoryWithOptions", "category")
.orderBy("tag.code, category.code")
@ -278,7 +278,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedTags[1].categoryWithOptions.name).to.be.equal("airplanes");
expect(loadedTags[1].categoryWithOptions.type).to.be.equal("common-category");
const loadedTag = await connection.entityManager
const loadedTag = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categoryWithOptions", "category")
.orderBy("category.code")
@ -299,7 +299,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.description = "category of cars";
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -307,23 +307,23 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.description = "category of airplanes";
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const tag1 = new Tag();
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
tag1.categoryWithNonPrimaryColumns = category1;
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 3;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
tag2.categoryWithNonPrimaryColumns = category2;
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const loadedTags = await connection.entityManager
const loadedTags = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categoryWithNonPrimaryColumns", "category")
.orderBy("tag.code, category.code")
@ -336,7 +336,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedTags[1].categoryWithNonPrimaryColumns.name).to.be.equal("airplanes");
expect(loadedTags[1].categoryWithNonPrimaryColumns.type).to.be.equal("common-category");
const loadedTag = await connection.entityManager
const loadedTag = await connection.manager
.createQueryBuilder(Tag, "tag")
.leftJoinAndSelect("tag.categoryWithNonPrimaryColumns", "category")
.orderBy("category.code")
@ -357,11 +357,11 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
const post1 = new Post();
post1.title = "About BMW";
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
const post2 = new Post();
post2.title = "About Boeing";
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
const category1 = new Category();
category1.name = "cars";
@ -369,7 +369,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.post = post1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -377,9 +377,9 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.post = post2;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.post", "post")
.orderBy("category.code, post.id")
@ -390,7 +390,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedCategories[1].post).to.not.be.empty;
expect(loadedCategories[1].post.id).to.be.equal(2);
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.post", "post")
.orderBy("post.id")
@ -408,13 +408,13 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 3;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const category1 = new Category();
category1.name = "cars";
@ -422,7 +422,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.tag = tag1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -430,9 +430,9 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.tag = tag2;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tag", "tag")
.orderBy("category.code, tag.code")
@ -445,7 +445,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedCategories[1].tag.title).to.be.equal("About Boeing");
expect(loadedCategories[1].tag.description).to.be.equal("tag about Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tag", "tag")
.orderBy("tag.code")
@ -464,13 +464,13 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 3;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const category1 = new Category();
category1.name = "cars";
@ -478,7 +478,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.tagWithOptions = tag1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -486,9 +486,9 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.tagWithOptions = tag2;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagWithOptions", "tag")
.orderBy("category.code, tag.code")
@ -501,7 +501,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedCategories[1].tagWithOptions.title).to.be.equal("About Boeing");
expect(loadedCategories[1].tagWithOptions.description).to.be.equal("tag about Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagWithOptions", "tag")
.orderBy("tag.code")
@ -520,13 +520,13 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 3;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const category1 = new Category();
category1.name = "cars";
@ -535,7 +535,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.version = 1;
category1.description = "category of cars";
category1.tagWithNonPrimaryColumns = tag1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -544,9 +544,9 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category2.version = 1;
category2.description = "category of airplanes";
category2.tagWithNonPrimaryColumns = tag2;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagWithNonPrimaryColumns", "tag")
.orderBy("category.code, tag.code")
@ -559,7 +559,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedCategories[1].tagWithNonPrimaryColumns.title).to.be.equal("About Boeing");
expect(loadedCategories[1].tagWithNonPrimaryColumns.description).to.be.equal("tag about Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagWithNonPrimaryColumns", "tag")
.orderBy("tag.code")
@ -578,13 +578,13 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 3;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const category1 = new Category();
category1.name = "cars";
@ -592,7 +592,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.code = 1;
category1.version = 1;
category1.tagWithOptions = tag1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -600,9 +600,9 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category2.code = 2;
category2.version = 1;
category2.tagWithOptions = tag2;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagWithOptions", "tag")
.orderBy("category.code, tag.code")
@ -615,7 +615,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedCategories[1].tagWithOptions.title).to.be.equal("About Boeing");
expect(loadedCategories[1].tagWithOptions.description).to.be.equal("tag about Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagWithOptions", "tag")
.orderBy("tag.code")
@ -634,13 +634,13 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
tag1.code = 1;
tag1.title = "About BMW";
tag1.description = "Tag about BMW";
await connection.entityManager.persist(tag1);
await connection.manager.persist(tag1);
const tag2 = new Tag();
tag2.code = 3;
tag2.title = "About Boeing";
tag2.description = "tag about Boeing";
await connection.entityManager.persist(tag2);
await connection.manager.persist(tag2);
const category1 = new Category();
category1.name = "cars";
@ -649,7 +649,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category1.version = 1;
category1.description = "category of cars";
category1.tagWithNonPrimaryColumns = tag1;
await connection.entityManager.persist(category1);
await connection.manager.persist(category1);
const category2 = new Category();
category2.name = "airplanes";
@ -658,9 +658,9 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
category2.version = 1;
category2.description = "category of airplanes";
category2.tagWithNonPrimaryColumns = tag2;
await connection.entityManager.persist(category2);
await connection.manager.persist(category2);
const loadedCategories = await connection.entityManager
const loadedCategories = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagWithNonPrimaryColumns", "tag")
.orderBy("category.code, tag.code")
@ -673,7 +673,7 @@ describe("relations > multiple-primary-keys > one-to-one", () => {
expect(loadedCategories[1].tagWithNonPrimaryColumns.title).to.be.equal("About Boeing");
expect(loadedCategories[1].tagWithNonPrimaryColumns.description).to.be.equal("tag about Boeing");
const loadedCategory = await connection.entityManager
const loadedCategory = await connection.manager
.createQueryBuilder(Category, "category")
.leftJoinAndSelect("category.tagWithNonPrimaryColumns", "tag")
.orderBy("tag.code")

24
test/functional/relations/multiple-primary-keys/multiple-primary-keys-other-cases/multiple-primary-keys-other-cases.ts
View File

@ -1,7 +1,7 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {Connection} from "../../../../../src/connection/Connection";
import {User} from "./entity/User";
import {EventMember} from "./entity/EventMember";
@ -24,45 +24,45 @@ describe.skip("relations > multiple-primary-keys > other-cases", () => {
const user1 = new User();
user1.name = "Alice";
await connection.entityManager.persist(user1);
await connection.manager.persist(user1);
const user2 = new User();
user2.name = "Bob";
await connection.entityManager.persist(user2);
await connection.manager.persist(user2);
const user3 = new User();
user3.name = "Clara";
await connection.entityManager.persist(user3);
await connection.manager.persist(user3);
const event1 = new Event();
event1.name = "Event #1";
await connection.entityManager.persist(event1);
await connection.manager.persist(event1);
const event2 = new Event();
event2.name = "Event #2";
await connection.entityManager.persist(event2);
await connection.manager.persist(event2);
const eventMember1 = new EventMember();
eventMember1.user = user1;
eventMember1.event = event1;
await connection.entityManager.persist(eventMember1);
await connection.manager.persist(eventMember1);
const eventMember2 = new EventMember();
eventMember2.user = user2;
eventMember2.event = event1;
await connection.entityManager.persist(eventMember2);
await connection.manager.persist(eventMember2);
const eventMember3 = new EventMember();
eventMember3.user = user1;
eventMember3.event = event2;
await connection.entityManager.persist(eventMember3);
await connection.manager.persist(eventMember3);
const eventMember4 = new EventMember();
eventMember4.user = user3;
eventMember4.event = event2;
await connection.entityManager.persist(eventMember4);
await connection.manager.persist(eventMember4);
const loadedEvents = await connection.entityManager
const loadedEvents = await connection.manager
.createQueryBuilder(Event, "event")
.leftJoinAndSelect("event.members", "members")
.leftJoinAndSelect("members.user", "user")
@ -80,7 +80,7 @@ describe.skip("relations > multiple-primary-keys > other-cases", () => {
expect(loadedEvents[1].members[1].user.id).to.be.equal(3);
expect(loadedEvents[1].members[1].user.name).to.be.equal("Clara");
const loadedUsers = await connection.entityManager
const loadedUsers = await connection.manager
.createQueryBuilder(User, "user")
.leftJoinAndSelect("user.members", "members")
.leftJoinAndSelect("members.event", "event")

8
test/functional/relations/relation-mapped-to-different-name-column/relation-mapped-to-different-name-column.ts
View File

@ -1,5 +1,5 @@
import "reflect-metadata";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {PostDetails} from "./entity/PostDetails";
@ -20,16 +20,16 @@ describe.skip("relations > relation mapped to relation with different name (#56)
// first create and save details
const details = new PostDetails();
details.keyword = "post-1";
await connection.entityManager.persist(details);
await connection.manager.persist(details);
// then create and save a post with details
const post1 = new Post();
post1.title = "Hello Post #1";
post1.details = details;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
// now check
const posts = await connection.entityManager.find(Post, {
const posts = await connection.manager.find(Post, {
join: {
alias: "post",
innerJoinAndSelect: {

6
test/functional/relations/relation-with-primary-key/relation-with-primary-key.ts
View File

@ -27,7 +27,7 @@ describe("relations > relation with primary key", () => {
post1.title = "Hello Post #1";
post1.category = category1;
await connection.entityManager.persist(post1);
await connection.manager.persist(post1);
// create second category and post and save them
const category2 = new Category();
@ -37,10 +37,10 @@ describe("relations > relation with primary key", () => {
post2.title = "Hello Post #2";
post2.category = category2;
await connection.entityManager.persist(post2);
await connection.manager.persist(post2);
// now check
const posts = await connection.entityManager.find(Post, {
const posts = await connection.manager.find(Post, {
join: {
alias: "post",
innerJoinAndSelect: {

2
test/utils/test-utils.ts
View File

@ -200,7 +200,7 @@ export function generateRandomText(length: number): string {
let text = "";
const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
for(let i = 0; i <= length; i++ )
for (let i = 0; i <= length; i++ )
text += characters.charAt(Math.floor(Math.random() * characters.length));
return text;